Mercurial > p > mysql-python > mysqldb-2
annotate _mysql_connections.c @ 48:f4fd8c20511c MySQLdb
Read a default file in the test setUp. Since Python 2.4, int() will return longs if needed so make all long references int as in Python 3.0 there is no more long due to int/long unification (new ints are old longs).
| author | adustman |
|---|---|
| date | Sun, 22 Feb 2009 20:01:31 +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 }; |