Skip to content

P
Postgres FD Implementation
Commit 13a0e910 authored by Marc G. Fournier's avatar Marc G. Fournier
Browse files
Options

parent 2c018f9b
Show whitespace changes
Inline Side-by-side
Showing with 0 additions and 5581 deletions
src/interfaces/python/Announce deleted 100644 → 0
View file @ 2c018f9b
Announce: Release of PyGreSQL version 3.3
=========================================
PyGreSQL v3.3 has been released.
It is available at: ftp://ftp.druid.net/pub/distrib/PyGreSQL.tgz. If
you are running NetBSD, look in the packages directory under databases.
There is also a package in the FreeBSD ports collection.
From March 1 2001 the PyGreSQL development has moved into the PostgreSQL
development tree.
PostgreSQL is a database system derived from Postgres4.2. It conforms
to (most of) ANSI SQL and offers many interesting capabilities (C
dynamic linking for functions or type definition, etc.). This package
is copyright by the Regents of the University of California, and is
freely distributable.
Python is an interpreted programming language. It is object oriented,
simple to use (light syntax, simple and straightforward statements), and
has many extensions for building GUIs, interfacing with WWW, etc. An
intelligent web browser (HotJava like) is currently under development
(November 1995), and this should open programmers many doors. Python is
copyrighted by Stichting S Mathematisch Centrum, Amsterdam, The
Netherlands, and is freely distributable.
PyGreSQL is a python module that interfaces to a PostgreSQL database. It
embeds the PostgreSQL query library to allow easy use of the powerful
PostgreSQL features from a Python script.
This release fixes a few bugs, adds a few minor features and makes a
few speedups in the code.
The next release (unless serious bugs are found) will be to match PyGreSQL
to version 2.0 of Python.
See the other changes below or in the Changelog file.
PyGreSQL 2.0 was developed and tested on a NetBSD 1.3_BETA system. It
is based on the PyGres95 code written by Pascal Andre,
andre@chimay.via.ecp.fr. I changed the version to 2.0 and updated the
code for Python 1.5 and PostgreSQL 6.2.1. While I was at it I upgraded
the code to use full ANSI style prototypes and changed the order of
arguments to connect. Later versions are fixes and enhancements to that.
The latest version of PyGreSQL works with Python 1.5.2 and PostgreSQL 7.0.x
Important changes from PyGreSQL 3.2 to PyGreSQL 3.3
- Added NUMERICOID to list of returned types. This fixes a bug when
returning aggregates in the latest version of PostgreSQL.
Important changes from PyGreSQL 3.1 to PyGreSQL 3.2
Note that there are very few changes to PostgreSQL between 3.1 and
3.2. The main reason for the release is the move into the PostgreSQL
development tree. Even the WIN32 changes are pretty minor.
- Add WIN32 support (gerhard@bigfoot.de)
- Fix some DB-API quoting problems (niall.smart@ebeon.com)
- Moved development into PostgreSQL development tree.
Important changes from PyGreSQL 3.0 to PyGreSQL 3.1
- Fix some quoting functions. In particular handle NULLs better.
- Use a method to add primary key information rather than direct
manipulation of the class structures.
- Break decimal out in _quote (in pg.py) and treat it as float.
- Treat timestamp like date for quoting purposes.
- Remove a redundant SELECT from the get method speeding it, and insert
since it calls get, up a little.
- Add test for BOOL type in typecast method to pgdbTypeCache class.
(tv@beamnet.de)
- Fix pgdb.py to send port as integer to lower level function
(dildog@l0pht.com)
- Change pg.py to speed up some operations
- Allow updates on tables with no primary keys.
Important changes from PyGreSQL 2.4 to PyGreSQL 3.0:
- Remove strlen() call from pglarge_write() and get size from object.
(Richard@Bouska.cz)
- Add a little more error checking to the quote function in the wrapper
- Add extra checking in _quote function
- Wrap query in pg.py for debugging
- Add DB-API 2.0 support to pgmodule.c (andre@via.ecp.fr)
- Add DB-API 2.0 wrapper pgdb.py (andre@via.ecp.fr)
- Correct keyword clash (temp) in tutorial
- Clean up layout of tutorial
- Return NULL values as None (rlawrence@lastfoot.com) (WARNING: This
will cause backwards compatibility issues.)
- Change None to NULL in insert and update
- Change hash-bang lines to use /usr/bin/env
- Clearing date should be blank (NULL) not TODAY
- Quote backslashes in strings in _quote (brian@CSUA.Berkeley.EDU)
- Expanded and clarified build instructions (tbryan@starship.python.net)
- Make code thread safe (Jerome.Alet@unice.fr)
- Add README.distutils (mwa@gate.net & jeremy@cnri.reston.va.us)
- Many fixes and increased DB-API compliance by chifungfan@yahoo.com,
tony@printra.net, jeremy@alum.mit.edu and others to get the final
version ready to release.
Important changes from PyGreSQL 2.3 to PyGreSQL 2.4:
- Insert returns None if the user doesn't have select permissions
on the table. It can (and does) happen that one has insert but
not select permissions on a table.
- Added ntuples() method to query object (brit@druid.net)
- Corrected a bug related to getresult() and the money type
- Corrected a bug related to negative money amounts
- Allow update based on primary key if munged oid not available and
table has a primary key
- Add many __doc__ strings. (andre@via.ecp.fr)
- Get method works with views if key specified
Important changes from PyGreSQL 2.2 to PyGreSQL 2.3:
- connect.host returns "localhost" when connected to Unix socket
(torppa@tuhnu.cutery.fi)
- Use PyArg_ParseTupleAndKeywords in connect() (torppa@tuhnu.cutery.fi)
- fixes and cleanups (torppa@tuhnu.cutery.fi)
- Fixed memory leak in dictresult() (terekhov@emc.com)
- Deprecated pgext.py - functionality now in pg.py
- More cleanups to the tutorial
- Added fileno() method - terekhov@emc.com (Mikhail Terekhov)
- added money type to quoting function
- Compiles cleanly with more warnings turned on
- Returns PostgreSQL error message on error
- Init accepts keywords (Jarkko Torppa)
- Convenience functions can be overridden (Jarkko Torppa)
- added close() method
Important changes from PyGreSQL 2.1 to PyGreSQL 2.2:
- Added user and password support thanks to Ng Pheng Siong <ngps@post1.com>
- Insert queries return the inserted oid
- Add new pg wrapper (C module renamed to _pg)
- Wrapped database connection in a class.
- Cleaned up some of the tutorial. (More work needed.)
- Added version and __version__. Thanks to thilo@eevolute.com for
the suggestion.
Important changes from PyGreSQL 2.0 to PyGreSQL 2.1:
- return fields as proper Python objects for field type
- Cleaned up pgext.py
- Added dictresult method
Important changes from Pygres95 1.0b to PyGreSQL 2.0:
- Updated code for PostgreSQL 6.2.1 and Python 1.5.
- Reformatted code and converted to ANSI .
- Changed name to PyGreSQL (from PyGres95.)
- Changed order of arguments to connect function.
- Created new type pgqueryobject and moved certain methods to it.
- Added a print function for pgqueryobject
- Various code changes - mostly stylistic.
For more information about each package, please have a look to their
web pages:
- Python : http://www.python.org/
- PostgreSQL : http://www.PostgreSQL.org/
- PyGreSQL : http://www.druid.net/pygresql/
D'Arcy J.M. Cain
darcy@druid.net
src/interfaces/python/ChangeLog deleted 100644 → 0
View file @ 2c018f9b
PyGreSQL changelog.
===================
This software is copyright (c) 1995, Pascal Andre (andre@via.ecp.fr)
Further copyright 1997, 1998 and 1999 by D'Arcy J.M. Cain (darcy@druid.net)
See file README for copyright information.
Version 3.3
A few cleanups. Mostly there was some confusion about the latest version
and so I am bumping the number to keep it straight.
- Added NUMERICOID to list of returned types. This fixes a bug when
returning aggregates.
Version 3.2
- Add WIN32 support (gerhard@bigfoot.de)
- Fix some DB-API quoting problems (niall.smart@ebeon.com)
- Moved development into PostgreSQL development tree.
Version 3.1
- Fix some quoting functions. In particular handle NULLs better.
- Use a method to add primary key information rather than direct
manipulation of the class structures.
- Break decimal out in _quote (in pg.py) and treat it as float.
- Treat timestamp like date for quoting purposes.
- Remove a redundant SELECT from the get method speeding it, and insert
since it calls get, up a little.
- Add test for BOOL type in typecast method to pgdbTypeCache class.
(tv@beamnet.de)
- Fix pgdb.py to send port as integer to lower level function
(dildog@l0pht.com)
- Change pg.py to speed up some operations
- Allow updates on tables with no primary keys.
Version 3.0
- Remove strlen() call from pglarge_write() and get size from object.
(Richard@Bouska.cz)
- Add a little more error checking to the quote function in the wrapper
- Add extra checking in _quote function
- Wrap query in pg.py for debugging
- Add DB-API 2.0 support to pgmodule.c (andre@via.ecp.fr)
- Add DB-API 2.0 wrapper pgdb.py (andre@via.ecp.fr)
- Correct keyword clash (temp) in tutorial
- Clean up layout of tutorial
- Return NULL values as None (rlawrence@lastfoot.com)
- Change None to NULL in insert and update
- Change hash-bang lines to use /usr/bin/env
- Clearing date should be blank (NULL) not TODAY
- Quote backslashes in strings in _quote (brian@CSUA.Berkeley.EDU)
- Expanded and clarified build instructions (tbryan@starship.python.net)
- Make code thread safe (Jerome.Alet@unice.fr)
- Add README.distutils (mwa@gate.net & jeremy@cnri.reston.va.us)
- Many fixes and increased DB-API compliance by chifungfan@yahoo.com,
tony@printra.net, jeremy@alum.mit.edu and others to get the final
version ready to release.
Version 2.4
- Insert returns None if the user doesn't have select permissions
on the table. It can (and does) happen that one has insert but
not select permissions on a table.
- Added ntuples() method to query object (brit@druid.net)
- Corrected a bug related to getresult() and the money type
- Corrected a bug related to negative money amounts
- Allow update based on primary key if munged oid not available and
table has a primary key
- Add many __doc__ strings. (andre@via.ecp.fr)
- Get method works with views if key specified
Version 2.3
- connect.host returns "localhost" when connected to Unix socket
(torppa@tuhnu.cutery.fi)
- Use PyArg_ParseTupleAndKeywords in connect() (torppa@tuhnu.cutery.fi)
- fixes and cleanups (torppa@tuhnu.cutery.fi)
- Fixed memory leak in dictresult() (terekhov@emc.com)
- Deprecated pgext.py - functionality now in pg.py
- More cleanups to the tutorial
- Added fileno() method - terekhov@emc.com (Mikhail Terekhov)
- added money type to quoting function
- Compiles cleanly with more warnings turned on
- Returns PostgreSQL error message on error
- Init accepts keywords (Jarkko Torppa)
- Convenience functions can be overridden (Jarkko Torppa)
- added close() method
Version 2.2
- Added user and password support thanks to Ng Pheng Siong <ngps@post1.com>
- Insert queries return the inserted oid
- Add new pg wrapper (C modile renamed to _pg)
- Wrapped database connection in a class.
- Cleaned up some of the tutorial. (More work needed.)
- Added version and __version__. Thanks to thilo@eevolute.com for
the suggestion.
Version 2.1
- return fields as proper Python objects for field type
- Cleaned up pgext.py
- Added dictresult method
Version 2.0 (23/12/1997):
- updated code for PostgreSQL 6.2.1 and Python 1.5
- reformatted code and converted to ANSI
- Changed name to PyGreSQL (from PyGres95)
- changed order of arguments to connect function
- Created new type pgqueryobject and moved certain methods to it.
- Added a print function for pgqueryobject
Version 1.0b (4/11/1995):
- keyword support for connect function moved from library file to C code
and taken away from library.
- rewrote documentation
- bug fix in connect function
- enhancements in large objects interface methods
Version 1.0a (30/10/1995) (limited release):
- module adapted to standard Python syntax
- keyword support for connect function in library file
- rewrote default parameters interface (internal use of strings)
- fixed minor bugs in module interface
- redefinition of error messages
Version 0.9b (10/10/1995) (first public release):
- large objects implementation
- many bug fixes, enhancements, ...
Version 0.1a (7/10/1995):
- basic libpq functions (SQL access)
src/interfaces/python/GNUmakefile deleted 100644 → 0
View file @ 2c018f9b
# $Header: /cvsroot/pgsql/src/interfaces/python/Attic/GNUmakefile,v 1.16 2003/03/21 17:18:34 petere Exp $
subdir = src/interfaces/python
top_builddir = ../../..
include $(top_builddir)/src/Makefile.global
NAME = _pgmodule
SO_MAJOR_VERSION = 2
SO_MINOR_VERSION = 4
OBJS = pgmodule.o
SHLIB_LINK = $(libpq)
ifeq ($(PORTNAME), cygwin)
override CPPFLAGS += -DUSE_DL_IMPORT
SHLIB_LINK += $(python_libspec)
endif
include $(top_srcdir)/src/Makefile.shlib
override CPPFLAGS := -I$(libpq_srcdir) $(CPPFLAGS) $(python_includespec)
all: all-lib
all-lib: libpq-all
.PHONY: libpq-all
libpq-all:
$(MAKE) -C $(libpq_builddir) all
install-warning-msg := { \
echo "*** Skipping the installation of the Python interface module for lack"; \
echo "*** of permissions. To install it, change to the directory"; \
echo "*** `pwd`,"; \
echo "*** become the appropriate user, and do '$(MAKE) install'."; }
install: all installdirs
@if test -w $(DESTDIR)$(python_moduleexecdir) && test -w $(DESTDIR)$(python_moduledir); then \
echo "$(INSTALL_SHLIB) $(shlib) $(DESTDIR)$(python_moduleexecdir)/_pgmodule$(DLSUFFIX)"; \
$(INSTALL_SHLIB) $(shlib) $(DESTDIR)$(python_moduleexecdir)/_pgmodule$(DLSUFFIX); \
\
echo "$(INSTALL_DATA) $(srcdir)/pg.py $(DESTDIR)$(python_moduledir)/pg.py"; \
$(INSTALL_DATA) $(srcdir)/pg.py $(DESTDIR)$(python_moduledir)/pg.py; \
\
echo "$(INSTALL_DATA) $(srcdir)/pgdb.py $(DESTDIR)$(python_moduledir)/pgdb.py"; \
$(INSTALL_DATA) $(srcdir)/pgdb.py $(DESTDIR)$(python_moduledir)/pgdb.py; \
else \
$(install-warning-msg); \
fi
installdirs:
$(mkinstalldirs) $(DESTDIR)$(python_moduleexecdir) $(DESTDIR)$(python_moduledir)
uninstall:
rm -f $(DESTDIR)$(python_moduleexecdir)/_pgmodule$(DLSUFFIX) \
$(DESTDIR)$(python_moduledir)/pg.py \
$(DESTDIR)$(python_moduledir)/pgdb.py
clean distclean maintainer-clean: clean-lib
rm -f $(OBJS)
src/interfaces/python/PyGreSQL.spec deleted 100644 → 0
View file @ 2c018f9b
%define version 3.0
%define release pre20000310
%define name PyGreSQL
%define pythonversion 1.5
Source: %{name}-%{version}-%{release}.tgz
Summary: A Python interface for PostgreSQL database.
Name: %{name}
Version: %{version}
Release: %{release}
#Patch:
Group: Applications/Databases
BuildRoot: /tmp/rpmbuild_%{name}
Copyright: GPL-like
Requires: python >= %{pythonversion}, postgresql
Packager: Hartmut Goebel <hartmut@goebel.noris.de>
Vendor: D'Arcy J.M. Cain <darcy@druid.net>
URL: http://www.druid.net/pygresql/
%changelog
#* Tue Oct 06 1998 Fabio Coatti <cova@felix.unife.it>
#- fixed installation directory files list
%description
PyGreSQL is a python module that interfaces to a PostgreSQL database. It
embeds the PostgreSQL query library to allow easy use of the powerful
PostgreSQL features from a Python script.
Version 3.0 includes DB-API 2.0 support.
%prep
rm -rf $RPM_BUILD_ROOT
%setup -n %{name}-%{version}-%{release}
#%patch
%build
mkdir -p $RPM_BUILD_ROOT/usr/lib/python%{pythonversion}/lib-dynload
cc -fpic -shared -o $RPM_BUILD_ROOT/usr/lib/python%{pythonversion}/lib-dynload/_pg.so -I/usr/include/pgsql/ -I/usr/include/python1.5 pgmodule.c -lpq
## import fails, since _pg is not yet installed
python -c 'import pg' || true
python -c 'import pgdb' || true
%install
cp *.py *.pyc $RPM_BUILD_ROOT/usr/lib/python%{pythonversion}/
cd $RPM_BUILD_ROOT
find . -type f | sed 's,^\.,\%attr(-\,root\,root) ,' > $RPM_BUILD_DIR/file.list.%{name}
find . -type l | sed 's,^\.,\%attr(-\,root\,root) ,' >> $RPM_BUILD_DIR/file.list.%{name}
%files -f ../file.list.%{name}
%doc %attr(-,root,root) Announce ChangeLog README tutorial
%clean
rm -rf $RPM_BUILD_ROOT
cd $RPM_BUILD_DIR
rm -rf %{name}-%{version}-%{release} file.list.%{name}
src/interfaces/python/README deleted 100644 → 0
View file @ 2c018f9b
PyGreSQL - v3.3: PostgreSQL module for Python
==============================================
0. Copyright notice
===================
PyGreSQL, version 3.3
A Python interface for PostgreSQL database.
Written by D'Arcy J.M. Cain, darcy@druid.net<BR>
Based heavily on code written by Pascal Andre, andre@chimay.via.ecp.fr.
Copyright (c) 1995, Pascal ANDRE (andre@via.ecp.fr)
Permission to use, copy, modify, and distribute this software and its
documentation for any purpose, without fee, and without a written agreement
is hereby granted, provided that the above copyright notice and this
paragraph and the following two paragraphs appear in all copies or in any
new file that contains a substantial portion of this file.
IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED
TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE
AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
ENHANCEMENTS, OR MODIFICATIONS.
Further modifications copyright 1997 - 2000 by D'Arcy J.M. Cain
(darcy@druid.net) subject to the same terms and conditions as above.
Note that as of March 1 2001 the development of PyGreSQL has been moved
directly into the PostgreSQL development tree and is subject to the
PostgreSQL copyright except where contradicted by the above copyrights
in which case the above copyrights apply.
1. Presentation
===============
1.1. Introduction
-----------------
PostgreSQL is a database system derived from Postgres4.2. It conforms to
(most of) ANSI SQL and offers many interesting capabilities (C dynamic linking
for functions or type definition, etc.). This package is copyright by the
Regents of the University of California, and is freely distributable.
Python is an interpreted programming language. It is object oriented, simple
to use (light syntax, simple and straightforward statements), and has many
extensions for building GUIs, interfacing with WWW, etc. An intelligent web
browser (HotJava like) is currently under development (November 1995), and
this should open programmers many doors. Python is copyrighted by Stichting S
Mathematisch Centrum, Amsterdam, The Netherlands, and is freely distributable.
PyGreSQL is a python module that interfaces to a PostgreSQL database. It
embeds the PostgreSQL query library to allow easy use of the powerful
PostgreSQL features from a Python script.
PyGreSQL 2.0 was developed and tested on a NetBSD 1.3_BETA system. It is
based on the PyGres95 code written by Pascal Andre, andre@chimay.via.ecp.fr.
I changed the version to 2.0 and updated the code for Python 1.5 and
PostgreSQL 6.2.1. While I was at it I upgraded the code to use full ANSI
style prototypes and changed the order of arguments to connect.
1.2. Distribution files
-----------------------
README - this file
Announce - announcement of this release
ChangeLog - changes that affected this package during its history
pgmodule.c - the C python module
pg.py - PyGreSQL DB class.
pgdb.py - DB-SIG DB-API 2.0 compliant API wrapper for PygreSQL
tutorial/ - demos directory
Content: basics.py, syscat.py, advanced.py, func.py and
pgtools.py. The samples here have been taken from the
PostgreSQL manual and were used for module testing. They
demonstrate some PostgreSQL features. Pgtools.py is an
add-in used for demonstration.
1.3. Installation
-----------------
* If you are building this from source on most systems you can simply add
the flag "--with-python" to the Configure command when building PostgreSQL.
This will cause PyGreSQL to be built at the same time. For this to work
you must already have built Python as well as the mxDateTime package
from http://starship.python.net/~lemburg/mxDateTime.html.
* For a Linux x86 system that uses RPMs, you can pick up an RPM at
ftp://ftp.druid.net/pub/distrib/pygresql.i386.rpm
* Note that if you are using the DB-API module you must also install
mxDateTime from http://starship.python.net/~lemburg/mxDateTime.html.
* Also, check out setup.py for an alternate method of installing the package.
You have two options. You can compile PyGreSQL as a stand-alone module
or you can build it into the Python interpreter.
GENERAL
* You must first have installed Python and PostgreSQL on your system.
The header files and developer's libraries for both Python and PostgreSQL
must be installed on your system before you can build PyGreSQL. If you
built both Python and PostgreSQL from source, you should be fine. If your
system uses some package mechanism (such as RPMs or NetBSD packages), then
you probably need to install packages such as Python-devel in addition to
the Python package.
* PyGreSQL is implemented as three parts, a C module labeled _pg and two
Python wrappers called pg.py and pgdb.py. This changed between 2.1 and
2.2 and again in 3.0. These changes should not affect any existing
programs but the installation is slightly different.
* Download and unpack the PyGreSQL tarball if you haven't already done so.
STAND-ALONE
* In the directory containing pgmodule.c, run the following command
cc -fpic -shared -o _pg.so -I[pyInc] -I[pgInc] -L[pgLib] -lpq pgmodule.c
where:
[pyInc] = path of the Python include (usually Python.h)
[pgInc] = path of the PostgreSQL include (usually postgres.h)
[pgLib] = path of the PostgreSQL libraries (usually libpq.so or libpq.a)
Some options may be added to this line:
-DNO_DEF_VAR - no default variables support
-DNO_DIRECT - no direct access methods
-DNO_LARGE - no large object support
-DNO_SNPRINTF - if running a system with no snprintf call
-DNO_PQSOCKET - if running an older PostgreSQL
On some systems you may need to include -lcrypt in the list of libraries
to make it compile.
Define NO_PQSOCKET if you are using a version of PostgreSQL before 6.4
that does not have the PQsocket function. The other options will be
described in the next sections.
* Test the new module. Something like the following should work.
$ python
>>> import _pg
>>> db = _pg.connect('thilo','localhost')
>>> db.query("INSERT INTO test VALUES ('ping','pong')")
18304
>>> db.query("SELECT * FROM test")
eins|zwei
----+----
ping|pong
(1 row)
* Finally, move the _pg.so, pg.py, and pgdb.py to a directory in your
PYTHONPATH. A good place would be /usr/lib/python1.5/site-python if
your Python modules are in /usr/lib/python1.5.
BUILT-IN TO PYTHON INTERPRETER
* Find the directory where your 'Setup' file lives (usually ??/Modules) in
the Python source hierarchy and copy or symlink the 'pgmodule.c' file there.
* Add the following line to your Setup file
_pg pgmodule.c -I[pgInc] -L[pgLib] -lpq # -lcrypt # needed on some systems
where:
[pgInc] = path of PostgreSQL include (often /usr/local/include/python1.5)
[pgLib] = path of the PostgreSQL libraries (often /usr/local/lib/python1.5)
Some options may be added to this line:
-DNO_DEF_VAR - no default variables support
-DNO_DIRECT - no direct access methods
-DNO_LARGE - no large object support
-DNO_SNPRINTF - if running a system with no snprintf call
-DNO_PQSOCKET - if running an older PostgreSQL
Define NO_PQSOCKET if you are using a version of PostgreSQL before 6.4
that does not have the PQsocket function. The other options will be
described in the next sections.
* If you want a shared module, make sure that the "*shared*" keyword is
uncommented and add the above line below it. You used to need to install
your shared modules with "make sharedinstall but this no longer seems
to be true."
* Copy pg.py to the lib directory where the rest of your modules are. For
example, that's /usr/local/lib/Python on my system.
* Rebuild Python from the root directory of the Python source hierarchy by
running 'make -f Makefile.pre.in boot' and 'make && make install'
* For more details read the documentation at the top of Makefile.pre.in
1.4. Where to get ... ?
-----------------------
The home sites of the different packages are:
- Python: http://www.python.org/
- PosgreSQL: http://www.PostgreSQL.org/
- PyGreSQL: http://www.druid.net/pygresql/
A Linux RPM can be picked up from
ftp://ftp.druid.net/pub/distrib/pygresql.i386.rpm. A NetBSD package thould
be in the distribution soon and is available at
ftp://ftp.druid.net/pub/distrib/pygresql.pkg.tgz. A WIN32 package is
available at http://highqualdev.com/.
1.5. Information and support
----------------------------
If you need information about these packages please check their web sites:
- Python: http://www.python.org/
- PostgreSQL: http://www.postgresql.org/
- PyGres95: http://www.via.ecp.fr/via/products/pygres.html
- PyGreSQL: http://www.druid.net/pygresql/
For support:
- Python: newgroup comp.lang.python
- PostgreSQL: mailing list (see package documentation for information)
- PyGres95: contact me (andre@via.ecp.fr) for bug reports, ideas,
remarks I will try to answer as long as my free time allow
me to do that.
- PyGreSQL: contact me (darcy@druid.net) concerning the changes to 2.x
and up. If you would like to proposes changes please
join the PyGreSQL mailing list and send context diffs
there. See http://www.vex.net/mailman/listinfo/pygresql
to join the mailing list.
2. Programming information
==========================
See main PostgreSQL documentation.
3. Todo
=======
The large object and direct access functions need much more attention.
An update query should return the number of rows affected.
The C module needs to be cleaned up and redundant code merged.
The DB-API module needs to be documented.
The fetch method should use real cursors.
4. Future directions
====================
Users should be able to register their own types with _pg.
I would like a new method that returns a dictionary of dictionaries from
a SELECT.
src/interfaces/python/Setup.in.raw deleted 100644 → 0
View file @ 2c018f9b
*shared*
_pg pgmodule.c -I@libpq_srcdir@ @INCLUDES@ -L@libpq_builddir@ -lpq @EXTRA_LIBS@
src/interfaces/python/pg.py deleted 100644 → 0
View file @ 2c018f9b
# pg.py
# Written by D'Arcy J.M. Cain
# This library implements some basic database management stuff. It
# includes the pg module and builds on it. This is known as the
# "Classic" interface. For DB-API compliance use the pgdb module.
from _pg import *
from types import *
import string, re, sys
# utility function
# We expect int, seq, decimal, text or date (more later)
def _quote(d, t):
if d == None:
return "NULL"
if t in ['int', 'seq']:
if d == "": return "NULL"
return "%d" % long(d)
if t == 'decimal':
if d == "": return "NULL"
return "%f" % float(d)
if t == 'money':
if d == "": return "NULL"
return "'%.2f'" % float(d)
if t == 'bool':
# Can't run upper() on these
if d in (0, 1): return ("'f'", "'t'")[d]
if string.upper(d) in ['T', 'TRUE', 'Y', 'YES', '1', 'ON']:
return "'t'"
else:
return "'f'"
if t == 'date' and d == '': return "NULL"
if t in ('inet', 'cidr') and d == '': return "NULL"
return "'%s'" % string.strip(re.sub("'", "''", \
re.sub("\\\\", "\\\\\\\\", "%s" % d)))
class DB:
"""This class wraps the pg connection type"""
def __init__(self, *args, **kw):
self.db = apply(connect, args, kw)
# Create convience methods, in a way that is still overridable
# (members are not copied because they are actually functions)
for e in self.db.__methods__:
setattr(self, e, getattr(self.db, e))
self.__attnames__ = {}
self.__pkeys__ = {}
self.debug = None # For debugging scripts, set to output format
# that takes a single string arg. For example
# in a CGI set to "%s<BR>"
def _do_debug(self, s):
if not self.debug: return
if type(self.debug) == StringType: print self.debug % s
if type(self.debug) == FunctionType: self.debug(s)
if type(self.debug) == FileType: print >> self.debug, s
# wrap query for debugging
def query(self, qstr):
self._do_debug(qstr)
return self.db.query(qstr)
def pkey(self, cl, newpkey = None):
"""This method returns the primary key of a class. If newpkey
is set and is set and is not a dictionary then set that
value as the primary key of the class. If it is a dictionary
then replace the __pkeys__ dictionary with it."""
# Get all the primary keys at once
if type(newpkey) == DictType:
self.__pkeys__ = newpkey
return
if newpkey:
self.__pkeys__[cl] = newpkey
return newpkey
if self.__pkeys__ == {}:
for rel, att in self.db.query("""SELECT
pg_class.relname, pg_attribute.attname
FROM pg_class, pg_attribute, pg_index
WHERE pg_class.oid = pg_attribute.attrelid AND
pg_class.oid = pg_index.indrelid AND
pg_index.indkey[0] = pg_attribute.attnum AND
pg_index.indisprimary = 't' AND
pg_attribute.attisdropped = 'f'""").getresult():
self.__pkeys__[rel] = att
# will raise an exception if primary key doesn't exist
return self.__pkeys__[cl]
def get_databases(self):
l = []
for n in self.db.query("SELECT datname FROM pg_database").getresult():
l.append(n[0])
return l
def get_tables(self):
l = []
for n in self.db.query("""SELECT relname FROM pg_class
WHERE relkind = 'r' AND
relname !~ '^Inv' AND
relname !~ '^pg_'""").getresult():
l.append(n[0])
return l
def get_attnames(self, cl, newattnames = None):
"""This method gets a list of attribute names for a class. If
the optional newattnames exists it must be a dictionary and
will become the new attribute names dictionary."""
if type(newattnames) == DictType:
self.__attnames__ = newattnames
return
elif newattnames:
raise error, "If supplied, newattnames must be a dictionary"
# May as well cache them
if self.__attnames__.has_key(cl):
return self.__attnames__[cl]
query = """SELECT pg_attribute.attname, pg_type.typname
FROM pg_class, pg_attribute, pg_type
WHERE pg_class.relname = '%s' AND
pg_attribute.attnum > 0 AND
pg_attribute.attrelid = pg_class.oid AND
pg_attribute.atttypid = pg_type.oid AND
pg_attribute.attisdropped = 'f'"""
l = {}
for attname, typname in self.db.query(query % cl).getresult():
if re.match("^int", typname):
l[attname] = 'int'
elif re.match("^oid", typname):
l[attname] = 'int'
elif re.match("^text", typname):
l[attname] = 'text'
elif re.match("^char", typname):
l[attname] = 'text'
elif re.match("^name", typname):
l[attname] = 'text'
elif re.match("^abstime", typname):
l[attname] = 'date'
elif re.match("^date", typname):
l[attname] = 'date'
elif re.match("^timestamp", typname):
l[attname] = 'date'
elif re.match("^bool", typname):
l[attname] = 'bool'
elif re.match("^float", typname):
l[attname] = 'decimal'
elif re.match("^money", typname):
l[attname] = 'money'
else:
l[attname] = 'text'
l['oid'] = 'int' # every table has this
self.__attnames__[cl] = l # cache it
return self.__attnames__[cl]
# return a tuple from a database
def get(self, cl, arg, keyname = None, view = 0):
if cl[-1] == '*': # need parent table name
xcl = cl[:-1]
else:
xcl = cl
if keyname == None: # use the primary key by default
keyname = self.pkey(xcl)
fnames = self.get_attnames(xcl)
if type(arg) == DictType:
# To allow users to work with multiple tables we munge the
# name when the key is "oid"
if keyname == 'oid': k = arg['oid_%s' % xcl]
else: k = arg[keyname]
else:
k = arg
arg = {}
# We want the oid for later updates if that isn't the key
if keyname == 'oid':
q = "SELECT * FROM %s WHERE oid = %s" % (cl, k)
elif view:
q = "SELECT * FROM %s WHERE %s = %s" % \
(cl, keyname, _quote(k, fnames[keyname]))
else:
q = "SELECT oid AS oid_%s, %s FROM %s WHERE %s = %s" % \
(xcl, string.join(fnames.keys(), ','),\
cl, keyname, _quote(k, fnames[keyname]))
self._do_debug(q)
res = self.db.query(q).dictresult()
if res == []:
raise error, \
"No such record in %s where %s is %s" % \
(cl, keyname, _quote(k, fnames[keyname]))
return None
for k in res[0].keys():
arg[k] = res[0][k]
return arg
# Inserts a new tuple into a table
# We currently don't support insert into views although PostgreSQL does
def insert(self, cl, a):
fnames = self.get_attnames(cl)
l = []
n = []
for f in fnames.keys():
if f != 'oid' and a.has_key(f):
l.append(_quote(a[f], fnames[f]))
n.append(f)
try:
q = "INSERT INTO %s (%s) VALUES (%s)" % \
(cl, string.join(n, ','), string.join(l, ','))
self._do_debug(q)
a['oid_%s' % cl] = self.db.query(q)
except:
raise error, "Error inserting into %s: %s" % (cl, sys.exc_value)
# reload the dictionary to catch things modified by engine
# note that get() changes 'oid' below to oid_table
# if no read perms (it can and does happen) return None
try: return self.get(cl, a, 'oid')
except: return None
# Update always works on the oid which get returns if available
# otherwise use the primary key. Fail if neither.
def update(self, cl, a):
self.pkey(cl) # make sure we have a self.__pkeys__ dictionary
foid = 'oid_%s' % cl
if a.has_key(foid):
where = "oid = %s" % a[foid]
elif self.__pkeys__.has_key(cl) and a.has_key(self.__pkeys__[cl]):
where = "%s = '%s'" % (self.__pkeys__[cl], a[self.__pkeys__[cl]])
else:
raise error, "Update needs primary key or oid as %s" % foid
v = []
k = 0
fnames = self.get_attnames(cl)
for ff in fnames.keys():
if ff != 'oid' and a.has_key(ff):
v.append("%s = %s" % (ff, _quote(a[ff], fnames[ff])))
if v == []:
return None
try:
q = "UPDATE %s SET %s WHERE %s" % \
(cl, string.join(v, ','), where)
self._do_debug(q)
self.db.query(q)
except:
raise error, "Can't update %s: %s" % (cl, sys.exc_value)
# reload the dictionary to catch things modified by engine
if a.has_key(foid):
return self.get(cl, a, 'oid')
else:
return self.get(cl, a)
# At some point we will need a way to get defaults from a table
def clear(self, cl, a = {}):
fnames = self.get_attnames(cl)
for ff in fnames.keys():
if fnames[ff] in ['int', 'decimal', 'seq', 'money']:
a[ff] = 0
else:
a[ff] = ""
a['oid'] = 0
return a
# Like update, delete works on the oid
# one day we will be testing that the record to be deleted
# isn't referenced somewhere (or else PostgreSQL will)
def delete(self, cl, a):
try:
q = "DELETE FROM %s WHERE oid = %s" % (cl, a['oid_%s' % cl])
self._do_debug(q)
self.db.query(q)
except:
raise error, "Can't delete %s: %s" % (cl, sys.exc_value)
return None
src/interfaces/python/pgdb.py deleted 100644 → 0
View file @ 2c018f9b
""" pgdb - DB-SIG compliant module for PygreSQL.
(c) 1999, Pascal Andre <andre@via.ecp.fr>.
See package documentation for further information on copyright.
Inline documentation is sparse. See DB-SIG 2.0 specification for
usage information.
basic usage:
pgdb.connect(connect_string) -> connection
connect_string = 'host:database:user:password:opt:tty'
All parts are optional. You may also pass host through
password as keyword arguments. To pass a port, pass it in
the host keyword parameter:
pgdb.connect(host='localhost:5432')
connection.cursor() -> cursor
connection.commit()
connection.close()
connection.rollback()
cursor.execute(query[, params])
execute a query, binding params (a dictionary) if it is
passed. The binding syntax is the same as the % operator
for dictionaries, and no quoting is done.
cursor.executemany(query, list of params)
execute a query many times, binding each param dictionary
from the list.
cursor.fetchone() -> [value, value, ...]
cursor.fetchall() -> [[value, value, ...], ...]
cursor.fetchmany([size]) -> [[value, value, ...], ...]
returns size or cursor.arraysize number of rows from result
set. Default cursor.arraysize is 1.
cursor.description -> [(column_name, type_name, display_size,
internal_size, precision, scale, null_ok), ...]
Note that precision, scale and null_ok are not implemented.
cursor.rowcount
number of rows available in the result set. Available after
a call to execute.
cursor.close()
"""
import _pg
import string
import exceptions
import types
import time
import types
# Marc-Andre is changing where DateTime goes. This handles it either way.
try: from mx import DateTime
except ImportError: import DateTime
### module constants
# compliant with DB SIG 2.0
apilevel = '2.0'
# module may be shared, but not connections
threadsafety = 1
# this module use extended python format codes
paramstyle = 'pyformat'
### exception hierarchy
class Warning(StandardError):
pass
class Error(StandardError):
pass
class InterfaceError(Error):
pass
class DatabaseError(Error):
pass
class DataError(DatabaseError):
pass
class OperationalError(DatabaseError):
pass
class IntegrityError(DatabaseError):
pass
class InternalError(DatabaseError):
pass
class ProgrammingError(DatabaseError):
pass
class NotSupportedError(DatabaseError):
pass
### internal type handling class
class pgdbTypeCache:
def __init__(self, cnx):
self.__source = cnx.source()
self.__type_cache = {}
def typecast(self, typ, value):
# for NULL values, no typecast is necessary
if value == None:
return value
if typ == STRING:
pass
elif typ == BINARY:
pass
elif typ == BOOL:
value = (value[:1] in ['t','T'])
elif typ == INTEGER:
value = int(value)
elif typ == LONG:
value = long(value)
elif typ == FLOAT:
value = float(value)
elif typ == MONEY:
value = string.replace(value, "$", "")
value = string.replace(value, ",", "")
value = float(value)
elif typ == DATETIME:
# format may differ ... we'll give string
pass
elif typ == ROWID:
value = long(value)
return value
def getdescr(self, oid):
try:
return self.__type_cache[oid]
except:
self.__source.execute(
"SELECT typname, typlen "
"FROM pg_type WHERE oid = %s" % oid
)
res = self.__source.fetch(1)[0]
# column name is omitted from the return value. It will
# have to be prepended by the caller.
res = (
res[0],
None, string.atoi(res[1]),
None, None, None
)
self.__type_cache[oid] = res
return res
### cursor object
class pgdbCursor:
def __init__(self, src, cache):
self.__cache = cache
self.__source = src
self.description = None
self.rowcount = -1
self.arraysize = 1
def close(self):
self.__source.close()
self.description = None
self.rowcount = -1
def execute(self, operation, params = None):
# "The parameters may also be specified as list of
# tuples to e.g. insert multiple rows in a single
# operation, but this kind of usage is deprecated:
if params and type(params) == types.ListType and \
type(params[0]) == types.TupleType:
self.executemany(operation, params)
else:
# not a list of tuples
self.executemany(operation, (params,))
def executemany(self, operation, param_seq):
self.description = None
self.rowcount = -1
# first try to execute all queries
totrows = 0
sql = "INIT"
try:
for params in param_seq:
if params != None:
sql = _quoteparams(operation, params)
else:
sql = operation
rows = self.__source.execute(sql)
if rows != None: # true is __source is NOT a DQL
totrows = totrows + rows
except _pg.error, msg:
raise DatabaseError, "error '%s' in '%s'" % ( msg, sql )
except:
raise OperationalError, "internal error in '%s'" % sql
# then initialize result raw count and description
if self.__source.resulttype == _pg.RESULT_DQL:
self.rowcount = self.__source.ntuples
d = []
for typ in self.__source.listinfo():
# listinfo is a sequence of
# (index, column_name, type_oid)
# getdescr returns all items needed for a
# description tuple except the column_name.
desc = typ[1:2]+self.__cache.getdescr(typ[2])
d.append(desc)
self.description = d
else:
self.rowcount = totrows
self.description = None
def fetchone(self):
res = self.fetchmany(1, 0)
try:
return res[0]
except:
return None
def fetchall(self):
return self.fetchmany(-1, 0)
def fetchmany(self, size = None, keep = 1):
if size == None:
size = self.arraysize
if keep == 1:
self.arraysize = size
try: res = self.__source.fetch(size)
except _pg.error, e: raise DatabaseError, str(e)
result = []
for r in res:
row = []
for i in range(len(r)):
row.append(self.__cache.typecast(
self.description[i][1],
r[i]
)
)
result.append(row)
return result
def nextset(self):
raise NotSupportedError, "nextset() is not supported"
def setinputsizes(self, sizes):
pass
def setoutputsize(self, size, col = 0):
pass
try:
_quote = _pg.quote_fast
_quoteparams = _pg.quoteparams_fast
except (NameError, AttributeError):
def _quote(x):
if type(x) == DateTime.DateTimeType:
x = str(x)
if type(x) == types.StringType:
x = "'" + string.replace(
string.replace(str(x), '\\', '\\\\'), "'", "''") + "'"
elif type(x) in (types.IntType, types.LongType, types.FloatType):
pass
elif x is None:
x = 'NULL'
elif type(x) in (types.ListType, types.TupleType):
x = '(%s)' % string.join(map(lambda x: str(_quote(x)), x), ',')
elif hasattr(x, '__pg_repr__'):
x = x.__pg_repr__()
else:
raise InterfaceError, 'do not know how to handle type %s' % type(x)
return x
def _quoteparams(s, params):
if hasattr(params, 'has_key'):
x = {}
for k, v in params.items():
x[k] = _quote(v)
params = x
else:
params = tuple(map(_quote, params))
return s % params
### connection object
class pgdbCnx:
def __init__(self, cnx):
self.__cnx = cnx
self.__cache = pgdbTypeCache(cnx)
try:
src = self.__cnx.source()
src.execute("BEGIN")
except:
raise OperationalError, "invalid connection."
def close(self):
self.__cnx.close()
def commit(self):
try:
src = self.__cnx.source()
src.execute("COMMIT")
src.execute("BEGIN")
except:
raise OperationalError, "can't commit."
def rollback(self):
try:
src = self.__cnx.source()
src.execute("ROLLBACK")
src.execute("BEGIN")
except:
raise OperationalError, "can't rollback."
def cursor(self):
try:
src = self.__cnx.source()
return pgdbCursor(src, self.__cache)
except:
raise pgOperationalError, "invalid connection."
### module interface
# connects to a database
def connect(dsn = None, user = None, password = None, host = None, database = None):
# first get params from DSN
dbport = -1
dbhost = ""
dbbase = ""
dbuser = ""
dbpasswd = ""
dbopt = ""
dbtty = ""
try:
params = string.split(dsn, ":")
dbhost = params[0]
dbbase = params[1]
dbuser = params[2]
dbpasswd = params[3]
dbopt = params[4]
dbtty = params[5]
except:
pass
# override if necessary
if user != None:
dbuser = user
if password != None:
dbpasswd = password
if database != None:
dbbase = database
if host != None:
try:
params = string.split(host, ":")
dbhost = params[0]
dbport = int(params[1])
except:
pass
# empty host is localhost
if dbhost == "":
dbhost = None
if dbuser == "":
dbuser = None
# open the connection
cnx = _pg.connect(dbbase, dbhost, dbport, dbopt,
dbtty, dbuser, dbpasswd)
return pgdbCnx(cnx)
### types handling
# PostgreSQL is object-oriented: types are dynamic. We must thus use type names
# as internal type codes.
class pgdbType:
def __init__(self, *values):
self.values= values
def __cmp__(self, other):
if other in self.values:
return 0
if other < self.values:
return 1
else:
return -1
STRING = pgdbType(
'char', 'bpchar', 'name', 'text', 'varchar'
)
# BLOB support is pg specific
BINARY = pgdbType()
INTEGER = pgdbType('int2', 'int4', 'serial')
LONG = pgdbType('int8')
FLOAT = pgdbType('float4', 'float8', 'numeric')
BOOL = pgdbType('bool')
MONEY = pgdbType('money')
# this may be problematic as type are quite different ... I hope it won't hurt
DATETIME = pgdbType(
'abstime', 'reltime', 'tinterval', 'date', 'time', 'timespan', 'timestamp', 'timestamptz', 'interval'
)
# OIDs are used for everything (types, tables, BLOBs, rows, ...). This may cause
# confusion, but we are unable to find out what exactly is behind the OID (at
# least not easily enough). Should this be undefined as BLOBs ?
ROWID = pgdbType(
'oid', 'oid8'
)
# mandatory type helpers
def Date(year, month, day):
return DateTime.DateTime(year, month, day)
def Time(hour, minute, second):
return DateTime.TimeDelta(hour, minute, second)
def Timestamp(year, month, day, hour, minute, second):
return DateTime.DateTime(year, month, day, hour, minute, second)
def DateFromTicks(ticks):
return apply(Date, time.localtime(ticks)[:3])
def TimeFromTicks(ticks):
return apply(Time, time.localtime(ticks)[3:6])
def TimestampFromTicks(ticks):
return apply(Timestamp, time.localtime(ticks)[:6])
src/interfaces/python/pgmodule.c deleted 100644 → 0
View file @ 2c018f9b
/*
* PyGres, version 2.2 A Python interface for PostgreSQL database. Written by
* D'Arcy J.M. Cain, (darcy@druid.net). Based heavily on code written by
* Pascal Andre, andre@chimay.via.ecp.fr. Copyright (c) 1995, Pascal Andre
* (andre@via.ecp.fr).
*
* Permission to use, copy, modify, and distribute this software and its
* documentation for any purpose, without fee, and without a written
* agreement is hereby granted, provided that the above copyright notice and
* this paragraph and the following two paragraphs appear in all copies or in
* any new file that contains a substantial portion of this file.
*
* IN NO EVENT SHALL THE AUTHOR BE LIABLE TO ANY PARTY FOR DIRECT, INDIRECT,
* SPECIAL, INCIDENTAL, OR CONSEQUENTIAL DAMAGES, INCLUDING LOST PROFITS,
* ARISING OUT OF THE USE OF THIS SOFTWARE AND ITS DOCUMENTATION, EVEN IF THE
* AUTHOR HAS BEEN ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
*
* THE AUTHOR SPECIFICALLY DISCLAIMS ANY WARRANTIES, INCLUDING, BUT NOT LIMITED
* TO, THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
* PURPOSE. THE SOFTWARE PROVIDED HEREUNDER IS ON AN "AS IS" BASIS, AND THE
* AUTHOR HAS NO OBLIGATIONS TO PROVIDE MAINTENANCE, SUPPORT, UPDATES,
* ENHANCEMENTS, OR MODIFICATIONS.
*
* Further modifications copyright 1997, 1998, 1999 by D'Arcy J.M. Cain
* (darcy@druid.net) subject to the same terms and conditions as above.
*
*/
#include <Python.h>
#include "postgres.h"
#include "libpq-fe.h"
#include "libpq/libpq-fs.h"
#include "catalog/pg_type.h"
#include <stdio.h>
#include <stdlib.h>
#include <string.h>
/* PyObject_Del does not exist in older versions of Python. */
#if PY_VERSION_HEX < 0x01060000
#define PyObject_Del(op) PyMem_DEL((op))
#endif
static PyObject *PGError;
static const char *PyPgVersion = "3.4 (beta)";
/* taken from fileobject.c */
#define BUF(v) PyString_AS_STRING((PyStringObject *)(v))
/* default values */
#define MODULE_NAME "pgsql"
#define ARRAYSIZE 1
/* flags for object validity checks */
#define CHECK_OPEN 1
#define CHECK_CLOSE 2
#define CHECK_CNX 4
#define CHECK_RESULT 8
#define CHECK_DQL 16
/* query result types */
#define RESULT_EMPTY 1
#define RESULT_DML 2
#define RESULT_DDL 3
#define RESULT_DQL 4
/* flags for move methods */
#define QUERY_MOVEFIRST 1
#define QUERY_MOVELAST 2
#define QUERY_MOVENEXT 3
#define QUERY_MOVEPREV 4
/* moves names for errors */
const char *__movename[5] =
{"", "movefirst", "movelast", "movenext", "moveprev"};
#define MAX_BUFFER_SIZE 8192 /* maximum transaction size */
#ifndef NO_DIRECT
#define DIRECT_ACCESS 1 /* enables direct access functions */
#endif /* NO_DIRECT */
#ifndef NO_LARGE
#define LARGE_OBJECTS 1 /* enables large objects support */
#endif /* NO_LARGE */
#ifndef NO_DEF_VAR
#define DEFAULT_VARS 1 /* enables default variables use */
#endif /* NO_DEF_VAR */
#ifdef MS_WIN32
#define NO_SNPRINTF 1
#endif
/* --------------------------------------------------------------------- */
/* MODULE GLOBAL VARIABLES */
#ifdef DEFAULT_VARS
static PyObject *pg_default_host; /* default database host */
static PyObject *pg_default_base; /* default database name */
static PyObject *pg_default_opt; /* default connection options */
static PyObject *pg_default_tty; /* default debug tty */
static PyObject *pg_default_port; /* default connection port */
static PyObject *pg_default_user; /* default username */
static PyObject *pg_default_passwd; /* default password */
#endif /* DEFAULT_VARS */
DL_EXPORT(void) init_pg(void);
int *get_type_array(PGresult *result, int nfields);
/* --------------------------------------------------------------------- */
/* OBJECTS DECLARATION */
/* pg connection object */
typedef struct
{
PyObject_HEAD
int valid; /* validity flag */
PGconn *cnx; /* PostGres connection handle */
PGresult *last_result; /* last result content */
} pgobject;
staticforward PyTypeObject PgType;
#define is_pgobject(v) ((v)->ob_type == &PgType)
static PyObject *
pgobject_New(void)
{
pgobject *pgobj;
if ((pgobj = PyObject_NEW(pgobject, &PgType)) == NULL)
return NULL;
pgobj->valid = 1;
pgobj->last_result = NULL;
pgobj->cnx = NULL;
return (PyObject *) pgobj;
}
/* pg query object */
typedef struct
{
PyObject_HEAD
PGresult *last_result; /* last result content */
int result_type; /* type of previous result */
long current_pos; /* current position in last result */
long num_rows; /* number of (affected) rows */
} pgqueryobject;
staticforward PyTypeObject PgQueryType;
#define is_pgqueryobject(v) ((v)->ob_type == &PgQueryType)
/* pg source object */
typedef struct
{
PyObject_HEAD
int valid; /* validity flag */
pgobject *pgcnx; /* parent connection object */
PGresult *last_result; /* last result content */
int result_type; /* result type (DDL/DML/DQL) */
long arraysize; /* array size for fetch method */
int current_row; /* current selected row */
int max_row; /* number of rows in the result */
int num_fields; /* number of fields in each row */
} pgsourceobject;
staticforward PyTypeObject PgSourceType;
#define is_pgsourceobject(v) ((v)->ob_type == &PgSourceType)
#ifdef LARGE_OBJECTS
/* pg large object */
typedef struct
{
PyObject_HEAD
pgobject * pgcnx; /* parent connection object */
Oid lo_oid; /* large object oid */
int lo_fd; /* large object fd */
} pglargeobject;
staticforward PyTypeObject PglargeType;
#define is_pglargeobject(v) ((v)->ob_type == &PglargeType)
#endif /* LARGE_OBJECTS */
/* --------------------------------------------------------------------- */
/* INTERNAL FUNCTIONS */
/* checks connection validity */
static int
check_cnx_obj(pgobject * self)
{
if (!self->valid)
{
PyErr_SetString(PGError, "connection has been closed");
return 0;
}
return 1;
}
#ifdef LARGE_OBJECTS
/* checks large object validity */
static int
check_lo_obj(pglargeobject * self, int level)
{
if (!check_cnx_obj(self->pgcnx))
return 0;
if (!self->lo_oid)
{
PyErr_SetString(PGError, "object is not valid (null oid).");
return 0;
}
if (level & CHECK_OPEN)
{
if (self->lo_fd < 0)
{
PyErr_SetString(PyExc_IOError, "object is not opened.");
return 0;
}
}
if (level & CHECK_CLOSE)
{
if (self->lo_fd >= 0)
{
PyErr_SetString(PyExc_IOError, "object is already opened.");
return 0;
}
}
return 1;
}
#endif /* LARGE_OBJECTS */
/* checks source object validity */
static int
check_source_obj(pgsourceobject * self, int level)
{
if (!self->valid)
{
PyErr_SetString(PGError, "object has been closed");
return 0;
}
if ((level & CHECK_RESULT) && self->last_result == NULL)
{
PyErr_SetString(PGError, "no result.");
return 0;
}
if ((level & CHECK_DQL) && self->result_type != RESULT_DQL)
{
PyErr_SetString(PGError, "last query did not return tuples.");
return 0;
}
if ((level & CHECK_CNX) && !check_cnx_obj(self->pgcnx))
return 0;
return 1;
}
/* shared functions for converting PG types to Python types */
int *
get_type_array(PGresult *result, int nfields)
{
int *typ;
int j;
if ((typ = malloc(sizeof(int) * nfields)) == NULL)
{
PyErr_SetString(PyExc_SyntaxError, "memory error in getresult().");
return NULL;
}
for (j = 0; j < nfields; j++)
{
switch (PQftype(result, j))
{
case INT2OID:
case INT4OID:
case OIDOID:
typ[j] = 1;
break;
case INT8OID:
typ[j] = 2;
break;
case FLOAT4OID:
case FLOAT8OID:
case NUMERICOID:
typ[j] = 3;
break;
case CASHOID:
typ[j] = 4;
break;
default:
typ[j] = 5;
break;
}
}
return typ;
}
/* prototypes for constructors */
static pgsourceobject *pgsource_new(pgobject * pgcnx);
/* --------------------------------------------------------------------- */
/* PG SOURCE OBJECT IMPLEMENTATION */
/* constructor (internal use only) */
static pgsourceobject *
pgsource_new(pgobject * pgcnx)
{
pgsourceobject *npgobj;
/* allocates new query object */
if ((npgobj = PyObject_NEW(pgsourceobject, &PgSourceType)) == NULL)
return NULL;
/* initializes internal parameters */
Py_XINCREF(pgcnx);
npgobj->pgcnx = pgcnx;
npgobj->last_result = NULL;
npgobj->valid = 1;
npgobj->arraysize = ARRAYSIZE;
return npgobj;
}
/* destructor */
static void
pgsource_dealloc(pgsourceobject * self)
{
if (self->last_result)
PQclear(self->last_result);
Py_XDECREF(self->pgcnx);
PyObject_Del(self);
}
/* closes object */
static char pgsource_close__doc__[] =
"close() -- close query object without deleting it. "
"All instances of the query object can no longer be used after this call.";
static PyObject *
pgsource_close(pgsourceobject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_TypeError, "method close() takes no parameter.");
return NULL;
}
/* frees result if necessary and invalidates object */
if (self->last_result)
{
PQclear(self->last_result);
self->result_type = RESULT_EMPTY;
self->last_result = NULL;
}
self->valid = 0;
/* return None */
Py_INCREF(Py_None);
return Py_None;
}
/* database query */
static char pgsource_execute__doc__[] =
"execute(sql) -- execute a SQL statement (string).\n "
"On success, this call returns the number of affected rows, "
"or None for DQL (SELECT, ...) statements.\n"
"The fetch (fetch(), fetchone() and fetchall()) methods can be used "
"to get result rows.";
static PyObject *
pgsource_execute(pgsourceobject * self, PyObject * args)
{
char *query;
const char *temp;
long num_rows;
/* checks validity */
if (!check_source_obj(self, CHECK_CNX))
return NULL;
/* get query args */
if (!PyArg_ParseTuple(args, "s", &query))
{
PyErr_SetString(PyExc_TypeError, "execute(sql), with sql (string).");
return NULL;
}
/* frees previous result */
if (self->last_result)
{
PQclear(self->last_result);
self->last_result = NULL;
}
self->max_row = 0;
self->current_row = 0;
self->num_fields = 0;
/* gets result */
Py_BEGIN_ALLOW_THREADS
self->last_result = PQexec(self->pgcnx->cnx, query);
Py_END_ALLOW_THREADS
/* checks result validity */
if (!self->last_result)
{
PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->pgcnx->cnx));
return NULL;
}
/* checks result status */
switch (PQresultStatus(self->last_result))
{
/* query succeeded */
case PGRES_TUPLES_OK: /* DQL: returns None (DB-SIG compliant) */
self->result_type = RESULT_DQL;
self->max_row = PQntuples(self->last_result);
self->num_fields = PQnfields(self->last_result);
Py_INCREF(Py_None);
return Py_None;
case PGRES_COMMAND_OK: /* other requests */
case PGRES_COPY_OUT:
case PGRES_COPY_IN:
self->result_type = RESULT_DDL;
temp = PQcmdTuples(self->last_result);
num_rows = 1;
if (temp[0] != 0)
{
self->result_type = RESULT_DML;
num_rows = atol(temp);
}
return PyInt_FromLong(num_rows);
/* query failed */
case PGRES_EMPTY_QUERY:
PyErr_SetString(PyExc_ValueError, "empty query.");
break;
case PGRES_BAD_RESPONSE:
case PGRES_FATAL_ERROR:
case PGRES_NONFATAL_ERROR:
PyErr_SetString(PGError, PQerrorMessage(self->pgcnx->cnx));
break;
default:
PyErr_SetString(PGError, "internal error: "
"unknown result status.");
break;
}
/* frees result and returns error */
PQclear(self->last_result);
self->last_result = NULL;
self->result_type = RESULT_EMPTY;
return NULL;
}
/* gets oid status for last query (valid for INSERTs, 0 for other) */
static char pgsource_oidstatus__doc__[] =
"oidstatus() -- return oid of last inserted row (if available).";
static PyObject *
pgsource_oidstatus(pgsourceobject * self, PyObject * args)
{
long oid;
/* checks validity */
if (!check_source_obj(self, CHECK_RESULT))
return NULL;
/* checks args */
if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
{
PyErr_SetString(PyExc_SyntaxError,
"method oidstatus() takes no parameters.");
return NULL;
}
/* retrieves oid status */
if ((oid = PQoidValue(self->last_result)) == InvalidOid)
oid = 0;
return PyInt_FromLong(oid);
}
/* fetches rows from last result */
static char pgsource_fetch__doc__[] =
"fetch(num) -- return the next num rows from the last result in a list. "
"If num parameter is omitted arraysize attribute value is used. "
"If size equals -1, all rows are fetched.";
static PyObject *
pgsource_fetch(pgsourceobject * self, PyObject * args)
{
PyObject *rowtuple,
*reslist,
*str;
int i,
j;
long size;
/* checks validity */
if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
return NULL;
/* checks args */
size = self->arraysize;
if (!PyArg_ParseTuple(args, "|l", &size))
{
PyErr_SetString(PyExc_SyntaxError,
"fetch(num), with num (integer, optional).");
return NULL;
}
/* seeks last line */
/* limit size to be within the amount of data we actually have */
if (size == -1 || (self->max_row - self->current_row) < size)
size = self->max_row - self->current_row;
/* allocate list for result */
if ((reslist = PyList_New(0)) == NULL)
return NULL;
/* builds result */
for (i = 0; i < size; ++i)
{
if ((rowtuple = PyTuple_New(self->num_fields)) == NULL)
{
Py_DECREF(reslist);
return NULL;
}
for (j = 0; j < self->num_fields; j++)
{
if (PQgetisnull(self->last_result, self->current_row, j))
{
Py_INCREF(Py_None);
str = Py_None;
}
else
str = PyString_FromString(PQgetvalue(self->last_result, self->current_row, j));
PyTuple_SET_ITEM(rowtuple, j, str);
}
PyList_Append(reslist, rowtuple);
Py_DECREF(rowtuple);
self->current_row++;
}
return reslist;
}
/* changes current row (internal wrapper for all "move" methods) */
static PyObject *
pgsource_move(pgsourceobject * self, PyObject * args, int move)
{
/* checks validity */
if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
return NULL;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
char errbuf[256];
#ifdef NO_SNPRINTF
sprintf(errbuf, "method %s() takes no parameter.", __movename[move]);
#else
snprintf(errbuf, sizeof(errbuf),
"method %s() takes no parameter.", __movename[move]);
#endif
PyErr_SetString(PyExc_SyntaxError, errbuf);
return NULL;
}
/* changes the current row */
switch (move)
{
case QUERY_MOVEFIRST:
self->current_row = 0;
break;
case QUERY_MOVELAST:
self->current_row = self->max_row - 1;
break;
case QUERY_MOVENEXT:
if (self->current_row != self->max_row)
self->current_row++;
break;
case QUERY_MOVEPREV:
if (self->current_row > 0)
self->current_row--;
break;
}
Py_INCREF(Py_None);
return Py_None;
}
/* move to first result row */
static char pgsource_movefirst__doc__[] =
"movefirst() -- move to first result row.";
static PyObject *
pgsource_movefirst(pgsourceobject * self, PyObject * args)
{
return pgsource_move(self, args, QUERY_MOVEFIRST);
}
/* move to last result row */
static char pgsource_movelast__doc__[] =
"movelast() -- move to last valid result row.";
static PyObject *
pgsource_movelast(pgsourceobject * self, PyObject * args)
{
return pgsource_move(self, args, QUERY_MOVELAST);
}
/* move to next result row */
static char pgsource_movenext__doc__[] =
"movenext() -- move to next result row.";
static PyObject *
pgsource_movenext(pgsourceobject * self, PyObject * args)
{
return pgsource_move(self, args, QUERY_MOVENEXT);
}
/* move to previous result row */
static char pgsource_moveprev__doc__[] =
"moveprev() -- move to previous result row.";
static PyObject *
pgsource_moveprev(pgsourceobject * self, PyObject * args)
{
return pgsource_move(self, args, QUERY_MOVEPREV);
}
/* finds field number from string/integer (internal use only) */
static int
pgsource_fieldindex(pgsourceobject * self, PyObject * param, const char *usage)
{
int num;
/* checks validity */
if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
return -1;
/* gets field number */
if (PyString_Check(param))
num = PQfnumber(self->last_result, PyString_AsString(param));
else if (PyInt_Check(param))
num = PyInt_AsLong(param);
else
{
PyErr_SetString(PyExc_TypeError, usage);
return -1;
}
/* checks field validity */
if (num < 0 || num >= self->num_fields)
{
PyErr_SetString(PyExc_ValueError, "Unknown field.");
return -1;
}
return num;
}
/* builds field information from position (internal use only) */
static PyObject *
pgsource_buildinfo(pgsourceobject * self, int num)
{
PyObject *result;
/* allocates tuple */
result = PyTuple_New(3);
if (!result)
return NULL;
/* affects field information */
PyTuple_SET_ITEM(result, 0, PyInt_FromLong(num));
PyTuple_SET_ITEM(result, 1,
PyString_FromString(PQfname(self->last_result, num)));
PyTuple_SET_ITEM(result, 2,
PyInt_FromLong(PQftype(self->last_result, num)));
return result;
}
/* lists fields info */
static char pgsource_listinfo__doc__[] =
"listinfo() -- return information for all fields "
"(position, name, type oid).";
static PyObject *
pgsource_listinfo(pgsourceobject * self, PyObject * args)
{
int i;
PyObject *result,
*info;
/* checks validity */
if (!check_source_obj(self, CHECK_RESULT | CHECK_DQL))
return NULL;
/* gets args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_TypeError,
"method listinfo() takes no parameter.");
return NULL;
}
/* builds result */
if ((result = PyTuple_New(self->num_fields)) == NULL)
return NULL;
for (i = 0; i < self->num_fields; i++)
{
info = pgsource_buildinfo(self, i);
if (!info)
{
Py_DECREF(result);
return NULL;
}
PyTuple_SET_ITEM(result, i, info);
}
/* returns result */
return result;
};
/* list fields information for last result */
static char pgsource_fieldinfo__doc__[] =
"fieldinfo(string|integer) -- return specified field information "
"(position, name, type oid).";
static PyObject *
pgsource_fieldinfo(pgsourceobject * self, PyObject * args)
{
static const char short_usage[] =
"fieldinfo(desc), with desc (string|integer).";
int num;
PyObject *param;
/* gets args */
if (!PyArg_ParseTuple(args, "O", &param))
{
PyErr_SetString(PyExc_TypeError, short_usage);
return NULL;
}
/* checks args and validity */
if ((num = pgsource_fieldindex(self, param, short_usage)) == -1)
return NULL;
/* returns result */
return pgsource_buildinfo(self, num);
};
/* retrieve field value */
static char pgsource_field__doc__[] =
"field(string|integer) -- return specified field value.";
static PyObject *
pgsource_field(pgsourceobject * self, PyObject * args)
{
static const char short_usage[] =
"field(desc), with desc (string|integer).";
int num;
PyObject *param;
/* gets args */
if (!PyArg_ParseTuple(args, "O", &param))
{
PyErr_SetString(PyExc_TypeError, short_usage);
return NULL;
}
/* checks args and validity */
if ((num = pgsource_fieldindex(self, param, short_usage)) == -1)
return NULL;
return PyString_FromString(PQgetvalue(self->last_result,
self->current_row, num));
}
/* query object methods */
static PyMethodDef pgsource_methods[] = {
{"close", (PyCFunction) pgsource_close, 1,
pgsource_close__doc__},
{"execute", (PyCFunction) pgsource_execute, 1,
pgsource_execute__doc__},
{"oidstatus", (PyCFunction) pgsource_oidstatus, 1,
pgsource_oidstatus__doc__},
{"fetch", (PyCFunction) pgsource_fetch, 1,
pgsource_fetch__doc__},
{"movefirst", (PyCFunction) pgsource_movefirst, 1,
pgsource_movefirst__doc__},
{"movelast", (PyCFunction) pgsource_movelast, 1,
pgsource_movelast__doc__},
{"movenext", (PyCFunction) pgsource_movenext, 1,
pgsource_movenext__doc__},
{"moveprev", (PyCFunction) pgsource_moveprev, 1,
pgsource_moveprev__doc__},
{"field", (PyCFunction) pgsource_field, 1,
pgsource_field__doc__},
{"fieldinfo", (PyCFunction) pgsource_fieldinfo, 1,
pgsource_fieldinfo__doc__},
{"listinfo", (PyCFunction) pgsource_listinfo, 1,
pgsource_listinfo__doc__},
{NULL, NULL}
};
/* gets query object attributes */
static PyObject *
pgsource_getattr(pgsourceobject * self, char *name)
{
/* pg connection object */
if (!strcmp(name, "pgcnx"))
{
if (check_source_obj(self, 0))
{
Py_INCREF(self->pgcnx);
return (PyObject *) (self->pgcnx);
}
Py_INCREF(Py_None);
return Py_None;
}
/* arraysize */
if (!strcmp(name, "arraysize"))
return PyInt_FromLong(self->arraysize);
/* resulttype */
if (!strcmp(name, "resulttype"))
return PyInt_FromLong(self->result_type);
/* ntuples */
if (!strcmp(name, "ntuples"))
return PyInt_FromLong(self->max_row);
/* nfields */
if (!strcmp(name, "nfields"))
return PyInt_FromLong(self->num_fields);
/* attributes list */
if (!strcmp(name, "__members__"))
{
PyObject *list = PyList_New(5);
PyList_SET_ITEM(list, 0, PyString_FromString("pgcnx"));
PyList_SET_ITEM(list, 1, PyString_FromString("arraysize"));
PyList_SET_ITEM(list, 2, PyString_FromString("resulttype"));
PyList_SET_ITEM(list, 3, PyString_FromString("ntuples"));
PyList_SET_ITEM(list, 4, PyString_FromString("nfields"));
return list;
}
/* module name */
if (!strcmp(name, "__module__"))
return PyString_FromString(MODULE_NAME);
/* class name */
if (!strcmp(name, "__class__"))
return PyString_FromString("pgsource");
/* seeks name in methods (fallback) */
return Py_FindMethod(pgsource_methods, (PyObject *) self, name);
}
/* sets query object attributes */
static int
pgsource_setattr(pgsourceobject * self, char *name, PyObject * v)
{
/* arraysize */
if (!strcmp(name, "arraysize"))
{
if (!PyInt_Check(v))
{
PyErr_SetString(PyExc_TypeError, "arraysize must be integer.");
return -1;
}
self->arraysize = PyInt_AsLong(v);
return 0;
}
/* unknown attribute */
PyErr_SetString(PyExc_TypeError, "not a writable attribute.");
return -1;
}
/* prints query object in human readable format */
static int
pgsource_print(pgsourceobject * self, FILE *fp, int flags)
{
PQprintOpt op;
switch (self->result_type)
{
case RESULT_DQL:
memset(&op, 0, sizeof(op));
op.align = 1;
op.header = 1;
op.fieldSep = "|";
op.pager = 1;
PQprint(fp, self->last_result, &op);
break;
case RESULT_DDL:
case RESULT_DML:
fputs(PQcmdStatus(self->last_result), fp);
break;
case RESULT_EMPTY:
default:
fputs("Empty PostgreSQL source object.", fp);
break;
}
return 0;
}
/* query type definition */
staticforward PyTypeObject PgSourceType = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"pgsourceobject", /* tp_name */
sizeof(pgsourceobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor) pgsource_dealloc, /* tp_dealloc */
(printfunc) pgsource_print, /* tp_print */
(getattrfunc) pgsource_getattr, /* tp_getattr */
(setattrfunc) pgsource_setattr, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
};
/* --------------------------------------------------------------------- */
/* PG "LARGE" OBJECT IMPLEMENTATION */
#ifdef LARGE_OBJECTS
/* constructor (internal use only) */
static pglargeobject *
pglarge_new(pgobject * pgcnx, Oid oid)
{
pglargeobject *npglo;
if ((npglo = PyObject_NEW(pglargeobject, &PglargeType)) == NULL)
return NULL;
Py_XINCREF(pgcnx);
npglo->pgcnx = pgcnx;
npglo->lo_fd = -1;
npglo->lo_oid = oid;
return npglo;
}
/* destructor */
static void
pglarge_dealloc(pglargeobject * self)
{
if (self->lo_fd >= 0 && check_cnx_obj(self->pgcnx))
lo_close(self->pgcnx->cnx, self->lo_fd);
Py_XDECREF(self->pgcnx);
PyObject_Del(self);
}
/* opens large object */
static char pglarge_open__doc__[] =
"open(mode) -- open access to large object with specified mode "
"(INV_READ, INV_WRITE constants defined by module).";
static PyObject *
pglarge_open(pglargeobject * self, PyObject * args)
{
int mode,
fd;
/* check validity */
if (!check_lo_obj(self, CHECK_CLOSE))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &mode))
{
PyErr_SetString(PyExc_TypeError, "open(mode), with mode(integer).");
return NULL;
}
/* opens large object */
if ((fd = lo_open(self->pgcnx->cnx, self->lo_oid, mode)) < 0)
{
PyErr_SetString(PyExc_IOError, "can't open large object.");
return NULL;
}
self->lo_fd = fd;
/* no error : returns Py_None */
Py_INCREF(Py_None);
return Py_None;
}
/* close large object */
static char pglarge_close__doc__[] =
"close() -- close access to large object data.";
static PyObject *
pglarge_close(pglargeobject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method close() takes no parameters.");
return NULL;
}
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* closes large object */
if (lo_close(self->pgcnx->cnx, self->lo_fd))
{
PyErr_SetString(PyExc_IOError, "error while closing large object fd.");
return NULL;
}
self->lo_fd = -1;
/* no error : returns Py_None */
Py_INCREF(Py_None);
return Py_None;
}
/* reads from large object */
static char pglarge_read__doc__[] =
"read(integer) -- read from large object to sized string. "
"Object must be opened in read mode before calling this method.";
static PyObject *
pglarge_read(pglargeobject * self, PyObject * args)
{
int size;
PyObject *buffer;
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &size))
{
PyErr_SetString(PyExc_TypeError, "read(size), wih size (integer).");
return NULL;
}
if (size <= 0)
{
PyErr_SetString(PyExc_ValueError, "size must be positive.");
return NULL;
}
/* allocate buffer and runs read */
buffer = PyString_FromStringAndSize((char *) NULL, size);
if ((size = lo_read(self->pgcnx->cnx, self->lo_fd, BUF(buffer), size)) < 0)
{
PyErr_SetString(PyExc_IOError, "error while reading.");
Py_XDECREF(buffer);
return NULL;
}
/* resize buffer and returns it */
_PyString_Resize(&buffer, size);
return buffer;
}
/* write to large object */
static char pglarge_write__doc__[] =
"write(string) -- write sized string to large object. "
"Object must be opened in read mode before calling this method.";
static PyObject *
pglarge_write(pglargeobject * self, PyObject * args)
{
char *buffer;
int size,
bufsize;
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "s#", &buffer, &bufsize))
{
PyErr_SetString(PyExc_TypeError,
"write(buffer), with buffer (sized string).");
return NULL;
}
/* sends query */
if ((size = lo_write(self->pgcnx->cnx, self->lo_fd, buffer,
bufsize)) < bufsize)
{
PyErr_SetString(PyExc_IOError, "buffer truncated during write.");
return NULL;
}
/* no error : returns Py_None */
Py_INCREF(Py_None);
return Py_None;
}
/* go to position in large object */
static char pglarge_seek__doc__[] =
"seek(off, whence) -- move to specified position. Object must be opened "
"before calling this method. whence can be SEEK_SET, SEEK_CUR or SEEK_END, "
"constants defined by module.";
static PyObject *
pglarge_lseek(pglargeobject * self, PyObject * args)
{
/* offset and whence are initialized to keep compiler happy */
int ret,
offset = 0,
whence = 0;
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "ii", &offset, &whence))
{
PyErr_SetString(PyExc_TypeError,
"lseek(offset, whence), with offset and whence (integers).");
return NULL;
}
/* sends query */
if ((ret = lo_lseek(self->pgcnx->cnx, self->lo_fd, offset, whence)) == -1)
{
PyErr_SetString(PyExc_IOError, "error while moving cursor.");
return NULL;
}
/* returns position */
return PyInt_FromLong(ret);
}
/* gets large object size */
static char pglarge_size__doc__[] =
"size() -- return large object size. "
"Object must be opened before calling this method.";
static PyObject *
pglarge_size(pglargeobject * self, PyObject * args)
{
int start,
end;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method size() takes no parameters.");
return NULL;
}
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* gets current position */
if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
{
PyErr_SetString(PyExc_IOError, "error while getting current position.");
return NULL;
}
/* gets end position */
if ((end = lo_lseek(self->pgcnx->cnx, self->lo_fd, 0, SEEK_END)) == -1)
{
PyErr_SetString(PyExc_IOError, "error while getting end position.");
return NULL;
}
/* move back to start position */
if ((start = lo_lseek(self->pgcnx->cnx, self->lo_fd, start, SEEK_SET)) == -1)
{
PyErr_SetString(PyExc_IOError,
"error while moving back to first position.");
return NULL;
}
/* returns size */
return PyInt_FromLong(end);
}
/* gets large object cursor position */
static char pglarge_tell__doc__[] =
"tell() -- give current position in large object. "
"Object must be opened before calling this method.";
static PyObject *
pglarge_tell(pglargeobject * self, PyObject * args)
{
int start;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method tell() takes no parameters.");
return NULL;
}
/* checks validity */
if (!check_lo_obj(self, CHECK_OPEN))
return NULL;
/* gets current position */
if ((start = lo_tell(self->pgcnx->cnx, self->lo_fd)) == -1)
{
PyErr_SetString(PyExc_IOError, "error while getting position.");
return NULL;
}
/* returns size */
return PyInt_FromLong(start);
}
/* exports large object as unix file */
static char pglarge_export__doc__[] =
"export(string) -- export large object data to specified file. "
"Object must be closed when calling this method.";
static PyObject *
pglarge_export(pglargeobject * self, PyObject * args)
{
char *name;
/* checks validity */
if (!check_lo_obj(self, CHECK_CLOSE))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError,
"export(filename), with filename (string).");
return NULL;
}
/* runs command */
if (!lo_export(self->pgcnx->cnx, self->lo_oid, name))
{
PyErr_SetString(PyExc_IOError, "error while exporting large object.");
return NULL;
}
Py_INCREF(Py_None);
return Py_None;
}
/* deletes a large object */
static char pglarge_unlink__doc__[] =
"unlink() -- destroy large object. "
"Object must be closed when calling this method.";
static PyObject *
pglarge_unlink(pglargeobject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method unlink() takes no parameters.");
return NULL;
}
/* checks validity */
if (!check_lo_obj(self, CHECK_CLOSE))
return NULL;
/* deletes the object, invalidate it on success */
if (!lo_unlink(self->pgcnx->cnx, self->lo_oid))
{
PyErr_SetString(PyExc_IOError, "error while unlinking large object");
return NULL;
}
self->lo_oid = 0;
Py_INCREF(Py_None);
return Py_None;
}
/* large object methods */
static struct PyMethodDef pglarge_methods[] = {
{"open", (PyCFunction) pglarge_open, 1, pglarge_open__doc__},
{"close", (PyCFunction) pglarge_close, 1, pglarge_close__doc__},
{"read", (PyCFunction) pglarge_read, 1, pglarge_read__doc__},
{"write", (PyCFunction) pglarge_write, 1, pglarge_write__doc__},
{"seek", (PyCFunction) pglarge_lseek, 1, pglarge_seek__doc__},
{"size", (PyCFunction) pglarge_size, 1, pglarge_size__doc__},
{"tell", (PyCFunction) pglarge_tell, 1, pglarge_tell__doc__},
{"export", (PyCFunction) pglarge_export, 1, pglarge_export__doc__},
{"unlink", (PyCFunction) pglarge_unlink, 1, pglarge_unlink__doc__},
{NULL, NULL}
};
/* get attribute */
static PyObject *
pglarge_getattr(pglargeobject * self, char *name)
{
/* list postgreSQL large object fields */
/* associated pg connection object */
if (!strcmp(name, "pgcnx"))
{
if (check_lo_obj(self, 0))
{
Py_INCREF(self->pgcnx);
return (PyObject *) (self->pgcnx);
}
Py_INCREF(Py_None);
return Py_None;
}
/* large object oid */
if (!strcmp(name, "oid"))
{
if (check_lo_obj(self, 0))
return PyInt_FromLong(self->lo_oid);
Py_INCREF(Py_None);
return Py_None;
}
/* error (status) message */
if (!strcmp(name, "error"))
return PyString_FromString(PQerrorMessage(self->pgcnx->cnx));
/* attributes list */
if (!strcmp(name, "__members__"))
{
PyObject *list = PyList_New(3);
if (list)
{
PyList_SET_ITEM(list, 0, PyString_FromString("oid"));
PyList_SET_ITEM(list, 1, PyString_FromString("pgcnx"));
PyList_SET_ITEM(list, 2, PyString_FromString("error"));
}
return list;
}
/* module name */
if (!strcmp(name, "__module__"))
return PyString_FromString(MODULE_NAME);
/* class name */
if (!strcmp(name, "__class__"))
return PyString_FromString("pglarge");
/* seeks name in methods (fallback) */
return Py_FindMethod(pglarge_methods, (PyObject *) self, name);
}
/* prints query object in human readable format */
static int
pglarge_print(pglargeobject * self, FILE *fp, int flags)
{
char print_buffer[128];
if (self->lo_fd >= 0)
{
#ifdef NO_SNPRINTF
sprintf(print_buffer,
"Opened large object, oid %ld", (long) self->lo_oid);
#else
snprintf(print_buffer, sizeof(print_buffer),
"Opened large object, oid %ld", (long) self->lo_oid);
#endif
fputs(print_buffer, fp);
}
else
{
#ifdef NO_SNPRINTF
sprintf(print_buffer,
"Closed large object, oid %ld", (long) self->lo_oid);
#else
snprintf(print_buffer, sizeof(print_buffer),
"Closed large object, oid %ld", (long) self->lo_oid);
#endif
fputs(print_buffer, fp);
}
return 0;
}
/* object type definition */
staticforward PyTypeObject PglargeType = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"pglarge", /* tp_name */
sizeof(pglargeobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor) pglarge_dealloc, /* tp_dealloc */
(printfunc) pglarge_print, /* tp_print */
(getattrfunc) pglarge_getattr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
};
#endif /* LARGE_OBJECTS */
/* --------------------------------------------------------------------- */
/* PG QUERY OBJECT IMPLEMENTATION */
/* connects to a database */
static char connect__doc__[] =
"connect(dbname, host, port, opt, tty) -- connect to a PostgreSQL database "
"using specified parameters (optionals, keywords aware).";
static PyObject *
pgconnect(pgobject * self, PyObject * args, PyObject * dict)
{
static const char *kwlist[] = {"dbname", "host", "port", "opt",
"tty", "user", "passwd", NULL};
char *pghost,
*pgopt,
*pgtty,
*pgdbname,
*pguser,
*pgpasswd;
int pgport;
char port_buffer[20];
pgobject *npgobj;
pghost = pgopt = pgtty = pgdbname = pguser = pgpasswd = NULL;
pgport = -1;
/*
* parses standard arguments With the right compiler warnings, this
* will issue a diagnostic. There is really no way around it. If I
* don't declare kwlist as const char *kwlist[] then it complains when
* I try to assign all those constant strings to it.
*/
if (!PyArg_ParseTupleAndKeywords(args, dict, "|zzizzzz", (char **) kwlist,
&pgdbname, &pghost, &pgport, &pgopt, &pgtty, &pguser, &pgpasswd))
return NULL;
#ifdef DEFAULT_VARS
/* handles defaults variables (for uninitialised vars) */
if ((!pghost) && (pg_default_host != Py_None))
pghost = PyString_AsString(pg_default_host);
if ((pgport == -1) && (pg_default_port != Py_None))
pgport = PyInt_AsLong(pg_default_port);
if ((!pgopt) && (pg_default_opt != Py_None))
pgopt = PyString_AsString(pg_default_opt);
if ((!pgtty) && (pg_default_tty != Py_None))
pgtty = PyString_AsString(pg_default_tty);
if ((!pgdbname) && (pg_default_base != Py_None))
pgdbname = PyString_AsString(pg_default_base);
if ((!pguser) && (pg_default_user != Py_None))
pguser = PyString_AsString(pg_default_user);
if ((!pgpasswd) && (pg_default_passwd != Py_None))
pgpasswd = PyString_AsString(pg_default_passwd);
#endif /* DEFAULT_VARS */
if ((npgobj = (pgobject *) pgobject_New()) == NULL)
return NULL;
if (pgport != -1)
{
memset(port_buffer, 0, sizeof(port_buffer));
sprintf(port_buffer, "%d", pgport);
npgobj->cnx = PQsetdbLogin(pghost, port_buffer, pgopt, pgtty, pgdbname,
pguser, pgpasswd);
}
else
npgobj->cnx = PQsetdbLogin(pghost, NULL, pgopt, pgtty, pgdbname,
pguser, pgpasswd);
if (PQstatus(npgobj->cnx) == CONNECTION_BAD)
{
PyErr_SetString(PGError, PQerrorMessage(npgobj->cnx));
Py_XDECREF(npgobj);
return NULL;
}
return (PyObject *) npgobj;
}
/* pgobject methods */
/* destructor */
static void
pg_dealloc(pgobject * self)
{
if (self->cnx)
PQfinish(self->cnx);
PyObject_Del(self);
}
/* close without deleting */
static char pg_close__doc__[] =
"close() -- close connection. All instances of the connection object and "
"derived objects (queries and large objects) can no longer be used after "
"this call.";
static PyObject *
pg_close(pgobject * self, PyObject * args)
{
/* gets args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_TypeError, "close().");
return NULL;
}
if (self->cnx)
PQfinish(self->cnx);
self->cnx = NULL;
Py_INCREF(Py_None);
return Py_None;
}
static void
pgquery_dealloc(pgqueryobject * self)
{
if (self->last_result)
PQclear(self->last_result);
PyObject_Del(self);
}
/* resets connection */
static char pg_reset__doc__[] =
"reset() -- reset connection with current parameters. All derived queries "
"and large objects derived from this connection will not be usable after "
"this call.";
static PyObject *
pg_reset(pgobject * self, PyObject * args)
{
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method reset() takes no parameters.");
return NULL;
}
/* resets the connection */
PQreset(self->cnx);
Py_INCREF(Py_None);
return Py_None;
}
/* get connection socket */
static char pg_fileno__doc__[] =
"fileno() -- return database connection socket file handle.";
static PyObject *
pg_fileno(pgobject * self, PyObject * args)
{
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method fileno() takes no parameters.");
return NULL;
}
#ifdef NO_PQSOCKET
return PyInt_FromLong((long) self->cnx->sock);
#else
return PyInt_FromLong((long) PQsocket(self->cnx));
#endif
}
/* get number of rows */
static char pgquery_ntuples__doc__[] =
"ntuples() -- returns number of tuples returned by query.";
static PyObject *
pgquery_ntuples(pgqueryobject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method ntuples() takes no parameters.");
return NULL;
}
return PyInt_FromLong((long) PQntuples(self->last_result));
}
/* list fields names from query result */
static char pgquery_listfields__doc__[] =
"listfields() -- Lists field names from result.";
static PyObject *
pgquery_listfields(pgqueryobject * self, PyObject * args)
{
int i,
n;
char *name;
PyObject *fieldstuple,
*str;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method listfields() takes no parameters.");
return NULL;
}
/* builds tuple */
n = PQnfields(self->last_result);
fieldstuple = PyTuple_New(n);
for (i = 0; i < n; i++)
{
name = PQfname(self->last_result, i);
str = PyString_FromString(name);
PyTuple_SET_ITEM(fieldstuple, i, str);
}
return fieldstuple;
}
/* get field name from last result */
static char pgquery_fieldname__doc__[] =
"fieldname() -- returns name of field from result from its position.";
static PyObject *
pgquery_fieldname(pgqueryobject * self, PyObject * args)
{
int i;
char *name;
/* gets args */
if (!PyArg_ParseTuple(args, "i", &i))
{
PyErr_SetString(PyExc_TypeError,
"fieldname(number), with number(integer).");
return NULL;
}
/* checks number validity */
if (i >= PQnfields(self->last_result))
{
PyErr_SetString(PyExc_ValueError, "invalid field number.");
return NULL;
}
/* gets fields name and builds object */
name = PQfname(self->last_result, i);
return PyString_FromString(name);
}
/* gets fields number from name in last result */
static char pgquery_fieldnum__doc__[] =
"fieldnum() -- returns position in query for field from its name.";
static PyObject *
pgquery_fieldnum(pgqueryobject * self, PyObject * args)
{
char *name;
int num;
/* gets args */
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError, "fieldnum(name), with name (string).");
return NULL;
}
/* gets field number */
if ((num = PQfnumber(self->last_result, name)) == -1)
{
PyErr_SetString(PyExc_ValueError, "Unknown field.");
return NULL;
}
return PyInt_FromLong(num);
}
/* retrieves last result */
static char pgquery_getresult__doc__[] =
"getresult() -- Gets the result of a query. The result is returned "
"as a list of rows, each one a list of fields in the order returned "
"by the server.";
static PyObject *
pgquery_getresult(pgqueryobject * self, PyObject * args)
{
PyObject *rowtuple,
*reslist,
*val;
int i,
j,
m,
n,
*typ;
/* checks args (args == NULL for an internal call) */
if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
{
PyErr_SetString(PyExc_SyntaxError,
"method getresult() takes no parameters.");
return NULL;
}
/* stores result in tuple */
m = PQntuples(self->last_result);
n = PQnfields(self->last_result);
reslist = PyList_New(m);
typ = get_type_array(self->last_result, n);
for (i = 0; i < m; i++)
{
if ((rowtuple = PyTuple_New(n)) == NULL)
{
Py_DECREF(reslist);
reslist = NULL;
goto exit;
}
for (j = 0; j < n; j++)
{
int k;
char *s = PQgetvalue(self->last_result, i, j);
char cashbuf[64];
if (PQgetisnull(self->last_result, i, j))
{
Py_INCREF(Py_None);
val = Py_None;
}
else
switch (typ[j])
{
case 1:
val = PyInt_FromLong(strtol(s, NULL, 10));
break;
case 2:
val = PyLong_FromLong(strtol(s, NULL, 10));
break;
case 3:
val = PyFloat_FromDouble(strtod(s, NULL));
break;
case 4:
{
int mult = 1;
if (*s == '$') /* there's talk of getting
* rid of it */
s++;
if (*s == '-' || *s == '(')
{
s++;
mult = -1;
}
/* get rid of the '$' and commas */
if (*s == '$') /* Just in case we exposed
* one */
s++;
for (k = 0; *s; s++)
if (*s != ',')
cashbuf[k++] = *s;
cashbuf[k] = 0;
val = PyFloat_FromDouble(strtod(cashbuf, NULL) * mult);
break;
}
default:
val = PyString_FromString(s);
break;
}
if (val == NULL)
{
Py_DECREF(reslist);
Py_DECREF(rowtuple);
reslist = NULL;
goto exit;
}
PyTuple_SET_ITEM(rowtuple, j, val);
}
PyList_SET_ITEM(reslist, i, rowtuple);
}
exit:
free(typ);
/* returns list */
return reslist;
}
/* retrieves last result as a list of dictionaries*/
static char pgquery_dictresult__doc__[] =
"dictresult() -- Gets the result of a query. The result is returned "
"as a list of rows, each one a dictionary with the field names used "
"as the labels.";
static PyObject *
pgquery_dictresult(pgqueryobject * self, PyObject * args)
{
PyObject *dict,
*reslist,
*val;
int i,
j,
m,
n,
*typ;
/* checks args (args == NULL for an internal call) */
if ((args != NULL) && (!PyArg_ParseTuple(args, "")))
{
PyErr_SetString(PyExc_SyntaxError,
"method getresult() takes no parameters.");
return NULL;
}
/* stores result in list */
m = PQntuples(self->last_result);
n = PQnfields(self->last_result);
reslist = PyList_New(m);
typ = get_type_array(self->last_result, n);
for (i = 0; i < m; i++)
{
if ((dict = PyDict_New()) == NULL)
{
Py_DECREF(reslist);
reslist = NULL;
goto exit;
}
for (j = 0; j < n; j++)
{
int k;
char *s = PQgetvalue(self->last_result, i, j);
char cashbuf[64];
if (PQgetisnull(self->last_result, i, j))
{
Py_INCREF(Py_None);
val = Py_None;
}
else
switch (typ[j])
{
case 1:
val = PyInt_FromLong(strtol(s, NULL, 10));
break;
case 2:
val = PyLong_FromLong(strtol(s, NULL, 10));
break;
case 3:
val = PyFloat_FromDouble(strtod(s, NULL));
break;
case 4:
{
int mult = 1;
if (*s == '$') /* there's talk of getting
* rid of it */
s++;
if (*s == '-' || *s == '(')
{
s++;
mult = -1;
}
/* get rid of the '$' and commas */
if (*s == '$') /* Just in case we exposed
* one */
s++;
for (k = 0;
*s && k < sizeof(cashbuf) / sizeof(cashbuf[0]) - 1;
s++)
{
if (*s != ',')
cashbuf[k++] = *s;
}
cashbuf[k] = 0;
val = PyFloat_FromDouble(strtod(cashbuf, NULL) * mult);
break;
}
default:
val = PyString_FromString(s);
break;
}
if (val == NULL)
{
Py_DECREF(dict);
Py_DECREF(reslist);
reslist = NULL;
goto exit;
}
PyDict_SetItemString(dict, PQfname(self->last_result, j), val);
Py_DECREF(val);
}
PyList_SET_ITEM(reslist, i, dict);
}
exit:
free(typ);
/* returns list */
return reslist;
}
/* gets asynchronous notify */
static char pg_getnotify__doc__[] =
"getnotify() -- get database notify for this connection.";
static PyObject *
pg_getnotify(pgobject * self, PyObject * args)
{
PGnotify *notify;
PGresult *result;
PyObject *notify_result,
*temp;
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method getnotify() takes no parameters.");
return NULL;
}
/* gets notify and builds result */
/*
* notifies only come back as result of a query, so I send an empty
* query
*/
Py_BEGIN_ALLOW_THREADS
result = PQexec(self->cnx, " ");
Py_END_ALLOW_THREADS
if ((notify = PQnotifies(self->cnx)) != NULL)
{
if ((notify_result = PyTuple_New(2)) == NULL)
{
PQclear(result);
return NULL;
}
if ((temp = PyString_FromString(notify->relname)) == NULL)
{
PQclear(result);
return NULL;
}
PyTuple_SET_ITEM(notify_result, 0, temp);
if ((temp = PyInt_FromLong(notify->be_pid)) == NULL)
{
PQclear(result);
Py_DECREF(notify_result);
return NULL;
}
PyTuple_SET_ITEM(notify_result, 1, temp);
PQfreemem(notify);
}
else
{
Py_INCREF(Py_None);
notify_result = Py_None;
}
PQclear(result);
/* returns result */
return notify_result;
}
/* source creation */
static char pg_source__doc__[] =
"source() -- creates a new source object for this connection";
static PyObject *
pg_source(pgobject * self, PyObject * args)
{
/* checks validity */
if (!check_cnx_obj(self))
return NULL;
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_TypeError, "method source() takes no parameter.");
return NULL;
}
/* allocate new pg query object */
return (PyObject *) pgsource_new(self);
}
/* database query */
static char pg_query__doc__[] =
"query(sql) -- creates a new query object for this connection,"
" using sql (string) request.";
static PyObject *
pg_query(pgobject * self, PyObject * args)
{
char *query;
PGresult *result;
pgqueryobject *npgobj;
int status;
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* get query args */
if (!PyArg_ParseTuple(args, "s", &query))
{
PyErr_SetString(PyExc_TypeError, "query(sql), with sql (string).");
return NULL;
}
/* frees previous result */
if (self->last_result)
{
PQclear(self->last_result);
self->last_result = NULL;
}
/* gets result */
Py_BEGIN_ALLOW_THREADS
result = PQexec(self->cnx, query);
Py_END_ALLOW_THREADS
/* checks result validity */
if (!result)
{
PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
return NULL;
}
/* checks result status */
if ((status = PQresultStatus(result)) != PGRES_TUPLES_OK)
{
Oid oid;
PQclear(result);
switch (status)
{
case PGRES_EMPTY_QUERY:
PyErr_SetString(PyExc_ValueError, "empty query.");
break;
case PGRES_BAD_RESPONSE:
case PGRES_FATAL_ERROR:
case PGRES_NONFATAL_ERROR:
PyErr_SetString(PGError, PQerrorMessage(self->cnx));
break;
case PGRES_COMMAND_OK: /* could be an INSERT */
if ((oid = PQoidValue(result)) == InvalidOid) /* nope */
{
Py_INCREF(Py_None);
return Py_None;
}
/* otherwise, return the oid */
return PyInt_FromLong(oid);
case PGRES_COPY_OUT: /* no data will be received */
case PGRES_COPY_IN:
Py_INCREF(Py_None);
return Py_None;
default:
PyErr_SetString(PGError, "internal error: "
"unknown result status.");
break;
}
return NULL; /* error detected on query */
}
if ((npgobj = PyObject_NEW(pgqueryobject, &PgQueryType)) == NULL)
return NULL;
/* stores result and returns object */
npgobj->last_result = result;
return (PyObject *) npgobj;
}
#ifdef DIRECT_ACCESS
static char pg_putline__doc__[] =
"putline() -- sends a line directly to the backend";
/* direct acces function : putline */
static PyObject *
pg_putline(pgobject * self, PyObject * args)
{
char *line;
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* reads args */
if (!PyArg_ParseTuple(args, "s", &line))
{
PyErr_SetString(PyExc_TypeError, "putline(line), with line (string).");
return NULL;
}
/* sends line to backend */
PQputline(self->cnx, line);
Py_INCREF(Py_None);
return Py_None;
}
/* direct access function : getline */
static char pg_getline__doc__[] =
"getline() -- gets a line directly from the backend.";
static PyObject *
pg_getline(pgobject * self, PyObject * args)
{
char line[MAX_BUFFER_SIZE];
PyObject *str = NULL; /* GCC */
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method getline() takes no parameters.");
return NULL;
}
/* gets line */
switch (PQgetline(self->cnx, line, MAX_BUFFER_SIZE))
{
case 0:
str = PyString_FromString(line);
break;
case 1:
PyErr_SetString(PyExc_MemoryError, "buffer overflow");
str = NULL;
break;
case EOF:
Py_INCREF(Py_None);
str = Py_None;
break;
}
return str;
}
/* direct access function : end copy */
static char pg_endcopy__doc__[] =
"endcopy() -- synchronizes client and server";
static PyObject *
pg_endcopy(pgobject * self, PyObject * args)
{
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method endcopy() takes no parameters.");
return NULL;
}
/* ends direct copy */
PQendcopy(self->cnx);
Py_INCREF(Py_None);
return Py_None;
}
#endif /* DIRECT_ACCESS */
static PyObject *
pgquery_print(pgqueryobject * self, FILE *fp, int flags)
{
PQprintOpt op;
memset(&op, 0, sizeof(op));
op.align = 1;
op.header = 1;
op.fieldSep = "|";
op.pager = 1;
PQprint(fp, self->last_result, &op);
return 0;
}
static PyObject *
pgquery_repr(pgqueryobject * self)
{
return PyString_FromString("<pg query result>");
}
/* insert table */
static char pg_inserttable__doc__[] =
"inserttable(string, list) -- insert list in table. The fields in the "
"list must be in the same order as in the table.";
static PyObject *
pg_inserttable(pgobject * self, PyObject * args)
{
PGresult *result;
char *table,
*buffer,
*bufpt,
*temp;
size_t bufsiz;
PyObject *list,
*sublist,
*item;
PyObject *(*getitem) (PyObject *, int);
PyObject *(*getsubitem) (PyObject *, int);
int i,
j,
m,
n;
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* gets arguments */
if (!PyArg_ParseTuple(args, "sO:filter", &table, &list))
{
PyErr_SetString(PyExc_TypeError,
"tableinsert(table, content), with table (string) "
"and content (list).");
return NULL;
}
/* checks list type */
if (PyTuple_Check(list))
{
m = PyTuple_Size(list);
getitem = PyTuple_GetItem;
}
else if (PyList_Check(list))
{
m = PyList_Size(list);
getitem = PyList_GetItem;
}
else
{
PyErr_SetString(PyExc_TypeError,
"second arg must be some kind of array.");
return NULL;
}
if (m)
{
/* not strictly necessary but removes a bogus warning */
n = 0;
/* checks sublists type and size */
for (i = 0; i < m; i++)
{
sublist = getitem(list, i);
if (PyTuple_Check(sublist))
j = PyTuple_Size(sublist);
else if (PyList_Check(sublist))
j = PyList_Size(sublist);
else
{
PyErr_SetString(PyExc_TypeError,
"second arg must contain some kind of arrays.");
return NULL;
}
if (i)
{
if (j != n)
{
PyErr_SetString(PyExc_TypeError,
"arrays contained in second arg must have same size.");
return NULL;
}
}
else
n = j; /* never used before this assignment */
}
if (n)
{
/* allocate buffer */
if (!(buffer = malloc(MAX_BUFFER_SIZE)))
{
PyErr_SetString(PyExc_MemoryError,
"can't allocate insert buffer.");
return NULL;
}
/* starts query */
sprintf(buffer, "copy %s from stdin", table);
Py_BEGIN_ALLOW_THREADS
result = PQexec(self->cnx, buffer);
Py_END_ALLOW_THREADS
if (!result)
{
free(buffer);
PyErr_SetString(PyExc_ValueError, PQerrorMessage(self->cnx));
return NULL;
}
PQclear(result);
/* feeds table */
for (i = 0; i < m; i++)
{
sublist = getitem(list, i);
if (PyTuple_Check(sublist))
getsubitem = PyTuple_GetItem;
else
getsubitem = PyList_GetItem;
/* builds insert line */
bufpt=buffer;
bufsiz = MAX_BUFFER_SIZE - 1;
for (j = 0; j < n; j++)
{
item = getsubitem(sublist, j);
/* converts item to string */
if (item == Py_None)
{
if (bufsiz > 2)
{
*bufpt++ = '\\'; *bufpt++ = 'N';
bufsiz -= 2;
}
else
bufsiz = 0;
}
else if (PyString_Check(item))
{
temp = PyString_AS_STRING(item);
while (*temp && bufsiz)
{
if (*temp == '\\'
|| *temp == '\t'
|| *temp == '\n')
{
*bufpt++='\\'; --bufsiz;
if (!bufsiz) break;
}
*bufpt++=*temp++; --bufsiz;
}
}
else if (PyInt_Check(item))
{
long k;
int h;
k = PyInt_AsLong(item);
h = snprintf(bufpt, bufsiz, "%ld", k);
if (h > 0)
{
bufpt += h; bufsiz -= h;
}
else
bufsiz = 0;
}
else if (PyLong_Check(item))
{
long k;
int h;
k = PyLong_AsLong(item);
h = snprintf(bufpt, bufsiz, "%ld", k);
if (h > 0)
{
bufpt += h; bufsiz -= h;
}
else
bufsiz = 0;
}
else if (PyFloat_Check(item))
{
double k;
int h;
k = PyFloat_AS_DOUBLE(item);
h = snprintf(bufpt, bufsiz, "%g", k);
if (h > 0)
{
bufpt += h; bufsiz -= h;
}
else
bufsiz = 0;
}
else
{
free(buffer);
PyErr_SetString(PyExc_ValueError,
"items must be strings, integers, "
"longs or double (real).");
return NULL;
}
if (j < n-1)
{
*bufpt++ = '\t'; --bufsiz;
}
if (bufsiz <= 0)
{
free(buffer);
PyErr_SetString(PyExc_MemoryError,
"insert buffer overflow.");
return NULL;
}
}
*bufpt++ = '\n'; *bufpt = '\0';
/* sends data */
PQputline(self->cnx, buffer);
}
/* ends query */
PQputline(self->cnx, "\\.\n");
PQendcopy(self->cnx);
free(buffer);
}
}
/* no error : returns nothing */
Py_INCREF(Py_None);
return Py_None;
}
/* creates large object */
static char pg_locreate__doc__[] =
"locreate() -- creates a new large object in the database.";
static PyObject *
pg_locreate(pgobject * self, PyObject * args)
{
int mode;
Oid lo_oid;
/* checks validity */
if (!check_cnx_obj(self))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &mode))
{
PyErr_SetString(PyExc_TypeError,
"locreate(mode), with mode (integer).");
return NULL;
}
/* creates large object */
lo_oid = lo_creat(self->cnx, mode);
if (lo_oid == 0)
{
PyErr_SetString(PGError, "can't create large object.");
return NULL;
}
return (PyObject *) pglarge_new(self, lo_oid);
}
/* init from already known oid */
static char pg_getlo__doc__[] =
"getlo(long) -- create a large object instance for the specified oid.";
static PyObject *
pg_getlo(pgobject * self, PyObject * args)
{
int lo_oid;
/* checks validity */
if (!check_cnx_obj(self))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "i", &lo_oid))
{
PyErr_SetString(PyExc_TypeError, "getlo(oid), with oid (integer).");
return NULL;
}
if (!lo_oid)
{
PyErr_SetString(PyExc_ValueError, "the object oid can't be null.");
return NULL;
}
/* creates object */
return (PyObject *) pglarge_new(self, lo_oid);
}
/* import unix file */
static char pg_loimport__doc__[] =
"loimport(string) -- create a new large object from specified file.";
static PyObject *
pg_loimport(pgobject * self, PyObject * args)
{
char *name;
Oid lo_oid;
/* checks validity */
if (!check_cnx_obj(self))
return NULL;
/* gets arguments */
if (!PyArg_ParseTuple(args, "s", &name))
{
PyErr_SetString(PyExc_TypeError, "loimport(name), with name (string).");
return NULL;
}
/* imports file and checks result */
lo_oid = lo_import(self->cnx, name);
if (lo_oid == 0)
{
PyErr_SetString(PGError, "can't create large object.");
return NULL;
}
return (PyObject *) pglarge_new(self, lo_oid);
}
/* connection object methods */
static struct PyMethodDef pgobj_methods[] = {
{"source", (PyCFunction) pg_source, 1, pg_source__doc__},
{"query", (PyCFunction) pg_query, 1, pg_query__doc__},
{"reset", (PyCFunction) pg_reset, 1, pg_reset__doc__},
{"close", (PyCFunction) pg_close, 1, pg_close__doc__},
{"fileno", (PyCFunction) pg_fileno, 1, pg_fileno__doc__},
{"getnotify", (PyCFunction) pg_getnotify, 1, pg_getnotify__doc__},
{"inserttable", (PyCFunction) pg_inserttable, 1, pg_inserttable__doc__},
#ifdef DIRECT_ACCESS
{"putline", (PyCFunction) pg_putline, 1, pg_putline__doc__},
{"getline", (PyCFunction) pg_getline, 1, pg_getline__doc__},
{"endcopy", (PyCFunction) pg_endcopy, 1, pg_endcopy__doc__},
#endif /* DIRECT_ACCESS */
#ifdef LARGE_OBJECTS
{"locreate", (PyCFunction) pg_locreate, 1, pg_locreate__doc__},
{"getlo", (PyCFunction) pg_getlo, 1, pg_getlo__doc__},
{"loimport", (PyCFunction) pg_loimport, 1, pg_loimport__doc__},
#endif /* LARGE_OBJECTS */
{NULL, NULL} /* sentinel */
};
/* get attribute */
static PyObject *
pg_getattr(pgobject * self, char *name)
{
/*
* Although we could check individually, there are only a few
* attributes that don't require a live connection and unless someone
* has an urgent need, this will have to do
*/
if (!self->cnx)
{
PyErr_SetString(PyExc_TypeError, "Connection is not valid");
return NULL;
}
/* list postgreSQL connection fields */
/* postmaster host */
if (!strcmp(name, "host"))
{
char *r = PQhost(self->cnx);
return r ? PyString_FromString(r) : PyString_FromString("localhost");
}
/* postmaster port */
if (!strcmp(name, "port"))
return PyInt_FromLong(atol(PQport(self->cnx)));
/* selected database */
if (!strcmp(name, "db"))
return PyString_FromString(PQdb(self->cnx));
/* selected options */
if (!strcmp(name, "options"))
return PyString_FromString(PQoptions(self->cnx));
/* selected postgres tty */
if (!strcmp(name, "tty"))
return PyString_FromString(PQtty(self->cnx));
/* error (status) message */
if (!strcmp(name, "error"))
return PyString_FromString(PQerrorMessage(self->cnx));
/* connection status : 1 - OK, 0 - BAD */
if (!strcmp(name, "status"))
return PyInt_FromLong(PQstatus(self->cnx) == CONNECTION_OK ? 1 : 0);
/* provided user name */
if (!strcmp(name, "user"))
return PyString_FromString("Deprecated facility");
/* return PyString_FromString(fe_getauthname("<unknown user>")); */
/* attributes list */
if (!strcmp(name, "__members__"))
{
PyObject *list = PyList_New(8);
if (list)
{
PyList_SET_ITEM(list, 0, PyString_FromString("host"));
PyList_SET_ITEM(list, 1, PyString_FromString("port"));
PyList_SET_ITEM(list, 2, PyString_FromString("db"));
PyList_SET_ITEM(list, 3, PyString_FromString("options"));
PyList_SET_ITEM(list, 4, PyString_FromString("tty"));
PyList_SET_ITEM(list, 5, PyString_FromString("error"));
PyList_SET_ITEM(list, 6, PyString_FromString("status"));
PyList_SET_ITEM(list, 7, PyString_FromString("user"));
}
return list;
}
return Py_FindMethod(pgobj_methods, (PyObject *) self, name);
}
/* object type definition */
staticforward PyTypeObject PgType = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"pgobject", /* tp_name */
sizeof(pgobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor) pg_dealloc, /* tp_dealloc */
0, /* tp_print */
(getattrfunc) pg_getattr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
0, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
};
/* query object methods */
static struct PyMethodDef pgquery_methods[] = {
{"getresult", (PyCFunction) pgquery_getresult, 1, pgquery_getresult__doc__},
{"dictresult", (PyCFunction) pgquery_dictresult, 1, pgquery_dictresult__doc__},
{"fieldname", (PyCFunction) pgquery_fieldname, 1, pgquery_fieldname__doc__},
{"fieldnum", (PyCFunction) pgquery_fieldnum, 1, pgquery_fieldnum__doc__},
{"listfields", (PyCFunction) pgquery_listfields, 1, pgquery_listfields__doc__},
{"ntuples", (PyCFunction) pgquery_ntuples, 1, pgquery_ntuples__doc__},
{NULL, NULL}
};
/* gets query object attributes */
static PyObject *
pgquery_getattr(pgqueryobject * self, char *name)
{
/* list postgreSQL connection fields */
return Py_FindMethod(pgquery_methods, (PyObject *) self, name);
}
/* query type definition */
staticforward PyTypeObject PgQueryType = {
PyObject_HEAD_INIT(NULL)
0, /* ob_size */
"pgqueryobject", /* tp_name */
sizeof(pgqueryobject), /* tp_basicsize */
0, /* tp_itemsize */
/* methods */
(destructor) pgquery_dealloc, /* tp_dealloc */
(printfunc) pgquery_print, /* tp_print */
(getattrfunc) pgquery_getattr, /* tp_getattr */
0, /* tp_setattr */
0, /* tp_compare */
(reprfunc) pgquery_repr, /* tp_repr */
0, /* tp_as_number */
0, /* tp_as_sequence */
0, /* tp_as_mapping */
0, /* tp_hash */
};
/* --------------------------------------------------------------------- */
/* MODULE FUNCTIONS */
#ifdef DEFAULT_VARS
/* gets default host */
static char getdefhost__doc__[] =
"get_defhost() -- return default database host.";
static PyObject *
pggetdefhost(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_defhost() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_host);
return pg_default_host;
}
/* sets default host */
static char setdefhost__doc__[] =
"set_defhost(string) -- set default database host. Return previous value.";
static PyObject *
pgsetdefhost(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_defhost(name), with name (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_host;
if (temp)
pg_default_host = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_host = Py_None;
}
return old;
}
/* gets default base */
static char getdefbase__doc__[] =
"get_defbase() -- return default database name.";
static PyObject *
pggetdefbase(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_defbase() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_base);
return pg_default_base;
}
/* sets default base */
static char setdefbase__doc__[] =
"set_defbase(string) -- set default database name. Return previous value";
static PyObject *
pgsetdefbase(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_defbase(name), with name (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_base;
if (temp)
pg_default_base = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_base = Py_None;
}
return old;
}
/* gets default options */
static char getdefopt__doc__[] =
"get_defopt() -- return default database options.";
static PyObject *
pggetdefopt(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_defopt() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_opt);
return pg_default_opt;
}
/* sets default opt */
static char setdefopt__doc__[] =
"set_defopt(string) -- set default database options. Return previous value.";
static PyObject *
pgsetdefopt(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_defopt(name), with name (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_opt;
if (temp)
pg_default_opt = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_opt = Py_None;
}
return old;
}
/* gets default tty */
static char getdeftty__doc__[] =
"get_deftty() -- return default database debug terminal.";
static PyObject *
pggetdeftty(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_deftty() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_tty);
return pg_default_tty;
}
/* sets default tty */
static char setdeftty__doc__[] =
"set_deftty(string) -- set default database debug terminal. "
"Return previous value.";
static PyObject *
pgsetdeftty(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_deftty(name), with name (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_tty;
if (temp)
pg_default_tty = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_tty = Py_None;
}
return old;
}
/* gets default username */
static char getdefuser__doc__[] =
"get_defuser() -- return default database username.";
static PyObject *
pggetdefuser(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_defuser() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_user);
return pg_default_user;
}
/* sets default username */
static char setdefuser__doc__[] =
"set_defuser() -- set default database username. Return previous value.";
static PyObject *
pgsetdefuser(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_defuser(name), with name (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_user;
if (temp)
pg_default_user = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_user = Py_None;
}
return old;
}
/* sets default password */
static char setdefpasswd__doc__[] =
"set_defpasswd() -- set default database password.";
static PyObject *
pgsetdefpasswd(PyObject * self, PyObject * args)
{
char *temp = NULL;
PyObject *old;
/* gets arguments */
if (!PyArg_ParseTuple(args, "z", &temp))
{
PyErr_SetString(PyExc_TypeError,
"set_defpasswd(password), with password (string/None).");
return NULL;
}
/* adjusts value */
old = pg_default_passwd;
if (temp)
pg_default_passwd = PyString_FromString(temp);
else
{
Py_INCREF(Py_None);
pg_default_passwd = Py_None;
}
Py_INCREF(Py_None);
return Py_None;
}
/* gets default port */
static char getdefport__doc__[] =
"get_defport() -- return default database port.";
static PyObject *
pggetdefport(PyObject * self, PyObject * args)
{
/* checks args */
if (!PyArg_ParseTuple(args, ""))
{
PyErr_SetString(PyExc_SyntaxError,
"method get_defport() takes no parameter.");
return NULL;
}
Py_XINCREF(pg_default_port);
return pg_default_port;
}
/* sets default port */
static char setdefport__doc__[] =
"set_defport(integer) -- set default database port. Return previous value.";
static PyObject *
pgsetdefport(PyObject * self, PyObject * args)
{
long int port = -2;
PyObject *old;
/* gets arguments */
if ((!PyArg_ParseTuple(args, "l", &port)) || (port < -1))
{
PyErr_SetString(PyExc_TypeError, "set_defport(port), with port "
"(positive integer/-1).");
return NULL;
}
/* adjusts value */
old = pg_default_port;
if (port != -1)
pg_default_port = PyLong_FromLong(port);
else
{
Py_INCREF(Py_None);
pg_default_port = Py_None;
}
return old;
}
#endif /* DEFAULT_VARS */
/* List of functions defined in the module */
static struct PyMethodDef pg_methods[] = {
{"connect", (PyCFunction) pgconnect, 3, connect__doc__},
#ifdef DEFAULT_VARS
{"get_defhost", pggetdefhost, 1, getdefhost__doc__},
{"set_defhost", pgsetdefhost, 1, setdefhost__doc__},
{"get_defbase", pggetdefbase, 1, getdefbase__doc__},
{"set_defbase", pgsetdefbase, 1, setdefbase__doc__},
{"get_defopt", pggetdefopt, 1, getdefopt__doc__},
{"set_defopt", pgsetdefopt, 1, setdefopt__doc__},
{"get_deftty", pggetdeftty, 1, getdeftty__doc__},
{"set_deftty", pgsetdeftty, 1, setdeftty__doc__},
{"get_defport", pggetdefport, 1, getdefport__doc__},
{"set_defport", pgsetdefport, 1, setdefport__doc__},
{"get_defuser", pggetdefuser, 1, getdefuser__doc__},
{"set_defuser", pgsetdefuser, 1, setdefuser__doc__},
{"set_defpasswd", pgsetdefpasswd, 1, setdefpasswd__doc__},
#endif /* DEFAULT_VARS */
{NULL, NULL} /* sentinel */
};
static char pg__doc__[] = "Python interface to PostgreSQL DB";
/* Initialization function for the module */
DL_EXPORT(void)
init_pg(void)
{
PyObject *mod,
*dict,
*v;
/* Initialize here because some WIN platforms get confused otherwise */
PglargeType.ob_type = PgType.ob_type = PgQueryType.ob_type =
PgSourceType.ob_type = &PyType_Type;
/* Create the module and add the functions */
mod = Py_InitModule4("_pg", pg_methods, pg__doc__, NULL, PYTHON_API_VERSION);
dict = PyModule_GetDict(mod);
/* Add some symbolic constants to the module */
PGError = PyString_FromString("_pg.error");
PyDict_SetItemString(dict, "error", PGError);
/* Make the version available */
v = PyString_FromString(PyPgVersion);
PyDict_SetItemString(dict, "version", v);
PyDict_SetItemString(dict, "__version__", v);
Py_DECREF(v);
/* results type for queries */
PyDict_SetItemString(dict, "RESULT_EMPTY", PyInt_FromLong(RESULT_EMPTY));
PyDict_SetItemString(dict, "RESULT_DML", PyInt_FromLong(RESULT_DML));
PyDict_SetItemString(dict, "RESULT_DDL", PyInt_FromLong(RESULT_DDL));
PyDict_SetItemString(dict, "RESULT_DQL", PyInt_FromLong(RESULT_DQL));
#ifdef LARGE_OBJECTS
/* create mode for large objects */
PyDict_SetItemString(dict, "INV_READ", PyInt_FromLong(INV_READ));
PyDict_SetItemString(dict, "INV_WRITE", PyInt_FromLong(INV_WRITE));
/* position flags for lo_lseek */
PyDict_SetItemString(dict, "SEEK_SET", PyInt_FromLong(SEEK_SET));
PyDict_SetItemString(dict, "SEEK_CUR", PyInt_FromLong(SEEK_CUR));
PyDict_SetItemString(dict, "SEEK_END", PyInt_FromLong(SEEK_END));
#endif /* LARGE_OBJECTS */
#ifdef DEFAULT_VARS
/* prepares default values */
Py_INCREF(Py_None);
pg_default_host = Py_None;
Py_INCREF(Py_None);
pg_default_base = Py_None;
Py_INCREF(Py_None);
pg_default_opt = Py_None;
Py_INCREF(Py_None);
pg_default_port = Py_None;
Py_INCREF(Py_None);
pg_default_tty = Py_None;
Py_INCREF(Py_None);
pg_default_user = Py_None;
Py_INCREF(Py_None);
pg_default_passwd = Py_None;
#endif /* DEFAULT_VARS */
/* Check for errors */
if (PyErr_Occurred())
Py_FatalError("can't initialize module _pg");
}
src/interfaces/python/setup.py deleted 100755 → 0
View file @ 2c018f9b
#!/usr/bin/env python
# Setup script for the PyGreSQL version 3
# created 2000/04 Mark Alexander <mwa@gate.net>
# tweaked 2000/05 Jeremy Hylton <jeremy@cnri.reston.va.us>
# win32 support 2001/01 Gerhard Haering <gerhard@bigfoot.de>
# requires distutils; standard in Python 1.6, otherwise download from
# http://www.python.org/sigs/distutils-sig/download.html
# You may have to change the first 3 variables (include_dirs,
# library_dirs, optional_libs) to match your postgres distribution.
# Now, you can:
# python setup.py build # to build the module
# python setup.py install # to install it
# See http://www.python.org/sigs/distutils-sig/doc/ for more information
# on using distutils to install Python programs.
from distutils.core import setup
from distutils.extension import Extension
import sys
if sys.platform == "win32":
# If you want to build from source; you must have built a win32 native libpq # before and copied libpq.dll into the PyGreSQL root directory.
win_pg_build_root = 'd:/dev/pg/postgresql-7.0.2/'
include_dirs=[ win_pg_build_root + 'src/include', win_pg_build_root + '/src/include/libpq', win_pg_build_root + 'src', win_pg_build_root + 'src/interfaces/libpq' ]
library_dirs=[ win_pg_build_root + 'src/interfaces/libpq/Release' ]
optional_libs=[ 'libpqdll', 'wsock32', 'advapi32' ]
data_files = [ 'libpq.dll' ]
else:
include_dirs=['../../include','../libpq','/usr/include/pgsql']
library_dirs=['../libpq','/usr/lib/pgsql']
optional_libs=['pq']
data_files = []
setup (name = "PyGreSQL",
version = "3.3",
description = "Python PostgreSQL Interfaces",
author = "D'Arcy J. M. Cain",
author_email = "darcy@druid.net",
url = "http://www.druid.net/pygresql/",
licence = "Python",
py_modules = ['pg', 'pgdb'],
ext_modules = [ Extension(
name='_pg',
sources = ['pgmodule.c'],
include_dirs = include_dirs,
library_dirs = library_dirs,
libraries = optional_libs
)],
data_files = data_files
)
src/interfaces/python/tutorial/advanced.py deleted 100755 → 0
View file @ 2c018f9b
#! /usr/bin/env python
# advanced.py - demo of advanced features of PostGres. Some may not be ANSI.
# inspired from the Postgres tutorial
# adapted to Python 1995 by Pascal Andre
print """
__________________________________________________________________
MODULE ADVANCED.PY : ADVANCED POSTGRES SQL COMMANDS TUTORIAL
This module is designed for being imported from python prompt
In order to run the samples included here, first create a connection
using : cnx = advanced.DB(...)
The "..." should be replaced with whatever arguments you need to open an
existing database. Usually all you need is the name of the database and,
in fact, if it is the same as your login name, you can leave it empty.
then start the demo with: advanced.demo(cnx)
__________________________________________________________________
"""
from pg import DB
import sys
# waits for a key
def wait_key():
print "Press <enter>"
sys.stdin.read(1)
# inheritance features
def inherit_demo(pgcnx):
print "-----------------------------"
print "-- Inheritance:"
print "-- a table can inherit from zero or more tables. A query"
print "-- can reference either all rows of a table or all rows "
print "-- of a table plus all of its descendants."
print "-----------------------------"
print
print "-- For example, the capitals table inherits from cities table."
print "-- (It inherits all data fields from cities.)"
print
print "CREATE TABLE cities ("
print " name text,"
print " population float8,"
print " altitude int"
print ")"
print
print "CREATE TABLE capitals ("
print " state varchar(2)"
print ") INHERITS (cities)"
pgcnx.query("""CREATE TABLE cities (
name text,
population float8,
altitude int)""")
pgcnx.query("""CREATE TABLE capitals (
state varchar(2)) INHERITS (cities)""")
wait_key()
print
print "-- now, let's populate the tables"
print
print "INSERT INTO cities VALUES ('San Francisco', 7.24E+5, 63)"
print "INSERT INTO cities VALUES ('Las Vegas', 2.583E+5, 2174)"
print "INSERT INTO cities VALUES ('Mariposa', 1200, 1953)"
print
print "INSERT INTO capitals VALUES ('Sacramento', 3.694E+5, 30, 'CA')"
print "INSERT INTO capitals VALUES ('Madison', 1.913E+5, 845, 'WI')"
print
pgcnx.query("INSERT INTO cities VALUES ('San Francisco', 7.24E+5, 63)")
pgcnx.query("INSERT INTO cities VALUES ('Las Vegas', 2.583E+5, 2174)")
pgcnx.query("INSERT INTO cities VALUES ('Mariposa', 1200, 1953)")
pgcnx.query("INSERT INTO capitals VALUES ('Sacramento',3.694E+5,30,'CA')")
pgcnx.query("INSERT INTO capitals VALUES ('Madison', 1.913E+5, 845, 'WI')")
print
print "SELECT * FROM cities"
print pgcnx.query("SELECT * FROM cities")
print "SELECT * FROM capitals"
print pgcnx.query("SELECT * FROM capitals")
print
print "-- like before, a regular query references rows of the base"
print "-- table only"
print
print "SELECT name, altitude"
print "FROM cities"
print "WHERE altitude > 500;"
print pgcnx.query("""SELECT name, altitude
FROM cities
WHERE altitude > 500""")
print
print "-- on the other hand, you can find all cities, including "
print "-- capitals, that are located at an altitude of 500 'ft "
print "-- or higher by:"
print
print "SELECT c.name, c.altitude"
print "FROM cities* c"
print "WHERE c.altitude > 500"
print pgcnx.query("""SELECT c.name, c.altitude
FROM cities* c
WHERE c.altitude > 500""")
# arrays attributes
def array_demo(pgcnx):
print "----------------------"
print "-- Arrays:"
print "-- attributes can be arrays of base types or user-defined "
print "-- types"
print "----------------------"
print
print "CREATE TABLE sal_emp ("
print " name text,"
print " pay_by_quarter int4[],"
print " pay_by_extra_quarter int8[],"
print " schedule text[][]"
print ")"
pgcnx.query("""CREATE TABLE sal_emp (
name text,
pay_by_quarter int4[],
pay_by_extra_quarter int8[],
schedule text[][])""")
wait_key()
print
print "-- insert instances with array attributes. "
print " Note the use of braces"
print
print "INSERT INTO sal_emp VALUES ("
print " 'Bill',"
print " '{10000,10000,10000,10000}',"
print " '{9223372036854775800,9223372036854775800,9223372036854775800}',"
print " '{{\"meeting\", \"lunch\"}, {}}')"
print
print "INSERT INTO sal_emp VALUES ("
print " 'Carol',"
print " '{20000,25000,25000,25000}',"
print " '{9223372036854775807,9223372036854775807,9223372036854775807}',"
print " '{{\"talk\", \"consult\"}, {\"meeting\"}}')"
print
pgcnx.query("""INSERT INTO sal_emp VALUES (
'Bill', '{10000,10000,10000,10000}',
'{9223372036854775800,9223372036854775800,9223372036854775800}',
'{{\"meeting\", \"lunch\"}, {}}')""")
pgcnx.query("""INSERT INTO sal_emp VALUES (
'Carol', '{20000,25000,25000,25000}',
'{9223372036854775807,9223372036854775807,9223372036854775807}',
'{{\"talk\", \"consult\"}, {\"meeting\"}}')""")
wait_key()
print
print "----------------------"
print "-- queries on array attributes"
print "----------------------"
print
print "SELECT name FROM sal_emp WHERE"
print " sal_emp.pay_by_quarter[1] <> sal_emp.pay_by_quarter[2]"
print
print pgcnx.query("""SELECT name FROM sal_emp WHERE
sal_emp.pay_by_quarter[1] <> sal_emp.pay_by_quarter[2]""")
print
print pgcnx.query("""SELECT name FROM sal_emp WHERE
sal_emp.pay_by_extra_quarter[1] <> sal_emp.pay_by_extra_quarter[2]""")
print
print "-- retrieve third quarter pay of all employees"
print
print "SELECT sal_emp.pay_by_quarter[3] FROM sal_emp"
print
print pgcnx.query("SELECT sal_emp.pay_by_quarter[3] FROM sal_emp")
print
print "-- retrieve third quarter extra pay of all employees"
print
print "SELECT sal_emp.pay_by_extra_quarter[3] FROM sal_emp"
print pgcnx.query("SELECT sal_emp.pay_by_extra_quarter[3] FROM sal_emp")
print
print "-- retrieve first two quarters of extra quarter pay of all employees"
print
print "SELECT sal_emp.pay_by_extra_quarter[1:2] FROM sal_emp"
print
print pgcnx.query("SELECT sal_emp.pay_by_extra_quarter[1:2] FROM sal_emp")
print
print "-- select subarrays"
print
print "SELECT sal_emp.schedule[1:2][1:1] FROM sal_emp WHERE"
print " sal_emp.name = 'Bill'"
print pgcnx.query("SELECT sal_emp.schedule[1:2][1:1] FROM sal_emp WHERE " \
"sal_emp.name = 'Bill'")
# base cleanup
def demo_cleanup(pgcnx):
print "-- clean up (you must remove the children first)"
print "DROP TABLE sal_emp"
print "DROP TABLE capitals"
print "DROP TABLE cities;"
pgcnx.query("DROP TABLE sal_emp")
pgcnx.query("DROP TABLE capitals")
pgcnx.query("DROP TABLE cities")
# main demo function
def demo(pgcnx):
inherit_demo(pgcnx)
array_demo(pgcnx)
demo_cleanup(pgcnx)
src/interfaces/python/tutorial/basics.py deleted 100755 → 0
View file @ 2c018f9b
#! /usr/bin/env python
# basics.py - basic SQL commands tutorial
# inspired from the Postgres95 tutorial
# adapted to Python 1995 by Pascal ANDRE
print """
__________________________________________________________________
MODULE BASICS.PY : BASIC POSTGRES SQL COMMANDS TUTORIAL
This module is designed for being imported from python prompt
In order to run the samples included here, first create a connection
using : cnx = basics.DB(...)
The "..." should be replaced with whatever arguments you need to open an
existing database. Usually all you need is the name of the database and,
in fact, if it is the same as your login name, you can leave it empty.
then start the demo with: basics.demo(cnx)
__________________________________________________________________
"""
from pg import DB
import sys
# waits for a key
def wait_key():
print "Press <enter>"
sys.stdin.read(1)
# table creation commands
def create_table(pgcnx):
print "-----------------------------"
print "-- Creating a table:"
print "-- a CREATE TABLE is used to create base tables. POSTGRES"
print "-- SQL has its own set of built-in types. (Note that"
print "-- keywords are case-insensitive but identifiers are "
print "-- case-sensitive.)"
print "-----------------------------"
print
print "Sending query :"
print "CREATE TABLE weather ("
print " city varchar(80),"
print " temp_lo int,"
print " temp_hi int,"
print " prcp float8,"
print " date date"
print ")"
pgcnx.query("""CREATE TABLE weather (city varchar(80), temp_lo int,
temp_hi int, prcp float8, date date)""")
print
print "Sending query :"
print "CREATE TABLE cities ("
print " name varchar(80),"
print " location point"
print ")"
pgcnx.query("""CREATE TABLE cities (
name varchar(80),
location point)""")
# data insertion commands
def insert_data(pgcnx):
print "-----------------------------"
print "-- Inserting data:"
print "-- an INSERT statement is used to insert a new row into"
print "-- a table. There are several ways you can specify what"
print "-- columns the data should go to."
print "-----------------------------"
print
print "-- 1. the simplest case is when the list of value correspond to"
print "-- the order of the columns specified in CREATE TABLE."
print
print "Sending query :"
print "INSERT INTO weather "
print " VALUES ('San Francisco', 46, 50, 0.25, '11/27/1994')"
pgcnx.query("""INSERT INTO weather
VALUES ('San Francisco', 46, 50, 0.25, '11/27/1994')""")
print
print "Sending query :"
print "INSERT INTO cities "
print " VALUES ('San Francisco', '(-194.0, 53.0)')"
pgcnx.query("""INSERT INTO cities
VALUES ('San Francisco', '(-194.0, 53.0)')""")
print
wait_key()
print "-- 2. you can also specify what column the values correspond "
print " to. (The columns can be specified in any order. You may "
print " also omit any number of columns. eg. unknown precipitation"
print " below)"
print "Sending query :"
print "INSERT INTO weather (city, temp_lo, temp_hi, prcp, date)"
print " VALUES ('San Francisco', 43, 57, 0.0, '11/29/1994')"
pgcnx.query("INSERT INTO weather (date, city, temp_hi, temp_lo)" \
"VALUES ('11/29/1994', 'Hayward', 54, 37)")
# direct selection commands
def select_data1(pgcnx):
print "-----------------------------"
print "-- Retrieving data:"
print "-- a SELECT statement is used for retrieving data. The "
print "-- basic syntax is:"
print "-- SELECT columns FROM tables WHERE predicates"
print "-----------------------------"
print
print "-- a simple one would be the query:"
print "SELECT * FROM weather"
print
print "The result is :"
q = pgcnx.query("SELECT * FROM weather")
print q
print
print "-- you may also specify expressions in the target list (the "
print "-- 'AS column' specifies the column name of the result. It is "
print "-- optional.)"
print "The query :"
print " SELECT city, (temp_hi+temp_lo)/2 AS temp_avg, date "
print " FROM weather"
print "Gives :"
print pgcnx.query("""SELECT city, (temp_hi+temp_lo)/2
AS temp_avg, date FROM weather""")
print
print "-- if you want to retrieve rows that satisfy certain condition"
print "-- (ie. a restriction), specify the condition in WHERE. The "
print "-- following retrieves the weather of San Francisco on rainy "
print "-- days."
print "SELECT *"
print "FROM weather"
print "WHERE city = 'San Francisco' "
print " and prcp > 0.0"
print pgcnx.query("""SELECT * FROM weather WHERE city = 'San Francisco'
AND prcp > 0.0""")
print
print "-- here is a more complicated one. Duplicates are removed when "
print "-- DISTINCT is specified. ORDER BY specifies the column to sort"
print "-- on. (Just to make sure the following won't confuse you, "
print "-- DISTINCT and ORDER BY can be used separately.)"
print "SELECT DISTINCT city"
print "FROM weather"
print "ORDER BY city;"
print pgcnx.query("SELECT DISTINCT city FROM weather ORDER BY city")
# selection to a temporary table
def select_data2(pgcnx):
print "-----------------------------"
print "-- Retrieving data into other classes:"
print "-- a SELECT ... INTO statement can be used to retrieve "
print "-- data into another class."
print "-----------------------------"
print
print "The query :"
print "SELECT * INTO TABLE temptab "
print "FROM weather"
print "WHERE city = 'San Francisco' "
print " and prcp > 0.0"
pgcnx.query("""SELECT * INTO TABLE temptab FROM weather
WHERE city = 'San Francisco' and prcp > 0.0""")
print "Fills the table temptab, that can be listed with :"
print "SELECT * from temptab"
print pgcnx.query("SELECT * from temptab")
# aggregate creation commands
def create_aggregate(pgcnx):
print "-----------------------------"
print "-- Aggregates"
print "-----------------------------"
print
print "Let's consider the query :"
print "SELECT max(temp_lo)"
print "FROM weather;"
print pgcnx.query("SELECT max(temp_lo) FROM weather")
print
print "-- Aggregate with GROUP BY"
print "SELECT city, max(temp_lo)"
print "FROM weather "
print "GROUP BY city;"
print pgcnx.query( """SELECT city, max(temp_lo)
FROM weather GROUP BY city""")
# table join commands
def join_table(pgcnx):
print "-----------------------------"
print "-- Joining tables:"
print "-- queries can access multiple tables at once or access"
print "-- the same table in such a way that multiple instances"
print "-- of the table are being processed at the same time."
print "-----------------------------"
print
print "-- suppose we want to find all the records that are in the "
print "-- temperature range of other records. W1 and W2 are aliases "
print "--for weather."
print
print "SELECT W1.city, W1.temp_lo, W1.temp_hi, "
print " W2.city, W2.temp_lo, W2.temp_hi"
print "FROM weather W1, weather W2"
print "WHERE W1.temp_lo < W2.temp_lo "
print " and W1.temp_hi > W2.temp_hi"
print
print pgcnx.query("""SELECT W1.city, W1.temp_lo, W1.temp_hi,
W2.city, W2.temp_lo, W2.temp_hi FROM weather W1, weather W2
WHERE W1.temp_lo < W2.temp_lo and W1.temp_hi > W2.temp_hi""")
print
print "-- let's join two tables. The following joins the weather table"
print "-- and the cities table."
print
print "SELECT city, location, prcp, date"
print "FROM weather, cities"
print "WHERE name = city"
print
print pgcnx.query("""SELECT city, location, prcp, date FROM weather, cities
WHERE name = city""")
print
print "-- since the column names are all different, we don't have to "
print "-- specify the table name. If you want to be clear, you can do "
print "-- the following. They give identical results, of course."
print
print "SELECT w.city, c.location, w.prcp, w.date"
print "FROM weather w, cities c"
print "WHERE c.name = w.city;"
print
print pgcnx.query("""SELECT w.city, c.location, w.prcp, w.date
FROM weather w, cities c WHERE c.name = w.city""")
# data updating commands
def update_data(pgcnx):
print "-----------------------------"
print "-- Updating data:"
print "-- an UPDATE statement is used for updating data. "
print "-----------------------------"
print
print "-- suppose you discover the temperature readings are all off by"
print "-- 2 degrees as of Nov 28, you may update the data as follow:"
print
print "UPDATE weather"
print " SET temp_hi = temp_hi - 2, temp_lo = temp_lo - 2"
print " WHERE date > '11/28/1994'"
print
pgcnx.query("""UPDATE weather
SET temp_hi = temp_hi - 2, temp_lo = temp_lo - 2
WHERE date > '11/28/1994'""")
print
print "SELECT * from weather"
print pgcnx.query("SELECT * from weather")
# data deletion commands
def delete_data(pgcnx):
print "-----------------------------"
print "-- Deleting data:"
print "-- a DELETE statement is used for deleting rows from a "
print "-- table."
print "-----------------------------"
print
print "-- suppose you are no longer interested in the weather of "
print "-- Hayward, you can do the following to delete those rows from"
print "-- the table"
print
print "DELETE FROM weather WHERE city = 'Hayward'"
pgcnx.query("DELETE FROM weather WHERE city = 'Hayward'")
print
print "SELECT * from weather"
print
print pgcnx.query("SELECT * from weather")
print
print "-- you can also delete all the rows in a table by doing the "
print "-- following. (This is different from DROP TABLE which removes "
print "-- the table in addition to the removing the rows.)"
print
print "DELETE FROM weather"
pgcnx.query("DELETE FROM weather")
print
print "SELECT * from weather"
print pgcnx.query("SELECT * from weather")
# table removal commands
def remove_table(pgcnx):
print "-----------------------------"
print "-- Removing the tables:"
print "-- DROP TABLE is used to remove tables. After you have"
print "-- done this, you can no longer use those tables."
print "-----------------------------"
print
print "DROP TABLE weather, cities, temptab"
pgcnx.query("DROP TABLE weather, cities, temptab")
# main demo function
def demo(pgcnx):
create_table(pgcnx)
wait_key()
insert_data(pgcnx)
wait_key()
select_data1(pgcnx)
select_data2(pgcnx)
create_aggregate(pgcnx)
join_table(pgcnx)
update_data(pgcnx)
delete_data(pgcnx)
remove_table(pgcnx)
src/interfaces/python/tutorial/func.py deleted 100755 → 0
View file @ 2c018f9b
# func.py - demonstrate the use of SQL functions
# inspired from the PostgreSQL tutorial
# adapted to Python 1995 by Pascal ANDRE
print """
__________________________________________________________________
MODULE FUNC.PY : SQL FUNCTION DEFINITION TUTORIAL
This module is designed for being imported from python prompt
In order to run the samples included here, first create a connection
using : cnx = func.DB(...)
The "..." should be replaced with whatever arguments you need to open an
existing database. Usually all you need is the name of the database and,
in fact, if it is the same as your login name, you can leave it empty.
then start the demo with: func.demo(cnx)
__________________________________________________________________
"""
from pg import DB
import sys
# waits for a key
def wait_key():
print "Press <enter>"
sys.stdin.read(1)
# basic functions declaration
def base_func(pgcnx):
print "-----------------------------"
print "-- Creating SQL Functions on Base Types"
print "-- a CREATE FUNCTION statement lets you create a new "
print "-- function that can be used in expressions (in SELECT, "
print "-- INSERT, etc.). We will start with functions that "
print "-- return values of base types."
print "-----------------------------"
print
print "--"
print "-- let's create a simple SQL function that takes no arguments"
print "-- and returns 1"
print
print "CREATE FUNCTION one() RETURNS int4"
print " AS 'SELECT 1 as ONE' LANGUAGE 'sql'"
pgcnx.query("""CREATE FUNCTION one() RETURNS int4
AS 'SELECT 1 as ONE' LANGUAGE 'sql'""")
wait_key()
print
print "--"
print "-- functions can be used in any expressions (eg. in the target"
print "-- list or qualifications)"
print
print "SELECT one() AS answer"
print pgcnx.query("SELECT one() AS answer")
print
print "--"
print "-- here's how you create a function that takes arguments. The"
print "-- following function returns the sum of its two arguments:"
print
print "CREATE FUNCTION add_em(int4, int4) RETURNS int4"
print " AS 'SELECT $1 + $2' LANGUAGE 'sql'"
pgcnx.query("""CREATE FUNCTION add_em(int4, int4) RETURNS int4
AS 'SELECT $1 + $2' LANGUAGE 'sql'""")
print
print "SELECT add_em(1, 2) AS answer"
print pgcnx.query("SELECT add_em(1, 2) AS answer")
# functions on composite types
def comp_func(pgcnx):
print "-----------------------------"
print "-- Creating SQL Functions on Composite Types"
print "-- it is also possible to create functions that return"
print "-- values of composite types."
print "-----------------------------"
print
print "-- before we create more sophisticated functions, let's "
print "-- populate an EMP table"
print
print "CREATE TABLE EMP ("
print " name text,"
print " salary int4,"
print " age int4,"
print " dept varchar(16)"
print ")"
pgcnx.query("""CREATE TABLE EMP (
name text,
salary int4,
age int4,
dept varchar(16))""")
print
print "INSERT INTO EMP VALUES ('Sam', 1200, 16, 'toy')"
print "INSERT INTO EMP VALUES ('Claire', 5000, 32, 'shoe')"
print "INSERT INTO EMP VALUES ('Andy', -1000, 2, 'candy')"
print "INSERT INTO EMP VALUES ('Bill', 4200, 36, 'shoe')"
print "INSERT INTO EMP VALUES ('Ginger', 4800, 30, 'candy')"
pgcnx.query("INSERT INTO EMP VALUES ('Sam', 1200, 16, 'toy')")
pgcnx.query("INSERT INTO EMP VALUES ('Claire', 5000, 32, 'shoe')")
pgcnx.query("INSERT INTO EMP VALUES ('Andy', -1000, 2, 'candy')")
pgcnx.query("INSERT INTO EMP VALUES ('Bill', 4200, 36, 'shoe')")
pgcnx.query("INSERT INTO EMP VALUES ('Ginger', 4800, 30, 'candy')")
wait_key()
print
print "-- the argument of a function can also be a tuple. For "
print "-- instance, double_salary takes a tuple of the EMP table"
print
print "CREATE FUNCTION double_salary(EMP) RETURNS int4"
print " AS 'SELECT $1.salary * 2 AS salary' LANGUAGE 'sql'"
pgcnx.query("""CREATE FUNCTION double_salary(EMP) RETURNS int4
AS 'SELECT $1.salary * 2 AS salary' LANGUAGE 'sql'""")
print
print "SELECT name, double_salary(EMP) AS dream"
print "FROM EMP"
print "WHERE EMP.dept = 'toy'"
print pgcnx.query("""SELECT name, double_salary(EMP) AS dream
FROM EMP WHERE EMP.dept = 'toy'""")
print
print "-- the return value of a function can also be a tuple. However,"
print "-- make sure that the expressions in the target list is in the "
print "-- same order as the columns of EMP."
print
print "CREATE FUNCTION new_emp() RETURNS EMP"
print " AS 'SELECT \'None\'::text AS name,"
print " 1000 AS salary,"
print " 25 AS age,"
print " \'none\'::varchar(16) AS dept'"
print " LANGUAGE 'sql'"
pgcnx.query("""CREATE FUNCTION new_emp() RETURNS EMP
AS 'SELECT \\\'None\\\'::text AS name,
1000 AS salary,
25 AS age,
\\\'none\\\'::varchar(16) AS dept'
LANGUAGE 'sql'""")
wait_key()
print
print "-- you can then project a column out of resulting the tuple by"
print "-- using the \"function notation\" for projection columns. "
print "-- (ie. bar(foo) is equivalent to foo.bar) Note that we don't"
print "-- support new_emp().name at this moment."
print
print "SELECT name(new_emp()) AS nobody"
print pgcnx.query("SELECT name(new_emp()) AS nobody")
print
print "-- let's try one more function that returns tuples"
print "CREATE FUNCTION high_pay() RETURNS setof EMP"
print " AS 'SELECT * FROM EMP where salary > 1500'"
print " LANGUAGE 'sql'"
pgcnx.query("""CREATE FUNCTION high_pay() RETURNS setof EMP
AS 'SELECT * FROM EMP where salary > 1500'
LANGUAGE 'sql'""")
print
print "SELECT name(high_pay()) AS overpaid"
print pgcnx.query("SELECT name(high_pay()) AS overpaid")
# function with multiple SQL commands
def mult_func(pgcnx):
print "-----------------------------"
print "-- Creating SQL Functions with multiple SQL statements"
print "-- you can also create functions that do more than just a"
print "-- SELECT."
print "-----------------------------"
print
print "-- you may have noticed that Andy has a negative salary. We'll"
print "-- create a function that removes employees with negative "
print "-- salaries."
print
print "SELECT * FROM EMP"
print pgcnx.query("SELECT * FROM EMP")
print
print "CREATE FUNCTION clean_EMP () RETURNS int4"
print " AS 'DELETE FROM EMP WHERE EMP.salary <= 0"
print " SELECT 1 AS ignore_this'"
print " LANGUAGE 'sql'"
pgcnx.query("CREATE FUNCTION clean_EMP () RETURNS int4 AS 'DELETE FROM EMP WHERE EMP.salary <= 0; SELECT 1 AS ignore_this' LANGUAGE 'sql'")
print
print "SELECT clean_EMP()"
print pgcnx.query("SELECT clean_EMP()")
print
print "SELECT * FROM EMP"
print pgcnx.query("SELECT * FROM EMP")
# base cleanup
def demo_cleanup(pgcnx):
print "-- remove functions that were created in this file"
print
print "DROP FUNCTION clean_EMP()"
print "DROP FUNCTION high_pay()"
print "DROP FUNCTION new_emp()"
print "DROP FUNCTION add_em(int4, int4)"
print "DROP FUNCTION one()"
print
print "DROP TABLE EMP CASCADE"
pgcnx.query("DROP FUNCTION clean_EMP()")
pgcnx.query("DROP FUNCTION high_pay()")
pgcnx.query("DROP FUNCTION new_emp()")
pgcnx.query("DROP FUNCTION add_em(int4, int4)")
pgcnx.query("DROP FUNCTION one()")
pgcnx.query("DROP TABLE EMP CASCADE")
# main demo function
def demo(pgcnx):
base_func(pgcnx)
comp_func(pgcnx)
mult_func(pgcnx)
demo_cleanup(pgcnx)
src/interfaces/python/tutorial/syscat.py deleted 100755 → 0
View file @ 2c018f9b
# syscat.py - parses some system catalogs
# inspired from the PostgreSQL tutorial
# adapted to Python 1995 by Pascal ANDRE
print """
__________________________________________________________________
MODULE SYSCAT.PY : PARSES SOME POSTGRESQL SYSTEM CATALOGS
This module is designed for being imported from python prompt
In order to run the samples included here, first create a connection
using : cnx = syscat.DB(...)
The "..." should be replaced with whatever arguments you need to open an
existing database. Usually all you need is the name of the database and,
in fact, if it is the same as your login name, you can leave it empty.
then start the demo with: syscat.demo(cnx)
Some results may be empty, depending on your base status."
__________________________________________________________________
"""
from pg import DB
import sys
# waits for a key
def wait_key():
print "Press <enter>"
sys.stdin.read(1)
# lists all simple indices
def list_simple_ind(pgcnx):
result = pgcnx.query("""SELECT bc.relname AS class_name,
ic.relname AS index_name, a.attname
FROM pg_class bc, pg_class ic, pg_index i, pg_attribute a
WHERE i.indrelid = bc.oid AND i.indexrelid = bc.oid
AND i.indkey[0] = a.attnum AND i.indnatts = 1
AND a.attrelid = bc.oid AND a.attisdropped = 'f'
ORDER BY class_name, index_name, attname""")
return result
# list all user defined attributes and their type in user-defined classes
def list_all_attr(pgcnx):
result = pgcnx.query("""SELECT c.relname, a.attname, t.typname
FROM pg_class c, pg_attribute a, pg_type t
WHERE c.relkind = 'r' and c.relname !~ '^pg_'
AND c.relname !~ '^Inv' and a.attnum > 0
AND a.attrelid = c.oid and a.atttypid = t.oid
AND a.attisdropped = 'f'
ORDER BY relname, attname""")
return result
# list all user defined base type
def list_user_base_type(pgcnx):
result = pgcnx.query("""SELECT u.usename, t.typname
FROM pg_type t, pg_user u
WHERE u.usesysid = int2in(int4out(t.typowner))
AND t.typrelid = '0'::oid and t.typelem = '0'::oid
AND u.usename <> 'postgres' order by usename, typname""")
return result
# list all right-unary operators
def list_right_unary_operator(pgcnx):
result = pgcnx.query("""SELECT o.oprname AS right_unary,
lt.typname AS operand, result.typname AS return_type
FROM pg_operator o, pg_type lt, pg_type result
WHERE o.oprkind='r' and o.oprleft = lt.oid
AND o.oprresult = result.oid
ORDER BY operand""")
return result
# list all left-unary operators
def list_left_unary_operator(pgcnx):
result = pgcnx.query("""SELECT o.oprname AS left_unary,
rt.typname AS operand, result.typname AS return_type
FROM pg_operator o, pg_type rt, pg_type result
WHERE o.oprkind='l' AND o.oprright = rt.oid
AND o.oprresult = result.oid
ORDER BY operand""")
return result
# list all binary operators
def list_binary_operator(pgcnx):
result = pgcnx.query("""SELECT o.oprname AS binary_op,
rt.typname AS right_opr, lt.typname AS left_opr,
result.typname AS return_type
FROM pg_operator o, pg_type rt, pg_type lt, pg_type result
WHERE o.oprkind = 'b' AND o.oprright = rt.oid
AND o.oprleft = lt.oid AND o.oprresult = result.oid""")
return result
# returns the name, args and return type from all function of lang l
def list_lang_func(pgcnx, l):
result = pgcnx.query("""SELECT p.proname, p.pronargs, t.typname
FROM pg_proc p, pg_language l, pg_type t
WHERE p.prolang = l.oid AND p.prorettype = t.oid
AND l.lanname = '%s'
ORDER BY proname""" % l)
return result
# lists all the aggregate functions and the type to which they can be applied
def list_agg_func(pgcnx):
result = pgcnx.query("""SELECT p.proname, t.typname
FROM pg_aggregate a, pg_proc p, pg_type t
WHERE a.aggfnoid = p.oid
and p.proargtypes[0] = t.oid
ORDER BY proname, typname""")
return result
# lists all the operator classes that can be used with each access method as
# well as the operators that can be used with the respective operator classes
def list_op_class(pgcnx):
result = pgcnx.query("""SELECT am.amname, opc.opcname, opr.oprname
FROM pg_am am, pg_amop amop, pg_opclass opc, pg_operator opr
WHERE amop.amopid = am.oid and amop.amopclaid = opc.oid
AND amop.amopopr = opr.oid order by amname, opcname, oprname""")
return result
# demo function - runs all examples
def demo(pgcnx):
import sys, os
save_stdout = sys.stdout
sys.stdout = os.popen("more", "w")
print "Listing simple indices ..."
print list_simple_ind(pgcnx)
print "Listing all attributes ..."
print list_all_attr(pgcnx)
print "Listing all user-defined base types ..."
print list_user_base_type(pgcnx)
print "Listing all left-unary operators defined ..."
print list_left_unary_operator(pgcnx)
print "Listing all right-unary operators defined ..."
print list_right_unary_operator(pgcnx)
print "Listing all binary operators ..."
print list_binary_operator(pgcnx)
print "Listing C external function linked ..."
print list_lang_func(pgcnx, 'C')
print "Listing C internal functions ..."
print list_lang_func(pgcnx, 'internal')
print "Listing SQL functions defined ..."
print list_lang_func(pgcnx, 'sql')
print "Listing 'aggregate functions' ..."
print list_agg_func(pgcnx)
print "Listing 'operator classes' ..."
print list_op_class(pgcnx)
del sys.stdout
sys.stdout = save_stdout
Markdown is supported
0% or
You are about to add 0 people to the discussion. Proceed with caution.
Finish editing this message first!
Please register or to comment