Skip to content

P
Postgres FD Implementation
Commit f36e7ff0 authored by Bruce Momjian's avatar Bruce Momjian
Browse files
Options

Update for PyGreSQL 3.0, from D'Arcy J.M. Cain

parent 0bd84442
Expand all Hide whitespace changes
Inline Side-by-side
Showing with 1981 additions and 1373 deletions
doc/TODO
View file @ f36e7ff0
......@@ -250,7 +250,7 @@ MISC
* allow configuration of maximum number of open files
* Remove pg_listener index
* Remove ANALYZE from VACUUM so it can be run separately without locks
* Gather more accurate statistics using indexes
* Gather more accurate disbursion statistics using indexes
* Improve statistics storage in pg_class [performance]
* Improve VACUUM speed with indexes [vacuum]
* -BSD/OS does not support locale because there is no LC_MESSAGES (Bruce)
......
src/interfaces/python/Announce
View file @ f36e7ff0
Announce: Release of PyGreSQL version 2.4
Announce: Release of PyGreSQL version 3.0
===============================================
PyGreSQL v2.4 has been released.
PyGreSQL v3.0 has been released.
It is available at: ftp://ftp.druid.net/pub/distrib/PyGreSQL.tgz. If
you are on NetBSD, look in the packages directory under databases. If
it isn't there yet, it should be there shortly. You can also pick up the
package files from ftp://ftp.druid.net/pub/distrib/pygresql.pkg.tgz.
There is also a package in the FreeBSD ports collection but as I write
this it is at version 2.1. I will try to get that updated as well.
you are running NetBSD, look in the packages directory under databases.
There is also a package in the FreeBSD ports collection.
PostgreSQL is a database system derived from Postgres4.2. It conforms
to (most of) ANSI SQL and offers many interesting capabilities (C
......@@ -28,19 +25,49 @@ 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.
I wanted to have DB-SIG API support in the next release but there are
enough fixes and improvements to make one more release before starting
on that. The next version will be 3.0 and have the DB-SIG API support.
Note that I said this for 2.4 but some required changes from others have
been slow in coming (I'm not complaining, people do have lives) and
there were enough fixes that I didn't want to keep them from a release.
This release of PyGreSQL is the first DB-SIG API. That's why we have
a bump in the major number. There is also a potential problem in
backwards compatibility. Previously when there was a NULL in a returned
field it was returned as a blank. Now it is more properly returned as
a Python None. Any scripts that expect NULLs to be blanks will have
problems with this.
PyGreSQL 2.3 was developed and tested on a NetBSD 1.3_BETA system. It
Due to the fact that the DB-API is brand new, it is expected that there
will be a 3.1 release shortly with corrections once many people have
had a chance to test it.
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 6.5.
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
......@@ -48,10 +75,11 @@ Important changes from PyGreSQL 2.3 to PyGreSQL 2.4:
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 but related to negative money amounts
- 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
......
src/interfaces/python/ChangeLog
View file @ f36e7ff0
......@@ -5,16 +5,39 @@ 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.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 but related to negative money amounts
- 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
......
src/interfaces/python/PyGreSQL.spec 0 → 100644
View file @ f36e7ff0
%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
View file @ f36e7ff0
PyGreSQL - v2.4: PostgreSQL module for Python
PyGreSQL - v2.5: PostgreSQL module for Python
==============================================
0. Copyright notice
===================
PyGreSQL, version 2.4
PyGreSQL, version 2.5
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.
......@@ -57,7 +57,8 @@ 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.
style prototypes and changed the order of arguments to connect. The latest
version of PyGreSQL works with PostgreSQL 6.5 and Python 1.5.2.
1.2. Distribution files
......@@ -78,25 +79,90 @@ style prototypes and changed the order of arguments to connect.
1.3. Installation
-----------------
* You first have to get and build Python and PostgreSQL.
* If you are on NetBSD, look in the packages directory under databases. If
it isn't there yet, it should be there shortly. You can also pick up the
package files from ftp://ftp.druid.net/pub/distrib/pygresql.pkg.tgz.
There is also a package in the FreeBSD ports collection but as I write
this it is at version 2.1. I will try to get that updated as well.
* For Linux installation look at README.linux. If you're on an x86 system
that uses RPMs, then you can pick up an RPM at
ftp://ftp.druid.net/pub/distrib/pygresql.i386.rpm
* 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 two parts, a C module labeled _pg and a
Python wrapper called pg.py. This changed between 2.1 and 2.2. This
should not affect any existing programs but the installation is slightly
different.
* Find the directory where your 'Setup' file lives (usually ??/Modules) and
copy or symlink the 'pgmodule.c' file there.
* 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 # -lcrypt # needed on some systems
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
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 the PostgreSQL include
[pgLib] = path of the PostgreSQL libraries
[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
......@@ -108,21 +174,14 @@ style prototypes and changed the order of arguments to connect.
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
* 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.
* Do 'make -f Makefile.pre.in boot' and do 'make && make install'
* 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
* If you are on NetBSD, look in the packages directory under databases. If
it isn't there yet, it should be there shortly. You can also pick up the
package files from ftp://ftp.druid.net/pub/distrib/pygresql.pkg.tgz.
There is also a package in the FreeBSD ports collection but as I write
this it is at version 2.1. I will try to get that updated as well.
* For Linux installation look at README.linux
1.4. Where to get ... ?
-----------------------
......@@ -133,9 +192,10 @@ The home sites of the different packages are:
- PosgreSQL: http://www.PostgreSQL.org/
- PyGreSQL: http://www.druid.net/pygresql/
A Linux RPM can be picked up from ftp://www.eevolute.com/pub/python/.
A NetBSD package thould be in the distribution soon and is available
at ftp://ftp.druid.net/pub/distrib/pygresql.pkg.tgz.
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.
1.5. Information and support
----------------------------
......@@ -394,7 +454,7 @@ methods are specified by the tag [LO].
inserted row. If it is otherwise a query that does not return a result
(ie. is not a some kind of SELECT statement), it returns None.
Otherwise, it returns a pgqueryobject that can be accessed via the
getresult method or printed.
getresult or dictresult method or simply printed.
pgqueryobject methods
---------------------
......@@ -411,8 +471,8 @@ methods are specified by the tag [LO].
pg.error - invalid previous result
Description:
This method returns the list of the values returned by the query.
More information about this result may be get using listfields,
fieldname and fiednum methods.
More information about this result may be accessed using listfields,
fieldname and fieldnum methods.
2.2.1.2. dictresult - like getresult but returns list of dictionaries
---------------------------------------------------------------------
......@@ -839,8 +899,8 @@ has a class called DB. The above functions are also included in the
name space so it isn't necessary to import both modules. The preferred
way to use this module is as follows.
from pg import DB
db = DB(...) # See description of the initialization method below.
import pg
db = pg.DB(...) # See description of the initialization method below.
The following describes the methods and variables of this class.
......@@ -973,11 +1033,30 @@ The following describes the methods and variables of this class.
as munged as described above.
4. Future directions
====================
4. DB-API reference
===================
This section needs to be written.
5. Todo
=======
The large object and direct access functions need much more attention.
I want to add a DB-SIG API wrapper around the underlying module. This
will be in 3.0.
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.
6. 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/README.linux
View file @ f36e7ff0
Thanks to thilo@eevolute.com for this README and the RPM
Note: The precompiled RPM package is not available at www.eevolute.com.
You may use the spec file provided with PyGreSQL to build your
own package.
Hartmut Goebel <hartmut@goebel.noris.de>
INSTALLING PyGreSQL on Redhat Linux 5.1 or 5.2
==============================================
......
src/interfaces/python/mkdefines
View file @ f36e7ff0
#! /usr/local/bin/python
#! /usr/bin/env python
import string
......
src/interfaces/python/pg.py
View file @ f36e7ff0
......@@ -10,13 +10,16 @@ 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', 'decimal', 'seq']:
if d == "": return 0
return "%s" % d
return "%d" % int(d)
if t == 'money':
if d == "": return '0.00'
return "'%.2f'" % d
return "'%.2f'" % float(d)
if t == 'bool':
if string.upper(d) in ['T', 'TRUE', 'Y', 'YES', 1, '1', 'ON']:
......@@ -25,7 +28,8 @@ def _quote(d, t):
return "'f'"
if d == "": return "null"
return "'%s'" % string.strip(re.sub("'", "''", "%s" % d))
return "'%s'" % string.strip(re.sub("'", "''", \
re.sub("\\\\", "\\\\\\\\", "%s" %d)))
class DB:
"""This class wraps the pg connection type"""
......@@ -42,8 +46,8 @@ class DB:
if not hasattr(self,e) and hasattr(self.db,e):
exec 'self.%s = self.db.%s' % ( e, e )
self.attnames = {}
self.pkeys = {}
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>"
......@@ -56,11 +60,17 @@ class DB:
pg_class.oid = pg_index.indrelid AND
pg_index.indkey[0] = pg_attribute.attnum AND
pg_index.indisprimary = 't'""").getresult():
self.pkeys[rel] = att
self.__pkeys__[rel] = att
# wrap query for debugging
def query(self, qstr):
if self.debug != None:
print self.debug % qstr
return self.db.query(qstr)
def pkey(self, cl):
# will raise an exception if primary key doesn't exist
return self.pkeys[cl]
return self.__pkeys__[cl]
def get_databases(self):
l = []
......@@ -79,8 +89,8 @@ class DB:
def get_attnames(self, cl):
# May as well cache them
if self.attnames.has_key(cl):
return self.attnames[cl]
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
......@@ -114,13 +124,13 @@ class DB:
else:
l[attname] = 'text'
self.attnames[cl] = l
return self.attnames[cl]
self.__attnames__[cl] = l
return self.__attnames__[cl]
# return a tuple from a database
def get(self, cl, arg, keyname = None):
def get(self, cl, arg, keyname = None, view = 0):
if keyname == None: # use the primary key by default
keyname = self.pkeys[cl]
keyname = self.__pkeys__[cl]
fnames = self.get_attnames(cl)
......@@ -136,6 +146,9 @@ class DB:
# 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" % \
(cl, string.join(fnames.keys(), ','),\
......@@ -155,6 +168,7 @@ class DB:
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 = []
......@@ -183,7 +197,7 @@ class DB:
# otherwise use the primary key. Fail if neither.
def update(self, cl, a):
foid = 'oid_%s' % cl
pk = self.pkeys[cl]
pk = self.__pkeys__[cl]
if a.has_key(foid):
where = "oid = %s" % a[foid]
elif a.has_key(pk):
......@@ -228,8 +242,6 @@ class DB:
for ff in fnames.keys():
if fnames[ff] in ['int', 'decimal', 'seq', 'money']:
a[ff] = 0
elif fnames[ff] == 'date':
a[ff] = 'TODAY'
else:
a[ff] = ""
......
src/interfaces/python/pgdb.py 0 → 100644
View file @ f36e7ff0
""" pgdb - DB-SIG compliant module for PygreSQL.
(c) 1999, Pascal Andre <andre@via.ecp.fr>.
See package documentation for further information on copyright.
Even though this file is distributed with a release version of
PyGreSQL, this is beta software. 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 DateTime
import time
### 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 == 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, typprtlen, 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],
string.atoi(res[1]), string.atoi(res[2]),
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 = 5
def close(self):
self.__source.close()
self.description = None
self.rowcount = -1
def execute(self, operation, params = None):
if type(params) == types.TupleType or type(params) == types.ListType:
self.executemany(operation, params)
else:
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 = 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
res = self.__source.fetch(size)
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 setinputsizes(self, sizes):
pass
def setoutputsize(self, size, col = 0):
pass
### 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 = params[1]
except:
pass
# empty host is localhost
if dbhost == "":
dbhost = None
if dbuser == "":
dbuser = None
# open the connection
cnx = _pg.connect(host = dbhost, dbname = dbbase, port = dbport,
opt = dbopt, tty = dbtty,
user = dbuser, passwd = 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', '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'
)
# 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
View file @ f36e7ff0
This diff is collapsed.
src/interfaces/python/pgsqldb.py deleted 100644 → 0
View file @ 0bd84442
# pgsqldb.py
# Written by D'Arcy J.M. Cain
# This library implements the DB-SIG API
# It includes the pg module and builds on it
from _pg import *
import string
class _cursor:
"""For cursor object"""
def __init__(self, conn):
self.conn = conn
self.cursor = None
self.arraysize = 1
self.description = None
self.name = string.split(`self`)[3][:-1]
def close(self):
if self.conn == None: raise self.conn.error, "Cursor has been closed"
if self.cursor == None: raise self.conn.error, "No cursor created"
self.conn.query('CLOSE %s' % self.name)
self.conn = None
def __del__(self):
if self.cursor != None and self.conn != None:
self.conn.query('CLOSE %s' % self.name)
class pgsqldb:
"""This class wraps the pg connection type in a DB-SIG API interface"""
def __init__(self, *args, **kw):
self.db = apply(connect, args, kw)
# Create convience methods, in a way that is still overridable.
for e in ('query', 'reset', 'close', 'getnotify', 'inserttable',
'putline', 'getline', 'endcopy',
'host', 'port', 'db', 'options',
'tty', 'error', 'status', 'user',
'locreate', 'getlo', 'loimport'):
if not hasattr(self,e) and hasattr(self.db,e):
exec 'self.%s = self.db.%s' % ( e, e )
src/interfaces/python/setup.py 0 → 100755
View file @ f36e7ff0
#!/usr/bin/env python
include_dirs=['/usr/include/pgsql']
library_dirs=['usr/lib/pgsql']
optional_libs=['pq']
# 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>
# 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
setup (name = "PyGreSQL",
version = "3.0",
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 = [ ('_pgmodule', {
'sources': ['pgmodule.c'],
'include_dirs': include_dirs,
'library_dirs': library_dirs,
'libraries': optional_libs
}
)]
)
src/interfaces/python/tutorial/advanced.py deleted 100755 → 0
View file @ 0bd84442
#! /usr/local/bin/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 "__________________________________________________________________"
print "MODULE ADVANCED.PY : ADVANCED POSTGRES SQL COMMANDS TUTORIAL"
print
print "This module is designed for being imported from python prompt"
print
print "In order to run the samples included here, first create a connection"
print "using : cnx = advanced.DB(...)"
print "then start the demo with: advanced.demo(cnx)"
print "__________________________________________________________________"
from pgtools import *
from pg import DB
# 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 " schedule text[][]"
print ")"
pgcnx.query("CREATE TABLE sal_emp (" \
"name text," \
"pay_by_quarter int4[]," \
"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 " '{{\"meeting\", \"lunch\"}, {}}')"
print
print "INSERT INTO sal_emp VALUES ("
print " 'Carol',"
print " '{20000,25000,25000,25000}',"
print " '{{\"talk\", \"consult\"}, {\"meeting\"}}')"
print
pgcnx.query("INSERT INTO sal_emp VALUES (" \
"'Bill', '{10000,10000,10000,10000}'," \
"'{{\"meeting\", \"lunch\"}, {}}')")
pgcnx.query("INSERT INTO sal_emp VALUES (" \
"'Carol', '{20000,25000,25000,25000}'," \
"'{{\"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 "-- 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 "-- 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 @ 0bd84442
This diff is collapsed.
src/interfaces/python/tutorial/func.py deleted 100755 → 0
View file @ 0bd84442
# func.py - demonstrate the use of SQL functions
# inspired from the PostgreSQL tutorial
# adapted to Python 1995 by Pascal ANDRE
print "__________________________________________________________________"
print "MODULE FUNC.PY : SQL FUNCTION DEFINITION TUTORIAL"
print
print "This module is designed for being imported from python prompt"
print
print "In order to run the samples included here, first create a connection"
print "using : cnx = func.DB(...)"
print "then start the demo with: func.demo(cnx)"
print "__________________________________________________________________"
from pgtools import *
from pg import DB
# 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"
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")
# main demo function
def demo(pgcnx):
base_func(pgcnx)
comp_func(pgcnx)
mult_func(pgcnx)
demo_cleanup(pgcnx)
src/interfaces/python/tutorial/pgtools.py deleted 100755 → 0
View file @ 0bd84442
#! /usr/local/bin/python
# pgtools.py - valuable functions for PostGreSQL tutorial
# written 1995 by Pascal ANDRE
import sys
# number of rows
scr_size = 24
# waits for a key
def wait_key():
print "Press <enter>"
sys.stdin.read(1)
# displays a table for a select query result
def display(fields, result):
print result
# gets cols width
fmt = []
sep = '+'
head = '|'
for i in range(0, len(fields)):
max = len(fields[i])
for j in range(0, len(result)):
if i < len(result[j]):
if len(result[j][i]) > max:
max = len(result[j][i])
fmt.append(" %%%ds |" % max)
for j in range(0, max):
sep = sep + '-'
sep = sep + '--+'
for i in range(0, len(fields)):
head = head + fmt[i] % fields[i]
print sep + '\n' + head + '\n' + sep
pos = 6
for i in range(0, len(result)):
str = '|'
for j in range(0, len(result[i])):
str = str + fmt[j] % result[i][j]
print str
pos = pos + 1
if pos == scr_size:
print sep
wait_key()
print sep + '\n' + head + '\n' + sep
pos = 6
print sep
wait_key()
src/interfaces/python/tutorial/syscat.py deleted 100755 → 0
View file @ 0bd84442
# syscat.py - parses some system catalogs
# inspired from the PostgreSQL tutorial
# adapted to Python 1995 by Pascal ANDRE
print "____________________________________________________________________"
print
print "MODULE SYSCAT.PY : PARSES SOME POSTGRESQL SYSTEM CATALOGS"
print
print "This module is designed for being imported from python prompt"
print
print "In order to run the samples included here, first create a connection"
print "using : cnx = syscat.DB(...)"
print "then start the demo with: syscat.demo(cnx)"
print
print "Some results may be empty, depending on your base status."
print
print "____________________________________________________________________"
print
from pg import DB
from pgtools import *
# 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 a.attrelid = bc.oid " \
" and i.indproc = '0'::oid " \
"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 " \
"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 a.aggname, t.typname " \
"from pg_aggregate a, pg_type t " \
"where a.aggbasetype = t.oid order by aggname, 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