Changeset 343


Ignore:
Timestamp:
Nov 1, 2008, 11:38:02 AM (11 years ago)
Author:
cito
Message:

Some more code clean-up in the pgdb module.

Location:
trunk/module
Files:
2 edited

Legend:

Unmodified
Added
Removed
  • trunk/module/TEST_PyGreSQL_dbapi20.py

    r342 r343  
    11#!/usr/bin/env python
    2 # $Id: TEST_PyGreSQL_dbapi20.py,v 1.9 2008-11-01 13:04:07 cito Exp $
     2# $Id: TEST_PyGreSQL_dbapi20.py,v 1.10 2008-11-01 15:38:02 cito Exp $
    33
    44import dbapi20
     
    77import popen2
    88
    9 # We need a database to test against.  If LOCAL_PyGreSQL.py exists we will
    10 # get our information from that.  Otherwise we use the defaults.
     9# We need a database to test against.
     10# If LOCAL_PyGreSQL.py exists we will get our information from that.
     11# Otherwise we use the defaults.
    1112dbname = 'dbapi20_test'
    1213dbhost = None
    1314dbport = 5432
    14 try: from LOCAL_PyGreSQL import *
    15 except: pass
     15try:
     16    from LOCAL_PyGreSQL import *
     17except ImportError:
     18    pass
     19
    1620
    1721class test_PyGreSQL(dbapi20.DatabaseAPI20Test):
     22
    1823    driver = pgdb
    1924    connect_args = ()
     
    2328
    2429    def setUp(self):
    25         # Call superclass setUp In case this does something in the
    26         # future
     30        # Call superclass setUp in case this does something in the future
    2731        dbapi20.DatabaseAPI20Test.setUp(self)
    28 
    2932        try:
    3033            con = self._connect()
    3134            con.close()
    32         except:
     35        except Exception:
    3336            cmd = "psql -c 'create database dbapi20_test'"
    34             cout,cin = popen2.popen2(cmd)
     37            cout, cin = popen2.popen2(cmd)
    3538            cin.close()
    3639            cout.read()
  • trunk/module/pgdb.py

    r342 r343  
    55# Written by D'Arcy J.M. Cain
    66#
    7 # $Id: pgdb.py,v 1.42 2008-11-01 13:04:07 cito Exp $
     7# $Id: pgdb.py,v 1.43 2008-11-01 15:38:02 cito Exp $
    88#
    99
     
    6565
    6666from _pg import *
    67 import types
    6867import time
    6968try:
     
    119118        def __init__(self, cnx):
    120119                """Initialize type cache for connection."""
     120                super(pgdbTypeCache, self).__init__()
    121121                self._src = cnx.source()
    122122
     
    138138                try:
    139139                        return self[oid]
    140                 except:
     140                except KeyError:
    141141                        self._src.execute(
    142142                                "SELECT typname, typlen "
     
    158158
    159159
    160 def _quote(x):
     160def _quote(val):
    161161        """Quote value depending on its type."""
    162         if isinstance(x, DateTimeType):
    163                 x = str(x)
    164         elif isinstance(x, unicode):
    165                 x = x.encode( 'utf-8' )
    166         if isinstance(x, str):
    167                 x = "'%s'" % str(x).replace("\\", "\\\\").replace("'", "''")
    168         elif isinstance(x, (int, long, float)):
     162        if isinstance(val, DateTimeType):
     163                val = str(val)
     164        elif isinstance(val, unicode):
     165                val = val.encode( 'utf-8' )
     166        if isinstance(val, str):
     167                val = "'%s'" % str(val).replace("\\", "\\\\").replace("'", "''")
     168        elif isinstance(val, (int, long, float)):
    169169                pass
    170         elif x is None:
    171                 x = 'NULL'
    172         elif isinstance(x, (list, tuple)):
    173                 x = '(%s)' % ','.join(map(lambda x: str(_quote(x)), x))
    174         elif Decimal is not float and isinstance(x, Decimal):
     170        elif val is None:
     171                val = 'NULL'
     172        elif isinstance(val, (list, tuple)):
     173                val = '(%s)' % ','.join(map(lambda v: str(_quote(v)), val))
     174        elif Decimal is not float and isinstance(val, Decimal):
    175175                pass
    176         elif hasattr(x, '__pg_repr__'):
    177                 x = x.__pg_repr__()
     176        elif hasattr(val, '__pg_repr__'):
     177                val = val.__pg_repr__()
    178178        else:
    179                 raise InterfaceError('do not know how to handle type %s' % type(x))
    180         return x
    181 
    182 
    183 def _quoteparams(s, params):
     179                raise InterfaceError('do not know how to handle type %s' % type(val))
     180        return val
     181
     182
     183def _quoteparams(string, params):
    184184        """Quote parameters.
    185185
     
    191191        else:
    192192                params = tuple(map(_quote, params))
    193         return s % params
     193        return string % params
    194194
    195195
     
    200200
    201201        def __init__(self, dbcnx):
     202                """Create a cursor object for the database connection."""
    202203                self._dbcnx = dbcnx
    203204                self._cnx = dbcnx._cnx
     
    210211
    211212        def row_factory(row):
    212                 """You can overwrite this with a custom row factory
    213                         e.g. a dict_factory
    214 
    215                         class myCursor(pgdb.pgdbCursor):
    216                                 def cursor.row_factory(self, row):
    217                                         d = {}
    218                                         for idx, col in enumerate(self.description):
    219                                                 d[col[0]] = row[idx]
    220                                         return d
    221                         cursor = myCursor(cnx)
     213                """Process rows before they are returned.
     214
     215                You can overwrite this with a custom row factory,
     216                e.g. a dict factory:
     217
     218                class myCursor(pgdb.pgdbCursor):
     219                        def cursor.row_factory(self, row):
     220                                d = {}
     221                                for idx, col in enumerate(self.description):
     222                                        d[col[0]] = row[idx]
     223                                return d
     224                cursor = myCursor(cnx)
     225
    222226                """
    223227                return row
     
    225229
    226230        def close(self):
     231                """Close the cursor object."""
    227232                self._src.close()
    228233                self.description = None
    229234                self.rowcount = -1
    230235                self.lastrowid = None
    231 
    232         def arraysize(self, size):
    233                 self.arraysize = size
    234236
    235237        def execute(self, operation, params=None):
     
    261263                                except:
    262264                                        raise OperationalError("can't start transaction")
    263                                 self._dbcnx._tnx = 1
     265                                self._dbcnx._tnx = True
    264266                        for params in param_seq:
    265267                                if params:
     
    281283                if self._src.resulttype == RESULT_DQL:
    282284                        self.rowcount = self._src.ntuples
    283                         d = []
    284                         for typ in self._src.listinfo():
    285                                 # listinfo is a sequence of
    286                                 # (index, column_name, type_oid)
    287                                 # getdescr returns all items needed for a
    288                                 # description tuple except the column_name.
    289                                 desc = typ[1:2] + self._type_cache.getdescr(typ[2])
    290                                 d.append(desc)
    291                         self.description = d
     285                        getdescr = self._type_cache.getdescr
     286                        coltypes = self._src.listinfo()
     287                        self.description = [typ[1:2] + getdescr(typ[2]) for typ in coltypes]
    292288                        self.lastrowid = self._src.oidstatus()
    293289                else:
     
    297293
    298294        def fetchone(self):
    299                 res = self.fetchmany(1, 0)
     295                """Fetch the next row of a query result set."""
     296                res = self.fetchmany(1, False)
    300297                try:
    301298                        return res[0]
    302                 except:
     299                except IndexError:
    303300                        return None
    304301
    305302        def fetchall(self):
    306                 return self.fetchmany(-1, 0)
    307 
    308         def fetchmany(self, size=None, keep=0):
     303                """Fetch all (remaining) rows of a query result."""
     304                return self.fetchmany(-1, False)
     305
     306        def fetchmany(self, size=None, keep=False):
     307                """Fetch the next set of rows of a query result.
     308
     309                The number of rows to fetch per call is specified by the
     310                size parameter. If it is not given, the cursor's arraysize
     311                determines the number of rows to be fetched. If you set
     312                the keep parameter to true, this is kept as new arraysize.
     313
     314                """
    309315                if size is None:
    310316                        size = self.arraysize
    311                 if keep == 1:
     317                if keep:
    312318                        self.arraysize = size
    313319                try:
    314320                        result = self._src.fetch(size)
    315                 except Error, e:
    316                         raise DatabaseError(str(e))
     321                except Error, err:
     322                        raise DatabaseError(str(err))
    317323                row_factory = self.row_factory
    318324                typecast = self._type_cache.typecast
     
    322328
    323329        def nextset():
     330                """Not supported."""
    324331                raise NotSupportedError("nextset() is not supported")
    325332        nextset = staticmethod(nextset)
    326333
    327334        def setinputsizes(sizes):
     335                """Not supported."""
    328336                pass
    329337        setinputsizes = staticmethod(setinputsizes)
    330338
    331         def setoutputsize(size, col=0):
     339        def setoutputsize(size, column=0):
     340                """Not supported."""
    332341                pass
    333342        setoutputsize = staticmethod(setoutputsize)
     
    340349
    341350        def __init__(self, cnx):
     351                """Create a database connection object."""
    342352                self._cnx = cnx # connection
    343                 self._tnx = 0 # transaction state
     353                self._tnx = False # transaction state
    344354                self._type_cache = pgdbTypeCache(cnx)
    345355                try:
     
    349359
    350360        def close(self):
     361                """Close the connection object."""
    351362                if self._cnx:
    352363                        self._cnx.close()
     
    356367
    357368        def commit(self):
     369                """Commit any pending transaction to the database."""
    358370                if self._cnx:
    359371                        if self._tnx:
    360                                 self._tnx = 0
     372                                self._tnx = False
    361373                                try:
    362374                                        self._cnx.source().execute("COMMIT")
     
    367379
    368380        def rollback(self):
     381                """Roll back to the start of any pending transaction."""
    369382                if self._cnx:
    370383                        if self._tnx:
    371                                 self._tnx = 0
     384                                self._tnx = False
    372385                                try:
    373386                                        self._cnx.source().execute("ROLLBACK")
     
    378391
    379392        def cursor(self):
     393                """Return a new Cursor Object using the connection."""
    380394                if self._cnx:
    381395                        try:
     
    390404
    391405_connect_ = connect
     406
    392407def connect(dsn=None,
    393408                user=None, password=None,
     
    410425                dbopt = params[4]
    411426                dbtty = params[5]
    412         except:
     427        except (IndexError, TypeError):
    413428                pass
    414429
     
    425440                        dbhost = params[0]
    426441                        dbport = int(params[1])
    427                 except:
     442                except (IndexError, TypeError, ValueError):
    428443                        pass
    429444
     
    450465        """
    451466
    452         def __new__(cls, values):
    453                 # for Python >= 2.4
    454                 if isinstance(values, basestring):
    455                         values = values.split()
    456                 return super(pgdbType, cls).__new__(cls, values)
    457 
    458         def __init__(self, values):
    459                 # for Python < 2.4
    460                 if isinstance(values, basestring):
    461                         values = values.split()
    462                 super(pgdbType, self).__init__(values)
     467        if frozenset.__module__ == '__builtin__':
     468                def __new__(cls, values):
     469                        if isinstance(values, basestring):
     470                                values = values.split()
     471                        return super(pgdbType, cls).__new__(cls, values)
     472        else: # Python < 2.4
     473                def __init__(self, values):
     474                        if isinstance(values, basestring):
     475                                values = values.split()
     476                        super(pgdbType, self).__init__(values)
    463477
    464478        def __eq__(self, other):
     
    502516
    503517def Date(year, month, day):
     518        """Construct an object holding a date value."""
    504519        return DateTime(year, month, day)
    505520
    506521def Time(hour, minute, second):
     522        """Construct an object holding a time value."""
    507523        return TimeDelta(hour, minute, second)
    508524
    509525def Timestamp(year, month, day, hour, minute, second):
     526        """construct an object holding a time stamp value."""
    510527        return DateTime(year, month, day, hour, minute, second)
    511528
    512529def DateFromTicks(ticks):
     530        """Construct an object holding a date value from the given ticks value."""
    513531        return Date(*time.localtime(ticks)[:3])
    514532
    515533def TimeFromTicks(ticks):
     534        """construct an object holding a time value from the given ticks value."""
    516535        return Time(*time.localtime(ticks)[3:6])
    517536
    518537def TimestampFromTicks(ticks):
     538        """construct an object holding a time stamp from the given ticks value."""
    519539        return Timestamp(*time.localtime(ticks)[:6])
    520540
    521541def Binary(value):
     542        """construct an object capable of holding a binary (long) string value."""
    522543        return value
    523544
Note: See TracChangeset for help on using the changeset viewer.