Mercurial > p > mysql-python > mysqldb-2
annotate src/results.c @ 66:5a7c30cd9de2 MySQLdb
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
| author | adustman |
|---|---|
| date | Sun, 29 Mar 2009 16:26:30 +0000 |
| parents | e606fd52e866 |
| children | 98d968f5af11 |
| rev | line source |
|---|---|
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
1 /* -*- mode: C; indent-tabs-mode: t; c-basic-offset: 8; -*- */ |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
2 |
|
55
e606fd52e866
make things a little cleaner by moving to a src directory for the C code
kylev
parents:
53
diff
changeset
|
3 #include "mysqlmod.h" |
| 0 | 4 |
| 5 static char _mysql_ResultObject__doc__[] = | |
| 6 "result(connection, use=0, converter={}) -- Result set from a query.\n\ | |
| 7 \n\ | |
| 8 Creating instances of this class directly is an excellent way to\n\ | |
| 9 shoot yourself in the foot. If using _mysql.connection directly,\n\ | |
| 10 use connection.store_result() or connection.use_result() instead.\n\ | |
| 11 If using MySQLdb.Connection, this is done by the cursor class.\n\ | |
| 12 Just forget you ever saw this. Forget... FOR-GET..."; | |
| 13 | |
|
2
c0d1fc0429ce
Smashed _mysql.c with a great big hammer and got some smaller,
adustman
parents:
1
diff
changeset
|
14 int |
| 0 | 15 _mysql_ResultObject_Initialize( |
| 16 _mysql_ResultObject *self, | |
| 17 PyObject *args, | |
| 18 PyObject *kwargs) | |
| 19 { | |
| 20 static char *kwlist[] = {"connection", "use", "converter", NULL}; | |
| 45 | 21 MYSQL_RES *result; |
| 0 | 22 _mysql_ConnectionObject *conn=NULL; |
| 45 | 23 int use=0; |
| 0 | 24 PyObject *conv=NULL; |
| 25 int n, i; | |
| 26 MYSQL_FIELD *fields; | |
| 27 | |
| 28 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "O|iO", kwlist, | |
| 29 &conn, &use, &conv)) | |
| 30 return -1; | |
| 31 if (!conv) conv = PyDict_New(); | |
| 32 if (!conv) return -1; | |
| 33 self->conn = (PyObject *) conn; | |
| 34 Py_INCREF(conn); | |
| 35 self->use = use; | |
| 36 Py_BEGIN_ALLOW_THREADS ; | |
| 37 if (use) | |
| 38 result = mysql_use_result(&(conn->connection)); | |
| 39 else | |
| 40 result = mysql_store_result(&(conn->connection)); | |
| 41 self->result = result; | |
| 42 Py_END_ALLOW_THREADS ; | |
| 43 if (!result) { | |
| 44 self->converter = PyTuple_New(0); | |
| 45 return 0; | |
| 46 } | |
| 47 n = mysql_num_fields(result); | |
| 48 self->nfields = n; | |
| 49 if (!(self->converter = PyTuple_New(n))) return -1; | |
| 50 fields = mysql_fetch_fields(result); | |
| 51 for (i=0; i<n; i++) { | |
| 52 PyObject *tmp, *fun; | |
| 53 tmp = PyInt_FromLong((long) fields[i].type); | |
| 54 if (!tmp) return -1; | |
| 55 fun = PyObject_GetItem(conv, tmp); | |
| 56 Py_DECREF(tmp); | |
| 57 if (!fun) { | |
| 58 PyErr_Clear(); | |
| 59 fun = Py_None; | |
| 60 Py_INCREF(Py_None); | |
| 61 } | |
| 62 if (PySequence_Check(fun)) { | |
| 63 int j, n2=PySequence_Size(fun); | |
| 64 PyObject *fun2=NULL; | |
| 65 for (j=0; j<n2; j++) { | |
| 66 PyObject *t = PySequence_GetItem(fun, j); | |
| 67 if (!t) continue; | |
| 68 if (!PyTuple_Check(t)) goto cleanup; | |
| 69 if (PyTuple_GET_SIZE(t) == 2) { | |
| 70 long mask; | |
| 71 PyObject *pmask=NULL; | |
| 72 pmask = PyTuple_GET_ITEM(t, 0); | |
| 73 fun2 = PyTuple_GET_ITEM(t, 1); | |
| 74 if (PyInt_Check(pmask)) { | |
| 75 mask = PyInt_AS_LONG(pmask); | |
| 76 if (mask & fields[i].flags) { | |
|
53
4bfc4e612de0
don't leak special-case tuples (present in unicode modes), backport from 1.2br
kylev
parents:
45
diff
changeset
|
77 Py_DECREF(t); |
| 0 | 78 break; |
| 79 } | |
| 80 else { | |
|
53
4bfc4e612de0
don't leak special-case tuples (present in unicode modes), backport from 1.2br
kylev
parents:
45
diff
changeset
|
81 goto cleanup; |
| 0 | 82 } |
| 83 } else { | |
|
53
4bfc4e612de0
don't leak special-case tuples (present in unicode modes), backport from 1.2br
kylev
parents:
45
diff
changeset
|
84 Py_DECREF(t); |
| 0 | 85 break; |
| 86 } | |
| 87 } | |
| 88 cleanup: | |
| 89 Py_DECREF(t); | |
| 90 } | |
| 91 if (!fun2) fun2 = Py_None; | |
| 92 Py_INCREF(fun2); | |
| 93 Py_DECREF(fun); | |
| 94 fun = fun2; | |
| 95 } | |
| 96 PyTuple_SET_ITEM(self->converter, i, fun); | |
| 97 } | |
| 98 return 0; | |
| 99 } | |
| 100 | |
| 45 | 101 static int |
| 102 _mysql_ResultObject_traverse( | |
| 0 | 103 _mysql_ResultObject *self, |
| 104 visitproc visit, | |
| 105 void *arg) | |
| 106 { | |
| 107 int r; | |
| 108 if (self->converter) { | |
| 109 if (!(r = visit(self->converter, arg))) return r; | |
| 110 } | |
| 111 if (self->conn) | |
| 112 return visit(self->conn, arg); | |
| 113 return 0; | |
| 114 } | |
| 115 | |
| 45 | 116 static int |
| 117 _mysql_ResultObject_clear( | |
| 0 | 118 _mysql_ResultObject *self) |
| 119 { | |
| 120 Py_XDECREF(self->converter); | |
| 121 self->converter = NULL; | |
| 122 Py_XDECREF(self->conn); | |
| 123 self->conn = NULL; | |
| 124 return 0; | |
| 125 } | |
| 26 | 126 |
| 0 | 127 static char _mysql_ResultObject_describe__doc__[] = |
| 128 "Returns the sequence of 7-tuples required by the DB-API for\n\ | |
| 129 the Cursor.description attribute.\n\ | |
| 130 "; | |
| 131 | |
| 132 static PyObject * | |
| 133 _mysql_ResultObject_describe( | |
| 134 _mysql_ResultObject *self, | |
| 26 | 135 PyObject *unused) |
| 0 | 136 { |
| 137 PyObject *d; | |
| 138 MYSQL_FIELD *fields; | |
| 139 unsigned int i, n; | |
| 26 | 140 |
| 0 | 141 check_result_connection(self); |
| 142 n = mysql_num_fields(self->result); | |
| 143 fields = mysql_fetch_fields(self->result); | |
| 144 if (!(d = PyTuple_New(n))) return NULL; | |
| 145 for (i=0; i<n; i++) { | |
| 146 PyObject *t; | |
| 147 t = Py_BuildValue("(siiiiii)", | |
| 148 fields[i].name, | |
| 149 (long) fields[i].type, | |
| 150 (long) fields[i].max_length, | |
| 151 (long) fields[i].length, | |
| 152 (long) fields[i].length, | |
| 153 (long) fields[i].decimals, | |
| 154 (long) !(IS_NOT_NULL(fields[i].flags))); | |
| 155 if (!t) goto error; | |
| 156 PyTuple_SET_ITEM(d, i, t); | |
| 157 } | |
| 158 return d; | |
| 159 error: | |
| 160 Py_XDECREF(d); | |
| 161 return NULL; | |
| 162 } | |
|
18
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
163 |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
164 static char _mysql_ResultObject_fields__doc__[] = |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
165 "Returns the sequence of 7-tuples required by the DB-API for\n\ |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
166 the Cursor.description attribute.\n\ |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
167 "; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
168 |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
169 static PyObject * |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
170 _mysql_ResultObject_fields( |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
171 _mysql_ResultObject *self, |
| 26 | 172 PyObject *unused) |
|
18
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
173 { |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
174 PyObject *arglist=NULL, *kwarglist=NULL; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
175 PyObject *fields=NULL; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
176 _mysql_FieldObject *field=NULL; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
177 unsigned int i, n; |
| 26 | 178 |
|
18
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
179 check_result_connection(self); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
180 kwarglist = PyDict_New(); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
181 if (!kwarglist) goto error; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
182 n = mysql_num_fields(self->result); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
183 if (!(fields = PyTuple_New(n))) return NULL; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
184 for (i=0; i<n; i++) { |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
185 arglist = Py_BuildValue("(Oi)", self, i); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
186 if (!arglist) goto error; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
187 field = MyAlloc(_mysql_FieldObject, _mysql_FieldObject_Type); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
188 if (!field) goto error; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
189 if (_mysql_FieldObject_Initialize(field, arglist, kwarglist)) |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
190 goto error; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
191 Py_DECREF(arglist); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
192 PyTuple_SET_ITEM(fields, i, (PyObject *) field); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
193 } |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
194 Py_DECREF(kwarglist); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
195 return fields; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
196 error: |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
197 Py_XDECREF(arglist); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
198 Py_XDECREF(kwarglist); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
199 Py_XDECREF(fields); |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
200 return NULL; |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
201 } |
| 26 | 202 |
| 0 | 203 static char _mysql_ResultObject_field_flags__doc__[] = |
| 204 "Returns a tuple of field flags, one for each column in the result.\n\ | |
| 205 " ; | |
| 206 | |
| 207 static PyObject * | |
| 208 _mysql_ResultObject_field_flags( | |
| 209 _mysql_ResultObject *self, | |
| 26 | 210 PyObject *unused) |
| 0 | 211 { |
| 212 PyObject *d; | |
| 213 MYSQL_FIELD *fields; | |
| 214 unsigned int i, n; | |
| 26 | 215 |
| 0 | 216 check_result_connection(self); |
| 217 n = mysql_num_fields(self->result); | |
| 218 fields = mysql_fetch_fields(self->result); | |
| 219 if (!(d = PyTuple_New(n))) return NULL; | |
| 220 for (i=0; i<n; i++) { | |
| 221 PyObject *f; | |
| 222 if (!(f = PyInt_FromLong((long)fields[i].flags))) goto error; | |
| 223 PyTuple_SET_ITEM(d, i, f); | |
| 224 } | |
| 225 return d; | |
| 226 error: | |
| 227 Py_XDECREF(d); | |
| 228 return NULL; | |
| 229 } | |
| 230 | |
| 231 static PyObject * | |
| 232 _mysql_field_to_python( | |
| 233 PyObject *converter, | |
| 234 char *rowitem, | |
| 235 unsigned long length) | |
| 236 { | |
| 237 PyObject *v; | |
| 238 if (rowitem) { | |
| 239 if (converter != Py_None) | |
| 240 v = PyObject_CallFunction(converter, | |
| 241 "s#", | |
| 242 rowitem, | |
| 243 (int)length); | |
| 244 else | |
| 245 v = PyString_FromStringAndSize(rowitem, | |
| 246 (int)length); | |
| 247 if (!v) | |
| 248 return NULL; | |
| 249 } else { | |
| 250 Py_INCREF(Py_None); | |
| 251 v = Py_None; | |
| 252 } | |
| 253 return v; | |
| 254 } | |
| 255 | |
| 256 static PyObject * | |
| 257 _mysql_row_to_tuple( | |
| 258 _mysql_ResultObject *self, | |
| 259 MYSQL_ROW row) | |
| 260 { | |
| 261 unsigned int n, i; | |
| 262 unsigned long *length; | |
| 263 PyObject *r, *c; | |
| 264 | |
| 265 n = mysql_num_fields(self->result); | |
| 266 if (!(r = PyTuple_New(n))) return NULL; | |
| 267 length = mysql_fetch_lengths(self->result); | |
| 268 for (i=0; i<n; i++) { | |
| 269 PyObject *v; | |
| 270 c = PyTuple_GET_ITEM(self->converter, i); | |
| 271 v = _mysql_field_to_python(c, row[i], length[i]); | |
| 272 if (!v) goto error; | |
| 273 PyTuple_SET_ITEM(r, i, v); | |
| 274 } | |
| 275 return r; | |
| 276 error: | |
| 277 Py_XDECREF(r); | |
| 278 return NULL; | |
| 279 } | |
| 280 | |
| 281 static PyObject * | |
| 282 _mysql_row_to_dict( | |
| 283 _mysql_ResultObject *self, | |
| 284 MYSQL_ROW row) | |
| 285 { | |
| 286 unsigned int n, i; | |
| 287 unsigned long *length; | |
| 288 PyObject *r, *c; | |
| 289 MYSQL_FIELD *fields; | |
| 290 | |
| 291 n = mysql_num_fields(self->result); | |
| 292 if (!(r = PyDict_New())) return NULL; | |
| 293 length = mysql_fetch_lengths(self->result); | |
| 294 fields = mysql_fetch_fields(self->result); | |
| 295 for (i=0; i<n; i++) { | |
| 296 PyObject *v; | |
| 297 c = PyTuple_GET_ITEM(self->converter, i); | |
| 298 v = _mysql_field_to_python(c, row[i], length[i]); | |
| 299 if (!v) goto error; | |
| 300 if (!PyMapping_HasKeyString(r, fields[i].name)) { | |
| 301 PyMapping_SetItemString(r, fields[i].name, v); | |
| 302 } else { | |
| 303 int len; | |
| 304 char buf[256]; | |
| 305 strncpy(buf, fields[i].table, 256); | |
| 306 len = strlen(buf); | |
| 307 strncat(buf, ".", 256-len); | |
| 308 len = strlen(buf); | |
| 309 strncat(buf, fields[i].name, 256-len); | |
| 310 PyMapping_SetItemString(r, buf, v); | |
| 311 } | |
| 312 Py_DECREF(v); | |
| 313 } | |
| 314 return r; | |
| 315 error: | |
| 316 Py_XDECREF(r); | |
| 317 return NULL; | |
| 318 } | |
| 319 | |
| 320 static PyObject * | |
| 321 _mysql_row_to_dict_old( | |
| 322 _mysql_ResultObject *self, | |
| 323 MYSQL_ROW row) | |
| 324 { | |
| 325 unsigned int n, i; | |
| 326 unsigned long *length; | |
| 327 PyObject *r, *c; | |
| 328 MYSQL_FIELD *fields; | |
| 329 | |
| 330 n = mysql_num_fields(self->result); | |
| 331 if (!(r = PyDict_New())) return NULL; | |
| 332 length = mysql_fetch_lengths(self->result); | |
| 333 fields = mysql_fetch_fields(self->result); | |
| 334 for (i=0; i<n; i++) { | |
| 335 PyObject *v; | |
| 336 c = PyTuple_GET_ITEM(self->converter, i); | |
| 337 v = _mysql_field_to_python(c, row[i], length[i]); | |
| 338 if (!v) goto error; | |
| 339 { | |
| 340 int len=0; | |
| 341 char buf[256]=""; | |
| 342 if (strlen(fields[i].table)) { | |
| 343 strncpy(buf, fields[i].table, 256); | |
| 344 len = strlen(buf); | |
| 345 strncat(buf, ".", 256-len); | |
| 346 len = strlen(buf); | |
| 347 } | |
| 348 strncat(buf, fields[i].name, 256-len); | |
| 349 PyMapping_SetItemString(r, buf, v); | |
| 350 } | |
| 351 Py_DECREF(v); | |
| 352 } | |
| 353 return r; | |
| 354 error: | |
| 355 Py_XDECREF(r); | |
| 356 return NULL; | |
| 357 } | |
| 358 | |
| 359 typedef PyObject *_PYFUNC(_mysql_ResultObject *, MYSQL_ROW); | |
| 360 | |
| 361 int | |
| 362 _mysql__fetch_row( | |
| 363 _mysql_ResultObject *self, | |
| 364 PyObject **r, | |
| 365 int skiprows, | |
| 366 int maxrows, | |
| 367 _PYFUNC *convert_row) | |
| 368 { | |
| 369 unsigned int i; | |
| 370 MYSQL_ROW row; | |
| 371 | |
| 372 for (i = skiprows; i<(skiprows+maxrows); i++) { | |
| 373 PyObject *v; | |
| 374 if (!self->use) | |
| 375 row = mysql_fetch_row(self->result); | |
| 376 else { | |
| 377 Py_BEGIN_ALLOW_THREADS; | |
| 378 row = mysql_fetch_row(self->result); | |
| 379 Py_END_ALLOW_THREADS; | |
| 380 } | |
| 381 if (!row && mysql_errno(&(((_mysql_ConnectionObject *)(self->conn))->connection))) { | |
| 382 _mysql_Exception((_mysql_ConnectionObject *)self->conn); | |
| 383 goto error; | |
| 384 } | |
| 385 if (!row) { | |
|
44
2b9a9814daab
_PyTuple_Resize is stable since 2.2, so we don't need the macro MyTuple_Resize
kylev
parents:
42
diff
changeset
|
386 if (_PyTuple_Resize(r, i) == -1) goto error; |
| 0 | 387 break; |
| 388 } | |
| 389 v = convert_row(self, row); | |
| 390 if (!v) goto error; | |
| 391 PyTuple_SET_ITEM(*r, i, v); | |
| 392 } | |
| 393 return i-skiprows; | |
| 394 error: | |
| 395 return -1; | |
| 396 } | |
| 397 | |
| 398 static char _mysql_ResultObject_fetch_row__doc__[] = | |
| 399 "fetch_row([maxrows, how]) -- Fetches up to maxrows as a tuple.\n\ | |
| 400 The rows are formatted according to how:\n\ | |
| 401 \n\ | |
| 402 0 -- tuples (default)\n\ | |
| 403 1 -- dictionaries, key=column or table.column if duplicated\n\ | |
| 404 2 -- dictionaries, key=table.column\n\ | |
| 405 "; | |
| 406 | |
| 407 static PyObject * | |
| 408 _mysql_ResultObject_fetch_row( | |
| 409 _mysql_ResultObject *self, | |
| 410 PyObject *args, | |
| 411 PyObject *kwargs) | |
| 412 { | |
| 413 typedef PyObject *_PYFUNC(_mysql_ResultObject *, MYSQL_ROW); | |
| 414 static char *kwlist[] = { "maxrows", "how", NULL }; | |
| 415 static _PYFUNC *row_converters[] = | |
| 416 { | |
| 417 _mysql_row_to_tuple, | |
| 418 _mysql_row_to_dict, | |
| 419 _mysql_row_to_dict_old | |
| 420 }; | |
| 421 _PYFUNC *convert_row; | |
| 422 unsigned int maxrows=1, how=0, skiprows=0, rowsadded; | |
| 423 PyObject *r=NULL; | |
| 424 | |
| 425 if (!PyArg_ParseTupleAndKeywords(args, kwargs, "|ii:fetch_row", kwlist, | |
| 426 &maxrows, &how)) | |
| 427 return NULL; | |
| 428 check_result_connection(self); | |
| 429 if (how < 0 || how >= sizeof(row_converters)) { | |
| 430 PyErr_SetString(PyExc_ValueError, "how out of range"); | |
| 431 return NULL; | |
| 432 } | |
| 433 convert_row = row_converters[how]; | |
| 434 if (maxrows) { | |
| 435 if (!(r = PyTuple_New(maxrows))) goto error; | |
|
44
2b9a9814daab
_PyTuple_Resize is stable since 2.2, so we don't need the macro MyTuple_Resize
kylev
parents:
42
diff
changeset
|
436 rowsadded = _mysql__fetch_row(self, &r, skiprows, maxrows, |
| 0 | 437 convert_row); |
| 438 if (rowsadded == -1) goto error; | |
| 439 } else { | |
| 440 if (self->use) { | |
| 441 maxrows = 1000; | |
| 442 if (!(r = PyTuple_New(maxrows))) goto error; | |
| 443 while (1) { | |
| 444 rowsadded = _mysql__fetch_row(self, &r, skiprows, | |
| 445 maxrows, convert_row); | |
| 446 if (rowsadded == -1) goto error; | |
| 447 skiprows += rowsadded; | |
| 448 if (rowsadded < maxrows) break; | |
|
44
2b9a9814daab
_PyTuple_Resize is stable since 2.2, so we don't need the macro MyTuple_Resize
kylev
parents:
42
diff
changeset
|
449 if (_PyTuple_Resize(&r, skiprows + maxrows) == -1) |
| 0 | 450 goto error; |
| 451 } | |
| 452 } else { | |
| 453 /* XXX if overflow, maxrows<0? */ | |
| 454 maxrows = (int) mysql_num_rows(self->result); | |
| 455 if (!(r = PyTuple_New(maxrows))) goto error; | |
| 456 rowsadded = _mysql__fetch_row(self, &r, 0, | |
| 457 maxrows, convert_row); | |
| 458 if (rowsadded == -1) goto error; | |
| 459 } | |
| 460 } | |
| 461 return r; | |
| 462 error: | |
| 463 Py_XDECREF(r); | |
| 464 return NULL; | |
| 465 } | |
| 466 | |
| 467 | |
| 468 static char _mysql_ResultObject_num_fields__doc__[] = | |
| 469 "Returns the number of fields (column) in the result." ; | |
| 470 | |
| 471 static PyObject * | |
| 472 _mysql_ResultObject_num_fields( | |
| 473 _mysql_ResultObject *self, | |
| 26 | 474 PyObject *unused) |
| 0 | 475 { |
| 476 check_result_connection(self); | |
| 477 return PyInt_FromLong((long)mysql_num_fields(self->result)); | |
| 26 | 478 } |
| 0 | 479 |
| 480 static char _mysql_ResultObject_num_rows__doc__[] = | |
| 481 "Returns the number of rows in the result set. Note that if\n\ | |
| 482 use=1, this will not return a valid value until the entire result\n\ | |
| 483 set has been read.\n\ | |
| 484 "; | |
| 485 | |
| 486 static PyObject * | |
| 487 _mysql_ResultObject_num_rows( | |
| 488 _mysql_ResultObject *self, | |
| 26 | 489 PyObject *unused) |
| 0 | 490 { |
| 491 check_result_connection(self); | |
| 492 return PyLong_FromUnsignedLongLong(mysql_num_rows(self->result)); | |
| 26 | 493 } |
| 0 | 494 |
| 495 | |
| 496 static char _mysql_ResultObject_data_seek__doc__[] = | |
| 497 "data_seek(n) -- seek to row n of result set"; | |
| 498 static PyObject * | |
| 499 _mysql_ResultObject_data_seek( | |
| 500 _mysql_ResultObject *self, | |
| 501 PyObject *args) | |
| 502 { | |
| 503 unsigned int row; | |
| 504 if (!PyArg_ParseTuple(args, "i:data_seek", &row)) return NULL; | |
| 505 check_result_connection(self); | |
| 506 mysql_data_seek(self->result, row); | |
| 507 Py_INCREF(Py_None); | |
| 508 return Py_None; | |
| 509 } | |
| 510 | |
| 511 static char _mysql_ResultObject_row_seek__doc__[] = | |
| 512 "row_seek(n) -- seek by offset n rows of result set"; | |
| 513 static PyObject * | |
| 514 _mysql_ResultObject_row_seek( | |
| 515 _mysql_ResultObject *self, | |
| 516 PyObject *args) | |
| 517 { | |
| 518 int offset; | |
| 519 MYSQL_ROW_OFFSET r; | |
| 520 if (!PyArg_ParseTuple(args, "i:row_seek", &offset)) return NULL; | |
| 521 check_result_connection(self); | |
| 522 if (self->use) { | |
| 523 PyErr_SetString(_mysql_ProgrammingError, | |
| 524 "cannot be used with connection.use_result()"); | |
| 525 return NULL; | |
| 526 } | |
| 527 r = mysql_row_tell(self->result); | |
| 528 mysql_row_seek(self->result, r+offset); | |
| 529 Py_INCREF(Py_None); | |
| 530 return Py_None; | |
| 531 } | |
| 532 | |
| 533 static char _mysql_ResultObject_row_tell__doc__[] = | |
| 534 "row_tell() -- return the current row number of the result set."; | |
| 535 static PyObject * | |
| 536 _mysql_ResultObject_row_tell( | |
| 537 _mysql_ResultObject *self, | |
| 26 | 538 PyObject *unused) |
| 0 | 539 { |
| 540 MYSQL_ROW_OFFSET r; | |
| 26 | 541 |
| 0 | 542 check_result_connection(self); |
| 543 if (self->use) { | |
| 544 PyErr_SetString(_mysql_ProgrammingError, | |
| 545 "cannot be used with connection.use_result()"); | |
| 546 return NULL; | |
| 547 } | |
| 548 r = mysql_row_tell(self->result); | |
| 549 return PyInt_FromLong(r-self->result->data->data); | |
| 550 } | |
| 551 | |
| 552 static void | |
| 553 _mysql_ResultObject_dealloc( | |
| 554 _mysql_ResultObject *self) | |
| 555 { | |
| 556 PyObject_GC_UnTrack((PyObject *)self); | |
| 557 mysql_free_result(self->result); | |
| 558 _mysql_ResultObject_clear(self); | |
| 559 MyFree(self); | |
| 560 } | |
| 561 | |
| 562 static PyObject * | |
| 563 _mysql_ResultObject_repr( | |
| 564 _mysql_ResultObject *self) | |
| 565 { | |
| 566 char buf[300]; | |
| 567 sprintf(buf, "<_mysql.result object at %lx>", | |
| 568 (long)self); | |
| 569 return PyString_FromString(buf); | |
| 570 } | |
| 571 | |
| 572 static PyMethodDef _mysql_ResultObject_methods[] = { | |
| 573 { | |
| 574 "data_seek", | |
| 575 (PyCFunction)_mysql_ResultObject_data_seek, | |
| 576 METH_VARARGS, | |
| 577 _mysql_ResultObject_data_seek__doc__ | |
| 578 }, | |
| 579 { | |
| 580 "row_seek", | |
| 581 (PyCFunction)_mysql_ResultObject_row_seek, | |
| 582 METH_VARARGS, | |
| 583 _mysql_ResultObject_row_seek__doc__ | |
| 584 }, | |
| 585 { | |
| 586 "row_tell", | |
| 587 (PyCFunction)_mysql_ResultObject_row_tell, | |
| 26 | 588 METH_NOARGS, |
| 0 | 589 _mysql_ResultObject_row_tell__doc__ |
| 590 }, | |
| 591 { | |
| 592 "describe", | |
| 593 (PyCFunction)_mysql_ResultObject_describe, | |
| 26 | 594 METH_NOARGS, |
| 0 | 595 _mysql_ResultObject_describe__doc__ |
| 596 }, | |
| 597 { | |
|
18
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
598 "fields", |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
599 (PyCFunction)_mysql_ResultObject_fields, |
| 26 | 600 METH_NOARGS, |
|
18
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
601 _mysql_ResultObject_fields__doc__ |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
602 }, |
|
d55bfb1a4701
Tons of changes from major refactoring/cleanup. This is all really broken
adustman
parents:
2
diff
changeset
|
603 { |
| 0 | 604 "fetch_row", |
| 605 (PyCFunction)_mysql_ResultObject_fetch_row, | |
| 606 METH_VARARGS | METH_KEYWORDS, | |
| 607 _mysql_ResultObject_fetch_row__doc__ | |
| 608 }, | |
| 609 { | |
| 610 "field_flags", | |
| 611 (PyCFunction)_mysql_ResultObject_field_flags, | |
| 26 | 612 METH_NOARGS, |
| 0 | 613 _mysql_ResultObject_field_flags__doc__ |
| 614 }, | |
| 615 { | |
| 616 "num_fields", | |
| 617 (PyCFunction)_mysql_ResultObject_num_fields, | |
| 26 | 618 METH_NOARGS, |
| 0 | 619 _mysql_ResultObject_num_fields__doc__ |
| 620 }, | |
| 621 { | |
| 622 "num_rows", | |
| 623 (PyCFunction)_mysql_ResultObject_num_rows, | |
| 26 | 624 METH_NOARGS, |
| 0 | 625 _mysql_ResultObject_num_rows__doc__ |
| 626 }, | |
| 627 {NULL, NULL} /* sentinel */ | |
| 628 }; | |
| 629 | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
630 static struct PyMemberDef _mysql_ResultObject_memberlist[] = { |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
631 { |
|
66
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
632 "connection", |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
633 T_OBJECT, |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
634 offsetof(_mysql_ConnectionObject, connection), |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
635 RO, |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
636 "Connection associated with result" |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
637 }, |
|
5a7c30cd9de2
By exposing connection on result, decoders can be simplified: Only the field object is needed. Turned on leak testing and found a leak writing BLOBs. removed one of the old stubs in Cursor.
adustman
parents:
55
diff
changeset
|
638 { |
| 0 | 639 "converter", |
| 640 T_OBJECT, | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
641 offsetof(_mysql_ResultObject, converter), |
| 0 | 642 RO, |
| 643 "Type conversion mapping" | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
644 }, |
| 0 | 645 {NULL} /* Sentinel */ |
| 646 }; | |
| 647 | |
| 648 static PyObject * | |
| 649 _mysql_ResultObject_getattr( | |
| 650 _mysql_ResultObject *self, | |
| 651 char *name) | |
| 652 { | |
| 653 PyObject *res; | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
654 struct PyMemberDef *l; |
| 0 | 655 |
| 656 res = Py_FindMethod(_mysql_ResultObject_methods, (PyObject *)self, name); | |
| 657 if (res != NULL) | |
| 658 return res; | |
| 659 PyErr_Clear(); | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
660 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
661 for (l = _mysql_ResultObject_memberlist; l->name != NULL; l++) { |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
662 if (strcmp(l->name, name) == 0) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
663 return PyMember_GetOne((char *)self, l); |
| 0 | 664 } |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
665 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
666 PyErr_SetString(PyExc_AttributeError, name); |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
667 return NULL; |
| 0 | 668 } |
| 669 | |
| 670 static int | |
| 671 _mysql_ResultObject_setattr( | |
| 672 _mysql_ResultObject *self, | |
| 673 char *name, | |
| 674 PyObject *v) | |
| 675 { | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
676 struct PyMemberDef *l; |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
677 |
| 0 | 678 if (v == NULL) { |
| 679 PyErr_SetString(PyExc_AttributeError, | |
| 680 "can't delete connection attributes"); | |
| 681 return -1; | |
| 682 } | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
683 |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
684 for (l = _mysql_ResultObject_memberlist; l->name != NULL; l++) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
685 if (strcmp(l->name, name) == 0) |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
686 return PyMember_SetOne((char *)self, l, v); |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
687 |
| 0 | 688 PyErr_SetString(PyExc_AttributeError, name); |
| 689 return -1; | |
| 690 } | |
| 691 | |
| 692 PyTypeObject _mysql_ResultObject_Type = { | |
| 693 PyObject_HEAD_INIT(NULL) | |
| 694 0, | |
| 695 "_mysql.result", | |
| 696 sizeof(_mysql_ResultObject), | |
| 697 0, | |
| 698 (destructor)_mysql_ResultObject_dealloc, /* tp_dealloc */ | |
| 699 0, /*tp_print*/ | |
| 700 (getattrfunc)_mysql_ResultObject_getattr, /* tp_getattr */ | |
| 701 (setattrfunc)_mysql_ResultObject_setattr, /* tp_setattr */ | |
| 702 0, /*tp_compare*/ | |
| 703 (reprfunc)_mysql_ResultObject_repr, /* tp_repr */ | |
| 45 | 704 |
| 0 | 705 /* Method suites for standard classes */ |
| 45 | 706 |
| 0 | 707 0, /* (PyNumberMethods *) tp_as_number */ |
| 708 0, /* (PySequenceMethods *) tp_as_sequence */ | |
| 709 0, /* (PyMappingMethods *) tp_as_mapping */ | |
| 45 | 710 |
| 0 | 711 /* More standard operations (here for binary compatibility) */ |
| 45 | 712 |
| 0 | 713 0, /* (hashfunc) tp_hash */ |
| 714 0, /* (ternaryfunc) tp_call */ | |
| 715 0, /* (reprfunc) tp_str */ | |
| 716 0, /* (getattrofunc) tp_getattro */ | |
| 717 0, /* (setattrofunc) tp_setattro */ | |
| 45 | 718 |
| 0 | 719 /* Functions to access object as input/output buffer */ |
| 720 0, /* (PyBufferProcs *) tp_as_buffer */ | |
| 45 | 721 |
| 0 | 722 /* Flags to define presence of optional/expanded features */ |
| 45 | 723 Py_TPFLAGS_DEFAULT | Py_TPFLAGS_HAVE_GC | Py_TPFLAGS_BASETYPE, /* (long) tp_flags */ |
| 724 | |
| 0 | 725 _mysql_ResultObject__doc__, /* (char *) tp_doc Documentation string */ |
| 726 /* call function for all accessible objects */ | |
| 45 | 727 (traverseproc)_mysql_ResultObject_traverse, /* tp_traverse */ |
| 0 | 728 /* delete references to contained objects */ |
| 45 | 729 (inquiry)_mysql_ResultObject_clear, /* tp_clear */ |
| 730 | |
| 0 | 731 /* rich comparisons */ |
| 732 0, /* (richcmpfunc) tp_richcompare */ | |
| 45 | 733 |
| 0 | 734 /* weak reference enabler */ |
| 735 0, /* (long) tp_weaklistoffset */ | |
| 45 | 736 |
| 0 | 737 /* Iterators */ |
| 738 0, /* (getiterfunc) tp_iter */ | |
| 739 0, /* (iternextfunc) tp_iternext */ | |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
740 |
| 0 | 741 /* Attribute descriptor and subclassing stuff */ |
|
42
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
742 (struct PyMethodDef *)_mysql_ResultObject_methods, /* tp_methods */ |
|
fdf0cabb27be
Member stuff is stable post py2.2, so remove the MyMember* workarounds
kylev
parents:
26
diff
changeset
|
743 (struct PyMemberDef *)_mysql_ResultObject_memberlist, /*tp_members */ |
| 0 | 744 0, /* (struct getsetlist *) tp_getset; */ |
| 745 0, /* (struct _typeobject *) tp_base; */ | |
| 746 0, /* (PyObject *) tp_dict */ | |
| 747 0, /* (descrgetfunc) tp_descr_get */ | |
| 748 0, /* (descrsetfunc) tp_descr_set */ | |
| 749 0, /* (long) tp_dictoffset */ | |
| 750 (initproc)_mysql_ResultObject_Initialize, /* tp_init */ | |
| 751 NULL, /* tp_alloc */ | |
| 752 NULL, /* tp_new */ | |
| 753 NULL, /* tp_free Low-level free-memory routine */ | |
| 754 0, /* (PyObject *) tp_bases */ | |
| 755 0, /* (PyObject *) tp_mro method resolution order */ | |
| 756 0, /* (PyObject *) tp_defined */ | |
| 757 }; |