Mercurial > p > mysql-python > mysqldb-2
annotate _mysql_connections.c @ 54:6e31278d3433 MySQLdb
There's no good reason to delay imports when the module is (1) useless without
it or (2) you do the same late import more than once.
| author | kylev |
|---|---|
| date | Mon, 23 Feb 2009 23:52:44 +0000 |
| parents | fdf0cabb27be |
| children |
| rev | line source |
|---|---|
| 29 | 1 /* -*- mode: C; indent-tabs-mode: t; c-basic-offset: 8; -*- */ |
| 2 | |
|
2
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
3 #include "_mysql.h" |
| 0 | 4 |
| 5 static int | |
| 6 _mysql_ConnectionObject_Initialize( | |
| 7 _mysql_ConnectionObject *self, | |
| 8 PyObject *args, | |
| 9 PyObject *kwargs) | |
| 10 { | |
| 11 MYSQL *conn = NULL; | |
| 12 PyObject *conv = NULL; | |
| 13 PyObject *ssl = NULL; | |
| 14 #if HAVE_OPENSSL | |
| 15 char *key = NULL, *cert = NULL, *ca = NULL, | |
| 16 *capath = NULL, *cipher = NULL; | |
| 17 #endif | |
| 18 char *host = NULL, *user = NULL, *passwd = NULL, | |
| 19 *db = NULL, *unix_socket = NULL; | |
| 21 | 20 unsigned int port = 0; |
| 21 unsigned int client_flag = 0; | |
| 0 | 22 static char *kwlist[] = { "host", "user", "passwd", "db", "port", |
| 23 "unix_socket", "conv", | |
| 24 "connect_timeout", "compress", | |
| 25 "named_pipe", "init_command", | |
| 26 "read_default_file", "read_default_group", | |
| 27 "client_flag", "ssl", | |
| 28 "local_infile", | |
| 29 NULL } ; | |
| 30 int connect_timeout = 0; | |
| 31 int compress = -1, named_pipe = -1, local_infile = -1; | |
| 32 char *init_command=NULL, | |
| 33 *read_default_file=NULL, | |
| 34 *read_default_group=NULL; | |
| 35 | |
| 36 self->converter = NULL; | |
| 37 self->open = 0; | |
| 38 check_server_init(-1); | |
| 39 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ssssisOiiisssiOi:connect", | |
| 40 kwlist, | |
| 41 &host, &user, &passwd, &db, | |
| 42 &port, &unix_socket, &conv, | |
| 43 &connect_timeout, | |
| 44 &compress, &named_pipe, | |
| 45 &init_command, &read_default_file, | |
| 46 &read_default_group, | |
| 47 &client_flag, &ssl, | |
| 48 &local_infile | |
| 49 )) | |
| 50 return -1; | |
| 51 | |
| 29 | 52 /* Keep the converter mapping or a blank mapping dict */ |
| 53 if (!conv) | |
| 0 | 54 conv = PyDict_New(); |
| 55 else | |
| 56 Py_INCREF(conv); | |
| 57 if (!conv) | |
| 58 return -1; | |
| 59 self->converter = conv; | |
| 60 | |
| 61 #define _stringsuck(d,t,s) {t=PyMapping_GetItemString(s,#d);\ | |
| 62 if(t){d=PyString_AsString(t);Py_DECREF(t);}\ | |
| 63 PyErr_Clear();} | |
| 64 | |
| 65 if (ssl) { | |
| 66 #if HAVE_OPENSSL | |
| 67 PyObject *value = NULL; | |
| 68 _stringsuck(ca, value, ssl); | |
| 69 _stringsuck(capath, value, ssl); | |
| 70 _stringsuck(cert, value, ssl); | |
| 71 _stringsuck(key, value, ssl); | |
| 72 _stringsuck(cipher, value, ssl); | |
| 73 #else | |
| 74 PyErr_SetString(_mysql_NotSupportedError, | |
| 75 "client library does not have SSL support"); | |
| 76 return -1; | |
| 77 #endif | |
| 78 } | |
| 79 | |
| 80 Py_BEGIN_ALLOW_THREADS ; | |
| 81 conn = mysql_init(&(self->connection)); | |
| 82 if (connect_timeout) { | |
| 83 unsigned int timeout = connect_timeout; | |
| 84 mysql_options(&(self->connection), MYSQL_OPT_CONNECT_TIMEOUT, | |
| 85 (char *)&timeout); | |
| 86 } | |
| 87 if (compress != -1) { | |
| 88 mysql_options(&(self->connection), MYSQL_OPT_COMPRESS, 0); | |
| 89 client_flag |= CLIENT_COMPRESS; | |
| 90 } | |
| 91 if (named_pipe != -1) | |
| 92 mysql_options(&(self->connection), MYSQL_OPT_NAMED_PIPE, 0); | |
| 93 if (init_command != NULL) | |
| 94 mysql_options(&(self->connection), MYSQL_INIT_COMMAND, init_command); | |
| 95 if (read_default_file != NULL) | |
| 96 mysql_options(&(self->connection), MYSQL_READ_DEFAULT_FILE, read_default_file); | |
| 97 if (read_default_group != NULL) | |
| 98 mysql_options(&(self->connection), MYSQL_READ_DEFAULT_GROUP, read_default_group); | |
| 99 | |
| 100 if (local_infile != -1) | |
| 101 mysql_options(&(self->connection), MYSQL_OPT_LOCAL_INFILE, (char *) &local_infile); | |
| 102 | |
| 103 #if HAVE_OPENSSL | |
| 104 if (ssl) | |
| 105 mysql_ssl_set(&(self->connection), | |
| 106 key, cert, ca, capath, cipher); | |
| 107 #endif | |
| 108 | |
| 109 conn = mysql_real_connect(&(self->connection), host, user, passwd, db, | |
| 110 port, unix_socket, client_flag); | |
| 111 | |
| 112 Py_END_ALLOW_THREADS ; | |
| 113 | |
| 114 if (!conn) { | |
| 115 _mysql_Exception(self); | |
| 116 return -1; | |
| 117 } | |
| 118 /* | |
| 119 PyType_GenericAlloc() automatically sets up GC allocation and | |
| 120 tracking for GC objects, at least in 2.2.1, so it does not need to | |
| 121 be done here. tp_dealloc still needs to call PyObject_GC_UnTrack(), | |
| 122 however. | |
| 123 */ | |
| 124 self->open = 1; | |
| 125 return 0; | |
| 126 } | |
| 127 | |
|
2
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
128 char _mysql_connect__doc__[] = |
| 0 | 129 "Returns a MYSQL connection object. Exclusive use of\n\ |
| 130 keyword parameters strongly recommended. Consult the\n\ | |
| 131 MySQL C API documentation for more details.\n\ | |
| 132 \n\ | |
| 133 host\n\ | |
| 134 string, host to connect\n\ | |
| 135 \n\ | |
| 136 user\n\ | |
| 137 string, user to connect as\n\ | |
| 138 \n\ | |
| 139 passwd\n\ | |
| 140 string, password to use\n\ | |
| 141 \n\ | |
| 142 db\n\ | |
| 143 string, database to use\n\ | |
| 144 \n\ | |
| 145 port\n\ | |
| 146 integer, TCP/IP port to connect to\n\ | |
| 147 \n\ | |
| 148 unix_socket\n\ | |
| 149 string, location of unix_socket (UNIX-ish only)\n\ | |
| 150 \n\ | |
| 151 conv\n\ | |
| 152 mapping, maps MySQL FIELD_TYPE.* to Python functions which\n\ | |
| 153 convert a string to the appropriate Python type\n\ | |
| 154 \n\ | |
| 155 connect_timeout\n\ | |
| 156 number of seconds to wait before the connection\n\ | |
| 157 attempt fails.\n\ | |
| 158 \n\ | |
| 159 compress\n\ | |
| 160 if set, gzip compression is enabled\n\ | |
| 161 \n\ | |
| 162 named_pipe\n\ | |
| 163 if set, connect to server via named pipe (Windows only)\n\ | |
| 164 \n\ | |
| 165 init_command\n\ | |
| 166 command which is run once the connection is created\n\ | |
| 167 \n\ | |
| 168 read_default_file\n\ | |
| 169 see the MySQL documentation for mysql_options()\n\ | |
| 170 \n\ | |
| 171 read_default_group\n\ | |
| 172 see the MySQL documentation for mysql_options()\n\ | |
| 173 \n\ | |
| 174 client_flag\n\ | |
| 175 client flags from MySQLdb.constants.CLIENT\n\ | |
| 176 \n\ | |
| 177 load_infile\n\ | |
| 178 int, non-zero enables LOAD LOCAL INFILE, zero disables\n\ | |
| 179 \n\ | |
| 180 "; | |
| 181 | |
|
2
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
182 PyObject * |
| 0 | 183 _mysql_connect( |
| 184 PyObject *self, | |
| 185 PyObject *args, | |
| 186 PyObject *kwargs) | |
| 187 { | |
| 188 _mysql_ConnectionObject *c=NULL; | |
| 189 | |
| 190 c = MyAlloc(_mysql_ConnectionObject, _mysql_ConnectionObject_Type); | |
| 191 if (c == NULL) return NULL; | |
| 192 if (_mysql_ConnectionObject_Initialize(c, args, kwargs)) { | |
| 193 Py_DECREF(c); | |
| 194 c = NULL; | |
| 195 } | |
| 196 return (PyObject *) c; | |
| 197 } | |
| 198 | |
| 199 static int _mysql_ConnectionObject_traverse( | |
| 200 _mysql_ConnectionObject *self, | |
| 201 visitproc visit, | |
| 202 void *arg) | |
| 203 { | |
| 204 if (self->converter) | |
| 205 return visit(self->converter, arg); | |
| 206 return 0; | |
| 207 } | |
| 208 | |
| 209 static int _mysql_ConnectionObject_clear( | |
| 210 _mysql_ConnectionObject *self) | |
| 211 { | |
| 212 Py_XDECREF(self->converter); | |
| 213 self->converter = NULL; | |
| 214 return 0; | |
| 215 } | |
| 216 | |
|
2
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
217 extern PyObject * |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
218 _escape_item( |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
219 PyObject *item, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
220 PyObject *d); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
221 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
222 char _mysql_escape__doc__[] = |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
223 "escape(obj, dict) -- escape any special characters in object obj\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
224 using mapping dict to provide quoting functions for each type.\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
225 Returns a SQL literal string."; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
226 PyObject * |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
227 _mysql_escape( |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
228 PyObject *self, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
229 PyObject *args) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
230 { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
231 PyObject *o=NULL, *d=NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
232 if (!PyArg_ParseTuple(args, "O|O:escape", &o, &d)) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
233 return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
234 if (d) { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
235 if (!PyMapping_Check(d)) { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
236 PyErr_SetString(PyExc_TypeError, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
237 "argument 2 must be a mapping"); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
238 return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
239 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
240 return _escape_item(o, d); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
241 } else { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
242 if (!self) { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
243 PyErr_SetString(PyExc_TypeError, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
244 "argument 2 must be a mapping"); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
245 return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
246 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
247 return _escape_item(o, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
248 ((_mysql_ConnectionObject *) self)->converter); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
249 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
250 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
251 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
252 char _mysql_escape_string__doc__[] = |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
253 "escape_string(s) -- quote any SQL-interpreted characters in string s.\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
254 \n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
255 Use connection.escape_string(s), if you use it at all.\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
256 _mysql.escape_string(s) cannot handle character sets. You are\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
257 probably better off using connection.escape(o) instead, since\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
258 it will escape entire sequences as well as strings."; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
259 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
260 PyObject * |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
261 _mysql_escape_string( |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
262 _mysql_ConnectionObject *self, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
263 PyObject *args) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
264 { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
265 PyObject *str; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
266 char *in, *out; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
267 int len, size; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
268 if (!PyArg_ParseTuple(args, "s#:escape_string", &in, &size)) return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
269 str = PyString_FromStringAndSize((char *) NULL, size*2+1); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
270 if (!str) return PyErr_NoMemory(); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
271 out = PyString_AS_STRING(str); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
272 #if MYSQL_VERSION_ID < 32321 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
273 len = mysql_escape_string(out, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
274 #else |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
275 check_server_init(NULL); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
276 if (self && self->open) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
277 len = mysql_real_escape_string(&(self->connection), out, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
278 else |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
279 len = mysql_escape_string(out, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
280 #endif |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
281 if (_PyString_Resize(&str, len) < 0) return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
282 return (str); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
283 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
284 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
285 char _mysql_string_literal__doc__[] = |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
286 "string_literal(obj) -- converts object obj into a SQL string literal.\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
287 This means, any special SQL characters are escaped, and it is enclosed\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
288 within single quotes. In other words, it performs:\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
289 \n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
290 \"'%s'\" % escape_string(str(obj))\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
291 \n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
292 Use connection.string_literal(obj), if you use it at all.\n\ |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
293 _mysql.string_literal(obj) cannot handle character sets."; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
294 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
295 PyObject * |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
296 _mysql_string_literal( |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
297 _mysql_ConnectionObject *self, |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
298 PyObject *args) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
299 { |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
300 PyObject *str, *s, *o, *d; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
301 char *in, *out; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
302 int len, size; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
303 if (!PyArg_ParseTuple(args, "O|O:string_literal", &o, &d)) return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
304 s = PyObject_Str(o); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
305 if (!s) return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
306 in = PyString_AsString(s); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
307 size = PyString_GET_SIZE(s); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
308 str = PyString_FromStringAndSize((char *) NULL, size*2+3); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
309 if (!str) return PyErr_NoMemory(); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
310 out = PyString_AS_STRING(str); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
311 #if MYSQL_VERSION_ID < 32321 |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
312 len = mysql_escape_string(out+1, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
313 #else |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
314 check_server_init(NULL); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
315 if (self && self->open) |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
316 len = mysql_real_escape_string(&(self->connection), out+1, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
317 else |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
318 len = mysql_escape_string(out+1, in, size); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
319 #endif |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
320 *out = *(out+len+1) = '\''; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
321 if (_PyString_Resize(&str, len+2) < 0) return NULL; |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
322 Py_DECREF(s); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
323 return (str); |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
324 } |
|
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
325 |
| 0 | 326 static char _mysql_ConnectionObject_close__doc__[] = |
| 327 "Close the connection. No further activity possible."; | |
| 328 | |
| 329 static PyObject * | |
| 330 _mysql_ConnectionObject_close( | |
| 331 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
332 PyObject *unused) |
| 0 | 333 { |
| 334 if (self->open) { | |
| 335 Py_BEGIN_ALLOW_THREADS | |
| 336 mysql_close(&(self->connection)); | |
| 337 Py_END_ALLOW_THREADS | |
| 338 self->open = 0; | |
| 339 } else { | |
| 340 PyErr_SetString(_mysql_ProgrammingError, | |
| 341 "closing a closed connection"); | |
| 342 return NULL; | |
| 343 } | |
| 344 _mysql_ConnectionObject_clear(self); | |
| 345 Py_INCREF(Py_None); | |
| 346 return Py_None; | |
| 347 } | |
| 348 | |
| 349 static char _mysql_ConnectionObject_affected_rows__doc__ [] = | |
| 350 "Return number of rows affected by the last query.\n\ | |
| 351 Non-standard. Use Cursor.rowcount.\n\ | |
| 352 "; | |
| 353 | |
| 354 static PyObject * | |
| 355 _mysql_ConnectionObject_affected_rows( | |
| 356 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
357 PyObject *unused) |
| 0 | 358 { |
| 359 check_connection(self); | |
| 360 return PyLong_FromUnsignedLongLong(mysql_affected_rows(&(self->connection))); | |
| 361 } | |
| 362 | |
| 363 static char _mysql_ConnectionObject_dump_debug_info__doc__[] = | |
| 364 "Instructs the server to write some debug information to the\n\ | |
| 365 log. The connected user must have the process privilege for\n\ | |
| 366 this to work. Non-standard.\n\ | |
| 367 "; | |
| 368 | |
| 369 static PyObject * | |
| 370 _mysql_ConnectionObject_dump_debug_info( | |
| 371 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
372 PyObject *unused) |
| 0 | 373 { |
| 374 int err; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
375 |
| 0 | 376 check_connection(self); |
| 377 Py_BEGIN_ALLOW_THREADS | |
| 378 err = mysql_dump_debug_info(&(self->connection)); | |
| 379 Py_END_ALLOW_THREADS | |
| 380 if (err) return _mysql_Exception(self); | |
| 381 Py_INCREF(Py_None); | |
| 382 return Py_None; | |
| 383 } | |
| 384 | |
| 385 static char _mysql_ConnectionObject_autocommit__doc__[] = | |
| 386 "Set the autocommit mode. True values enable; False value disable.\n\ | |
| 387 "; | |
| 388 static PyObject * | |
| 389 _mysql_ConnectionObject_autocommit( | |
| 390 _mysql_ConnectionObject *self, | |
| 391 PyObject *args) | |
| 392 { | |
| 393 int flag, err; | |
| 394 if (!PyArg_ParseTuple(args, "i", &flag)) return NULL; | |
| 395 Py_BEGIN_ALLOW_THREADS | |
| 396 #if MYSQL_VERSION_ID >= 40100 | |
| 397 err = mysql_autocommit(&(self->connection), flag); | |
| 398 #else | |
| 399 { | |
| 400 char query[256]; | |
| 401 snprintf(query, 256, "SET AUTOCOMMIT=%d", flag); | |
| 402 err = mysql_query(&(self->connection), query); | |
| 403 } | |
| 404 #endif | |
| 405 Py_END_ALLOW_THREADS | |
| 406 if (err) return _mysql_Exception(self); | |
| 407 Py_INCREF(Py_None); | |
| 408 return Py_None; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
409 } |
| 0 | 410 |
| 411 static char _mysql_ConnectionObject_commit__doc__[] = | |
| 412 "Commits the current transaction\n\ | |
| 413 "; | |
| 414 static PyObject * | |
| 415 _mysql_ConnectionObject_commit( | |
| 416 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
417 PyObject *unused) |
| 0 | 418 { |
| 419 int err; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
420 |
| 0 | 421 Py_BEGIN_ALLOW_THREADS |
| 422 #if MYSQL_VERSION_ID >= 40100 | |
| 423 err = mysql_commit(&(self->connection)); | |
| 424 #else | |
| 425 err = mysql_query(&(self->connection), "COMMIT"); | |
| 426 #endif | |
| 427 Py_END_ALLOW_THREADS | |
| 428 if (err) return _mysql_Exception(self); | |
| 429 Py_INCREF(Py_None); | |
| 430 return Py_None; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
431 } |
| 0 | 432 |
| 433 static char _mysql_ConnectionObject_rollback__doc__[] = | |
| 434 "Rolls backs the current transaction\n\ | |
| 435 "; | |
| 436 static PyObject * | |
| 437 _mysql_ConnectionObject_rollback( | |
| 438 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
439 PyObject *unused) |
| 0 | 440 { |
| 441 int err; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
442 |
| 0 | 443 Py_BEGIN_ALLOW_THREADS |
| 444 #if MYSQL_VERSION_ID >= 40100 | |
| 445 err = mysql_rollback(&(self->connection)); | |
| 446 #else | |
| 447 err = mysql_query(&(self->connection), "ROLLBACK"); | |
| 448 #endif | |
| 449 Py_END_ALLOW_THREADS | |
| 450 if (err) return _mysql_Exception(self); | |
| 451 Py_INCREF(Py_None); | |
| 452 return Py_None; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
453 } |
| 0 | 454 |
| 455 static char _mysql_ConnectionObject_next_result__doc__[] = | |
| 456 "If more query results exist, next_result() reads the next query\n\ | |
| 457 results and returns the status back to application.\n\ | |
| 458 \n\ | |
| 459 After calling next_result() the state of the connection is as if\n\ | |
| 460 you had called query() for the next query. This means that you can\n\ | |
| 461 now call store_result(), warning_count(), affected_rows()\n\ | |
| 462 , and so forth. \n\ | |
| 463 \n\ | |
| 464 Returns 0 if there are more results; -1 if there are no more results\n\ | |
| 465 \n\ | |
| 466 Non-standard.\n\ | |
| 467 "; | |
| 468 static PyObject * | |
| 469 _mysql_ConnectionObject_next_result( | |
| 470 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
471 PyObject *unused) |
| 0 | 472 { |
| 473 int err; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
474 |
| 0 | 475 Py_BEGIN_ALLOW_THREADS |
| 476 #if MYSQL_VERSION_ID >= 40100 | |
| 477 err = mysql_next_result(&(self->connection)); | |
| 478 #else | |
| 479 err = -1; | |
| 480 #endif | |
| 481 Py_END_ALLOW_THREADS | |
| 482 if (err > 0) return _mysql_Exception(self); | |
| 483 return PyInt_FromLong(err); | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
484 } |
| 0 | 485 |
| 486 #if MYSQL_VERSION_ID >= 40100 | |
| 487 | |
| 488 static char _mysql_ConnectionObject_set_server_option__doc__[] = | |
| 489 "set_server_option(option) -- Enables or disables an option\n\ | |
| 490 for the connection.\n\ | |
| 491 \n\ | |
| 492 Non-standard.\n\ | |
| 493 "; | |
| 494 static PyObject * | |
| 495 _mysql_ConnectionObject_set_server_option( | |
| 496 _mysql_ConnectionObject *self, | |
| 497 PyObject *args) | |
| 498 { | |
| 499 int err, flags=0; | |
| 500 if (!PyArg_ParseTuple(args, "i", &flags)) | |
| 501 return NULL; | |
| 502 Py_BEGIN_ALLOW_THREADS | |
| 503 err = mysql_set_server_option(&(self->connection), flags); | |
| 504 Py_END_ALLOW_THREADS | |
| 505 if (err) return _mysql_Exception(self); | |
| 506 return PyInt_FromLong(err); | |
| 507 } | |
| 508 | |
| 509 static char _mysql_ConnectionObject_sqlstate__doc__[] = | |
| 510 "Returns a string containing the SQLSTATE error code\n\ | |
| 511 for the last error. The error code consists of five characters.\n\ | |
| 512 '00000' means \"no error.\" The values are specified by ANSI SQL\n\ | |
| 513 and ODBC. For a list of possible values, see section 23\n\ | |
| 514 Error Handling in MySQL in the MySQL Manual.\n\ | |
| 515 \n\ | |
| 516 Note that not all MySQL errors are yet mapped to SQLSTATE's.\n\ | |
| 517 The value 'HY000' (general error) is used for unmapped errors.\n\ | |
| 518 \n\ | |
| 519 Non-standard.\n\ | |
| 520 "; | |
| 521 static PyObject * | |
| 522 _mysql_ConnectionObject_sqlstate( | |
| 523 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
524 PyObject *unused) |
| 0 | 525 { |
| 526 return PyString_FromString(mysql_sqlstate(&(self->connection))); | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
527 } |
| 0 | 528 |
| 529 static char _mysql_ConnectionObject_warning_count__doc__[] = | |
| 530 "Returns the number of warnings generated during execution\n\ | |
| 531 of the previous SQL statement.\n\ | |
| 532 \n\ | |
| 533 Non-standard.\n\ | |
| 534 "; | |
| 535 static PyObject * | |
| 536 _mysql_ConnectionObject_warning_count( | |
| 537 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
538 PyObject *unused) |
| 0 | 539 { |
| 540 return PyInt_FromLong(mysql_warning_count(&(self->connection))); | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
541 } |
| 0 | 542 |
| 543 #endif | |
| 544 | |
| 545 static char _mysql_ConnectionObject_errno__doc__[] = | |
| 546 "Returns the error code for the most recently invoked API function\n\ | |
| 547 that can succeed or fail. A return value of zero means that no error\n\ | |
| 548 occurred.\n\ | |
| 549 "; | |
| 550 | |
| 551 static PyObject * | |
| 552 _mysql_ConnectionObject_errno( | |
| 553 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
554 PyObject *unused) |
| 0 | 555 { |
| 556 check_connection(self); | |
| 557 return PyInt_FromLong((long)mysql_errno(&(self->connection))); | |
| 558 } | |
| 559 | |
| 560 static char _mysql_ConnectionObject_error__doc__[] = | |
| 561 "Returns the error message for the most recently invoked API function\n\ | |
| 562 that can succeed or fail. An empty string ("") is returned if no error\n\ | |
| 563 occurred.\n\ | |
| 564 "; | |
| 565 | |
| 566 static PyObject * | |
| 567 _mysql_ConnectionObject_error( | |
| 568 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
569 PyObject *unused) |
| 0 | 570 { |
| 571 check_connection(self); | |
| 572 return PyString_FromString(mysql_error(&(self->connection))); | |
| 573 } | |
| 574 | |
| 575 #if MYSQL_VERSION_ID >= 32303 | |
| 576 | |
| 577 static char _mysql_ConnectionObject_change_user__doc__[] = | |
| 578 "Changes the user and causes the database specified by db to\n\ | |
| 579 become the default (current) database on the connection\n\ | |
| 580 specified by mysql. In subsequent queries, this database is\n\ | |
| 581 the default for table references that do not include an\n\ | |
| 582 explicit database specifier.\n\ | |
| 583 \n\ | |
| 584 This function was introduced in MySQL Version 3.23.3.\n\ | |
| 585 \n\ | |
| 586 Fails unless the connected user can be authenticated or if he\n\ | |
| 587 doesn't have permission to use the database. In this case the\n\ | |
| 588 user and database are not changed.\n\ | |
| 589 \n\ | |
| 590 The db parameter may be set to None if you don't want to have\n\ | |
| 591 a default database.\n\ | |
| 592 "; | |
| 593 | |
| 594 static PyObject * | |
| 595 _mysql_ConnectionObject_change_user( | |
| 596 _mysql_ConnectionObject *self, | |
| 597 PyObject *args, | |
| 598 PyObject *kwargs) | |
| 599 { | |
| 600 char *user, *pwd=NULL, *db=NULL; | |
| 601 int r; | |
| 602 static char *kwlist[] = { "user", "passwd", "db", NULL } ; | |
| 603 | |
| 604 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "s|ss:change_user", | |
| 605 kwlist, &user, &pwd, &db)) | |
| 606 return NULL; | |
| 607 check_connection(self); | |
| 608 Py_BEGIN_ALLOW_THREADS | |
| 609 r = mysql_change_user(&(self->connection), user, pwd, db); | |
| 610 Py_END_ALLOW_THREADS | |
| 611 if (r) return _mysql_Exception(self); | |
| 612 Py_INCREF(Py_None); | |
| 613 return Py_None; | |
| 614 } | |
| 615 #endif | |
| 616 | |
| 617 static char _mysql_ConnectionObject_character_set_name__doc__[] = | |
| 618 "Returns the default character set for the current connection.\n\ | |
| 619 Non-standard.\n\ | |
| 620 "; | |
| 621 | |
| 622 static PyObject * | |
| 623 _mysql_ConnectionObject_character_set_name( | |
| 624 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
625 PyObject *unused) |
| 0 | 626 { |
| 627 const char *s; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
628 |
| 0 | 629 check_connection(self); |
| 630 #if MYSQL_VERSION_ID >= 32321 | |
| 631 s = mysql_character_set_name(&(self->connection)); | |
| 632 #else | |
| 633 s = "latin1"; | |
| 634 #endif | |
| 635 return PyString_FromString(s); | |
| 636 } | |
| 637 | |
| 638 #if MYSQL_VERSION_ID >= 50007 | |
| 639 static char _mysql_ConnectionObject_set_character_set__doc__[] = | |
| 640 "Sets the default character set for the current connection.\n\ | |
| 641 Non-standard.\n\ | |
| 642 "; | |
| 643 | |
| 644 static PyObject * | |
| 645 _mysql_ConnectionObject_set_character_set( | |
| 646 _mysql_ConnectionObject *self, | |
| 647 PyObject *args) | |
| 648 { | |
| 649 const char *s; | |
| 650 int err; | |
| 651 if (!PyArg_ParseTuple(args, "s", &s)) return NULL; | |
| 652 check_connection(self); | |
| 653 Py_BEGIN_ALLOW_THREADS | |
| 654 err = mysql_set_character_set(&(self->connection), s); | |
| 655 Py_END_ALLOW_THREADS | |
| 656 if (err) return _mysql_Exception(self); | |
| 657 Py_INCREF(Py_None); | |
| 658 return Py_None; | |
| 659 } | |
| 660 #endif | |
| 661 | |
| 662 #if MYSQL_VERSION_ID >= 50010 | |
| 663 static char _mysql_ConnectionObject_get_character_set_info__doc__[] = | |
| 664 "Returns a dict with information about the current character set:\n\ | |
| 665 \n\ | |
| 666 collation\n\ | |
| 667 collation name\n\ | |
| 668 name\n\ | |
| 669 character set name\n\ | |
| 670 comment\n\ | |
| 671 comment or descriptive name\n\ | |
| 672 dir\n\ | |
| 673 character set directory\n\ | |
| 674 mbminlen\n\ | |
| 675 min. length for multibyte string\n\ | |
| 676 mbmaxlen\n\ | |
| 677 max. length for multibyte string\n\ | |
| 678 \n\ | |
| 679 Not all keys may be present, particularly dir.\n\ | |
| 680 \n\ | |
| 681 Non-standard.\n\ | |
| 682 "; | |
| 683 | |
| 684 static PyObject * | |
| 685 _mysql_ConnectionObject_get_character_set_info( | |
| 686 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
687 PyObject *unused) |
| 0 | 688 { |
| 689 PyObject *result; | |
| 690 MY_CHARSET_INFO cs; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
691 |
| 0 | 692 check_connection(self); |
| 693 mysql_get_character_set_info(&(self->connection), &cs); | |
| 694 if (!(result = PyDict_New())) return NULL; | |
| 695 if (cs.csname) | |
| 696 PyDict_SetItemString(result, "name", PyString_FromString(cs.csname)); | |
| 697 if (cs.name) | |
| 698 PyDict_SetItemString(result, "collation", PyString_FromString(cs.name)); | |
| 699 if (cs.comment) | |
| 700 PyDict_SetItemString(result, "comment", PyString_FromString(cs.comment)); | |
| 701 if (cs.dir) | |
| 702 PyDict_SetItemString(result, "dir", PyString_FromString(cs.dir)); | |
| 703 PyDict_SetItemString(result, "mbminlen", PyInt_FromLong(cs.mbminlen)); | |
| 704 PyDict_SetItemString(result, "mbmaxlen", PyInt_FromLong(cs.mbmaxlen)); | |
| 705 return result; | |
| 706 } | |
| 707 #endif | |
| 708 | |
| 709 static char _mysql_ConnectionObject_get_host_info__doc__[] = | |
| 710 "Returns a string that represents the MySQL client library\n\ | |
| 711 version. Non-standard.\n\ | |
| 712 "; | |
| 713 | |
| 714 static PyObject * | |
| 715 _mysql_ConnectionObject_get_host_info( | |
| 716 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
717 PyObject *unused) |
| 0 | 718 { |
| 719 check_connection(self); | |
| 720 return PyString_FromString(mysql_get_host_info(&(self->connection))); | |
| 721 } | |
| 722 | |
| 723 static char _mysql_ConnectionObject_get_proto_info__doc__[] = | |
| 724 "Returns an unsigned integer representing the protocol version\n\ | |
| 725 used by the current connection. Non-standard.\n\ | |
| 726 "; | |
| 727 | |
| 728 static PyObject * | |
| 729 _mysql_ConnectionObject_get_proto_info( | |
| 730 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
731 PyObject *unused) |
| 0 | 732 { |
| 733 check_connection(self); | |
| 734 return PyInt_FromLong((long)mysql_get_proto_info(&(self->connection))); | |
| 735 } | |
| 736 | |
| 737 static char _mysql_ConnectionObject_get_server_info__doc__[] = | |
| 738 "Returns a string that represents the server version number.\n\ | |
| 739 Non-standard.\n\ | |
| 740 "; | |
| 741 | |
| 742 static PyObject * | |
| 743 _mysql_ConnectionObject_get_server_info( | |
| 744 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
745 PyObject *unused) |
| 0 | 746 { |
| 747 check_connection(self); | |
| 748 return PyString_FromString(mysql_get_server_info(&(self->connection))); | |
| 749 } | |
| 750 | |
| 751 static char _mysql_ConnectionObject_info__doc__[] = | |
| 752 "Retrieves a string providing information about the most\n\ | |
| 753 recently executed query. Non-standard. Use messages or\n\ | |
| 754 Cursor.messages.\n\ | |
| 755 "; | |
| 756 | |
| 757 static PyObject * | |
| 758 _mysql_ConnectionObject_info( | |
| 759 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
760 PyObject *unused) |
| 0 | 761 { |
| 762 const char *s; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
763 |
| 0 | 764 check_connection(self); |
| 765 s = mysql_info(&(self->connection)); | |
| 766 if (s) return PyString_FromString(s); | |
| 767 Py_INCREF(Py_None); | |
| 768 return Py_None; | |
| 769 } | |
| 770 | |
| 771 static char _mysql_ConnectionObject_insert_id__doc__[] = | |
| 772 "Returns the ID generated for an AUTO_INCREMENT column by the previous\n\ | |
| 773 query. Use this function after you have performed an INSERT query into a\n\ | |
| 774 table that contains an AUTO_INCREMENT field.\n\ | |
| 775 \n\ | |
| 776 Note that this returns 0 if the previous query does not\n\ | |
| 777 generate an AUTO_INCREMENT value. If you need to save the value for\n\ | |
| 778 later, be sure to call this immediately after the query\n\ | |
| 779 that generates the value.\n\ | |
| 780 \n\ | |
| 781 The ID is updated after INSERT and UPDATE statements that generate\n\ | |
| 782 an AUTO_INCREMENT value or that set a column value to\n\ | |
| 783 LAST_INSERT_ID(expr). See section 6.3.5.2 Miscellaneous Functions\n\ | |
| 784 in the MySQL documentation.\n\ | |
| 785 \n\ | |
| 786 Also note that the value of the SQL LAST_INSERT_ID() function always\n\ | |
| 787 contains the most recently generated AUTO_INCREMENT value, and is not\n\ | |
| 788 reset between queries because the value of that function is maintained\n\ | |
| 789 in the server.\n\ | |
| 790 " ; | |
| 791 | |
| 792 static PyObject * | |
| 793 _mysql_ConnectionObject_insert_id( | |
| 794 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
795 PyObject *unused) |
| 0 | 796 { |
| 797 my_ulonglong r; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
798 |
| 0 | 799 check_connection(self); |
| 800 Py_BEGIN_ALLOW_THREADS | |
| 801 r = mysql_insert_id(&(self->connection)); | |
| 802 Py_END_ALLOW_THREADS | |
| 803 return PyLong_FromUnsignedLongLong(r); | |
| 804 } | |
| 805 | |
| 806 static char _mysql_ConnectionObject_kill__doc__[] = | |
| 807 "Asks the server to kill the thread specified by pid.\n\ | |
| 808 Non-standard."; | |
| 809 | |
| 810 static PyObject * | |
| 811 _mysql_ConnectionObject_kill( | |
| 812 _mysql_ConnectionObject *self, | |
| 813 PyObject *args) | |
| 814 { | |
| 815 unsigned long pid; | |
| 816 int r; | |
| 817 if (!PyArg_ParseTuple(args, "i:kill", &pid)) return NULL; | |
| 818 check_connection(self); | |
| 819 Py_BEGIN_ALLOW_THREADS | |
| 820 r = mysql_kill(&(self->connection), pid); | |
| 821 Py_END_ALLOW_THREADS | |
| 822 if (r) return _mysql_Exception(self); | |
| 823 Py_INCREF(Py_None); | |
| 824 return Py_None; | |
| 825 } | |
| 826 | |
| 827 static char _mysql_ConnectionObject_field_count__doc__[] = | |
| 828 "Returns the number of columns for the most recent query on the\n\ | |
| 829 connection. Non-standard. Will probably give you bogus results\n\ | |
| 830 on most cursor classes. Use Cursor.rowcount.\n\ | |
| 831 "; | |
| 832 | |
| 833 static PyObject * | |
| 834 _mysql_ConnectionObject_field_count( | |
| 835 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
836 PyObject *unused) |
| 0 | 837 { |
| 838 check_connection(self); | |
| 839 #if MYSQL_VERSION_ID < 32224 | |
| 840 return PyInt_FromLong((long)mysql_num_fields(&(self->connection))); | |
| 841 #else | |
| 842 return PyInt_FromLong((long)mysql_field_count(&(self->connection))); | |
| 843 #endif | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
844 } |
| 0 | 845 |
| 846 static char _mysql_ConnectionObject_ping__doc__[] = | |
| 847 "Checks whether or not the connection to the server is\n\ | |
| 848 working. If it has gone down, an automatic reconnection is\n\ | |
| 849 attempted.\n\ | |
| 850 \n\ | |
| 851 This function can be used by clients that remain idle for a\n\ | |
| 852 long while, to check whether or not the server has closed the\n\ | |
| 853 connection and reconnect if necessary.\n\ | |
| 854 \n\ | |
| 5 | 855 New in 1.2.2: Accepts an optional reconnect parameter. If True,\n\ |
| 856 then the client will attempt reconnection. Note that this setting\n\ | |
| 857 is persistent. By default, this is on in MySQL<5.0.3, and off\n\ | |
| 858 thereafter.\n\ | |
| 859 \n\ | |
| 860 Non-standard. You should assume that ping() performs an\n\ | |
| 861 implicit rollback; use only when starting a new transaction.\n\ | |
| 862 You have been warned.\n\ | |
| 0 | 863 "; |
| 864 | |
| 865 static PyObject * | |
| 866 _mysql_ConnectionObject_ping( | |
| 867 _mysql_ConnectionObject *self, | |
| 868 PyObject *args) | |
| 869 { | |
| 5 | 870 int r, reconnect = -1; |
| 871 if (!PyArg_ParseTuple(args, "|I", &reconnect)) return NULL; | |
| 0 | 872 check_connection(self); |
| 5 | 873 if ( reconnect != -1 ) self->connection.reconnect = reconnect; |
| 0 | 874 Py_BEGIN_ALLOW_THREADS |
| 875 r = mysql_ping(&(self->connection)); | |
| 876 Py_END_ALLOW_THREADS | |
| 877 if (r) return _mysql_Exception(self); | |
| 878 Py_INCREF(Py_None); | |
| 879 return Py_None; | |
| 880 } | |
| 881 | |
| 882 static char _mysql_ConnectionObject_query__doc__[] = | |
| 883 "Execute a query. store_result() or use_result() will get the\n\ | |
| 884 result set, if any. Non-standard. Use cursor() to create a cursor,\n\ | |
| 885 then cursor.execute().\n\ | |
| 886 " ; | |
| 887 | |
| 888 static PyObject * | |
| 889 _mysql_ConnectionObject_query( | |
| 890 _mysql_ConnectionObject *self, | |
| 891 PyObject *args) | |
| 892 { | |
| 893 char *query; | |
| 894 int len, r; | |
| 895 if (!PyArg_ParseTuple(args, "s#:query", &query, &len)) return NULL; | |
| 896 check_connection(self); | |
| 897 Py_BEGIN_ALLOW_THREADS | |
| 898 r = mysql_real_query(&(self->connection), query, len); | |
| 899 Py_END_ALLOW_THREADS | |
| 900 if (r) return _mysql_Exception(self); | |
| 901 Py_INCREF(Py_None); | |
| 902 return Py_None; | |
| 903 } | |
| 904 | |
| 905 | |
| 906 static char _mysql_ConnectionObject_select_db__doc__[] = | |
| 907 "Causes the database specified by db to become the default\n\ | |
| 908 (current) database on the connection specified by mysql. In subsequent\n\ | |
| 909 queries, this database is the default for table references that do not\n\ | |
| 910 include an explicit database specifier.\n\ | |
| 911 \n\ | |
| 912 Fails unless the connected user can be authenticated as having\n\ | |
| 913 permission to use the database.\n\ | |
| 914 \n\ | |
| 915 Non-standard.\n\ | |
| 916 "; | |
| 917 | |
| 918 static PyObject * | |
| 919 _mysql_ConnectionObject_select_db( | |
| 920 _mysql_ConnectionObject *self, | |
| 921 PyObject *args) | |
| 922 { | |
| 923 char *db; | |
| 924 int r; | |
| 925 if (!PyArg_ParseTuple(args, "s:select_db", &db)) return NULL; | |
| 926 check_connection(self); | |
| 927 Py_BEGIN_ALLOW_THREADS | |
| 928 r = mysql_select_db(&(self->connection), db); | |
| 929 Py_END_ALLOW_THREADS | |
| 930 if (r) return _mysql_Exception(self); | |
| 931 Py_INCREF(Py_None); | |
| 932 return Py_None; | |
| 933 } | |
| 934 | |
| 935 static char _mysql_ConnectionObject_shutdown__doc__[] = | |
| 936 "Asks the database server to shut down. The connected user must\n\ | |
| 937 have shutdown privileges. Non-standard.\n\ | |
| 938 "; | |
| 939 | |
| 940 static PyObject * | |
| 941 _mysql_ConnectionObject_shutdown( | |
| 942 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
943 PyObject *unused) |
| 0 | 944 { |
| 945 int r; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
946 |
| 0 | 947 check_connection(self); |
| 948 Py_BEGIN_ALLOW_THREADS | |
| 949 r = mysql_shutdown(&(self->connection) | |
| 950 #if MYSQL_VERSION_ID >= 40103 | |
| 951 , SHUTDOWN_DEFAULT | |
| 952 #endif | |
| 953 ); | |
| 954 Py_END_ALLOW_THREADS | |
| 955 if (r) return _mysql_Exception(self); | |
| 956 Py_INCREF(Py_None); | |
| 957 return Py_None; | |
| 958 } | |
| 959 | |
| 960 static char _mysql_ConnectionObject_stat__doc__[] = | |
| 961 "Returns a character string containing information similar to\n\ | |
| 962 that provided by the mysqladmin status command. This includes\n\ | |
| 963 uptime in seconds and the number of running threads,\n\ | |
| 964 questions, reloads, and open tables. Non-standard.\n\ | |
| 965 "; | |
| 966 | |
| 967 static PyObject * | |
| 968 _mysql_ConnectionObject_stat( | |
| 969 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
970 PyObject *unused) |
| 0 | 971 { |
| 972 const char *s; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
973 |
| 0 | 974 check_connection(self); |
| 975 Py_BEGIN_ALLOW_THREADS | |
| 976 s = mysql_stat(&(self->connection)); | |
| 977 Py_END_ALLOW_THREADS | |
| 978 if (!s) return _mysql_Exception(self); | |
| 979 return PyString_FromString(s); | |
| 980 } | |
| 981 | |
| 982 static char _mysql_ConnectionObject_store_result__doc__[] = | |
| 983 "Returns a result object acquired by mysql_store_result\n\ | |
| 984 (results stored in the client). If no results are available,\n\ | |
| 985 None is returned. Non-standard.\n\ | |
| 986 "; | |
| 987 | |
| 988 static PyObject * | |
| 989 _mysql_ConnectionObject_store_result( | |
| 990 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
991 PyObject *unused) |
| 0 | 992 { |
| 993 PyObject *arglist=NULL, *kwarglist=NULL, *result=NULL; | |
| 994 _mysql_ResultObject *r=NULL; | |
| 995 | |
| 996 check_connection(self); | |
| 997 arglist = Py_BuildValue("(OiO)", self, 0, self->converter); | |
| 998 if (!arglist) goto error; | |
| 999 kwarglist = PyDict_New(); | |
| 1000 if (!kwarglist) goto error; | |
| 1001 r = MyAlloc(_mysql_ResultObject, _mysql_ResultObject_Type); | |
| 1002 if (!r) goto error; | |
| 1003 if (_mysql_ResultObject_Initialize(r, arglist, kwarglist)) | |
| 1004 goto error; | |
| 1005 result = (PyObject *) r; | |
| 1006 if (!(r->result)) { | |
| 1007 Py_DECREF(result); | |
| 1008 Py_INCREF(Py_None); | |
| 1009 result = Py_None; | |
| 1010 } | |
| 1011 error: | |
| 1012 Py_XDECREF(arglist); | |
| 1013 Py_XDECREF(kwarglist); | |
| 1014 return result; | |
| 1015 } | |
| 1016 | |
| 1017 static char _mysql_ConnectionObject_thread_id__doc__[] = | |
| 1018 "Returns the thread ID of the current connection. This value\n\ | |
| 1019 can be used as an argument to kill() to kill the thread.\n\ | |
| 1020 \n\ | |
| 1021 If the connection is lost and you reconnect with ping(), the\n\ | |
| 1022 thread ID will change. This means you should not get the\n\ | |
| 1023 thread ID and store it for later. You should get it when you\n\ | |
| 1024 need it.\n\ | |
| 1025 \n\ | |
| 1026 Non-standard."; | |
| 1027 | |
| 1028 static PyObject * | |
| 1029 _mysql_ConnectionObject_thread_id( | |
| 1030 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1031 PyObject *unused) |
| 0 | 1032 { |
| 1033 unsigned long pid; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1034 |
| 0 | 1035 check_connection(self); |
| 1036 Py_BEGIN_ALLOW_THREADS | |
| 1037 pid = mysql_thread_id(&(self->connection)); | |
| 1038 Py_END_ALLOW_THREADS | |
| 1039 return PyInt_FromLong((long)pid); | |
| 1040 } | |
| 1041 | |
| 1042 static char _mysql_ConnectionObject_use_result__doc__[] = | |
| 1043 "Returns a result object acquired by mysql_use_result\n\ | |
| 1044 (results stored in the server). If no results are available,\n\ | |
| 1045 None is returned. Non-standard.\n\ | |
| 1046 "; | |
| 1047 | |
| 1048 static PyObject * | |
| 1049 _mysql_ConnectionObject_use_result( | |
| 1050 _mysql_ConnectionObject *self, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1051 PyObject *unused) |
| 0 | 1052 { |
| 1053 PyObject *arglist=NULL, *kwarglist=NULL, *result=NULL; | |
| 1054 _mysql_ResultObject *r=NULL; | |
| 1055 | |
| 1056 check_connection(self); | |
| 1057 arglist = Py_BuildValue("(OiO)", self, 1, self->converter); | |
| 1058 if (!arglist) return NULL; | |
| 1059 kwarglist = PyDict_New(); | |
| 1060 if (!kwarglist) goto error; | |
| 1061 r = MyAlloc(_mysql_ResultObject, _mysql_ResultObject_Type); | |
| 1062 if (!r) goto error; | |
| 1063 result = (PyObject *) r; | |
| 1064 if (_mysql_ResultObject_Initialize(r, arglist, kwarglist)) | |
| 1065 goto error; | |
| 1066 if (!(r->result)) { | |
| 1067 Py_DECREF(result); | |
| 1068 Py_INCREF(Py_None); | |
| 1069 result = Py_None; | |
| 1070 } | |
| 1071 error: | |
| 1072 Py_DECREF(arglist); | |
| 1073 Py_XDECREF(kwarglist); | |
| 1074 return result; | |
| 1075 } | |
| 1076 | |
| 1077 static void | |
| 1078 _mysql_ConnectionObject_dealloc( | |
| 1079 _mysql_ConnectionObject *self) | |
| 1080 { | |
| 1081 PyObject *o; | |
| 1082 | |
| 1083 PyObject_GC_UnTrack(self); | |
| 1084 if (self->open) { | |
| 1085 o = _mysql_ConnectionObject_close(self, NULL); | |
| 1086 Py_XDECREF(o); | |
| 1087 } | |
| 1088 MyFree(self); | |
| 1089 } | |
| 1090 | |
| 1091 static PyObject * | |
| 1092 _mysql_ConnectionObject_repr( | |
| 1093 _mysql_ConnectionObject *self) | |
| 1094 { | |
| 1095 char buf[300]; | |
| 1096 if (self->open) | |
| 1097 sprintf(buf, "<_mysql.connection open to '%.256s' at %lx>", | |
| 1098 self->connection.host, | |
| 1099 (long)self); | |
| 1100 else | |
| 1101 sprintf(buf, "<_mysql.connection closed at %lx>", | |
| 1102 (long)self); | |
| 1103 return PyString_FromString(buf); | |
| 1104 } | |
| 1105 | |
| 1106 static PyMethodDef _mysql_ConnectionObject_methods[] = { | |
| 1107 { | |
| 1108 "affected_rows", | |
| 1109 (PyCFunction)_mysql_ConnectionObject_affected_rows, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1110 METH_NOARGS, |
| 0 | 1111 _mysql_ConnectionObject_affected_rows__doc__ |
| 1112 }, | |
| 1113 { | |
| 1114 "autocommit", | |
| 1115 (PyCFunction)_mysql_ConnectionObject_autocommit, | |
| 1116 METH_VARARGS, | |
| 1117 _mysql_ConnectionObject_autocommit__doc__ | |
| 1118 }, | |
| 1119 { | |
| 1120 "commit", | |
| 1121 (PyCFunction)_mysql_ConnectionObject_commit, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1122 METH_NOARGS, |
| 0 | 1123 _mysql_ConnectionObject_commit__doc__ |
| 1124 }, | |
| 1125 { | |
| 1126 "rollback", | |
| 1127 (PyCFunction)_mysql_ConnectionObject_rollback, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1128 METH_NOARGS, |
| 0 | 1129 _mysql_ConnectionObject_rollback__doc__ |
| 1130 }, | |
| 1131 { | |
| 1132 "next_result", | |
| 1133 (PyCFunction)_mysql_ConnectionObject_next_result, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1134 METH_NOARGS, |
| 0 | 1135 _mysql_ConnectionObject_next_result__doc__ |
| 1136 }, | |
| 1137 #if MYSQL_VERSION_ID >= 40100 | |
| 1138 { | |
| 1139 "set_server_option", | |
| 1140 (PyCFunction)_mysql_ConnectionObject_set_server_option, | |
| 1141 METH_VARARGS, | |
| 1142 _mysql_ConnectionObject_set_server_option__doc__ | |
| 1143 }, | |
| 1144 { | |
| 1145 "sqlstate", | |
| 1146 (PyCFunction)_mysql_ConnectionObject_sqlstate, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1147 METH_NOARGS, |
| 0 | 1148 _mysql_ConnectionObject_sqlstate__doc__ |
| 1149 }, | |
| 1150 { | |
| 1151 "warning_count", | |
| 1152 (PyCFunction)_mysql_ConnectionObject_warning_count, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1153 METH_NOARGS, |
| 0 | 1154 _mysql_ConnectionObject_warning_count__doc__ |
| 1155 }, | |
| 1156 #endif | |
| 1157 #if MYSQL_VERSION_ID >= 32303 | |
| 1158 { | |
| 1159 "change_user", | |
| 1160 (PyCFunction)_mysql_ConnectionObject_change_user, | |
| 1161 METH_VARARGS | METH_KEYWORDS, | |
| 1162 _mysql_ConnectionObject_change_user__doc__ | |
| 1163 }, | |
| 1164 #endif | |
| 1165 { | |
| 1166 "character_set_name", | |
| 1167 (PyCFunction)_mysql_ConnectionObject_character_set_name, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1168 METH_NOARGS, |
| 0 | 1169 _mysql_ConnectionObject_character_set_name__doc__ |
| 1170 }, | |
| 1171 #if MYSQL_VERSION_ID >= 50007 | |
| 1172 { | |
| 1173 "set_character_set", | |
| 1174 (PyCFunction)_mysql_ConnectionObject_set_character_set, | |
| 1175 METH_VARARGS, | |
| 1176 _mysql_ConnectionObject_set_character_set__doc__ | |
| 1177 }, | |
| 1178 #endif | |
| 1179 #if MYSQL_VERSION_ID >= 50010 | |
| 1180 { | |
| 1181 "get_character_set_info", | |
| 1182 (PyCFunction)_mysql_ConnectionObject_get_character_set_info, | |
| 1183 METH_VARARGS, | |
| 1184 _mysql_ConnectionObject_get_character_set_info__doc__ | |
| 1185 }, | |
| 1186 #endif | |
| 1187 { | |
| 1188 "close", | |
| 1189 (PyCFunction)_mysql_ConnectionObject_close, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1190 METH_NOARGS, |
| 0 | 1191 _mysql_ConnectionObject_close__doc__ |
| 1192 }, | |
| 1193 { | |
| 1194 "dump_debug_info", | |
| 1195 (PyCFunction)_mysql_ConnectionObject_dump_debug_info, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1196 METH_NOARGS, |
| 0 | 1197 _mysql_ConnectionObject_dump_debug_info__doc__ |
| 1198 }, | |
| 1199 { | |
| 1200 "escape", | |
| 1201 (PyCFunction)_mysql_escape, | |
| 1202 METH_VARARGS, | |
| 1203 _mysql_escape__doc__ | |
| 1204 }, | |
| 1205 { | |
| 1206 "escape_string", | |
| 1207 (PyCFunction)_mysql_escape_string, | |
| 1208 METH_VARARGS, | |
| 1209 _mysql_escape_string__doc__ | |
| 1210 }, | |
| 1211 { | |
| 1212 "error", | |
| 1213 (PyCFunction)_mysql_ConnectionObject_error, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1214 METH_NOARGS, |
| 0 | 1215 _mysql_ConnectionObject_error__doc__ |
| 1216 }, | |
| 1217 { | |
| 1218 "errno", | |
| 1219 (PyCFunction)_mysql_ConnectionObject_errno, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1220 METH_NOARGS, |
| 0 | 1221 _mysql_ConnectionObject_errno__doc__ |
| 1222 }, | |
| 1223 { | |
| 1224 "field_count", | |
| 1225 (PyCFunction)_mysql_ConnectionObject_field_count, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1226 METH_NOARGS, |
| 0 | 1227 _mysql_ConnectionObject_field_count__doc__ |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1228 }, |
| 0 | 1229 { |
| 1230 "get_host_info", | |
| 1231 (PyCFunction)_mysql_ConnectionObject_get_host_info, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1232 METH_NOARGS, |
| 0 | 1233 _mysql_ConnectionObject_get_host_info__doc__ |
| 1234 }, | |
| 1235 { | |
| 1236 "get_proto_info", | |
| 1237 (PyCFunction)_mysql_ConnectionObject_get_proto_info, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1238 METH_NOARGS, |
| 0 | 1239 _mysql_ConnectionObject_get_proto_info__doc__ |
| 1240 }, | |
| 1241 { | |
| 1242 "get_server_info", | |
| 1243 (PyCFunction)_mysql_ConnectionObject_get_server_info, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1244 METH_NOARGS, |
| 0 | 1245 _mysql_ConnectionObject_get_server_info__doc__ |
| 1246 }, | |
| 1247 { | |
| 1248 "info", | |
| 1249 (PyCFunction)_mysql_ConnectionObject_info, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1250 METH_NOARGS, |
| 0 | 1251 _mysql_ConnectionObject_info__doc__ |
| 1252 }, | |
| 1253 { | |
| 1254 "insert_id", | |
| 1255 (PyCFunction)_mysql_ConnectionObject_insert_id, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1256 METH_NOARGS, |
| 0 | 1257 _mysql_ConnectionObject_insert_id__doc__ |
| 1258 }, | |
| 1259 { | |
| 1260 "kill", | |
| 1261 (PyCFunction)_mysql_ConnectionObject_kill, | |
| 1262 METH_VARARGS, | |
| 1263 _mysql_ConnectionObject_kill__doc__ | |
| 1264 }, | |
| 1265 { | |
| 1266 "ping", | |
| 1267 (PyCFunction)_mysql_ConnectionObject_ping, | |
| 1268 METH_VARARGS, | |
| 1269 _mysql_ConnectionObject_ping__doc__ | |
| 1270 }, | |
| 1271 { | |
| 1272 "query", | |
| 1273 (PyCFunction)_mysql_ConnectionObject_query, | |
| 1274 METH_VARARGS, | |
| 1275 _mysql_ConnectionObject_query__doc__ | |
| 1276 }, | |
| 1277 { | |
| 1278 "select_db", | |
| 1279 (PyCFunction)_mysql_ConnectionObject_select_db, | |
| 1280 METH_VARARGS, | |
| 1281 _mysql_ConnectionObject_select_db__doc__ | |
| 1282 }, | |
| 1283 { | |
| 1284 "shutdown", | |
| 1285 (PyCFunction)_mysql_ConnectionObject_shutdown, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1286 METH_NOARGS, |
| 0 | 1287 _mysql_ConnectionObject_shutdown__doc__ |
| 1288 }, | |
| 1289 { | |
| 1290 "stat", | |
| 1291 (PyCFunction)_mysql_ConnectionObject_stat, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1292 METH_NOARGS, |
| 0 | 1293 _mysql_ConnectionObject_stat__doc__ |
| 1294 }, | |
| 1295 { | |
| 1296 "store_result", | |
| 1297 (PyCFunction)_mysql_ConnectionObject_store_result, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1298 METH_NOARGS, |
| 0 | 1299 _mysql_ConnectionObject_store_result__doc__ |
| 1300 }, | |
| 1301 { | |
| 1302 "string_literal", | |
| 1303 (PyCFunction)_mysql_string_literal, | |
| 1304 METH_VARARGS, | |
| 1305 _mysql_string_literal__doc__}, | |
| 1306 { | |
| 1307 "thread_id", | |
| 1308 (PyCFunction)_mysql_ConnectionObject_thread_id, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1309 METH_NOARGS, |
| 0 | 1310 _mysql_ConnectionObject_thread_id__doc__ |
| 1311 }, | |
| 1312 { | |
| 1313 "use_result", | |
| 1314 (PyCFunction)_mysql_ConnectionObject_use_result, | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1315 METH_NOARGS, |
| 0 | 1316 _mysql_ConnectionObject_use_result__doc__ |
| 1317 }, | |
| 1318 {NULL, NULL} /* sentinel */ | |
| 1319 }; | |
| 1320 | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1321 static struct PyMemberDef _mysql_ConnectionObject_memberlist[] = { |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1322 { |
| 0 | 1323 "open", |
| 1324 T_INT, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1325 offsetof(_mysql_ConnectionObject, open), |
| 0 | 1326 RO, |
| 1327 "True if connection is open" | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1328 }, |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1329 { |
| 0 | 1330 "converter", |
| 1331 T_OBJECT, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1332 offsetof(_mysql_ConnectionObject, converter), |
| 0 | 1333 0, |
| 1334 "Type conversion mapping" | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1335 }, |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1336 { |
| 0 | 1337 "server_capabilities", |
| 1338 T_UINT, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1339 offsetof(_mysql_ConnectionObject, connection.server_capabilities), |
| 0 | 1340 RO, |
| 1341 "Capabilites of server; consult MySQLdb.constants.CLIENT" | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1342 }, |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1343 { |
| 0 | 1344 "port", |
| 1345 T_UINT, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1346 offsetof(_mysql_ConnectionObject, connection.port), |
| 0 | 1347 RO, |
| 1348 "TCP/IP port of the server connection" | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1349 }, |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1350 { |
| 0 | 1351 "client_flag", |
| 1352 T_UINT, | |
| 1353 RO, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1354 offsetof(_mysql_ConnectionObject, connection.client_flag), |
| 0 | 1355 "Client flags; refer to MySQLdb.constants.CLIENT" |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1356 }, |
| 0 | 1357 {NULL} /* Sentinel */ |
| 1358 }; | |
|
25
25c5d3b241ba
Start converting some some things to METH_NOARGS to save invocation time, add
kylev
parents:
21
diff
changeset
|
1359 |
| 0 | 1360 static PyObject * |
| 1361 _mysql_ConnectionObject_getattr( | |
| 1362 _mysql_ConnectionObject *self, | |
| 1363 char *name) | |
| 1364 { | |
| 1365 PyObject *res; | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1366 struct PyMemberDef *l; |
| 0 | 1367 |
| 1368 res = Py_FindMethod(_mysql_ConnectionObject_methods, (PyObject *)self, name); | |
| 1369 if (res != NULL) | |
| 1370 return res; | |
| 1371 PyErr_Clear(); | |
| 1372 if (strcmp(name, "closed") == 0) | |
| 1373 return PyInt_FromLong((long)!(self->open)); | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1374 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1375 for (l = _mysql_ConnectionObject_memberlist; l->name != NULL; l++) { |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1376 if (strcmp(l->name, name) == 0) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1377 return PyMember_GetOne((char *)self, l); |
| 0 | 1378 } |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1379 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1380 PyErr_SetString(PyExc_AttributeError, name); |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1381 return NULL; |
| 0 | 1382 } |
| 1383 | |
| 1384 static int | |
| 1385 _mysql_ConnectionObject_setattr( | |
| 1386 _mysql_ConnectionObject *self, | |
| 1387 char *name, | |
| 1388 PyObject *v) | |
| 1389 { | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1390 struct PyMemberDef *l; |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1391 |
| 0 | 1392 if (v == NULL) { |
| 1393 PyErr_SetString(PyExc_AttributeError, | |
| 1394 "can't delete connection attributes"); | |
| 1395 return -1; | |
| 1396 } | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1397 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1398 for (l = _mysql_ConnectionObject_memberlist; l->name != NULL; l++) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1399 if (strcmp(l->name, name) == 0) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1400 return PyMember_SetOne((char *)self, l, v); |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1401 |
| 0 | 1402 PyErr_SetString(PyExc_AttributeError, name); |
| 1403 return -1; | |
| 1404 } | |
| 1405 | |
| 1406 PyTypeObject _mysql_ConnectionObject_Type = { | |
| 1407 PyObject_HEAD_INIT(NULL) | |
| 1408 0, | |
| 1409 "_mysql.connection", /* (char *)tp_name For printing */ | |
| 29 | 1410 sizeof(_mysql_ConnectionObject), /* tp_basicsize */ |
| 0 | 1411 0, |
| 1412 (destructor)_mysql_ConnectionObject_dealloc, /* tp_dealloc */ | |
| 1413 0, /*tp_print*/ | |
| 1414 (getattrfunc)_mysql_ConnectionObject_getattr, /* tp_getattr */ | |
| 1415 (setattrfunc)_mysql_ConnectionObject_setattr, /* tp_setattr */ | |
| 1416 0, /*tp_compare*/ | |
| 1417 (reprfunc)_mysql_ConnectionObject_repr, /* tp_repr */ | |
| 29 | 1418 |
| 0 | 1419 /* Method suites for standard classes */ |
| 29 | 1420 |
| 0 | 1421 0, /* (PyNumberMethods *) tp_as_number */ |
| 1422 0, /* (PySequenceMethods *) tp_as_sequence */ | |
| 1423 0, /* (PyMappingMethods *) tp_as_mapping */ | |
| 29 | 1424 |
| 0 | 1425 /* More standard operations (here for binary compatibility) */ |
| 29 | 1426 |
| 0 | 1427 0, /* (hashfunc) tp_hash */ |
| 1428 0, /* (ternaryfunc) tp_call */ | |
| 1429 0, /* (reprfunc) tp_str */ | |
| 1430 0, /* (getattrofunc) tp_getattro */ | |
| 1431 0, /* (setattrofunc) tp_setattro */ | |
| 29 | 1432 |
| 0 | 1433 /* Functions to access object as input/output buffer */ |
| 1434 0, /* (PyBufferProcs *) tp_as_buffer */ | |
| 29 | 1435 |
| 0 | 1436 /* Flags to define presence of optional/expanded features */ |
| 1437 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, | |
| 29 | 1438 |
| 0 | 1439 _mysql_connect__doc__, /* (char *) tp_doc Documentation string */ |
| 29 | 1440 |
| 0 | 1441 /* call function for all accessible objects */ |
| 29 | 1442 (traverseproc)_mysql_ConnectionObject_traverse, /* tp_traverse */ |
| 1443 | |
| 0 | 1444 /* delete references to contained objects */ |
| 29 | 1445 (inquiry)_mysql_ConnectionObject_clear, /* tp_clear */ |
| 1446 | |
| 0 | 1447 /* rich comparisons */ |
| 1448 0, /* (richcmpfunc) tp_richcompare */ | |
| 29 | 1449 |
| 0 | 1450 /* weak reference enabler */ |
| 1451 0, /* (long) tp_weaklistoffset */ | |
| 29 | 1452 |
| 0 | 1453 /* Iterators */ |
| 1454 0, /* (getiterfunc) tp_iter */ | |
| 1455 0, /* (iternextfunc) tp_iternext */ | |
| 29 | 1456 |
| 0 | 1457 /* Attribute descriptor and subclassing stuff */ |
| 1458 (struct PyMethodDef *)_mysql_ConnectionObject_methods, /* tp_methods */ | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
29
diff
changeset
|
1459 (struct PyMemberDef *)_mysql_ConnectionObject_memberlist, /* tp_members */ |
| 0 | 1460 0, /* (struct getsetlist *) tp_getset; */ |
| 1461 0, /* (struct _typeobject *) tp_base; */ | |
| 1462 0, /* (PyObject *) tp_dict */ | |
| 1463 0, /* (descrgetfunc) tp_descr_get */ | |
| 1464 0, /* (descrsetfunc) tp_descr_set */ | |
| 1465 0, /* (long) tp_dictoffset */ | |
| 1466 (initproc)_mysql_ConnectionObject_Initialize, /* tp_init */ | |
| 1467 NULL, /* tp_alloc */ | |
| 1468 NULL, /* tp_new */ | |
| 29 | 1469 NULL, /* tp_free Low-level free-memory routine */ |
| 0 | 1470 0, /* (PyObject *) tp_bases */ |
| 1471 0, /* (PyObject *) tp_mro method resolution order */ | |
| 1472 0, /* (PyObject *) tp_defined */ | |
| 29 | 1473 }; |