开通博客赚积分
发布资源赚积分
分类

源码开发语言/平台
当前位置：首页 > 源码/资料 > 数据库系统 > 查看源码
pgmodule.c
资源名称：postgresql-6.5.2.tar.gz　[点击查看]
上传用户：blenddy
上传日期：2007-01-07
资源大小：6495k
文件大小：51k
源码类别：

数据库系统

开发平台：

Unix_Linux

pgmodule.c：源码内容
  1. /*
  2.  * PyGres, version 2.2 A Python interface for PostgreSQL database. Written by
  3.  * D'Arcy J.M. Cain, (darcy@druid.net).  Based heavily on code written by
  4.  * Pascal Andre, andre@chimay.via.ecp.fr. Copyright (c) 1995, Pascal Andre
  5.  * (andre@via.ecp.fr).
  6.  *
  7.  * Permission to use, copy, modify, and distribute this software and its
  8.  * documentation for any purpose, without fee, and without a written
  9.  * agreement is hereby granted, provided that the above copyright notice and
  10.  * this paragraph and the following two paragraphs appear in all copies or in
  11.  * any new file that contains a substantial portion of this file.
  12.  *
  13.  * IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
  14.  * SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
  15.  * ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
  16.  * AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  17.  *
  18.  * THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED
  19.  * TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  20.  * PURPOSE.  THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE
  21.  * AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
  22.  * ENHANCEMENTS, OR MODIFICATIONS.
  23.  *
  24.  * Further modifications copyright 1997, 1998, 1999 by D'Arcy J.M. Cain
  25.  * (darcy@druid.net) subject to the same terms and conditions as above.
  26.  *
  27.  */
  29. #include <Python.h>
  30. #include <libpq-fe.h>
  31. #include <libpq/libpq-fs.h>
  32. #include <stdio.h>
  33. #include <stdlib.h>
  34. #include <string.h>
  36. /* really bad stuff here - I'm so naughty */
  37. /* If you need to you can run mkdefines to get */
  38. /* current defines but it should not have changed */
  39. #define INT2OID 21
  40. #define INT4OID 23
  41. #define OIDOID 26
  42. #define FLOAT4OID 700
  43. #define FLOAT8OID 701
  44. #define CASHOID 790
  46. static PyObject *PGError;
  47. static const char *PyPgVersion = "2.4";
  49. /* taken from fileobject.c */
  50. #define BUF(v) PyString_AS_STRING((PyStringObject *)(v))
  52. /* default values */
  53. #define MODULE_NAME "pgsql"
  54. #define ARRAYSIZE 1
  56. /* flags for object validity checks */
  57. #define CHECK_OPEN 1
  58. #define CHECK_CLOSE 2
  59. #define CHECK_CNX 4
  60. #define CHECK_RESULT 8
  61. #define CHECK_DQL 16
  63. #define MAX_BUFFER_SIZE   8192 /* maximum transaction size */
  65. #ifndef NO_DIRECT
  66. #define DIRECT_ACCESS   1 /* enables direct access functions */
  67. #endif  /* NO_DIRECT */
  69. #ifndef NO_LARGE
  70. #define LARGE_OBJECTS   1 /* enables large objects support */
  71. #endif  /* NO_LARGE */
  73. #ifndef NO_DEF_VAR
  74. #define DEFAULT_VARS   1 /* enables default variables use */
  75. #endif  /* NO_DEF_VAR */
  77. /* --------------------------------------------------------------------- */
  79. /* MODULE GLOBAL VARIABLES */
  81. #ifdef DEFAULT_VARS
  83. static PyObject *pg_default_host; /* default database host */
  84. static PyObject *pg_default_base; /* default database name */
  85. static PyObject *pg_default_opt;/* default connection options */
  86. static PyObject *pg_default_tty;/* default debug tty */
  87. static PyObject *pg_default_port; /* default connection port */
  88. static PyObject *pg_default_user; /* default username */
  89. static PyObject *pg_default_passwd; /* default password */
  91. #endif  /* DEFAULT_VARS */
  93. /* --------------------------------------------------------------------- */
  94. /* OBJECTS DECLARATION */
  96. /* pg connection object */
  98. typedef struct
  99. {
  100. PyObject_HEAD
  101. int valid; /* validity flag */
  102. PGconn    *cnx; /* PostGres connection handle */
  103. } pgobject;
  105. staticforward PyTypeObject PgType;
  107. #define is_pgobject(v) ((v)->ob_type == &PgType)
  109. /* pg query object */
  111. typedef struct
  112. {
  113. PyObject_HEAD
  114. PGresult   *last_result; /* last result content */
  115. } pgqueryobject;
  117. staticforward PyTypeObject PgQueryType;
  119. #define is_pgqueryobject(v) ((v)->ob_type == &PgQueryType)
  121. #ifdef LARGE_OBJECTS
  122. /* pg large object */
  124. typedef struct
  125. {
  126. PyObject_HEAD
  127. pgobject * pgcnx; /* parent connection object */
  128. Oid lo_oid; /* large object oid */
  129. int lo_fd; /* large object fd */
  130. } pglargeobject;
  132. staticforward PyTypeObject PglargeType;
  134. #define is_pglargeobject(v) ((v)->ob_type == &PglargeType)
  135. #endif  /* LARGE_OBJECTS */
  137. /* --------------------------------------------------------------------- */
  138. /* INTERNAL FUNCTIONS */
  140. /* checks connection validity */
  141. static int
  142. check_cnx_obj(pgobject * self)
  143. {
  144. if (!self->valid)
  145. {
  146. PyErr_SetString(PGError, "connection has been closed");
  147. return 0;
  148. }
  149. return 1;
  150. }
  152. #ifdef LARGE_OBJECTS
  153. /* checks large object validity */
  154. static int
  155. check_lo_obj(pglargeobject * self, int level)
  156. {
  157. if (!check_cnx_obj(self->pgcnx))
  158. return 0;
  160. if (!self->lo_oid)
  161. {
  162. PyErr_SetString(PGError, "object is not valid (null oid).");
  163. return 0;
  164. }
  166. if (level & CHECK_OPEN)
  167. {
  168. if (self->lo_fd < 0)
  169. {
  170. PyErr_SetString(PyExc_IOError, "object is not opened.");
  171. return 0;
  172. }
  173. }
  175. if (level & CHECK_CLOSE)
  176. {
  177. if (self->lo_fd >= 0)
  178. {
  179. PyErr_SetString(PyExc_IOError, "object is already opened.");
  180. return 0;
  181. }
  182. }
  184. return 1;
  185. }
  187. #endif  /* LARGE_OBJECTS */
  189. /* --------------------------------------------------------------------- */
  190. /* PG CONNECTION OBJECT IMPLEMENTATION */
  192. #ifdef LARGE_OBJECTS
  194. /* constructor (internal use only) */
  195. static pglargeobject *
  196. pglarge_new(pgobject * pgcnx, Oid oid)
  197. {
  198. pglargeobject *npglo;
  200. if ((npglo = PyObject_NEW(pglargeobject, &PglargeType)) == NULL)
  201. return NULL;
  203. Py_XINCREF(pgcnx);
  204. npglo->pgcnx = pgcnx;
  205. npglo->lo_fd = -1;
  206. npglo->lo_oid = oid;
  208. return npglo;
  209. }
  211. /* destructor */
  212. static void
  213. pglarge_dealloc(pglargeobject * self)
  214. {
  215. if (self->lo_fd >= 0 && check_cnx_obj(self->pgcnx))
  216. lo_close(self->pgcnx->cnx, self->lo_fd);
  218. Py_XDECREF(self->pgcnx);
  219. PyMem_DEL(self);
  220. }
  222. /* opens large object */
  223. static char pglarge_open__doc__[] =
  224. "open(mode) -- open access to large object with specified mode "
  225. "(INV_READ, INV_WRITE constants defined by module).";
  227. static PyObject *
  228. pglarge_open(pglargeobject * self, PyObject * args)
  229. {
  230. int mode,
  231. fd;
  233. /* check validity */
  234. if (!check_lo_obj(self, CHECK_CLOSE))
  235. return NULL;
  237. /* gets arguments */
  238. if (!PyArg_ParseTuple(args, "i", &mode))
  239. {
  240. PyErr_SetString(PyExc_TypeError, "open(mode), with mode(integer).");
  241. return NULL;
  242. }
  244. /* opens large object */
  245. if ((fd = lo_open(self->pgcnx->cnx, self->lo_oid, mode)) < 0)
  246. {
  247. PyErr_SetString(PyExc_IOError, "can't open large object.");
  248. return NULL;
  249. }
  250. self->lo_fd = fd;
  252. /* no error : returns Py_None */
  253. Py_INCREF(Py_None);
  254. return Py_None;
  255. }
  257. /* close large object */
  258. static char pglarge_close__doc__[] =
  259. "close() -- close access to large object data.";
  261. static PyObject *
  262. pglarge_close(pglargeobject * self, PyObject * args)
  263. {
  264. /* checks args */
  265. if (!PyArg_ParseTuple(args, ""))
  266. {
  267. PyErr_SetString(PyExc_SyntaxError,
  268. "method close() takes no parameters.");
  269. return NULL;
  270. }
  272. /* checks validity */
  273. if (!check_lo_obj(self, CHECK_OPEN))
  274. return NULL;
  276. /* closes large object */
  277. if (lo_close(self->pgcnx->cnx, self->lo_fd))
  278. {
  279. PyErr_SetString(PyExc_IOError, "error while closing large object fd.");
  280. return NULL;
  281. }
  282. self->lo_fd = -1;
  284. /* no error : returns Py_None */
  285. Py_INCREF(Py_None);
  286. return Py_None;
  287. }
  289. /* reads from large object */
  290. static char pglarge_read__doc__[] =
  291. "read(integer) -- read from large object to sized string. "
  292. "Object must be opened in read mode before calling this method.";
  294. static PyObject *
  295. pglarge_read(pglargeobject * self, PyObject * args)
  296. {
  297. int size;
  298. PyObject   *buffer;
  300. /* checks validity */
  301. if (!check_lo_obj(self, CHECK_OPEN))
  302. return NULL;
  304. /* gets arguments */
  305. if (!PyArg_ParseTuple(args, "i", &size))
  306. {
  307. PyErr_SetString(PyExc_TypeError, "read(size), wih size (integer).");
  308. return NULL;
  309. }
  311. if (size <= 0)
  312. {
  313. PyErr_SetString(PyExc_ValueError, "size must be positive.");
  314. return NULL;
  315. }
  317. /* allocate buffer and runs read */
  318. buffer = PyString_FromStringAndSize((char *) NULL, size);
  320. if ((size = lo_read(self->pgcnx->cnx, self->lo_fd, BUF(buffer), size)) < 0)
  321. {
  322. PyErr_SetString(PyExc_IOError, "error while reading.");
  323. Py_XDECREF(buffer);
  324. return NULL;
  325. }
  327. /* resize buffer and returns it */
  328. _PyString_Resize(&buffer, size);
  329. return buffer;
  330. }
  332. /* write to large object */
  333. static char pglarge_write__doc__[] =
  334. "write(string) -- write sized string to large object. "
  335. "Object must be opened in read mode before calling this method.";
  337. static PyObject *
  338. pglarge_write(pglargeobject * self, PyObject * args)
  339. {
  340. char    *buffer;
  341. int size;
  343. /* checks validity */
  344. if (!check_lo_obj(self, CHECK_OPEN))
  345. return NULL;
  347. /* gets arguments */
  348. if (!PyArg_ParseTuple(args, "s", &buffer))
  349. {
  350. PyErr_SetString(PyExc_TypeError,
  351. "write(buffer), with buffer (sized string).");
  352. return NULL;
  353. }
  355. /* sends query */
  356. if ((size = lo_write(self->pgcnx->cnx, self->lo_fd, buffer,
  357.  strlen(buffer))) < strlen(buffer))
  358. {
  359. PyErr_SetString(PyExc_IOError, "buffer truncated during write.");
  360. return NULL;
  361. }
  363. /* no error : returns Py_None */
  364. Py_INCREF(Py_None);
  365. return Py_None;
  366. }
  368. /* go to position in large object */
  369. static char pglarge_seek__doc__[] =
  370. "seek(off, whence) -- move to specified position. Object must be opened "
  371. "before calling this method. whence can be SEEK_SET, SEEK_CUR or SEEK_END, "
  372. "constants defined by module.";
  374. static PyObject *
  375. pglarge_lseek(pglargeobject * self, PyObject * args)
  376. {
  377. /* offset and whence are initialized to keep compiler happy */
  378. int ret,
  379. offset = 0,
  380. whence = 0;
  382. /* checks validity */
  383. if (!check_lo_obj(self, CHECK_OPEN))
  384. return NULL;
  386. /* gets arguments */
  387. if (!PyArg_ParseTuple(args, "ii", &offset, &whence))
  388. {
  389. PyErr_SetString(PyExc_TypeError,
  390. "lseek(offset, whence), with offset and whence (integers).");
  391. return NULL;
  392. }
  394. /* sends query */
  395. if ((ret = lo_lseek(self->pgcnx->cnx, self->lo_fd, offset, whence)) == -1)
  396. {
  397. PyErr_SetString(PyExc_IOError, "error while moving cursor.");
  398. return NULL;
  399. }
  401. /* returns position */
  402. return PyInt_FromLong(ret);
  403. }
  405. /* gets large object size */
  406. static char pglarge_size__doc__[] =
  407. "size() -- return large object size. "
  408. "Object must be opened before calling this method.";
  410. static PyObject *
  411. pglarge_size(pglargeobject * self, PyObject * args)
  412. {
  413. int start,
  414. end;
  416. /* checks args */
  417. if (!PyArg_ParseTuple(args, ""))
  418. {
  419. PyErr_SetString(PyExc_SyntaxError,
  420. "method size() takes no parameters.");
  421. return NULL;
  422. }
  424. /* checks validity */
  425. if (!check_lo_obj(self, CHECK_OPEN))
  426. return NULL;
  428. /* gets current position */
  429. if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
  430. {
  431. PyErr_SetString(PyExc_IOError, "error while getting current position.");
  432. return NULL;
  433. }
  435. /* gets end position */
  436. if ((end = lo_lseek(self->pgcnx->cnx, self->lo_fd, 0, SEEK_END)) == -1)
  437. {
  438. PyErr_SetString(PyExc_IOError, "error while getting end position.");
  439. return NULL;
  440. }
  442. /* move back to start position */
  443. if ((start = lo_lseek(self->pgcnx->cnx, self->lo_fd, start, SEEK_SET)) == -1)
  444. {
  445. PyErr_SetString(PyExc_IOError,
  446. "error while moving back to first position.");
  447. return NULL;
  448. }
  450. /* returns size */
  451. return PyInt_FromLong(end);
  452. }
  454. /* gets large object cursor position */
  455. static char pglarge_tell__doc__[] =
  456. "tell() -- give current position in large object. "
  457. "Object must be opened before calling this method.";
  459. static PyObject *
  460. pglarge_tell(pglargeobject * self, PyObject * args)
  461. {
  462. int start;
  464. /* checks args */
  465. if (!PyArg_ParseTuple(args, ""))
  466. {
  467. PyErr_SetString(PyExc_SyntaxError,
  468. "method tell() takes no parameters.");
  469. return NULL;
  470. }
  472. /* checks validity */
  473. if (!check_lo_obj(self, CHECK_OPEN))
  474. return NULL;
  476. /* gets current position */
  477. if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
  478. {
  479. PyErr_SetString(PyExc_IOError, "error while getting position.");
  480. return NULL;
  481. }
  483. /* returns size */
  484. return PyInt_FromLong(start);
  485. }
  487. /* exports large object as unix file */
  488. static char pglarge_export__doc__[] =
  489. "export(string) -- export large object data to specified file. "
  490. "Object must be closed when calling this method.";
  492. static PyObject *
  493. pglarge_export(pglargeobject * self, PyObject * args)
  494. {
  495. char    *name;
  497. /* checks validity */
  498. if (!check_lo_obj(self, CHECK_CLOSE))
  499. return NULL;
  501. /* gets arguments */
  502. if (!PyArg_ParseTuple(args, "s", &name))
  503. {
  504. PyErr_SetString(PyExc_TypeError,
  505. "export(filename), with filename (string).");
  506. return NULL;
  507. }
  509. /* runs command */
  510. if (!lo_export(self->pgcnx->cnx, self->lo_oid, name))
  511. {
  512. PyErr_SetString(PyExc_IOError, "error while exporting large object.");
  513. return NULL;
  514. }
  516. Py_INCREF(Py_None);
  517. return Py_None;
  518. }
  520. /* deletes a large object */
  521. static char pglarge_unlink__doc__[] =
  522. "unlink() -- destroy large object. "
  523. "Object must be closed when calling this method.";
  525. static PyObject *
  526. pglarge_unlink(pglargeobject * self, PyObject * args)
  527. {
  528. /* checks args */
  529. if (!PyArg_ParseTuple(args, ""))
  530. {
  531. PyErr_SetString(PyExc_SyntaxError,
  532. "method unlink() takes no parameters.");
  533. return NULL;
  534. }
  536. /* checks validity */
  537. if (!check_lo_obj(self, CHECK_CLOSE))
  538. return NULL;
  540. /* deletes the object, invalidate it on success */
  541. if (!lo_unlink(self->pgcnx->cnx, self->lo_oid))
  542. {
  543. PyErr_SetString(PyExc_IOError, "error while unlinking large object");
  544. return NULL;
  545. }
  546. self->lo_oid = 0;
  548. Py_INCREF(Py_None);
  549. return Py_None;
  550. }
  552. /* large object methods */
  553. static struct PyMethodDef pglarge_methods[] = {
  554. {"open", (PyCFunction) pglarge_open, 1, pglarge_open__doc__},
  555. {"close", (PyCFunction) pglarge_close, 1, pglarge_close__doc__},
  556. {"read", (PyCFunction) pglarge_read, 1, pglarge_read__doc__},
  557. {"write", (PyCFunction) pglarge_write, 1, pglarge_write__doc__},
  558. {"seek", (PyCFunction) pglarge_lseek, 1, pglarge_seek__doc__},
  559. {"size", (PyCFunction) pglarge_size, 1, pglarge_size__doc__},
  560. {"tell", (PyCFunction) pglarge_tell, 1, pglarge_tell__doc__},
  561. {"export", (PyCFunction) pglarge_export, 1, pglarge_export__doc__},
  562. {"unlink", (PyCFunction) pglarge_unlink, 1, pglarge_unlink__doc__},
  563. {NULL, NULL}
  564. };
  566. /* get attribute */
  567. static PyObject *
  568. pglarge_getattr(pglargeobject * self, char *name)
  569. {
  570. /* list postgreSQL large object fields */
  572. /* associated pg connection object */
  573. if (!strcmp(name, "pgcnx"))
  574. {
  575. if (check_lo_obj(self, 0))
  576. {
  577. Py_INCREF(self->pgcnx);
  578. return (PyObject *) (self->pgcnx);
  579. }
  581. Py_INCREF(Py_None);
  582. return Py_None;
  583. }
  585. /* large object oid */
  586. if (!strcmp(name, "oid"))
  587. {
  588. if (check_lo_obj(self, 0))
  589. return PyInt_FromLong(self->lo_oid);
  591. Py_INCREF(Py_None);
  592. return Py_None;
  593. }
  595. /* error (status) message */
  596. if (!strcmp(name, "error"))
  597. return PyString_FromString(PQerrorMessage(self->pgcnx->cnx));
  599. /* attributes list */
  600. if (!strcmp(name, "__members__"))
  601. {
  602. PyObject   *list = PyList_New(3);
  604. if (list)
  605. {
  606. PyList_SetItem(list, 0, PyString_FromString("oid"));
  607. PyList_SetItem(list, 1, PyString_FromString("pgcnx"));
  608. PyList_SetItem(list, 2, PyString_FromString("error"));
  609. }
  611. return list;
  612. }
  614. /* module name */
  615. if (!strcmp(name, "__module__"))
  616. return PyString_FromString(MODULE_NAME);
  618. /* class name */
  619. if (!strcmp(name, "__class__"))
  620. return PyString_FromString("pglarge");
  622. /* seeks name in methods (fallback) */
  623. return Py_FindMethod(pglarge_methods, (PyObject *) self, name);
  624. }
  626. /* prints query object in human readable format */
  627. static int
  628. pglarge_print(pglargeobject * self, FILE *fp, int flags)
  629. {
  630. char print_buffer[128];
  632. if (self->lo_fd >= 0)
  633. {
  634. snprintf(print_buffer, sizeof(print_buffer),
  635.  "Opened large object, oid %ld", (long) self->lo_oid);
  636. fputs(print_buffer, fp);
  637. }
  638. else
  639. {
  640. snprintf(print_buffer, sizeof(print_buffer),
  641.  "Closed large object, oid %ld", (long) self->lo_oid);
  642. fputs(print_buffer, fp);
  643. }
  645. return 0;
  646. };
  648. /* object type definition */
  649. staticforward PyTypeObject PglargeType = {
  650. PyObject_HEAD_INIT(NULL)
  651. 0, /* ob_size */
  652. "pglarge", /* tp_name */
  653. sizeof(pglargeobject), /* tp_basicsize */
  654. 0, /* tp_itemsize */
  656. /* methods */
  657. (destructor) pglarge_dealloc, /* tp_dealloc */
  658. (printfunc) pglarge_print, /* tp_print */
  659. (getattrfunc) pglarge_getattr, /* tp_getattr */
  660. 0, /* tp_setattr */
  661. 0, /* tp_compare */
  662. 0, /* tp_repr */
  663. 0, /* tp_as_number */
  664. 0, /* tp_as_sequence */
  665. 0, /* tp_as_mapping */
  666. 0, /* tp_hash */
  667. };
  669. #endif  /* LARGE_OBJECTS */
  672. /* --------------------------------------------------------------------- */
  673. /* PG QUERY OBJECT IMPLEMENTATION */
  675. /* connects to a database */
  676. static char connect__doc__[] =
  677. "connect(dbname, host, port, opt, tty) -- connect to a PostgreSQL database "
  678. "using specified parameters (optionals, keywords aware).";
  680. static PyObject *
  681. pgconnect(pgobject * self, PyObject * args, PyObject * dict)
  682. {
  683. static const char *kwlist[] = {"dbname", "host", "port", "opt",
  684. "tty", "user", "passwd", NULL};
  685. char    *pghost,
  686.    *pgopt,
  687.    *pgtty,
  688.    *pgdbname,
  689.    *pguser,
  690.    *pgpasswd;
  691. int pgport;
  692. char port_buffer[20];
  693. pgobject   *npgobj;
  695. pghost = pgopt = pgtty = pgdbname = pguser = pgpasswd = NULL;
  696. pgport = -1;
  698. /*
  699.  * parses standard arguments With the right compiler warnings, this
  700.  * will issue a diagnostic. There is really no way around it.  If I
  701.  * don't declare kwlist as const char *kwlist[] then it complains when
  702.  * I try to assign all those constant strings to it.
  703.  */
  704. if (!PyArg_ParseTupleAndKeywords(args, dict, "|zzlzzzz", kwlist,
  705. &pgdbname, &pghost, &pgport, &pgopt, &pgtty, &pguser, &pgpasswd))
  706. return NULL;
  708. #ifdef DEFAULT_VARS
  709. /* handles defaults variables (for unintialised vars) */
  710. if ((!pghost) && (pg_default_host != Py_None))
  711. pghost = PyString_AsString(pg_default_host);
  713. if ((pgport == -1) && (pg_default_port != Py_None))
  714. pgport = PyInt_AsLong(pg_default_port);
  716. if ((!pgopt) && (pg_default_opt != Py_None))
  717. pgopt = PyString_AsString(pg_default_opt);
  719. if ((!pgtty) && (pg_default_tty != Py_None))
  720. pgtty = PyString_AsString(pg_default_tty);
  722. if ((!pgdbname) && (pg_default_base != Py_None))
  723. pgdbname = PyString_AsString(pg_default_base);
  725. if ((!pguser) && (pg_default_user != Py_None))
  726. pguser = PyString_AsString(pg_default_user);
  728. if ((!pgpasswd) && (pg_default_passwd != Py_None))
  729. pgpasswd = PyString_AsString(pg_default_passwd);
  730. #endif  /* DEFAULT_VARS */
  732. if ((npgobj = PyObject_NEW(pgobject, &PgType)) == NULL)
  733. return NULL;
  735. if (pgport != -1)
  736. {
  737. bzero(port_buffer, sizeof(port_buffer));
  738. sprintf(port_buffer, "%d", pgport);
  739. npgobj->cnx = PQsetdbLogin(pghost, port_buffer, pgopt, pgtty, pgdbname,
  740.    pguser, pgpasswd);
  741. }
  742. else
  743. npgobj->cnx = PQsetdbLogin(pghost, NULL, pgopt, pgtty, pgdbname,
  744.    pguser, pgpasswd);
  746. if (PQstatus(npgobj->cnx) == CONNECTION_BAD)
  747. {
  748. PyErr_SetString(PGError, PQerrorMessage(npgobj->cnx));
  749. Py_XDECREF(npgobj);
  750. return NULL;
  751. }
  753. return (PyObject *) npgobj;
  754. }
  756. /* pgobject methods */
  758. /* destructor */
  759. static void
  760. pg_dealloc(pgobject * self)
  761. {
  762. if (self->cnx)
  763. PQfinish(self->cnx);
  765. PyMem_DEL(self);
  766. }
  768. /* close without deleting */
  769. static char pg_close__doc__[] =
  770. "close() -- close connection. All instances of the connection object and "
  771. "derived objects (queries and large objects) can no longer be used after "
  772. "this call.";
  774. static PyObject *
  775. pg_close(pgobject * self, PyObject * args)
  776. {
  777. /* gets args */
  778. if (!PyArg_ParseTuple(args, ""))
  779. {
  780. PyErr_SetString(PyExc_TypeError, "close().");
  781. return NULL;
  782. }
  784. if (self->cnx)
  785. PQfinish(self->cnx);
  787. self->cnx = NULL;
  788. Py_INCREF(Py_None);
  789. return Py_None;
  790. }
  792. static void
  793. pgquery_dealloc(pgqueryobject * self)
  794. {
  795. if (self->last_result)
  796. PQclear(self->last_result);
  798. PyMem_DEL(self);
  799. }
  801. /* resets connection */
  802. static char pg_reset__doc__[] =
  803. "reset() -- reset connection with current parameters. All derived queries "
  804. "and large objects derived from this connection will not be usable after "
  805. "this call.";
  807. static PyObject *
  808. pg_reset(pgobject * self, PyObject * args)
  809. {
  810. if (!self->cnx)
  811. {
  812. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  813. return NULL;
  814. }
  816. /* checks args */
  817. if (!PyArg_ParseTuple(args, ""))
  818. {
  819. PyErr_SetString(PyExc_SyntaxError,
  820. "method reset() takes no parameters.");
  821. return NULL;
  822. }
  824. /* resets the connection */
  825. PQreset(self->cnx);
  826. Py_INCREF(Py_None);
  827. return Py_None;
  828. }
  830. /* get connection socket */
  831. static char pg_fileno__doc__[] =
  832. "fileno() -- return database connection socket file handle.";
  834. static PyObject *
  835. pg_fileno(pgobject * self, PyObject * args)
  836. {
  837. if (!self->cnx)
  838. {
  839. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  840. return NULL;
  841. }
  843. /* checks args */
  844. if (!PyArg_ParseTuple(args, ""))
  845. {
  846. PyErr_SetString(PyExc_SyntaxError,
  847. "method fileno() takes no parameters.");
  848. return NULL;
  849. }
  851. #ifdef NO_PQSOCKET
  852. return PyInt_FromLong((long) self->cnx->sock);
  853. #else
  854. return PyInt_FromLong((long) PQsocket(self->cnx));
  855. #endif
  856. }
  858. /* get number of rows */
  859. static char pgquery_ntuples__doc__[] =
  860. "ntuples() -- returns number of tuples returned by query.";
  862. static PyObject *
  863. pgquery_ntuples(pgqueryobject * self, PyObject * args)
  864. {
  865. /* checks args */
  866. if (!PyArg_ParseTuple(args, ""))
  867. {
  868. PyErr_SetString(PyExc_SyntaxError,
  869. "method ntuples() takes no parameters.");
  870. return NULL;
  871. }
  873. return PyInt_FromLong((long) PQntuples(self->last_result));
  874. }
  876. /* list fields names from query result */
  877. static char pgquery_listfields__doc__[] =
  878. "listfields() -- Lists field names from result.";
  880. static PyObject *
  881. pgquery_listfields(pgqueryobject * self, PyObject * args)
  882. {
  883. int i,
  884. n;
  885. char    *name;
  886. PyObject   *fieldstuple,
  887.    *str;
  889. /* checks args */
  890. if (!PyArg_ParseTuple(args, ""))
  891. {
  892. PyErr_SetString(PyExc_SyntaxError,
  893. "method listfields() takes no parameters.");
  894. return NULL;
  895. }
  897. /* builds tuple */
  898. n = PQnfields(self->last_result);
  899. fieldstuple = PyTuple_New(n);
  901. for (i = 0; i < n; i++)
  902. {
  903. name = PQfname(self->last_result, i);
  904. str = PyString_FromString(name);
  905. PyTuple_SetItem(fieldstuple, i, str);
  906. }
  908. return fieldstuple;
  909. }
  911. /* get field name from last result */
  912. static char pgquery_fieldname__doc__[] =
  913. "fieldname() -- returns name of field from result from its position.";
  915. static PyObject *
  916. pgquery_fieldname(pgqueryobject * self, PyObject * args)
  917. {
  918. int i;
  919. char    *name;
  921. /* gets args */
  922. if (!PyArg_ParseTuple(args, "i", &i))
  923. {
  924. PyErr_SetString(PyExc_TypeError,
  925. "fieldname(number), with number(integer).");
  926. return NULL;
  927. }
  929. /* checks number validity */
  930. if (i >= PQnfields(self->last_result))
  931. {
  932. PyErr_SetString(PyExc_ValueError, "invalid field number.");
  933. return NULL;
  934. }
  936. /* gets fields name and builds object */
  937. name = PQfname(self->last_result, i);
  938. return PyString_FromString(name);
  939. }
  941. /* gets fields number from name in last result */
  942. static char pgquery_fieldnum__doc__[] =
  943. "fieldnum() -- returns position in query for field from its name.";
  945. static PyObject *
  946. pgquery_fieldnum(pgqueryobject * self, PyObject * args)
  947. {
  948. char    *name;
  949. int num;
  951. /* gets args */
  952. if (!PyArg_ParseTuple(args, "s", &name))
  953. {
  954. PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string).");
  955. return NULL;
  956. }
  958. /* gets field number */
  959. if ((num = PQfnumber(self->last_result, name)) == -1)
  960. {
  961. PyErr_SetString(PyExc_ValueError, "Unknown field.");
  962. return NULL;
  963. }
  965. return PyInt_FromLong(num);
  966. }
  968. /* retrieves last result */
  969. static char pgquery_getresult__doc__[] =
  970. "getresult() -- Gets the result of a query.  The result is returned "
  971. "as a list of rows, each one a list of fields in the order returned "
  972. "by the server.";
  974. static PyObject *
  975. pgquery_getresult(pgqueryobject * self, PyObject * args)
  976. {
  977. PyObject   *rowtuple,
  978.    *reslist,
  979.    *val;
  980. int i,
  981. j,
  982. m,
  983. n,
  984.    *typ;
  986. /* checks args (args == NULL for an internal call) */
  987. if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
  988. {
  989. PyErr_SetString(PyExc_SyntaxError,
  990. "method getresult() takes no parameters.");
  991. return NULL;
  992. }
  994. /* stores result in tuple */
  995. reslist = PyList_New(0);
  996. m = PQntuples(self->last_result);
  997. n = PQnfields(self->last_result);
  999. if ((typ = malloc(sizeof(int) * n)) == NULL)
  1000. {
  1001. PyErr_SetString(PyExc_SyntaxError, "memory error in getresult().");
  1002. return NULL;
  1003. }
  1005. for (j = 0; j < n; j++)
  1006. {
  1007. switch (PQftype(self->last_result, j))
  1008. {
  1009. case INT2OID:
  1010. case INT4OID:
  1011. case OIDOID:
  1012. typ[j] = 1;
  1013. break;
  1015. case FLOAT4OID:
  1016. case FLOAT8OID:
  1017. typ[j] = 2;
  1018. break;
  1020. case CASHOID:
  1021. typ[j] = 3;
  1022. break;
  1024. default:
  1025. typ[j] = 4;
  1026. break;
  1027. }
  1028. }
  1030. for (i = 0; i < m; i++)
  1031. {
  1032. rowtuple = PyTuple_New(n);
  1033. for (j = 0; j < n; j++)
  1034. {
  1035. int k;
  1036. char    *s = PQgetvalue(self->last_result, i, j);
  1037. char cashbuf[64];
  1039. switch (typ[j])
  1040. {
  1041. case 1:
  1042. val = PyInt_FromLong(strtol(s, NULL, 10));
  1043. break;
  1045. case 2:
  1046. val = PyFloat_FromDouble(strtod(s, NULL));
  1047. break;
  1049. case 3: /* get rid of the '$' and commas */
  1050. if (*s == '$') /* there's talk of getting rid of
  1051.  * it */
  1052. s++;
  1054. if ((s[0] == '-' || s[0] == '(') && s[1] == '$')
  1055. *(++s) = '-';
  1057. for (k = 0; *s; s++)
  1058. if (*s != ',')
  1059. cashbuf[k++] = *s;
  1061. cashbuf[k] = 0;
  1062. val = PyFloat_FromDouble(strtod(cashbuf, NULL));
  1063. break;
  1065. default:
  1066. val = PyString_FromString(s);
  1067. break;
  1068. }
  1070. PyTuple_SetItem(rowtuple, j, val);
  1071. }
  1073. PyList_Append(reslist, rowtuple);
  1074. Py_XDECREF(rowtuple);
  1075. }
  1077. free(typ);
  1079. /* returns list */
  1080. return reslist;
  1081. }
  1083. /* retrieves last result as a list of dictionaries*/
  1084. static char pgquery_dictresult__doc__[] =
  1085. "dictresult() -- Gets the result of a query.  The result is returned "
  1086. "as a list of rows, each one a dictionary with the field names used "
  1087. "as the labels.";
  1089. static PyObject *
  1090. pgquery_dictresult(pgqueryobject * self, PyObject * args)
  1091. {
  1092. PyObject   *dict,
  1093.    *reslist,
  1094.    *val;
  1095. int i,
  1096. j,
  1097. m,
  1098. n,
  1099.    *typ;
  1101. /* checks args (args == NULL for an internal call) */
  1102. if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
  1103. {
  1104. PyErr_SetString(PyExc_SyntaxError,
  1105. "method getresult() takes no parameters.");
  1106. return NULL;
  1107. }
  1109. /* stores result in list */
  1110. reslist = PyList_New(0);
  1111. m = PQntuples(self->last_result);
  1112. n = PQnfields(self->last_result);
  1114. if ((typ = malloc(sizeof(int) * n)) == NULL)
  1115. {
  1116. PyErr_SetString(PyExc_SyntaxError, "memory error in dictresult().");
  1117. return NULL;
  1118. }
  1120. for (j = 0; j < n; j++)
  1121. {
  1122. switch (PQftype(self->last_result, j))
  1123. {
  1124. case INT2OID:
  1125. case INT4OID:
  1126. case OIDOID:
  1127. typ[j] = 1;
  1128. break;
  1130. case FLOAT4OID:
  1131. case FLOAT8OID:
  1132. typ[j] = 2;
  1133. break;
  1135. case CASHOID:
  1136. typ[j] = 3;
  1137. break;
  1139. default:
  1140. typ[j] = 4;
  1141. break;
  1142. }
  1143. }
  1145. for (i = 0; i < m; i++)
  1146. {
  1147. dict = PyDict_New();
  1148. for (j = 0; j < n; j++)
  1149. {
  1150. int k;
  1151. char    *s = PQgetvalue(self->last_result, i, j);
  1152. char cashbuf[64];
  1154. switch (typ[j])
  1155. {
  1156. case 1:
  1157. val = PyInt_FromLong(strtol(s, NULL, 10));
  1158. break;
  1160. case 2:
  1161. val = PyFloat_FromDouble(strtod(s, NULL));
  1162. break;
  1164. case 3: /* get rid of the '$' and commas */
  1165. if (*s == '$') /* there's talk of getting rid of
  1166.  * it */
  1167. s++;
  1169. if ((s[0] == '-' || s[0] == '(') && s[1] == '$')
  1170. *(++s) = '-';
  1172. for (k = 0; *s; s++)
  1173. if (*s != ',')
  1174. cashbuf[k++] = *s;
  1176. cashbuf[k] = 0;
  1177. val = PyFloat_FromDouble(strtod(cashbuf, NULL));
  1178. break;
  1180. default:
  1181. val = PyString_FromString(s);
  1182. break;
  1183. }
  1185. PyDict_SetItemString(dict, PQfname(self->last_result, j), val);
  1186. Py_XDECREF(val);
  1187. }
  1189. PyList_Append(reslist, dict);
  1190. Py_XDECREF(dict);
  1191. }
  1193. free(typ);
  1195. /* returns list */
  1196. return reslist;
  1197. }
  1199. /* gets asynchronous notify */
  1200. static char pg_getnotify__doc__[] =
  1201. "getnotify() -- get database notify for this connection.";
  1203. static PyObject *
  1204. pg_getnotify(pgobject * self, PyObject * args)
  1205. {
  1206. PGnotify   *notify;
  1207. PGresult   *result;
  1208. PyObject   *notify_result,
  1209.    *temp;
  1211. if (!self->cnx)
  1212. {
  1213. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1214. return NULL;
  1215. }
  1217. /* checks args */
  1218. if (!PyArg_ParseTuple(args, ""))
  1219. {
  1220. PyErr_SetString(PyExc_SyntaxError,
  1221. "method getnotify() takes no parameters.");
  1222. return NULL;
  1223. }
  1225. /* gets notify and builds result */
  1227. /*
  1228.  * notifies only come back as result of a query, so I send an empty
  1229.  * query
  1230.  */
  1231. result = PQexec(self->cnx, " ");
  1233. if ((notify = PQnotifies(self->cnx)) != NULL)
  1234. {
  1235. notify_result = PyTuple_New(2);
  1236. temp = PyString_FromString(notify->relname);
  1237. PyTuple_SetItem(notify_result, 0, temp);
  1238. temp = PyInt_FromLong(notify->be_pid);
  1239. PyTuple_SetItem(notify_result, 1, temp);
  1240. free(notify);
  1241. }
  1242. else
  1243. {
  1244. Py_INCREF(Py_None);
  1245. notify_result = Py_None;
  1246. }
  1248. PQclear(result);
  1250. /* returns result */
  1251. return notify_result;
  1252. }
  1254. /* database query */
  1255. static char pg_query__doc__[] =
  1256. "query() -- creates a new query object for this connection.";
  1258. static PyObject *
  1259. pg_query(pgobject * self, PyObject * args)
  1260. {
  1261. char    *query;
  1262. PGresult   *result;
  1263. pgqueryobject *npgobj;
  1264. int status;
  1266. if (!self->cnx)
  1267. {
  1268. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1269. return NULL;
  1270. }
  1272. /* get query args */
  1273. if (!PyArg_ParseTuple(args, "s", &query))
  1274. {
  1275. PyErr_SetString(PyExc_TypeError, "query(sql), with sql (string).");
  1276. return NULL;
  1277. }
  1279. /* gets result */
  1280. result = PQexec(self->cnx, query);
  1282. /* checks result validity */
  1283. if (!result)
  1284. {
  1285. PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
  1286. return NULL;
  1287. }
  1289. /* checks result status */
  1290. if ((status = PQresultStatus(result)) != PGRES_TUPLES_OK)
  1291. {
  1292. const char *str;
  1294. PQclear(result);
  1296. switch (status)
  1297. {
  1298. case PGRES_EMPTY_QUERY:
  1299. PyErr_SetString(PyExc_ValueError, "empty query.");
  1300. break;
  1301. case PGRES_BAD_RESPONSE:
  1302. case PGRES_FATAL_ERROR:
  1303. case PGRES_NONFATAL_ERROR:
  1304. PyErr_SetString(PGError, PQerrorMessage(self->cnx));
  1305. break;
  1306. case PGRES_COMMAND_OK: /* could be an INSERT */
  1307. if (*(str = PQoidStatus(result)) == 0) /* nope */
  1308. {
  1309. Py_INCREF(Py_None);
  1310. return Py_None;
  1311. }
  1313. /* otherwise, return the oid */
  1314. return PyInt_FromLong(strtol(str, NULL, 10));
  1316. case PGRES_COPY_OUT: /* no data will be received */
  1317. case PGRES_COPY_IN:
  1318. Py_INCREF(Py_None);
  1319. return Py_None;
  1320. default:
  1321. PyErr_SetString(PGError, "internal error: "
  1322. "unknown result status.");
  1323. break;
  1324. }
  1326. return NULL; /* error detected on query */
  1327. }
  1329. if ((npgobj = PyObject_NEW(pgqueryobject, &PgQueryType)) == NULL)
  1330. return NULL;
  1332. /* stores result and returns object */
  1333. npgobj->last_result = result;
  1334. return (PyObject *) npgobj;
  1335. }
  1337. #ifdef DIRECT_ACCESS
  1338. static char pg_putline__doc__[] =
  1339. "putline() -- sends a line directly to the backend";
  1341. /* direct acces function : putline */
  1342. static PyObject *
  1343. pg_putline(pgobject * self, PyObject * args)
  1344. {
  1345. char    *line;
  1347. if (!self->cnx)
  1348. {
  1349. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1350. return NULL;
  1351. }
  1353. /* reads args */
  1354. if (!PyArg_ParseTuple(args, "s", &line))
  1355. {
  1356. PyErr_SetString(PyExc_TypeError, "putline(line), with line (string).");
  1357. return NULL;
  1358. }
  1360. /* sends line to backend */
  1361. PQputline(self->cnx, line);
  1362. Py_INCREF(Py_None);
  1363. return Py_None;
  1364. }
  1366. /* direct access function : getline */
  1367. static char pg_getline__doc__[] =
  1368. "getline() -- gets a line directly from the backend.";
  1370. static PyObject *
  1371. pg_getline(pgobject * self, PyObject * args)
  1372. {
  1373. char line[MAX_BUFFER_SIZE];
  1374. PyObject   *str = NULL; /* GCC */
  1375. int ret;
  1377. if (!self->cnx)
  1378. {
  1379. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1380. return NULL;
  1381. }
  1383. /* checks args */
  1384. if (!PyArg_ParseTuple(args, ""))
  1385. {
  1386. PyErr_SetString(PyExc_SyntaxError,
  1387. "method getline() takes no parameters.");
  1388. return NULL;
  1389. }
  1391. /* gets line */
  1392. switch (PQgetline(self->cnx, line, MAX_BUFFER_SIZE))
  1393. {
  1394. case 0:
  1395. str = PyString_FromString(line);
  1396. break;
  1397. case 1:
  1398. PyErr_SetString(PyExc_MemoryError, "buffer overflow");
  1399. str = NULL;
  1400. break;
  1401. case EOF:
  1402. Py_INCREF(Py_None);
  1403. str = Py_None;
  1404. break;
  1405. }
  1407. return str;
  1408. }
  1410. /* direct access function : end copy */
  1411. static char pg_endcopy__doc__[] =
  1412. "endcopy() -- synchronizes client and server";
  1414. static PyObject *
  1415. pg_endcopy(pgobject * self, PyObject * args)
  1416. {
  1417. if (!self->cnx)
  1418. {
  1419. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1420. return NULL;
  1421. }
  1423. /* checks args */
  1424. if (!PyArg_ParseTuple(args, ""))
  1425. {
  1426. PyErr_SetString(PyExc_SyntaxError,
  1427. "method endcopy() takes no parameters.");
  1428. return NULL;
  1429. }
  1431. /* ends direct copy */
  1432. PQendcopy(self->cnx);
  1433. Py_INCREF(Py_None);
  1434. return Py_None;
  1435. }
  1437. #endif  /* DIRECT_ACCESS */
  1440. static PyObject *
  1441. pgquery_print(pgqueryobject * self, FILE *fp, int flags)
  1442. {
  1443. PQprintOpt op;
  1445. memset(&op, 0, sizeof(op));
  1446. op.align = 1;
  1447. op.header = 1;
  1448. op.fieldSep = "|";
  1449. op.pager = 1;
  1450. PQprint(fp, self->last_result, &op);
  1451. return 0;
  1452. }
  1454. /* insert table */
  1455. static char pg_inserttable__doc__[] =
  1456. "inserttable(string, list) -- insert list in table. The fields in the list "
  1457. "must be in the same order as in the table.";
  1459. static PyObject *
  1460. pg_inserttable(pgobject * self, PyObject * args)
  1461. {
  1462. PGresult   *result;
  1463. char    *table,
  1464.    *buffer,
  1465.    *temp;
  1466. char temp_buffer[256];
  1467. PyObject   *list,
  1468.    *sublist,
  1469.    *item;
  1470. PyObject   *(*getitem) (PyObject *, int);
  1471. PyObject   *(*getsubitem) (PyObject *, int);
  1472. int i,
  1473. j;
  1475. if (!self->cnx)
  1476. {
  1477. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1478. return NULL;
  1479. }
  1481. /* gets arguments */
  1482. if (!PyArg_ParseTuple(args, "sO:filter", &table, &list))
  1483. {
  1484. PyErr_SetString(PyExc_TypeError,
  1485.   "tableinsert(table, content), with table (string) "
  1486. "and content (list).");
  1487. return NULL;
  1488. }
  1490. /* checks list type */
  1491. if (PyTuple_Check(list))
  1492. getitem = PyTuple_GetItem;
  1493. else if (PyList_Check(list))
  1494. getitem = PyList_GetItem;
  1495. else
  1496. {
  1497. PyErr_SetString(PyExc_TypeError,
  1498. "second arg must be some kind of array.");
  1499. return NULL;
  1500. }
  1502. /* checks sublists type */
  1503. for (i = 0; (sublist = getitem(list, i)) != NULL; i++)
  1504. {
  1505. if (!PyTuple_Check(sublist) && !PyList_Check(sublist))
  1506. {
  1507. PyErr_SetString(PyExc_TypeError,
  1508.  "second arg must contain some kind of arrays.");
  1509. return NULL;
  1510. }
  1511. }
  1513. /* allocate buffer */
  1514. if (!(buffer = malloc(MAX_BUFFER_SIZE)))
  1515. {
  1516. PyErr_SetString(PyExc_MemoryError, "can't allocate insert buffer.");
  1517. return NULL;
  1518. }
  1520. /* starts query */
  1521. sprintf(buffer, "copy %s from stdin", table);
  1523. if (!(result = PQexec(self->cnx, buffer)))
  1524. {
  1525. free(buffer);
  1526. PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
  1527. return NULL;
  1528. }
  1530. PQclear(result);
  1532. /* feeds table */
  1533. for (i = 0; (sublist = getitem(list, i)) != NULL; i++)
  1534. {
  1535. if (PyTuple_Check(sublist))
  1536. getsubitem = PyTuple_GetItem;
  1537. else
  1538. getsubitem = PyList_GetItem;
  1540. /* builds insert line */
  1541. buffer[0] = 0;
  1543. for (j = 0; (item = getsubitem(sublist, j)) != NULL; j++)
  1544. {
  1545. /* converts item to string */
  1546. if (PyString_Check(item))
  1547. PyArg_ParseTuple(item, "s", &temp);
  1548. else if (PyInt_Check(item))
  1549. {
  1550. int k;
  1552. PyArg_ParseTuple(item, "i", &k);
  1553. sprintf(temp_buffer, "%d", k);
  1554. temp = temp_buffer;
  1555. }
  1556. else if (PyLong_Check(item))
  1557. {
  1558. long k;
  1560. PyArg_ParseTuple(item, "l", &k);
  1561. sprintf(temp_buffer, "%ld", k);
  1562. temp = temp_buffer;
  1563. }
  1564. else if (PyFloat_Check(item))
  1565. {
  1566. double k;
  1568. PyArg_ParseTuple(item, "d", &k);
  1569. sprintf(temp_buffer, "%g", k);
  1570. temp = temp_buffer;
  1571. }
  1572. else
  1573. {
  1574. free(buffer);
  1575. PyErr_SetString(PyExc_ValueError,
  1576. "items must be strings, integers, "
  1577. "longs or double (real).");
  1578. return NULL;
  1579. }
  1581. /* concats buffer */
  1582. if (strlen(buffer))
  1583. strncat(buffer, "t", MAX_BUFFER_SIZE - strlen(buffer));
  1585. fprintf(stderr, "Buffer: '%s', Temp: '%s'n", buffer, temp);
  1586. strncat(buffer, temp, MAX_BUFFER_SIZE - strlen(buffer));
  1587. }
  1589. strncat(buffer, "n", MAX_BUFFER_SIZE - strlen(buffer));
  1591. /* sends data */
  1592. PQputline(self->cnx, buffer);
  1593. }
  1595. /* ends query */
  1596. PQputline(self->cnx, ".n");
  1597. PQendcopy(self->cnx);
  1598. free(buffer);
  1600. /* no error : returns nothing */
  1601. Py_INCREF(Py_None);
  1602. return Py_None;
  1603. }
  1605. /* creates large object */
  1606. static char pg_locreate__doc__[] =
  1607. "locreate() -- creates a new large object in the database.";
  1609. static PyObject *
  1610. pg_locreate(pgobject * self, PyObject * args)
  1611. {
  1612. int mode;
  1613. Oid lo_oid;
  1615. /* checks validity */
  1616. if (!check_cnx_obj(self))
  1617. return NULL;
  1619. /* gets arguments */
  1620. if (!PyArg_ParseTuple(args, "i", &mode))
  1621. {
  1622. PyErr_SetString(PyExc_TypeError,
  1623. "locreate(mode), with mode (integer).");
  1624. return NULL;
  1625. }
  1627. /* creates large object */
  1628. lo_oid = lo_creat(self->cnx, mode);
  1629. if (lo_oid == 0)
  1630. {
  1631. PyErr_SetString(PGError, "can't create large object.");
  1632. return NULL;
  1633. }
  1635. return (PyObject *) pglarge_new(self, lo_oid);
  1636. }
  1638. /* init from already known oid */
  1639. static char pg_getlo__doc__[] =
  1640. "getlo(long) -- create a large object instance for the specified oid.";
  1642. static PyObject *
  1643. pg_getlo(pgobject * self, PyObject * args)
  1644. {
  1645. int lo_oid;
  1647. /* checks validity */
  1648. if (!check_cnx_obj(self))
  1649. return NULL;
  1651. /* gets arguments */
  1652. if (!PyArg_ParseTuple(args, "i", &lo_oid))
  1653. {
  1654. PyErr_SetString(PyExc_TypeError, "loopen(oid), with oid (integer).");
  1655. return NULL;
  1656. }
  1658. if (!lo_oid)
  1659. {
  1660. PyErr_SetString(PyExc_ValueError, "the object oid can't be null.");
  1661. return NULL;
  1662. }
  1664. /* creates object */
  1665. return (PyObject *) pglarge_new(self, lo_oid);
  1666. }
  1668. /* import unix file */
  1669. static char pg_loimport__doc__[] =
  1670. "loimport(string) -- create a new large object from specified file.";
  1672. static PyObject *
  1673. pg_loimport(pgobject * self, PyObject * args)
  1674. {
  1675. char    *name;
  1676. Oid lo_oid;
  1678. /* checks validity */
  1679. if (!check_cnx_obj(self))
  1680. return NULL;
  1682. /* gets arguments */
  1683. if (!PyArg_ParseTuple(args, "s", &name))
  1684. {
  1685. PyErr_SetString(PyExc_TypeError, "loimport(name), with name (string).");
  1686. return NULL;
  1687. }
  1689. /* imports file and checks result */
  1690. lo_oid = lo_import(self->cnx, name);
  1691. if (lo_oid == 0)
  1692. {
  1693. PyErr_SetString(PGError, "can't create large object.");
  1694. return NULL;
  1695. }
  1697. return (PyObject *) pglarge_new(self, lo_oid);
  1698. }
  1701. /* connection object methods */
  1702. static struct PyMethodDef pgobj_methods[] = {
  1703. {"query", (PyCFunction) pg_query, 1, pg_query__doc__},
  1704. {"reset", (PyCFunction) pg_reset, 1, pg_reset__doc__},
  1705. {"close", (PyCFunction) pg_close, 1, pg_close__doc__},
  1706. {"fileno", (PyCFunction) pg_fileno, 1, pg_fileno__doc__},
  1707. {"getnotify", (PyCFunction) pg_getnotify, 1, pg_getnotify__doc__},
  1708. {"inserttable", (PyCFunction) pg_inserttable, 1, pg_inserttable__doc__},
  1710. #ifdef DIRECT_ACCESS
  1711. {"putline", (PyCFunction) pg_putline, 1, pg_putline__doc__},
  1712. {"getline", (PyCFunction) pg_getline, 1, pg_getline__doc__},
  1713. {"endcopy", (PyCFunction) pg_endcopy, 1, pg_endcopy__doc__},
  1714. #endif  /* DIRECT_ACCESS */
  1716. #ifdef LARGE_OBJECTS
  1717. {"locreate", (PyCFunction) pg_locreate, 1, pg_locreate__doc__},
  1718. {"getlo", (PyCFunction) pg_getlo, 1, pg_getlo__doc__},
  1719. {"loimport", (PyCFunction) pg_loimport, 1, pg_loimport__doc__},
  1720. #endif  /* LARGE_OBJECTS */
  1722. {NULL, NULL} /* sentinel */
  1723. };
  1725. /* get attribute */
  1726. static PyObject *
  1727. pg_getattr(pgobject * self, char *name)
  1728. {
  1730. /*
  1731.  * Although we could check individually, there are only a few
  1732.  * attributes that don't require a live connection and unless someone
  1733.  * has an urgent need, this will have to do
  1734.  */
  1735. if (!self->cnx)
  1736. {
  1737. PyErr_SetString(PyExc_TypeError, "Connection is not valid");
  1738. return NULL;
  1739. }
  1741. /* list postgreSQL connection fields */
  1743. /* postmaster host */
  1744. if (!strcmp(name, "host"))
  1745. {
  1746. char    *r = PQhost(self->cnx);
  1748. return r ? PyString_FromString(r) : PyString_FromString("localhost");
  1749. }
  1751. /* postmaster port */
  1752. if (!strcmp(name, "port"))
  1753. return PyInt_FromLong(atol(PQport(self->cnx)));
  1755. /* selected database */
  1756. if (!strcmp(name, "db"))
  1757. return PyString_FromString(PQdb(self->cnx));
  1759. /* selected options */
  1760. if (!strcmp(name, "options"))
  1761. return PyString_FromString(PQoptions(self->cnx));
  1763. /* selected postgres tty */
  1764. if (!strcmp(name, "tty"))
  1765. return PyString_FromString(PQtty(self->cnx));
  1767. /* error (status) message */
  1768. if (!strcmp(name, "error"))
  1769. return PyString_FromString(PQerrorMessage(self->cnx));
  1771. /* connection status : 1 - OK, 0 - BAD */
  1772. if (!strcmp(name, "status"))
  1773. return PyInt_FromLong(PQstatus(self->cnx) == CONNECTION_OK ? 1 : 0);
  1775. /* provided user name */
  1776. if (!strcmp(name, "user"))
  1777. return PyString_FromString("Deprecated facility");
  1778. /* return PyString_FromString(fe_getauthname("<unknown user>")); */
  1780. /* attributes list */
  1781. if (!strcmp(name, "__members__"))
  1782. {
  1783. PyObject   *list = PyList_New(8);
  1785. if (list)
  1786. {
  1787. PyList_SetItem(list, 0, PyString_FromString("host"));
  1788. PyList_SetItem(list, 1, PyString_FromString("port"));
  1789. PyList_SetItem(list, 2, PyString_FromString("db"));
  1790. PyList_SetItem(list, 3, PyString_FromString("options"));
  1791. PyList_SetItem(list, 4, PyString_FromString("tty"));
  1792. PyList_SetItem(list, 5, PyString_FromString("error"));
  1793. PyList_SetItem(list, 6, PyString_FromString("status"));
  1794. PyList_SetItem(list, 7, PyString_FromString("user"));
  1795. }
  1797. return list;
  1798. }
  1800. return Py_FindMethod(pgobj_methods, (PyObject *) self, name);
  1801. }
  1803. /* object type definition */
  1804. staticforward PyTypeObject PgType = {
  1805. PyObject_HEAD_INIT(NULL)
  1806. 0, /* ob_size */
  1807. "pgobject", /* tp_name */
  1808. sizeof(pgobject), /* tp_basicsize */
  1809. 0, /* tp_itemsize */
  1810. /* methods */
  1811. (destructor) pg_dealloc, /* tp_dealloc */
  1812. 0, /* tp_print */
  1813. (getattrfunc) pg_getattr, /* tp_getattr */
  1814. 0, /* tp_setattr */
  1815. 0, /* tp_compare */
  1816. 0, /* tp_repr */
  1817. 0, /* tp_as_number */
  1818. 0, /* tp_as_sequence */
  1819. 0, /* tp_as_mapping */
  1820. 0, /* tp_hash */
  1821. };
  1824. /* query object methods */
  1825. static struct PyMethodDef pgquery_methods[] = {
  1826. {"getresult", (PyCFunction) pgquery_getresult, 1, pgquery_getresult__doc__},
  1827. {"dictresult", (PyCFunction) pgquery_dictresult, 1, pgquery_dictresult__doc__},
  1828. {"fieldname", (PyCFunction) pgquery_fieldname, 1, pgquery_fieldname__doc__},
  1829. {"fieldnum", (PyCFunction) pgquery_fieldnum, 1, pgquery_fieldnum__doc__},
  1830. {"listfields", (PyCFunction) pgquery_listfields, 1, pgquery_listfields__doc__},
  1831. {"ntuples", (PyCFunction) pgquery_ntuples, 1, pgquery_ntuples__doc__},
  1832. {NULL, NULL}
  1833. };
  1835. /* gets query object attributes */
  1836. static PyObject *
  1837. pgquery_getattr(pgqueryobject * self, char *name)
  1838. {
  1839. /* list postgreSQL connection fields */
  1840. return Py_FindMethod(pgquery_methods, (PyObject *) self, name);
  1841. }
  1843. /* query type definition */
  1844. staticforward PyTypeObject PgQueryType = {
  1845. PyObject_HEAD_INIT(NULL)
  1846. 0, /* ob_size */
  1847. "pgqueryobject", /* tp_name */
  1848. sizeof(pgqueryobject), /* tp_basicsize */
  1849. 0, /* tp_itemsize */
  1850. /* methods */
  1851. (destructor) pgquery_dealloc, /* tp_dealloc */
  1852. (printfunc) pgquery_print, /* tp_print */
  1853. (getattrfunc) pgquery_getattr, /* tp_getattr */
  1854. 0, /* tp_setattr */
  1855. 0, /* tp_compare */
  1856. 0, /* tp_repr */
  1857. 0, /* tp_as_number */
  1858. 0, /* tp_as_sequence */
  1859. 0, /* tp_as_mapping */
  1860. 0, /* tp_hash */
  1861. };
  1865. /* --------------------------------------------------------------------- */
  1867. /* MODULE FUNCTIONS */
  1869. #ifdef DEFAULT_VARS
  1871. /* gets default host */
  1872. static char getdefhost__doc__[] =
  1873. "get_defhost() -- return default database host.";
  1875. static PyObject *
  1876. pggetdefhost(PyObject * self, PyObject * args)
  1877. {
  1878. /* checks args */
  1879. if (!PyArg_ParseTuple(args, ""))
  1880. {
  1881. PyErr_SetString(PyExc_SyntaxError,
  1882. "method get_defhost() takes no parameter.");
  1883. return NULL;
  1884. }
  1886. Py_XINCREF(pg_default_host);
  1887. return pg_default_host;
  1888. }
  1890. /* sets default host */
  1891. static char setdefhost__doc__[] =
  1892. "set_defhost(string) -- set default database host. Return previous value.";
  1894. static PyObject *
  1895. pgsetdefhost(PyObject * self, PyObject * args)
  1896. {
  1897. char    *temp = NULL;
  1898. PyObject   *old;
  1900. /* gets arguments */
  1901. if (!PyArg_ParseTuple(args, "z", &temp))
  1902. {
  1903. PyErr_SetString(PyExc_TypeError,
  1904. "set_defhost(name), with name (string/None).");
  1905. return NULL;
  1906. }
  1908. /* adjusts value */
  1909. old = pg_default_host;
  1911. if (temp)
  1912. pg_default_host = PyString_FromString(temp);
  1913. else
  1914. {
  1915. Py_INCREF(Py_None);
  1916. pg_default_host = Py_None;
  1917. }
  1919. return old;
  1920. }
  1922. /* gets default base */
  1923. static char getdefbase__doc__[] =
  1924. "get_defbase() -- return default database name.";
  1926. static PyObject *
  1927. pggetdefbase(PyObject * self, PyObject * args)
  1928. {
  1929. /* checks args */
  1930. if (!PyArg_ParseTuple(args, ""))
  1931. {
  1932. PyErr_SetString(PyExc_SyntaxError,
  1933. "method get_defbase() takes no parameter.");
  1934. return NULL;
  1935. }
  1937. Py_XINCREF(pg_default_base);
  1938. return pg_default_base;
  1939. }
  1941. /* sets default base */
  1942. static char setdefbase__doc__[] =
  1943. "set_defbase(string) -- set default database name. Return previous value";
  1945. static PyObject *
  1946. pgsetdefbase(PyObject * self, PyObject * args)
  1947. {
  1948. char    *temp = NULL;
  1949. PyObject   *old;
  1951. /* gets arguments */
  1952. if (!PyArg_ParseTuple(args, "z", &temp))
  1953. {
  1954. PyErr_SetString(PyExc_TypeError,
  1955. "set_defbase(name), with name (string/None).");
  1956. return NULL;
  1957. }
  1959. /* adjusts value */
  1960. old = pg_default_base;
  1962. if (temp)
  1963. pg_default_base = PyString_FromString(temp);
  1964. else
  1965. {
  1966. Py_INCREF(Py_None);
  1967. pg_default_base = Py_None;
  1968. }
  1970. return old;
  1971. }
  1973. /* gets default options */
  1974. static char getdefopt__doc__[] =
  1975. "get_defopt() -- return default database options.";
  1977. static PyObject *
  1978. pggetdefopt(PyObject * self, PyObject * args)
  1979. {
  1980. /* checks args */
  1981. if (!PyArg_ParseTuple(args, ""))
  1982. {
  1983. PyErr_SetString(PyExc_SyntaxError,
  1984. "method get_defopt() takes no parameter.");
  1985. return NULL;
  1986. }
  1988. Py_XINCREF(pg_default_opt);
  1989. return pg_default_opt;
  1990. }
  1992. /* sets default opt */
  1993. static char setdefopt__doc__[] =
  1994. "set_defopt(string) -- set default database options. Return previous value.";
  1996. static PyObject *
  1997. pgsetdefopt(PyObject * self, PyObject * args)
  1998. {
  1999. char    *temp = NULL;
  2000. PyObject   *old;
  2002. /* gets arguments */
  2003. if (!PyArg_ParseTuple(args, "z", &temp))
  2004. {
  2005. PyErr_SetString(PyExc_TypeError,
  2006. "set_defopt(name), with name (string/None).");
  2007. return NULL;
  2008. }
  2010. /* adjusts value */
  2011. old = pg_default_opt;
  2013. if (temp)
  2014. pg_default_opt = PyString_FromString(temp);
  2015. else
  2016. {
  2017. Py_INCREF(Py_None);
  2018. pg_default_opt = Py_None;
  2019. }
  2021. return old;
  2022. }
  2024. /* gets default tty */
  2025. static char getdeftty__doc__[] =
  2026. "get_deftty() -- return default database debug terminal.";
  2028. static PyObject *
  2029. pggetdeftty(PyObject * self, PyObject * args)
  2030. {
  2031. /* checks args */
  2032. if (!PyArg_ParseTuple(args, ""))
  2033. {
  2034. PyErr_SetString(PyExc_SyntaxError,
  2035. "method get_deftty() takes no parameter.");
  2036. return NULL;
  2037. }
  2039. Py_XINCREF(pg_default_tty);
  2040. return pg_default_tty;
  2041. }
  2043. /* sets default tty */
  2044. static char setdeftty__doc__[] =
  2045. "set_deftty(string) -- set default database debug terminal. "
  2046. "Return previous value.";
  2048. static PyObject *
  2049. pgsetdeftty(PyObject * self, PyObject * args)
  2050. {
  2051. char    *temp = NULL;
  2052. PyObject   *old;
  2054. /* gets arguments */
  2055. if (!PyArg_ParseTuple(args, "z", &temp))
  2056. {
  2057. PyErr_SetString(PyExc_TypeError,
  2058. "set_deftty(name), with name (string/None).");
  2059. return NULL;
  2060. }
  2062. /* adjusts value */
  2063. old = pg_default_tty;
  2065. if (temp)
  2066. pg_default_tty = PyString_FromString(temp);
  2067. else
  2068. {
  2069. Py_INCREF(Py_None);
  2070. pg_default_tty = Py_None;
  2071. }
  2073. return old;
  2074. }
  2076. /* gets default username */
  2077. static char getdefuser__doc__[] =
  2078. "get_defuser() -- return default database username.";
  2080. static PyObject *
  2081. pggetdefuser(PyObject * self, PyObject * args)
  2082. {
  2083. /* checks args */
  2084. if (!PyArg_ParseTuple(args, ""))
  2085. {
  2086. PyErr_SetString(PyExc_SyntaxError,
  2087. "method get_defuser() takes no parameter.");
  2089. return NULL;
  2090. }
  2092. Py_XINCREF(pg_default_user);
  2093. return pg_default_user;
  2094. }
  2096. /* sets default username */
  2097. static char setdefuser__doc__[] =
  2098. "set_defuser() -- set default database username. Return previous value.";
  2100. static PyObject *
  2101. pgsetdefuser(PyObject * self, PyObject * args)
  2102. {
  2103. char    *temp = NULL;
  2104. PyObject   *old;
  2106. /* gets arguments */
  2107. if (!PyArg_ParseTuple(args, "z", &temp))
  2108. {
  2109. PyErr_SetString(PyExc_TypeError,
  2110. "set_defuser(name), with name (string/None).");
  2111. return NULL;
  2112. }
  2114. /* adjusts value */
  2115. old = pg_default_user;
  2117. if (temp)
  2118. pg_default_user = PyString_FromString(temp);
  2119. else
  2120. {
  2121. Py_INCREF(Py_None);
  2122. pg_default_user = Py_None;
  2123. }
  2125. return old;
  2126. }
  2128. /* sets default password */
  2129. static char setdefpasswd__doc__[] =
  2130. "set_defpasswd() -- set default database password.";
  2132. static PyObject *
  2133. pgsetdefpasswd(PyObject * self, PyObject * args)
  2134. {
  2135. char    *temp = NULL;
  2136. PyObject   *old;
  2138. /* gets arguments */
  2139. if (!PyArg_ParseTuple(args, "z", &temp))
  2140. {
  2141. PyErr_SetString(PyExc_TypeError,
  2142. "set_defpasswd(password), with password (string/None).");
  2143. return NULL;
  2144. }
  2146. /* adjusts value */
  2147. old = pg_default_passwd;
  2149. if (temp)
  2150. pg_default_passwd = PyString_FromString(temp);
  2151. else
  2152. {
  2153. Py_INCREF(Py_None);
  2154. pg_default_passwd = Py_None;
  2155. }
  2157. Py_INCREF(Py_None);
  2158. return Py_None;
  2159. }
  2161. /* gets default port */
  2162. static char getdefport__doc__[] =
  2163. "get_defport() -- return default database port.";
  2165. static PyObject *
  2166. pggetdefport(PyObject * self, PyObject * args)
  2167. {
  2168. /* checks args */
  2169. if (!PyArg_ParseTuple(args, ""))
  2170. {
  2171. PyErr_SetString(PyExc_SyntaxError,
  2172. "method get_defport() takes no parameter.");
  2173. return NULL;
  2174. }
  2176. Py_XINCREF(pg_default_port);
  2177. return pg_default_port;
  2178. }
  2180. /* sets default port */
  2181. static char setdefport__doc__[] =
  2182. "set_defport(integer) -- set default database port. Return previous value.";
  2184. static PyObject *
  2185. pgsetdefport(PyObject * self, PyObject * args)
  2186. {
  2187. long int port = -2;
  2188. PyObject   *old;
  2190. /* gets arguments */
  2191. if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
  2192. {
  2193. PyErr_SetString(PyExc_TypeError, "set_defport(port), with port "
  2194. "(positive integer/-1).");
  2195. return NULL;
  2196. }
  2198. /* adjusts value */
  2199. old = pg_default_port;
  2201. if (port != -1)
  2202. pg_default_port = PyLong_FromLong(port);
  2203. else
  2204. {
  2205. Py_INCREF(Py_None);
  2206. pg_default_port = Py_None;
  2207. }
  2209. return old;
  2210. }
  2212. #endif  /* DEFAULT_VARS */
  2214. /* List of functions defined in the module */
  2216. static struct PyMethodDef pg_methods[] = {
  2217. {"connect", (PyCFunction) pgconnect, 3, connect__doc__},
  2219. #ifdef DEFAULT_VARS
  2220. {"get_defhost", pggetdefhost, 1, getdefhost__doc__},
  2221. {"set_defhost", pgsetdefhost, 1, setdefhost__doc__},
  2222. {"get_defbase", pggetdefbase, 1, getdefbase__doc__},
  2223. {"set_defbase", pgsetdefbase, 1, setdefbase__doc__},
  2224. {"get_defopt", pggetdefopt, 1, getdefopt__doc__},
  2225. {"set_defopt", pgsetdefopt, 1, setdefopt__doc__},
  2226. {"get_deftty", pggetdeftty, 1, getdeftty__doc__},
  2227. {"set_deftty", pgsetdeftty, 1, setdeftty__doc__},
  2228. {"get_defport", pggetdefport, 1, getdefport__doc__},
  2229. {"set_defport", pgsetdefport, 1, setdefport__doc__},
  2230. {"get_defuser", pggetdefuser, 1, getdefuser__doc__},
  2231. {"set_defuser", pgsetdefuser, 1, setdefuser__doc__},
  2232. {"set_defpasswd", pgsetdefpasswd, 1, setdefpasswd__doc__},
  2233. #endif  /* DEFAULT_VARS */
  2234. {NULL, NULL} /* sentinel */
  2235. };
  2237. static char pg__doc__[] = "Python interface to PostgreSQL DB";
  2239. /* Initialization function for the module */
  2240. void init_pg(void); /* Python doesn't prototype this */
  2241. void
  2242. init_pg(void)
  2243. {
  2244. PyObject   *mod,
  2245.    *dict,
  2246.    *v;
  2248. /* Initialize here because some WIN platforms get confused otherwise */
  2249. PglargeType.ob_type = PgType.ob_type = PgQueryType.ob_type = &PyType_Type;
  2251. /* Create the module and add the functions */
  2252. mod = Py_InitModule4("_pg", pg_methods, pg__doc__, NULL, PYTHON_API_VERSION);
  2253. dict = PyModule_GetDict(mod);
  2255. /* Add some symbolic constants to the module */
  2256. PGError = PyString_FromString("pg.error");
  2257. PyDict_SetItemString(dict, "error", PGError);
  2259. /* Make the version available */
  2260. v = PyString_FromString(PyPgVersion);
  2261. PyDict_SetItemString(dict, "version", v);
  2262. PyDict_SetItemString(dict, "__version__", v);
  2263. Py_DECREF(v);
  2265. #ifdef LARGE_OBJECTS
  2266. /* create mode for large objects */
  2267. PyDict_SetItemString(dict, "INV_READ", PyInt_FromLong(INV_READ));
  2268. PyDict_SetItemString(dict, "INV_WRITE", PyInt_FromLong(INV_WRITE));
  2270. /* position flags for lo_lseek */
  2271. PyDict_SetItemString(dict, "SEEK_SET", PyInt_FromLong(SEEK_SET));
  2272. PyDict_SetItemString(dict, "SEEK_CUR", PyInt_FromLong(SEEK_CUR));
  2273. PyDict_SetItemString(dict, "SEEK_END", PyInt_FromLong(SEEK_END));
  2274. #endif  /* LARGE_OBJECTS */
  2276. #ifdef DEFAULT_VARS
  2277. /* prepares default values */
  2278. Py_INCREF(Py_None);
  2279. pg_default_host = Py_None;
  2280. Py_INCREF(Py_None);
  2281. pg_default_base = Py_None;
  2282. Py_INCREF(Py_None);
  2283. pg_default_opt = Py_None;
  2284. Py_INCREF(Py_None);
  2285. pg_default_port = Py_None;
  2286. Py_INCREF(Py_None);
  2287. pg_default_tty = Py_None;
  2288. Py_INCREF(Py_None);
  2289. pg_default_user = Py_None;
  2290. Py_INCREF(Py_None);
  2291. pg_default_passwd = Py_None;
  2292. #endif  /* DEFAULT_VARS */
  2294. /* Check for errors */
  2295. if (PyErr_Occurred())
  2296. Py_FatalError("can't initialize module _pg");
  2297. }