remove python module, as its moved to http://www.pygresql.org
This commit is contained in:
Marc G. Fournier
parent
2c018f9b10
commit
13a0e910cd
|
|
@ -1,158 +0,0 @@
|
|||
|
||||
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
|
||||
|
||||
|
||||
|
|
@ -1,125 +0,0 @@
|
|||
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)
|
||||
|
|
@ -1,59 +0,0 @@
|
|||
# $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)
|
||||
|
|
@ -1,57 +0,0 @@
|
|||
%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}
|
||||
|
|
@ -1,264 +0,0 @@
|
|||
|
||||
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.
|
||||
|
||||
|
||||
|
|
@ -1,3 +0,0 @@
|
|||
*shared*
|
||||
|
||||
_pg pgmodule.c -I@libpq_srcdir@ @INCLUDES@ -L@libpq_builddir@ -lpq @EXTRA_LIBS@
|
||||
|
|
@ -1,302 +0,0 @@
|
|||
# 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
|
||||
|
||||
|
|
@ -1,452 +0,0 @@
|
|||
""" 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])
|
||||
|
||||
File diff suppressed because it is too large
Load Diff
|
|
@ -1,56 +0,0 @@
|
|||
#!/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
|
||||
)
|
||||
|
||||
|
|
@ -1,198 +0,0 @@
|
|||
#! /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)
|
||||
|
|
@ -1,296 +0,0 @@
|
|||
#! /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)
|
||||
|
|
@ -1,205 +0,0 @@
|
|||
# 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)
|
||||
|
|
@ -1,149 +0,0 @@
|
|||
# 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
|
||||
Loading…
Reference in New Issue