← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to libdrizzle-2.0/libdrizzle/libdrizzle.hpp

  • Committer: Mark Atwood
  • Date: 2011-08-12 20:36:52 UTC
  • mfrom: (2385.3.5 rf)
  • Revision ID: me@mark.atwood.name-20110812203652-ljc8c0q8s8pzuxei
merge lp:~olafvdspek/drizzle/client

Show diffs side-by-side

added added

removed removed

Lines of Context:
libdrizzle-2.0/libdrizzle/libdrizzle.hpp
35
35
 
36
36
#include <cstring>
37
37
#include <libdrizzle/libdrizzle.h>
 
38
#include <sstream>
38
39
#include <stdexcept>
39
40
 
40
41
namespace drizzle {
43
44
{
44
45
};
45
46
 
46
 
class drizzle_c
 
47
class noncopyable
 
48
{
 
49
protected:
 
50
  noncopyable()
 
51
  {
 
52
  }
 
53
private:
 
54
  noncopyable(const noncopyable&);
 
55
  void operator=(const noncopyable&);
 
56
};
 
57
 
 
58
class drizzle_c : noncopyable
47
59
{
48
60
public:
49
61
  drizzle_c()
59
71
  drizzle_st b_;
60
72
};
61
73
 
62
 
class result_c
 
74
class result_c : noncopyable
63
75
{
64
76
public:
65
77
  result_c()
120
132
  drizzle_result_st b_;
121
133
};
122
134
 
123
 
class connection_c
 
135
class connection_c : noncopyable
124
136
{
125
137
public:
126
138
  explicit connection_c(drizzle_c& drizzle)
175
187
  drizzle_con_st b_;
176
188
};
177
189
 
178
 
/*
179
 
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const char* str, size_t str_size)
180
 
{
181
 
  drizzle_return_t ret;
182
 
  drizzle_query(con, &result.b_, str, str_size, &ret);
183
 
  if (ret == DRIZZLE_RETURN_OK)
184
 
    ret = drizzle_result_buffer(&result.b_);
185
 
  return ret;
186
 
}
187
 
 
188
 
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const std::string& str)
189
 
{
190
 
  return query(con, result, str.data(), str.size());
191
 
}
192
 
 
193
 
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const char* str)
194
 
{
195
 
  return query(con, result, str, strlen(str));
196
 
}
197
 
*/
 
190
class query_c
 
191
{
 
192
public:
 
193
  query_c(connection_c& con, const std::string& in = "") :
 
194
    con_(con),
 
195
    in_(in)
 
196
  {
 
197
  }
 
198
 
 
199
  void operator=(const std::string& v)
 
200
  {
 
201
    in_ = v;
 
202
    out_.clear();
 
203
  }
 
204
 
 
205
  void operator+=(const std::string& v)
 
206
  {
 
207
    in_ += v;
 
208
  }
 
209
 
 
210
  query_c& p_name(const std::string& v)
 
211
  {
 
212
    std::vector<char> r(2 * v.size() + 2);
 
213
    r.resize(drizzle_escape_string(&r.front() + 1, v.data(), v.size()) + 2);    
 
214
    r.front() = '`';
 
215
    r.back() = '`';
 
216
    p_raw(&r.front(), r.size());
 
217
    return *this;
 
218
  }
 
219
 
 
220
  query_c& p_raw(const char* v, size_t sz)
 
221
  {
 
222
    size_t i = in_.find('?');
 
223
    assert(i != std::string::npos);
 
224
    if (i == std::string::npos)
 
225
      return *this;
 
226
    out_.append(in_.substr(0, i));
 
227
    in_.erase(0, i + 1);
 
228
    out_.append(v, sz);
 
229
    return *this;
 
230
  }
 
231
 
 
232
  query_c& p_raw(const std::string& v)
 
233
  {
 
234
    return p_raw(v.data(), v.size());
 
235
  }
 
236
 
 
237
  query_c& p(const std::string& v)
 
238
  {
 
239
    std::vector<char> r(2 * v.size() + 2);
 
240
    r.resize(drizzle_escape_string(&r.front() + 1, v.data(), v.size()) + 2);    
 
241
    r.front() = '\'';
 
242
    r.back() = '\'';
 
243
    p_raw(&r.front(), r.size());
 
244
    return *this;
 
245
  }
 
246
 
 
247
  query_c& p(long long v)
 
248
  {
 
249
    std::stringstream ss;
 
250
    ss << v;
 
251
    p_raw(ss.str());
 
252
    return *this;
 
253
  }
 
254
 
 
255
  drizzle_return_t execute(result_c& result)
 
256
  {
 
257
    return con_.query(result, read());
 
258
  }
 
259
 
 
260
  std::string read() const
 
261
  {
 
262
    return out_ + in_;
 
263
  }
 
264
private:
 
265
  connection_c& con_;
 
266
  std::string in_;
 
267
  std::string out_;
 
268
};
198
269
 
199
270
}