« back to all changes in this revision
Viewing changes to interface/libdrizzle/connection.i
- browse files at revision 114
- compare with another revision
- download diff
- download tarball
- view history from revision 114
- Committer: Monty Taylor
- Date: 2009-10-28 02:20:39 UTC
- mfrom: (113.1.2 c-transition)
- Revision ID: mordred@inaugust.com-20091028022039-a202c33y8nm06x5n
Merged in transition to C.
- files added:
- interface/python/value_return.i
- files removed:
- interface/libdrizzle/column_server.i
- files renamed:
- interface/libdrizzle/client.i => interface/libdrizzle/connection.i
- files modified:
- Makefile.am
added
removed
interface/libdrizzle/connection.i
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
1
/* -*- mode: c; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
3
*
4
4
* drizzle-interface: Interface Wrappers for Drizzle
29
29
* SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
30
30
*/
31
31
32
class Client : public drizzle_con {};
33
34
%extend Client {
35
36
32
typedef struct drizzle_con_st {} Connection;
33
34
%extend Connection {
35
36
/* Set options for a connection. */
37
const char *host()
38
{
39
return drizzle_con_host($self);
40
}
41
42
in_port_t port()
43
{
44
return drizzle_con_port($self);
45
}
46
47
void set_tcp(char *host, in_port_t port)
48
{
49
drizzle_con_set_tcp($self, host, port);
50
}
51
52
const char *uds()
53
{
54
return drizzle_con_uds($self);
55
}
56
57
void set_uds(const char *uds)
58
{
59
drizzle_con_set_uds($self, uds);
60
}
61
62
const char *user()
63
{
64
return drizzle_con_user($self);
65
}
66
67
const char *password()
68
{
69
return drizzle_con_password($self);
70
}
71
72
void set_auth(const char *user, const char *password)
73
{
74
drizzle_con_set_auth($self, user, password);
75
}
76
77
const char *db()
78
{
79
return drizzle_con_db($self);
80
}
81
82
void set_db(char *db)
83
{
84
drizzle_con_set_db($self, db);
85
}
86
87
drizzle_con_options_t options()
88
{
89
return drizzle_con_options($self);
90
}
91
92
void set_options(drizzle_con_options_t options)
93
{
94
drizzle_con_set_options($self, options);
95
}
96
97
void add_options(drizzle_con_options_t options)
98
{
99
drizzle_con_add_options($self, options);
100
}
101
102
void remove_options(drizzle_con_options_t options)
103
{
104
drizzle_con_remove_options($self, options);
105
}
106
107
/* Connect to server. */
108
drizzle_return_t connect()
109
{
110
return drizzle_con_connect($self);
111
}
112
113
/* Close a connection. */
114
void close()
115
{
116
drizzle_con_close($self);
117
}
118
119
/* Get information on connection. */
120
uint8_t protocol_version()
121
{
122
return drizzle_con_protocol_version($self);
123
}
124
125
const char *server_version()
126
{
127
return drizzle_con_server_version($self);
128
}
129
130
uint32_t server_version_number()
131
{
132
return drizzle_con_server_version_number($self);
133
}
134
135
uint32_t thread_id()
136
{
137
return drizzle_con_thread_id($self);
138
}
139
140
const uint8_t *scramble()
141
{
142
return drizzle_con_scramble($self);
143
}
144
145
drizzle_capabilities_t capabilities()
146
{
147
return drizzle_con_capabilities($self);
148
}
149
150
drizzle_charset_t charset()
151
{
152
return drizzle_con_charset($self);
153
}
154
155
drizzle_con_status_t status()
156
{
157
return drizzle_con_status($self);
158
}
159
160
uint32_t max_packet_size()
161
{
162
return drizzle_con_max_packet_size($self);
163
}
164
165
/*
37
166
%exception {
38
167
$action
39
168
if (drizzle_return_value == DRIZZLE_RETURN_ERROR_CODE)
45
174
D_exception(InterfaceError, drizzle_con_error(arg1));
46
175
}
47
176
}
177
*/
48
178
49
179
/**
50
180
* Send query to server.
51
181
*/
52
result_client_buffered *buffer_query(const char *query, size_t size,
53
drizzle_return_t *drizzle_return_value)
54
{
55
result_client_buffered *result_ptr=
56
drizzle_query($self, NULL, query, size, drizzle_return_value);
57
if (*drizzle_return_value == DRIZZLE_RETURN_OK)
58
*drizzle_return_value= drizzle_result_buffer(result_ptr);
59
return result_ptr;
60
}
61
62
result_client_unbuffered *query(const char *query, size_t size,
63
drizzle_return_t *drizzle_return_value)
182
Result *query(const char *query, size_t size,
183
drizzle_return_t *drizzle_return_value)
64
184
{
65
185
return drizzle_query($self, NULL, query, size, drizzle_return_value);
66
186
}
67
187
68
188
69
189
/* Send query incrementally. */
70
result_client_unbuffered *query_inc(const char *query, size_t size,
71
size_t total,
72
drizzle_return_t *drizzle_return_value) {
190
Result *query_incremental(const char *query, size_t size,
191
size_t total,
192
drizzle_return_t *drizzle_return_value)
193
{
73
194
return drizzle_query_inc($self, NULL, query, size, total,
74
195
drizzle_return_value);
75
196
}
76
197
77
198
/* Send other requests to server. */
78
result_client *quit(drizzle_return_t *drizzle_return_value) {
199
Result *quit(drizzle_return_t *drizzle_return_value)
200
{
79
201
return drizzle_quit($self, NULL, drizzle_return_value);
80
202
}
81
203
82
result_client *select_db(char *db,
83
drizzle_return_t *drizzle_return_value) {
204
Result *select_db(char *db, drizzle_return_t *drizzle_return_value)
205
{
84
206
return drizzle_select_db($self, NULL, db, drizzle_return_value);
85
207
}
86
208
87
result_client *refresh(drizzle_refresh_options_t options,
88
drizzle_return_t *drizzle_return_value) {
209
Result *refresh(drizzle_refresh_options_t options,
210
drizzle_return_t *drizzle_return_value)
211
{
89
212
return drizzle_refresh($self, NULL, options, drizzle_return_value);
90
213
}
91
214
92
result_client *shutdown(shutdown_level level,
93
drizzle_return_t *drizzle_return_value) {
215
Result *shutdown(shutdown_level level, drizzle_return_t *drizzle_return_value)
216
{
94
217
return drizzle_shutdown($self, NULL, level, drizzle_return_value);
95
218
}
96
219
97
result_client *stat(drizzle_return_t *drizzle_return_value) {
220
Result *stat(drizzle_return_t *drizzle_return_value)
221
{
98
222
return drizzle_stat($self, NULL, drizzle_return_value);
99
223
}
100
224
101
result_client *debug_info(drizzle_return_t *drizzle_return_value) {
225
Result *debug_info(drizzle_return_t *drizzle_return_value)
226
{
102
227
return drizzle_debug_info($self, NULL, drizzle_return_value);
103
228
}
104
229
105
result_client *ping(drizzle_return_t *drizzle_return_value) {
230
Result *ping(drizzle_return_t *drizzle_return_value)
231
{
106
232
return drizzle_ping($self, NULL, drizzle_return_value);
107
233
}
108
234
109
result_client *change_user(const char *user,
110
const char *password,
111
const char *db,
112
drizzle_return_t *drizzle_return_value) {
235
Result *change_user(const char *user, const char *password, const char *db,
236
drizzle_return_t *drizzle_return_value)
237
{
113
238
return drizzle_change_user($self, NULL, user, password, db,
114
239
drizzle_return_value);
115
240
}
116
241
117
result_server *write(drizzle_command_t command,
118
const uint8_t *data, size_t size,
119
size_t total,
120
drizzle_return_t *drizzle_return_value) {
242
Result *write(drizzle_command_t command, const uint8_t *data, size_t size,
243
size_t total, drizzle_return_t *drizzle_return_value)
244
{
121
245
return drizzle_command_write($self, NULL, command, data,
122
246
size, total, drizzle_return_value);
123
247
}
124
248
125
249
126
result_client *result_read(drizzle_return_t *drizzle_return_value,
127
drizzle_result_st *to=NULL)
250
Result *result_read(drizzle_return_t *drizzle_return_value,
251
drizzle_result_st *to=NULL)
128
252
{
129
253
return drizzle_result_read($self, to, drizzle_return_value);
130
254
}
131
255
256
257
Result *result_create(drizzle_result_st *to=NULL)
258
{
259
return drizzle_result_create($self, to);
260
}
261
262
Result *result_clone(drizzle_result_st *clone_from)
263
{
264
return drizzle_result_clone($self, NULL, clone_from);
265
}
266
267
drizzle_return_t result_write(drizzle_result_st *to, bool flush)
268
{
269
return drizzle_result_write($self, to, flush);
270
}
271
132
272
%noexception;
133
273
134
result_client *result_create(drizzle_result_st *to=NULL)
135
{
136
return drizzle_result_create($self, to);
137
}
138
139
result_client *result_clone(drizzle_result_st *to,
140
drizzle_result_st *from)
141
{
142
return drizzle_result_clone($self, to, from);
143
}
144
145
result_client *result_clone(drizzle_result_st *from)
146
{
147
return drizzle_result_clone($self, NULL, from);
148
}
149
150
151
}
152
274
/**
275
* Set protocol version for a connection.
276
*/
277
void set_protocol_version(uint8_t protocol_version)
278
{
279
drizzle_con_set_protocol_version($self, protocol_version);
280
}
281
282
/**
283
* Set server version string for a connection.
284
*/
285
void set_server_version(const char *server_version)
286
{
287
drizzle_con_set_server_version($self, server_version);
288
}
289
290
/**
291
* Set thread ID for a connection.
292
*/
293
void set_thread_id(uint32_t thread_id)
294
{
295
drizzle_con_set_thread_id($self, thread_id);
296
}
297
298
/**
299
* Set scramble buffer for a connection.
300
*/
301
void set_scramble(const uint8_t *scramble)
302
{
303
drizzle_con_set_scramble($self, scramble);
304
}
305
306
/**
307
* Set capabilities for a connection.
308
*/
309
void set_capabilities(drizzle_capabilities_t capabilities)
310
{
311
drizzle_con_set_capabilities($self, capabilities);
312
}
313
314
/**
315
* Set charset for a connection.
316
*/
317
void set_charset(drizzle_charset_t charset)
318
{
319
drizzle_con_set_charset($self, charset);
320
}
321
322
/**
323
* Set status for a connection.
324
*/
325
void set_status(drizzle_con_status_t status)
326
{
327
drizzle_con_set_status($self, status);
328
}
329
330
/**
331
* Set max packet size for a connection.
332
*/
333
void set_max_packet_size(uint32_t max_packet_size)
334
{
335
drizzle_con_set_max_packet_size($self, max_packet_size);
336
}
337
338
/**
339
* Copy all handshake information from one connection into another.
340
*/
341
void copy_handshake(drizzle_con_st *source)
342
{
343
drizzle_con_copy_handshake($self, source);
344
}
345
346
}
Loggerhead is a web-based interface for Breezy
Version: 2.0.1