~drizzle-trunk/drizzle/development

« back to all changes in this revision

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

  • Committer: Olaf van der Spek
  • Date: 2011-06-17 07:07:02 UTC
  • mto: (2318.6.5 refactor7)
  • mto: This revision was merged to the branch mainline in revision 2340.
  • Revision ID: olafvdspek@gmail.com-20110617070702-gjj44nycxfhzlba3
Oops

Show diffs side-by-side

added added

removed removed

Lines of Context:
31
31
 * OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
32
32
 */
33
33
 
34
 
#pragma once
35
 
 
36
 
#include <libdrizzle/libdrizzle.h>
37
 
#include <stdexcept>
38
 
 
39
 
namespace drizzle {
40
 
 
41
 
class bad_query : public std::runtime_error
42
 
{
43
 
};
44
 
 
45
 
class drizzle_c
46
 
{
47
 
public:
48
 
  drizzle_c()
49
 
  {
50
 
    drizzle_create(&b_);
51
 
  }
52
 
 
53
 
  ~drizzle_c()
54
 
  {
55
 
    drizzle_free(&b_);
56
 
  }
57
 
 
58
 
  drizzle_st b_;
59
 
};
60
 
 
61
 
class result_c
62
 
{
63
 
public:
64
 
  result_c()
65
 
  {
66
 
    memset(&b_, 0, sizeof(b_));
67
 
  }
68
 
 
69
 
  ~result_c()
70
 
  {
71
 
    drizzle_result_free(&b_);
72
 
  }
73
 
 
 
34
#pragma once
 
35
 
 
36
#include <cstring>
 
37
#include <libdrizzle/libdrizzle.h>
 
38
#include <stdexcept>
 
39
 
 
40
namespace drizzle {
 
41
 
 
42
class bad_query : public std::runtime_error
 
43
{
 
44
};
 
45
 
 
46
class drizzle_c
 
47
{
 
48
public:
 
49
  drizzle_c()
 
50
  {
 
51
    drizzle_create(&b_);
 
52
  }
 
53
 
 
54
  ~drizzle_c()
 
55
  {
 
56
    drizzle_free(&b_);
 
57
  }
 
58
 
 
59
  drizzle_st b_;
 
60
};
 
61
 
 
62
class result_c
 
63
{
 
64
public:
 
65
  result_c()
 
66
  {
 
67
    memset(&b_, 0, sizeof(b_));
 
68
  }
 
69
 
 
70
  ~result_c()
 
71
  {
 
72
    drizzle_result_free(&b_);
 
73
  }
 
74
 
74
75
  const char* error()
75
76
  {
76
77
    return drizzle_result_error(&b_);
115
116
  {
116
117
    return drizzle_row_field_sizes(&b_);
117
118
  }
118
 
 
119
 
  drizzle_result_st b_;
120
 
};
121
 
 
122
 
class connection_c
123
 
{
124
 
public:
125
 
  explicit connection_c(drizzle_c& drizzle)
126
 
  {
127
 
    drizzle_con_create(&drizzle.b_, &b_);
128
 
  }
129
 
 
130
 
  ~connection_c()
131
 
  {
132
 
    drizzle_con_free(&b_);
133
 
  }
134
 
 
135
 
  const char* error()
136
 
  {
137
 
    return drizzle_con_error(&b_);
138
 
  }
139
 
 
 
119
 
 
120
  drizzle_result_st b_;
 
121
};
 
122
 
 
123
class connection_c
 
124
{
 
125
public:
 
126
  explicit connection_c(drizzle_c& drizzle)
 
127
  {
 
128
    drizzle_con_create(&drizzle.b_, &b_);
 
129
  }
 
130
 
 
131
  ~connection_c()
 
132
  {
 
133
    drizzle_con_free(&b_);
 
134
  }
 
135
 
 
136
  const char* error()
 
137
  {
 
138
    return drizzle_con_error(&b_);
 
139
  }
 
140
 
140
141
  drizzle_return_t query(result_c& result, const char* str, size_t str_size)
141
142
  {
142
143
    drizzle_return_t ret;
144
145
    if (ret == DRIZZLE_RETURN_OK)
145
146
      ret = drizzle_result_buffer(&result.b_);
146
147
    return ret;
147
 
  }
148
 
 
149
 
  drizzle_return_t query(result_c& result, const std::string& str)
150
 
  {
151
 
    return query(result, str.data(), str.size());
152
 
  }
153
 
 
154
 
  drizzle_return_t query(result_c& result, const char* str)
155
 
  {
156
 
    return query(result, str, strlen(str));
157
 
  }
158
 
 
159
 
  drizzle_con_st b_;
160
 
};
161
 
 
 
148
  }
 
149
 
 
150
  drizzle_return_t query(result_c& result, const std::string& str)
 
151
  {
 
152
    return query(result, str.data(), str.size());
 
153
  }
 
154
 
 
155
  drizzle_return_t query(result_c& result, const char* str)
 
156
  {
 
157
    return query(result, str, strlen(str));
 
158
  }
 
159
 
 
160
  drizzle_con_st b_;
 
161
};
 
162
 
162
163
/*
163
164
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const char* str, size_t str_size)
164
165
{
167
168
  if (ret == DRIZZLE_RETURN_OK)
168
169
    ret = drizzle_result_buffer(&result.b_);
169
170
  return ret;
170
 
}
171
 
 
 
171
}
 
172
 
172
173
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const std::string& str)
173
174
{
174
175
  return query(con, result, str.data(), str.size());
175
 
}
176
 
 
 
176
}
 
177
 
177
178
inline drizzle_return_t query(drizzle_con_st* con, result_c& result, const char* str)
178
179
{
179
180
  return query(con, result, str, strlen(str));
180
 
}
181
 
*/
182
 
 
183
 
}
 
181
}
 
182
*/
 
183
 
 
184
}