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