Changeset 10

Timestamp:

02/15/07 01:12:02

Author:

fumanchu

Message:

Separated all connection/transaction logic into a new 'connectionmanager' delegate:

1. Changed 'db.get_transaction' to be the default behavior (of db.connections.get) and hid the old bare connection() call as '_factory()'.
   
2. New Database.execute_ddl method to hide all the lock/unlock calls.
   
3. New "in_transaction" method for autocommitting db's.
   
4. Other name changes:
   
   • is_lock_error to is_timeout_error
     
   • disconnect to shutdown
     
   • transaction_key to id
     
   • lock_contention to contention
     

Also consolidated most of the two postgres modules into a single base. Also fixed a SQLiteTypeless bug.

Files:

• trunk/geniusql/__init__.py (modified) (16 diffs)
• trunk/geniusql/conn.py (modified) (3 diffs)
• trunk/geniusql/isolation.py (modified) (1 diff)
• trunk/geniusql/providers/__init__.py (modified) (1 diff)
• trunk/geniusql/providers/ado.py (modified) (16 diffs)
• trunk/geniusql/providers/firebird.py (modified) (12 diffs)
• trunk/geniusql/providers/mysql.py (modified) (9 diffs)
• trunk/geniusql/providers/postgres.py (added)
• trunk/geniusql/providers/psycopg.py (modified) (5 diffs)
• trunk/geniusql/providers/pypgsql.py (modified) (3 diffs)
• trunk/geniusql/providers/sqlite.py (modified) (14 diffs)
• trunk/geniusql/select.py (modified) (2 diffs)
• trunk/geniusql/test/zoo_fixture.py (modified) (1 diff)

trunk/geniusql/__init__.py

@@ -105 +105 @@
-        t = self.table
-        if t.created:
-
-
-
+
-                             (index.qname, t.qname,
-                              t.db.quote(index.colname)))
-            finally:
-                t.db.unlock()
-        dict.__setitem__(self, key, index)
-    
@@ -118 +114 @@
-        t = self.table
-        if t.created:
-
-
-
-
-
+
+
-        dict.__delitem__(self, key)
-
@@ -271 +264 @@
-            del self[key]
-        
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    
-    def _drop_column(self, column):
-        """Internal function to drop the column from the database."""
-
-
+_ddl
+    
-    
-    def __delitem__(self, key):
@@ -294 +283 @@
-            return
-        
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    
-    def _rename(self, oldcol, newcol):
-        # Override this to do the actual rename at the DB level.
-
-
+_ddl
+    
-    
-    def rename(self, oldkey, newkey):
@@ -326 +311 @@
-            newcol.name = newname
-            newcol.qname = self.db.quote(newname)
-
-
-
-
-
+
-        
-        # Use the superclass calls to avoid DROP COLUMN/ADD COLUMN.
@@ -391 +372 @@
-                values.append(val)
-        
-transconn = self.db.get_transaction
+conn = self.db.connections.get
-        
-        fields = ", ".join(fields)
-        values = ", ".join(values)
-        self.db.execute('INSERT INTO %s (%s) VALUES (%s);' %
-trans
+
-        
-        if idkeys:
-trans
+
-            for key in newids.keys():
-                col = self[key]
@@ -427 +408 @@
-            sql = ('UPDATE %s SET %s WHERE %s;' %
-                   (self.qname, ", ".join(parms), self.id_clause(**inputs)))
-, self.db.get_transaction()
+
-    
-    use_asterisk_to_delete_all = False
@@ -438 +419 @@
-            star = ""
-        self.db.execute('DELETE%s FROM %s WHERE %s;' %
-
-
+
-    
-    def delete_all(self, **inputs):
@@ -448 +428 @@
-            star = ""
-        self.db.execute('DELETE%s FROM %s WHERE %s;' %
-
-
+
-    
-    def select_all(self, restriction=None, **kwargs):
@@ -511 +490 @@
-    selectwriter = SelectWriter
-    tableclass = Table
+    connectionmanager = ConnectionManager
-    
-    def __new__(cls, name, **kwargs):
@@ -524 +504 @@
-        self.name = self.sql_name(name)
-        self.qname = self.quote(self.name)
-
-
+
+
+
+
-        self.discover_dbinfo()
-    
@@ -717 +699 @@
-        table.created = True
-        
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-            
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-                         (table.qname, ", ".join(fields), pk))
-    
-    
-    self.execute
+
+
+self.execute_ddl
-                             (index.qname, table.qname,
-                              self.quote(index.colname)))
-
-
-
+
+
-    
-    def __delitem__(self, key):
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    
-    def _rename(self, oldtable, newtable):
@@ -774 +749 @@
-            newtable.name = newname
-            newtable.qname = self.quote(newname)
-
-
-
-
-
+
-        
-        # Use the superclass calls to avoid DROP TABLE/CREATE TABLE.
@@ -840 +811 @@
-        return self.tableclass(name, self.quote(name), self)
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    
-    def execute(self, query, conn=None):
-        """Return a native response for the given query."""
-        if conn is None:
-
+s.get
-        if isinstance(query, unicode):
-            query = query.encode(self.adaptertosql.encoding)
@@ -875 +830 @@
-        return conn.query(query)
-    
+    def execute_ddl(self, query, conn=None):
+        """Return a native response for the given DDL statement.
+        
+        In general, DDL statements should lock out other statements
+        (especially those isolated in other transactions). Use this
+        method to perform a locked DDL statement.
+        """
+        self.connections.lock("Transaction denied due to DDL: %r" % query)
+        try:
+##            # Must shut down all connections to avoid
+##            # "being accessed by other users" error?
+##            self.connections.shutdown()
+            if conn is None:
+                # Important: use _factory(), not get(), to avoid the lock
+                conn = self.connections._factory()
+            self.execute(query, conn)
+        finally:
+            self.connections.unlock()
+    
-    def fetch(self, query, conn=None):
-        """Return rowdata, columns (name, type) for the given query.
@@ -890 +864 @@
-        """Yield matching data, coerced to Python types (where known)."""
-        sel = self.selectwriter(self, relation, attributes, restriction)
-, self.get_transaction()
+
-        return ResultSet(data, sel.columns, sel.imperfect)
-    
-    def create_database(self):
-
-
-
-
-
-
+
+
-    
-    def drop_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-
-

trunk/geniusql/conn.py

@@ -1 @@
-with the geniusql package
+and transactions with Geniusql
-
-__all__ = [
+    'ConnectionManager',
-    'ConnectionFactory', 'ConnectionPool', 'ConnectionWrapper',
-    'SingleConnection',
@@ -7 +8 @@
-
-import Queue
+import threading
-import time
-import weakref
-
-
+, isolation as _isolation
-
-
@@ -143 +145 @@
-            self._conn = None
-
+
+class ConnectionManager(object):
+    
+    implicit_trans = False
+    
+    # Change this to 'error' if you don't want autocommit on schema ops.
+    contention = 'commit'
+    
+    # The "default_isolation" value should be a value native to the DB.
+    default_isolation = None
+    
+    # The values in "isolation_levels" should match the names of
+    # IsolationLevel objects in isolation.py
+    isolation_levels = ["READ UNCOMMITTED", "READ COMMITTED",
+                        "REPEATABLE READ", "SERIALIZABLE"]
+    
+    def __init__(self, db, poolsize=10):
+        self.transactions = {}
+        self.db = db
+        self.poolsize = poolsize
+        if poolsize > 0:
+            self._factory = ConnectionPool(self._get_conn, self._del_conn,
+                                           poolsize)
+        else:
+            self._factory = ConnectionFactory(self._get_conn, self._del_conn)
+    
+    def shutdown(self):
+        """Release all database connections."""
+        self._factory.shutdown()
+    
+    def _get_conn(self):
+        """Create and return a connection object."""
+        # Override this with the connection call for your DB. Example:
+        #     return libpq.PQconnectdb(self.connstring)
+        raise NotImplementedError
+    
+    def _del_conn(self, conn):
+        """Close a connection object."""
+        # Override this with the close call (if any) for your DB.
+        conn.close()
+    
+    def get(self, started=False, isolation=None):
+        """Return the (possibly new) connection for the current transaction.
+        
+        If we are already in a transaction, this returns the connection for
+        that transaction. The "current transaction" context is determined by
+        self.id(); by default, this is the current thread ID (but subclasses
+        are free to change this). If there is no "current transaction", then
+        a new connection object is obtained (usually from a pool).
+
+        If self.implicit_trans is True, a new connection will automatically
+        call "START TRANSACTION". It will also be associated with self.id(),
+        and any subsequent calls to this method will then return the same
+        connection object. If self.implicit_trans is False, new connections
+        won't be STARTed or stored; the only exception to this is if the
+        'started' argument is True, in which case the connection will be
+        stored but not automatically STARTed.
+        """
+        key = self.id()
+        if key in self.transactions:
+            conn = self.transactions[key]
+            if isinstance(conn, errors.TransactionLock):
+                raise conn
+        else:
+            conn = self._factory()
+            if self.implicit_trans or started:
+                self.transactions[key] = conn
+                if not started:
+                    self.start(isolation)
+        return conn
+    
+    def id(self):
+        """The current transaction id."""
+        return threading._get_ident()
+    
+    def isolate(self, conn, isolation=None):
+        """Set the isolation level of the given connection.
+        
+        If 'isolation' is None, our default_isolation will be used for new
+        connections. Valid values for the 'isolation' argument may be native
+        values for your particular database. However, it is recommended you
+        pass items from the global 'levels' list instead; these will be
+        automatically replaced with native values.
+        
+        For many databases, this must be executed after START TRANSACTION.
+        """
+        if isolation is None:
+            isolation = self.default_isolation
+        
+        if isinstance(isolation, _isolation.IsolationLevel):
+            # Map the given IsolationLevel object to a native value.
+            isolation = isolation.name
+            if isolation not in self.isolation_levels:
+                raise ValueError("IsolationLevel %r not allowed by %s. "
+                                 "Try one of %r instead."
+                                 % (isolation, self.__class__.__name__,
+                                    self.isolation_levels))
+        
+        # This is SQL92 syntax, and should work with most DB's.
+        self.db.execute("SET TRANSACTION ISOLATION LEVEL %s;" % isolation, conn)
+    
+    def start(self, isolation=None):
+        """Start a transaction. Not needed if self.implicit_trans is True."""
+        conn = self.get(started=True)
+        self.db.execute("START TRANSACTION;", conn)
+        self.isolate(conn, isolation)
+    
+    def rollback(self):
+        """Roll back the current transaction, if any."""
+        key = self.id()
+        if key in self.transactions:
+            self.db.execute("ROLLBACK;", self.transactions[key])
+            del self.transactions[key]
+        else:
+            # This is critical in order to support polygonal SM structures
+            # (same store being called twice by separate proxies).
+            pass
+    
+    def commit(self):
+        """Commit the current transaction, if any."""
+        try:
+            conn = self.transactions.pop(self.id())
+        except KeyError:
+            # This is critical in order to support polygonal SM structures
+            # (same store being called twice by separate proxies).
+            pass
+        else:
+            self.db.execute("COMMIT;", conn)
+    
+    def lock(self, msg=None):
+        """Deny transactions during schema operations (DDL statements).
+        
+        Any code which calls this should also call 'unlock' in a try/finally:
+        
+        db.connections.lock('dropping storage')
+        try:
+            db.execute("DROP TABLE %s;" % tablename)
+        finally:
+            db.connections.unlock()
+        """
+        key = self.id()
+        if key in self.transactions:
+            if isinstance(self.transactions[key], errors.TransactionLock):
+                return
+            if self.contention == 'error':
+                raise errors.TransactionLock("Schema operations are not "
+                                             "allowed inside transactions.")
+            self.commit()
+        
+        if msg is None:
+            msg = "Transactions not allowed at the moment."
+        self.transactions[key] = errors.TransactionLock(msg)
+    
+    def unlock(self):
+        """Allow transactions."""
+        key = self.id()
+        trans = self.transactions.get(key, None)
+        if trans is None:
+            return
+        if not isinstance(trans, errors.TransactionLock):
+            raise errors.TransactionLock("Unlock called inside transaction.")
+        del self.transactions[key]
+    
+    def in_transaction(self):
+        """Return True if the current context is in a transaction.
+        
+        This also returns True if the current context is executing DDL
+        statements, or is barred from starting a transaction for some
+        other reason.
+        """
+        trans = self.transactions.get(self.id())
+        if trans is None or isinstance(trans, errors.TransactionLock):
+            return False
+        return True
+

trunk/geniusql/isolation.py

@@ -1 @@
-Dejavu
+Geniusql
-
-We follow the terminology of ANSI for specifying isolation levels,

trunk/geniusql/providers/__init__.py

@@ -47 +47 @@
-    "mysql": "geniusql.providers.mysql.MySQLDatabase",
-    
-
-
-
+yP
+yP
+yP
-    
-    "psycopg": "geniusql.providers.psycopg.PsycoPgDatabase",

trunk/geniusql/providers/ado.py

@@ -365 +365 @@
-        coldef = self.db.columnclause(column)
-        # SQL Server doesn't use the "COLUMN" keyword with "ADD"
-
+_ddl
-    
-    def _rename(self, oldcol, newcol):
-
+s.get
-        try:
-            cat = win32com.client.Dispatch(r'ADOX.Catalog')
@@ -387 +387 @@
-
-
+class ADOConnectionManager(geniusql.ConnectionManager):
+    
+    # the amount of time to try to close the db connection
+    # before raising an exception
+    shutdowntimeout = 1 # sec.
+    
+    ConnectionTimeout = None
+    CommandTimeout = None
+    
+    def _get_conn(self, master=False):
+        if master:
+            # Must shut down all connections to avoid
+            # "being accessed by other users" error.
+            self.shutdown()
+            
+            atoms = connatoms(self.Connect)
+            atoms['INITIAL CATALOG'] = "tempdb"
+            connectstr = "; ".join(["%s=%s" % (k, v)
+                                    for k, v in atoms.iteritems()])
+        else:
+            connectstr = self.Connect
+        
+        conn = win32com.client.Dispatch(r'ADODB.Connection')
+        conn.Open(connectstr)
+        if self.ConnectionTimeout is not None:
+            conn.ConnectionTimeout = self.ConnectionTimeout
+        if self.CommandTimeout is not None:
+            conn.CommandTimeout = self.CommandTimeout
+        return conn
+    
+    def _del_conn(self, conn):
+        for trial in xrange(self.shutdowntimeout * 10):
+            try:
+                # This may raise "Operation cannot be performed
+                # while executing asynchronously"
+                # if a prior operation has not yet completed.
+                conn.Close()
+                return
+            except pywintypes.com_error, e:
+                try:
+                    ecode = e.args[2][-1]
+                except IndexError:
+                    ecode = None
+                if ecode == -2146824577:
+                    # "Operation cannot be performed while executing asynchronously"
+                    # Try again...
+                    time.sleep(0.1)
+                    continue
+                raise
+    
+    #                            Transactions                             #
+    
+    def start(self, isolation=None):
+        """Start a transaction. Not needed if self.implicit_trans is True."""
+        conn = self.get(started=True)
+        self.db.execute("BEGIN TRANSACTION;", conn)
+        self.isolate(conn, isolation)
+
+
-class ADODatabase(geniusql.Database):
-    
@@ -393 +452 @@
-    tableclass = ADOTable
-    
-
-
-
-
+
+
+
-    
-    #                              Discovery                              #
@@ -587 +645 @@
-    
-    def _rename(self, oldtable, newtable):
-
+s.get
-        try:
-            cat = win32com.client.Dispatch(r'ADOX.Catalog')
@@ -602 +660 @@
-        return '[' + name + ']'
-    
-    #                             Connecting                              #
-    
-    ConnectionTimeout = None
-    CommandTimeout = None
-    
-    def _get_conn(self):
-        conn = win32com.client.Dispatch(r'ADODB.Connection')
-        conn.Open(self.Connect)
-        if self.ConnectionTimeout is not None:
-            conn.ConnectionTimeout = self.ConnectionTimeout
-        if self.CommandTimeout is not None:
-            conn.CommandTimeout = self.CommandTimeout
-        return conn
-    
-    def _del_conn(self, conn):
-        for trial in xrange(self.shutdowntimeout * 10):
-            try:
-                # This may raise "Operation cannot be performed
-                # while executing asynchronously"
-                # if a prior operation has not yet completed.
-                conn.Close()
-                return
-            except pywintypes.com_error, e:
-                try:
-                    ecode = e.args[2][-1]
-                except IndexError:
-                    ecode = None
-                if ecode == -2146824577:
-                    # "Operation cannot be performed while executing asynchronously"
-                    # Try again...
-                    time.sleep(0.1)
-                    continue
-                raise
-    
-    def execute(self, query, conn=None):
-        if conn is None:
-
+s.get
-        if isinstance(query, unicode):
-            query = query.encode(self.adaptertosql.encoding)
-        
-query
+repr((id(conn), id(getattr(conn, "conn", None)), query))
-        try:
-
+
+
-                # 'conn' is a ConnectionWrapper object, which .Open
-                # won't accept. Pass the unwrapped connection instead.
-
+
+
+
+
+
-            
-            # Call Execute directly, skipping win32com overhead.
-
-
-
+bare
+    
+    
-        except pywintypes.com_error, x:
-            x.args += (query, )
@@ -661 +690 @@
-        """fetch(query, conn=None) -> rowdata, columns."""
-        if conn is None:
-
+s.get
-        
-        try:
@@ -670 +699 @@
-                                                query, Empty, Empty)
-            else:
-
-
+
+
+
-                    # 'conn' is a ConnectionWrapper object, which .Open
-                    # won't accept. Pass the unwrapped connection instead.
-
+bare
-                
-                # Call conn.Open(query) directly, skipping win32com overhead.
-
+bare
-                                                ((8, 1), (16396, 18), (3, 49)),
-                                                # *args =
@@ -725 +755 @@
-        
-        return data, columns
-    
-    
-    #                            Transactions                             #
-    
-    def start(self, isolation=None):
-        """Start a transaction. Not needed if self.implicit_trans is True."""
-        conn = self.get_transaction(new=True)
-        self.execute("BEGIN TRANSACTION;", conn)
-        self.isolate(conn, isolation)
-
-
@@ -840 +861 @@
-    
-    def _rename(self, oldcol, newcol):
-
-
+_ddl
+    
-    
-    def _grab_new_ids(self, idkeys, conn):
@@ -853 +874 @@
-
-
+class SQLServerConnectionManager(ADOConnectionManager):
+    
+    default_isolation = "READ COMMITTED"
+
+
-class SQLServerDatabase(ADODatabase):
-    
@@ -859 +885 @@
-    adaptertosql = AdapterToADOSQL_SQLServer()
-    typeadapter = TypeAdapter_SQLServer()
+    connectionmanager = SQLServerConnectionManager
-    
-    def __init__(self, name, **kwargs):
-        ADODatabase.__init__(self, name, **kwargs)
-        if "2005" in self.version():
-
+connections.
-    
-    def version(self):
-adoconn = self._template_conn(
-ado
-ado
+conn = self.connections._get_conn(master=True
+
+
-        sqlv, = data[0]
-ado
-ado
+
+
-        return "ADO Version: %s\n%s" % (adov, sqlv)
-    
-    def _template_conn(self):
-        adoconn = win32com.client.Dispatch(r'ADODB.Connection')
-        atoms = connatoms(self.Connect)
-        atoms['INITIAL CATALOG'] = "tempdb"
-        adoconn.Open("; ".join(["%s=%s" % (k, v) for k, v in atoms.iteritems()]))
-        return adoconn
-    
-    def create_database(self):
-
-
-
-
-
-
-
-
+
+
+
+
-    
-    def drop_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
-    
-    def columnclause(self, column):
@@ -929 +937 @@
-        return '%s %s%s' % (column.qname, dbtype, clause)
-    
-
-
-
-
-
+
-        """If the given exception instance is a lock timeout, return True.
-        
@@ -1055 +1059 @@
-
-
+class MSAccessConnectionManager(ADOConnectionManager):
+    
+    poolsize = 0
+    default_isolation = "READ UNCOMMITTED"
+    isolation_levels = ["READ UNCOMMITTED",]
+    
+    def __init__(self, db, poolsize=0):
+        self.transactions = {}
+        self.db = db
+        self.poolsize = 0
+        # MS Access can't use a pool, because there doesn't seem
+        # to be a commit timeout. See http://support.microsoft.com/kb/200300
+        # for additional synchronization issues.
+        self._factory = geniusql.SingleConnection(self._get_conn, self._del_conn)
+    
+    def isolate(self, conn, isolation=None):
+        """Set the isolation level of the given connection.
+        
+        If 'isolation' is None, our default_isolation will be used for new
+        connections. Valid values for the 'isolation' argument may be native
+        values for your particular database. However, it is recommended you
+        pass items from the global 'levels' list instead; these will be
+        automatically replaced with native values.
+        
+        For many databases, this must be executed after START TRANSACTION.
+        """
+        if isolation is None:
+            isolation = self.default_isolation
+        
+        if isinstance(isolation, geniusql.IsolationLevel):
+            # Map the given IsolationLevel object to a native value.
+            isolation = isolation.name
+            if isolation not in self.isolation_levels:
+                raise ValueError("IsolationLevel %r not allowed by %s."
+                                 % (isolation, self.__class__.__name__))
+        
+        # No action to take, since you can't actually set iso level.
+        pass
+
+
-class MSAccessDatabase(ADODatabase):
-    
@@ -1061 +1105 @@
-    typeadapter = TypeAdapter_MSAccess()
-    tableclass = MSAccessTable
+    connectionmanager = MSAccessConnectionManager
-    
-    def version(self):
-ado
-ado
-ado
+
+
+
-        return "ADO Version: %s" % v
-    
@@ -1071 +1116 @@
-        cols = ADODatabase._get_columns(self, tablename, conn)
-        if conn is None:
-
+s._factory
-        
-        try:
-            # Horrible hack to get autoincrement property
-            query = "SELECT * FROM %s WHERE FALSE" % self.quote(tablename)
-
+
+
-                # 'conn' is a ConnectionWrapper object, which .Open
-                # won't accept. Pass the unwrapped connection instead.
-
+bare
-            
-            # Call conn.Open(query) directly, skipping win32com overhead.
@@ -1149 +1195 @@
-        return '%s %s' % (column.qname, dbtype)
-    
-    #                             Connecting                              #
-    
-    poolsize = 0
-    
-    def connect(self):
-        # MS Access can't use a pool, because there doesn't seem
-        # to be a commit timeout. See http://support.microsoft.com/kb/200300
-        # for additional synchronization issues.
-        self.connection = geniusql.SingleConnection(self._get_conn, self._del_conn)
-    
-    def create_database(self):
-
-
-
-
-
-
-
-
-
+
+
+
+
+
-    
-    def drop_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-
-

trunk/geniusql/providers/firebird.py

@@ -243 +243 @@
-        coldef = self.db.columnclause(column)
-        # FB doesn't recognize the keyword "COLUMN" in "ADD".
-
+_ddl
-    
-    def _drop_column(self, column):
-        """Internal function to drop the column from the database."""
-        # FB doesn't recognize the keyword "COLUMN" in "DROP".
-
-
+_ddl
+    
-    
-    def _rename(self, oldcol, newcol):
-        # FB doesn't use the keyword "RENAME".
-
-
+_ddl
+    
-    
-    def insert(self, **inputs):
@@ -283 +283 @@
-        values = ", ".join(values)
-        self.db.execute('INSERT INTO %s (%s) VALUES (%s);'
-
-
+
-        
-        return newids
+
+
+class FirebirdConnectionManager(geniusql.ConnectionManager):
+    
+    default_isolation = kinterbasdb.isc_tpb_read_committed
+    _no_iso_tpb = (
+        kinterbasdb.isc_tpb_version3
+        + kinterbasdb.isc_tpb_shared
+        + kinterbasdb.isc_tpb_nowait
+        + kinterbasdb.isc_tpb_write
+        + kinterbasdb.isc_tpb_rec_version
+        )
+    isolation_levels = ["READ COMMITTED", "REPEATABLE READ", "SERIALIZABLE"]
+    
+    def _get_conn(self):
+        conn = kinterbasdb.connect(host=self.db.host,
+                                   database=self.db.name,
+                                   user=self.db.user,
+                                   password=self.db.password,
+                                   charset=self.db.encoding,
+                                   )
+        # Set the default TPB (for implicit transactions).
+        conn.default_tpb = self._no_iso_tpb + self.default_isolation
+        
+        # Remove converters for FIXED so we can mix fixedpoint and decimal
+        conn.set_type_trans_in({'FIXED': None})
+        conn.set_type_trans_out({'FIXED': None})
+        return conn
+    
+    def isolate(self, isolation=None):
+        """isolate() is not implemented for Firebird."""
+        raise NotImplementedError("Firebird does not allow arbitrary re-isolation.")
+    
+    def start(self, isolation=None):
+        """Start a transaction. Not needed if self.implicit_trans is True."""
+        if isolation is None:
+            isolation = self.default_isolation
+        
+        if isinstance(isolation, geniusql.IsolationLevel):
+            # Map the given IsolationLevel object to a native value.
+            # This base class uses the four ANSI names as native values.
+            isolation = isolation.name
+            if isolation not in self.isolation_levels:
+                raise ValueError("IsolationLevel %r not allowed by %s. "
+                                 "Try one of %r instead."
+                                 % (isolation, self.__class__.__name__,
+                                    self.isolation_levels))
+            
+            if isolation == "READ COMMITTED":
+                isolation = kinterbasdb.isc_tpb_read_committed
+            elif isolation == "REPEATABLE READ":
+                isolation = kinterbasdb.isc_tpb_concurrency
+            else:
+                isolation = kinterbasdb.isc_tpb_consistency
+        
+        conn = self.get(started=True)
+        self.db.log("START TRANSACTION;")
+        conn.begin(self._no_iso_tpb + isolation)
+    
+    def rollback(self):
+        """Roll back the current transaction, if any."""
+        try:
+            conn = self.transactions.pop(self.id())
+        except KeyError:
+            pass
+        else:
+            self.db.log("ROLLBACK;")
+            conn.rollback()
+    
+    def commit(self):
+        """Commit the current transaction, if any."""
+        try:
+            conn = self.transactions.pop(self.id())
+        except KeyError:
+            pass
+        else:
+            self.db.log("COMMIT;")
+            conn.commit()
-
-
@@ -298 +375 @@
-    typeadapter = TypeAdapterFirebird()
-    tableclass = FirebirdTable
+    connectionmanager = FirebirdConnectionManager
-    
-    sql_name_max_length = 31
@@ -315 +393 @@
-        
-        self.qname = self.quote(self.name)
-
-
+
-        self.discover_dbinfo()
-    
@@ -478 +555 @@
-            sname = self.quote("%s_%s_seq" % (table.name, column.name))
-            column.sequence_name = sname
-
-
+_ddl
+_ddl
-    
-    def drop_sequence(self, column):
-        """Drop a SEQUENCE for the given column and remove its sequence_name."""
-        if column.sequence_name is not None:
-
+_ddl
-            column.sequence_name = None
-    
@@ -493 +570 @@
-        return '"' + name.replace('"', '""') + '"'
-    
-    def _get_conn(self):
-        conn = kinterbasdb.connect(host=self.host,
-                                   database=self.name,
-                                   user=self.user,
-                                   password=self.password,
-                                   charset=self.encoding,
-                                   )
-        # Set the default TPB (for implicit transactions).
-        conn.default_tpb = self._no_iso_tpb + self.default_isolation
-        
-        # Remove converters for FIXED so we can mix fixedpoint and decimal
-        conn.set_type_trans_in({'FIXED': None})
-        conn.set_type_trans_out({'FIXED': None})
-        return conn
-    
-    deadlock_timeout = 10
-    
@@ -513 +575 @@
-        try:
-            if conn is None:
-
+s.get
-            if isinstance(query, unicode):
-                query = query.encode(self.adaptertosql.encoding)
@@ -526 +588 @@
-                    # If we're not in a transaction, we need to auto-commit.
-                    # This prevents "Previous transaction still active" errors.
-
-
-
+
-                        conn.commit()
-                    
-                    return
-                except Exception, x:
-lock
+timeout
-                        if time.time() - start < self.deadlock_timeout:
-                            time.sleep(0.000001)
@@ -553 +613 @@
-        try:
-            if conn is None:
-
+s.get
-            if isinstance(query, unicode):
-                query = query.encode(self.adaptertosql.encoding)
@@ -566 +626 @@
-            # If we're not in a transaction, we need to auto-commit.
-            # This prevents "Previous transaction still active" errors.
-
-
-
+
-                conn.commit()
-            
@@ -581 +639 @@
-    
-    def create_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
-    
-    def drop_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-        """If the given exception instance is a lock timeout, return True.
-        
@@ -636 +675 @@
-        return "lock conflict" in exc.args[1]
-    
-    def isolate(self, isolation=None):
-        """isolate() is not implemented for Firebird."""
-        raise NotImplementedError("Firebird does not allow arbitrary re-isolation.")
-    
-    def start(self, isolation=None):
-        """Start a transaction. Not needed if self.implicit_trans is True."""
-        if isolation is None:
-            isolation = self.default_isolation
-        
-        if isinstance(isolation, geniusql.IsolationLevel):
-            # Map the given IsolationLevel object to a native value.
-            # This base class uses the four ANSI names as native values.
-            isolation = isolation.name
-            if isolation not in self.isolation_levels:
-                raise ValueError("IsolationLevel %r not allowed by %s. "
-                                 "Try one of %r instead."
-                                 % (isolation, self.__class__.__name__,
-                                    self.isolation_levels))
-            
-            if isolation == "READ COMMITTED":
-                isolation = kinterbasdb.isc_tpb_read_committed
-            elif isolation == "REPEATABLE READ":
-                isolation = kinterbasdb.isc_tpb_concurrency
-            else:
-                isolation = kinterbasdb.isc_tpb_consistency
-        
-        conn = self.get_transaction(new=True)
-        conn.begin(self._no_iso_tpb + isolation)
-    
-    def rollback(self):
-        """Roll back the current transaction, if any."""
-        key = self.transaction_key()
-        try:
-            conn = self.transactions.pop(key)
-        except KeyError:
-            pass
-        else:
-            conn.rollback()
-    
-    def commit(self):
-        """Commit the current transaction, if any."""
-        key = self.transaction_key()
-        try:
-            conn = self.transactions.pop(key)
-        except KeyError:
-            pass
-        else:
-            conn.commit()
-    
-    def version(self):
-        import kinterbasdb.services

trunk/geniusql/providers/mysql.py

@@ -141 +141 @@
-    def __delitem__(self, key):
-        t = self.table
-
-
-
-
-
-
-
-
+
+
+
+
-
-
@@ -156 +152 @@
-    
-    def _rename(self, oldcol, newcol):
-
-
-
+_ddl
+    
+    
-    
-    def _grab_new_ids(self, idkeys, conn):
-        return {idkeys[0]: conn.insert_id()}
+
-
-
@@ -169 +166 @@
-            "cursorclass", "client_flag",
-            ]
+
+class MySQLConnectionManager(geniusql.ConnectionManager):
+    
+    # InnoDB default
+    default_isolation = "REPEATABLE READ"
+    
+    def _get_conn(self, master=False):
+        if master:
+            args = self.connargs.copy()
+            args['db'] = 'mysql'
+        else:
+            args = self.connargs
+        
+        try:
+            conn = _mysql.connect(**args)
+        except _mysql.OperationalError, x:
+            if x.args[0] == 1040:   # Too many connections
+                raise errors.OutOfConnectionsError
+            raise
+        return conn
+
-
-class MySQLDatabase(geniusql.Database):
@@ -187 +205 @@
-    tableclass = MySQLTable
-    indexsetclass = MySQLIndexSet
-
-
-
+
-    
-    def __init__(self, name, **kwargs):
-        geniusql.Database.__init__(self, name, **kwargs)
-        
-
-
+ections.conn
+            
-        
-        self.decompiler = MySQLDecompiler
@@ -201 +217 @@
-        # Get the version string from MySQL, to see if we need
-        # a different decompiler.
-_template_conn(
+connections._get_conn(master=True
-        rowdata, cols = self.fetch("SELECT version();", conn)
-        conn.close()
@@ -274 +290 @@
-            encoding = " CHARACTER SET %s" % encoding
-        
-
-
-
+
-                         (table.qname, ", ".join(fields), pk, encoding))
-    
-    
-    
-    
-    
-    
-    
-    self.execute
+
+
+
+
+
+
+
+self.execute_ddl
-                             % (table.qname, fields, values))
-    
-    
-    
-    
-    
-    
-    self.execute
+
+
+
+
+
+
+self.execute_ddl
-                                 (index.qname, table.qname, q(index.colname)))
-    
-    self.execute
+
+self.execute_ddl
-                                 (index.qname, table.qname, q(index.colname)))
-
-
-
-
-
+
+
+
-        
-        dict.__setitem__(self, key, table)
@@ -432 +444 @@
-        return '`' + name.replace('`', '``') + '`'
-    
-    def _get_conn(self):
-        try:
-            conn = _mysql.connect(**self.connargs)
-        except _mysql.OperationalError, x:
-            if x.args[0] == 1040:   # Too many connections
-                raise errors.OutOfConnectionsError
-            raise
-        return conn
-    
-    def _template_conn(self):
-        tmplconn = self.connargs.copy()
-        tmplconn['db'] = 'mysql'
-        return _mysql.connect(**tmplconn)
-    
-    def execute(self, query, conn=None):
-        """execute(query, conn=None) -> result set."""
-        if conn is None:
-
+s.get
-        if isinstance(query, unicode):
-            query = query.encode(self.adaptertosql.encoding)
@@ -469 +467 @@
-        """
-        if conn is None:
-
+s.get
-        self.execute(query, conn)
-        
@@ -489 +487 @@
-    
-    def create_database(self):
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
-    
-    def drop_database(self):
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-        # OperationalError: (1205, 'Lock wait timeout exceeded; try restarting transaction')
-        if not isinstance(exc, _mysql.OperationalError):

trunk/geniusql/providers/psycopg.py

@@ -8 +8 @@
-
-
-import datetime
-try:
-    import cPickle as pickle
-except ImportError:
-    import pickle
-import re
-seq_name = re.compile(r"nextval\('([^:]+)'.*\)")
-escape_oct = re.compile(r"[\000-\037\177-\377]")
-replace_oct = lambda m: r"\\%03o" % ord(m.group(0))
-unescape_oct = re.compile(r"\\(\d\d\d)")
-replace_unoct = lambda m: chr(int(m.group(1), 8))
-
-import geniusql
-
+
+
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def coerce_any_to_datetime_datetime(self, value):
@@ -98 +25 @@
-
-
-Decompiler(geniusql.SQLDecompil
+ConnectionManager(geniusql.ConnectionManag
-    
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-        else:
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-
-
-IndexSet(geniusql.IndexSet
+Database(postgres.PgDatabase
-    
-    def __delitem__(self, key):
-        """Drop the specified index."""
-        t = self.table
-        t.db.lock("Dropping index. Transactions not allowed.")
-        try:
-            # PG doesn't use DROP INDEX .. ON ..
-            t.db.execute('DROP INDEX %s;' % self[key].qname)
-        finally:
-            t.db.unlock()
-
-
-class PsycoPgTable(geniusql.Table):
-    
-    indexsetclass = PsycoPgIndexSet
-    
-    def _grab_new_ids(self, idkeys, conn):
-        newids = {}
-        for idkey in idkeys:
-            col = self[idkey]
-            seq = col.sequence_name
-            data, _ = self.db.fetch("SELECT last_value FROM %s;" % seq, conn)
-            newids[idkey] = data[0][0]
-        return newids
-
-
-class PsycoPgDatabase(geniusql.Database):
-    
-    sql_name_max_length = 63
-    quote_all = True
-    poolsize = 10
-    encoding = 'SQL_ASCII'
-    
-    decompiler = PsycoPgDecompiler
-    adaptertosql = AdapterToPsycoPg()
-    adapterfromdb = AdapterFromPsycoPg()
-tableclass = PsycoPgTable
+connectionmanager = PsycoPgConnectionManager
-    
-    def _get_dbinfo(self, conn=None):
@@ -180 +74 @@
-        return dbinfo
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    
-    def execute(self, query, conn=None):
-        """execute(query, conn=None) -> result set."""
-        if conn is None:
-
+s.get
-        if isinstance(query, unicode):
-            query = query.encode(self.adaptertosql.encoding)
@@ -421 +97 @@
-        """fetch(query, conn=None) -> rowdata, columns."""
-        if conn is None:
-
+s.get
-        if isinstance(query, unicode):
-            query = query.encode(self.adaptertosql.encoding)
@@ -435 +111 @@
-        
-        return data, coldefs
-    
-    def create_database(self):
-        self.lock("Creating database. Transactions not allowed.")
-        try:
-            # Must shut down all connections to avoid
-            # "being accessed by other users" error.
-            self.connection.shutdown()
-            
-            c = self._template_conn()
-            encoding = self.encoding
-            if encoding:
-                encoding = " WITH ENCODING '%s'" % encoding
-            self.execute("CREATE DATABASE %s%s" % (self.qname, encoding), c)
-            c.close()
-            del c
-            self.clear()
-        finally:
-            self.unlock()
-    
-    def drop_database(self):
-        self.lock("Dropping database. Transactions not allowed.")
-        try:
-            # Must shut down all connections to avoid
-            # "being accessed by other users" error.
-            self.connection.shutdown()
-            
-            c = self._template_conn()
-            self.execute("DROP DATABASE %s;" % self.qname, c)
-            c.close()
-            del c
-            self.clear()
-        finally:
-            self.unlock()
-    
-    def version(self):
-        c = self._template_conn()
-        data, _ = self.fetch("SELECT version();", c)
-        v, = data[0]
-        c.close()
-        return "%s\npsycopg version: %s" % (v, _psycopg.__version__)
-

trunk/geniusql/providers/pypgsql.py

@@ -2 +2 @@
-from pyPgSQL import libpq
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-
-
-AdapterToPgSQL(geniusql.AdapterToSQL
+PyPgDatabase(postgres.PgDatabase
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
-    
-    def _get_dbinfo(self, conn=None):
@@ -166 +51 @@
-                raise
-        return dbinfo
-    
-    def _get_tables(self, conn=None):
-        data, _ = self.fetch("SELECT tablename FROM pg_tables WHERE schemaname"
-                             " not in ('information_schema', 'pg_catalog')",
-                             conn=conn)
-        return [self.tableclass(row[0], self.quote(row[0]),
-                                self, created=True)
-                for row in data]
-    
-    def _get_table(self, tablename, conn=None):
-        data, _ = self.fetch("SELECT tablename FROM pg_tables WHERE "
-                             "tablename = '%s'" % tablename,
-                             conn=conn)
-        for name, in data:
-            if name == tablename:
-                return self.tableclass(name, self.quote(name),
-                                       self, created=True)
-        raise errors.MappingError(tablename)
-    
-    def _get_columns(self, tablename, conn=None):
-        # Get the OID of the table
-        data, _ = self.fetch("SELECT oid FROM pg_class WHERE relname = '%s'"
-                             % tablename, conn=conn)
-        table_OID = data[0][0]
-        
-        # Get index data so we can set col.key if pg_index.indisprimary
-        data, _ = self.fetch("SELECT indkey FROM pg_index WHERE indrelid "
-                             "= %s AND indisprimary" % table_OID, conn=conn)
-        if data:
-            # indkey is an "array" (we get a space-separated string of ints).
-            # These will equal pg_attribute.attnum, below.
-            indices = map(int, data[0][0].split(" "))
-        else:
-            indices = []
-        
-        # Get column data
-        sql = ("SELECT attname, atttypid, attnum, attlen, atttypmod "
-               "FROM pg_attribute WHERE attisdropped = False AND "
-               "attrelid = %s" % table_OID)
-        data, _ = self.fetch(sql, conn=conn)
-        cols = []
-        for row in data:
-            name = row[0]
-            if name in ('tableoid', 'cmax', 'xmax', 'cmin', 'xmin',
-                        'oid', 'ctid'):
-                # This is a column which PostgreSQL defines automatically
-                continue
-            
-            # Data type
-            dbtype, _ = self.fetch("SELECT typname, typlen FROM pg_type "
-                                   "WHERE oid = %s" % row[1])
-            if dbtype:
-                dbtype = dbtype[0][0].upper()
-            else:
-                dbtype = None
-            c = geniusql.Column(self.python_type(dbtype), dbtype,
-                                None, {}, row[2] in indices,
-                                row[0], self.quote(row[0]))
-            
-            if dbtype in ('FLOAT4', 'FLOAT8'):
-                c.hints['precision'] = row[3]
-            elif dbtype in ('MONEY', 'NUMERIC'):
-                c.hints['precision'] = (row[4] >> 16) & 65535
-                c.hints['scale'] = (row[4] & 65535) - 4
-            
-            # Default value
-            default, _ = self.fetch("SELECT adsrc FROM pg_attrdef "
-                                    "WHERE adnum = %s AND adrelid = %s"
-                                    % (row[2], table_OID))
-            if default:
-                default = default[0][0]
-                if default.startswith("nextval("):
-                    # Grab seqname from "nextval(seqname::[text|regclass])"
-                    c.autoincrement = True
-                    c.sequence_name = seq_name.search(default).group(1)
-                    c.initial = self.fetch("SELECT min_value FROM %s" %
-                                           c.sequence_name)[0][0]
-                    c.default = None
-                else:
-                    # adsrc is always a string, so we must cast
-                    # it using our guessed type.
-                    c.default = self.python_type(dbtype)(default)
-            else:
-                c.default = None
-            
-            if dbtype.startswith('BPCHAR') or dbtype.startswith('VARCHAR'):
-                # See http://archives.postgresql.org/pgsql-interfaces/2004-07/msg00021.php
-                c.hints['bytes'] = row[4] - 4
-            else:
-                bytes = row[3]
-                if bytes > 0:
-                    c.hints['bytes'] = bytes
-                elif dbtype == 'TEXT':
-                    c.hints['bytes'] = 0
-            
-            cols.append(c)
-        return cols
-    
-    def _get_indices(self, tablename, conn=None):
-        # Get the OID of the parent table.
-        data, _ = self.fetch("SELECT oid FROM pg_class WHERE relname = '%s'"
-                             % tablename, conn=conn)
-        if not data:
-            return []
-        
-        table_OID = data[0][0]
-        indices = []
-        data, _ = self.fetch("SELECT pg_class.relname, indkey, indisprimary, "
-                             "indisunique FROM pg_index LEFT JOIN pg_class "
-                             "ON pg_index.indexrelid = pg_class.oid WHERE "
-                             "pg_index.indrelid = %s" % table_OID, conn=conn)
-        for row in data:
-            # indkey is an "array" (we get a space-separated string of ints).
-            cols = map(int, row[1].split(" "))
-            for col in cols:
-                d, _ = self.fetch("SELECT attname FROM pg_attribute "
-                                  "WHERE attrelid = %s AND attnum = %s"
-                                  % (table_OID, col), conn=conn)
-                i = geniusql.Index(row[0], self.quote(row[0]), tablename,
-                                   d[0][0], bool(row[3]))
-                indices.append(i)
-        
-        return indices
-    
-    def python_type(self, dbtype):
-        """Return a Python type which can store values of the given dbtype."""
-        dbtype = dbtype.upper()
-        if dbtype in ('INT2', 'INT4', 'INTEGER', 'SMALLINT'):
-            return int
-        elif dbtype in ('BOOL', 'BOOLEAN'):
-            return bool
-        elif dbtype in ('INT8', 'BIGINT'):
-            return long
-        elif dbtype in ('FLOAT4', 'FLOAT8', 'MONEY', 'DOUBLE PRECISION', 'REAL'):
-            return float
-        elif dbtype.startswith('NUMERIC'):
-            if typerefs.decimal:
-                return typerefs.decimal.Decimal
-            elif typerefs.fixedpoint:
-                return typerefs.fixedpoint.FixedPoint
-        elif dbtype == 'DATE':
-            return datetime.date
-        elif dbtype in ('TIMESTAMP', 'TIMESTAMPTZ'):
-            return datetime.datetime
-        elif dbtype in ('TIME', 'TIMETZ'):
-            return datetime.time
-        elif dbtype in ('BYTEA'):
-            return str
-        for t in ('CHAR', 'VARCHAR', 'BPCHAR', 'TEXT'):
-            if dbtype.startswith(t):
-                return str
-        
-        raise TypeError("Database type %r could not be converted "
-                        "to a Python type." % dbtype)
-    
-    def columnclause(self, column):
-        """Return a clause for the given column for CREATE or ALTER TABLE.
-        
-        This will be of the form "name type [DEFAULT [x | nextval('seq')]]".
-        
-        PostgreSQL creates the sequence in a separate statement.
-        """
-        if column.autoincrement:
-            default = "nextval('%s')" % column.sequence_name
-        else:
-            default = column.default or ""
-            if not isinstance(default, str):
-                default = self.adaptertosql.coerce(default, column.dbtype)
-        
-        if default:
-            default = " DEFAULT %s" % default
-        
-        return '%s %s%s' % (column.qname, column.dbtype, default)
-    
-    def create_sequence(self, table, column):
-        """Create a SEQUENCE for the given column and set its sequence_name."""
-        sname = column.sequence_name
-        if sname is None:
-            sname = self.quote("%s_%s_seq" % (table.name, column.name))
-            column.sequence_name = sname
-        self.execute("CREATE SEQUENCE %s START %s;" % (sname, column.initial))
-    
-    def drop_sequence(self, column):
-        """Drop a SEQUENCE for the given column and remove its sequence_name."""
-        if column.sequence_name is not None:
-            self.execute("DROP SEQUENCE %s;" % column.sequence_name)
-            column.sequence_name = None
-    
-    def quote(self, name):
-        if self.quote_all:
-            name = '"' + name.replace('"', '""') + '"'
-        return name
-    
-    def sql_name(self, name):
-        name = geniusql.Database.sql_name(self, name)
-        if not self.quote_all:
-            name = name.lower()
-        return name
-    
-    default_isolation = "READ COMMITTED"
-    
-    def _get_conn(self):
-        try:
-            return libpq.PQconnectdb(self.Connect)
-        except libpq.DatabaseError, x:
-            if x.args[0].startswith('could not connect'):
-                raise errors.OutOfConnectionsError()
-            raise
-    
-    def _del_conn(self, conn):
-        conn.finish()
-    
-    def _template_conn(self):
-        atoms = self.Connect.split(" ")
-        tmplconn = ""
-        for atom in atoms:
-            k, v = atom.split("=", 1)
-            if k == 'dbname': v = 'template1'
-            tmplconn += "%s=%s " % (k, v)
-        return libpq.PQconnectdb(tmplconn)
-    
-    def fetch(self, query, conn=None):
@@ -402 +67 @@
-        return data, columns
-    
-    def create_database(self):
-        self.lock("Creating database. Transactions not allowed.")
-        try:
-            c = self._template_conn()
-            encoding = self.encoding
-            if encoding:
-                encoding = " WITH ENCODING '%s'" % encoding
-            self.execute("CREATE DATABASE %s%s" % (self.qname, encoding), c)
-            c.finish()
-            self.clear()
-        finally:
-            self.unlock()
-    
-    def drop_database(self):
-        self.lock("Dropping database. Transactions not allowed.")
-        try:
-            # Must shut down all connections to avoid
-            # "being accessed by other users" error.
-            self.connection.shutdown()
-            
-            c = self._template_conn()
-            self.execute("DROP DATABASE %s;" % self.qname, c)
-            c.finish()
-            self.clear()
-        finally:
-            self.unlock()
-    
-    def version(self):
-_template_conn(
+connections._get_conn(master=True
-        v = c.version
-c.finish(
+self.connections._del_conn(c
-        return v
-

trunk/geniusql/providers/sqlite.py

@@ -56 +56 @@
-            return '1'
-        return '0'
+
+
+class AdapterToSQLiteTypeless(AdapterToSQLite):
+    
+    def cast_any_to_object(self, colref):
+        return colref
-
-
@@ -318 +324 @@
-                db.create_sequence(self, column)
-            
-            db.lock("Adding property. Transactions not allowed.")
-            try:
-                # Make a temporary copy.
-                tempkey, temptable = self._temp_copy()
-                # Add the new column to the copy.
-                dict.__setitem__(temptable, key, column)
-                # Bind the temp table to the DB.
-                db[tempkey] = temptable
-                
-                # Copy data from the old table to the temp table.
-                selfields = []
-                for k, c in temptable.iteritems():
-                    qname = c.qname
-                    if k == key:
-                        # This is a new column. Populate with NULL.
-                        qname = "NULL AS %s" % qname
-                    selfields.append(qname)
-                db.execute("INSERT INTO %s SELECT %s FROM %s;" %
-                           (temptable.qname, ", ".join(selfields), self.qname))
-                
-                # Copy data from the temp table to a new table for self.
-                self._copy_from_temp(temptable, self._parent_key(), tempkey)
-            finally:
-                db.unlock()
-    
-    def __delitem__(self, key):
-        if key in self.indices:
-            del self.indices[key]
-        
-        if not self.created:
-            dict.__delitem__(self, key)
-            return
-        
-        db = self.db
-        db.lock("Dropping property. Transactions not allowed.")
-        try:
-            column = self[key]
-            
-            # Make a temporary copy.
-            tempkey, temptable = self._temp_copy()
-Drop the column from
-delitem__(temptable, key
+Add the new column to
+setitem__(temptable, key, column
-            # Bind the temp table to the DB.
-            db[tempkey] = temptable
@@ -367 +335 @@
-            for k, c in temptable.iteritems():
-                qname = c.qname
+                if k == key:
+                    # This is a new column. Populate with NULL.
+                    qname = "NULL AS %s" % qname
-                selfields.append(qname)
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                       (temptable.qname, ", ".join(selfields), self.qname))
-
-
-
-
-
-
-
-
+
+
+
+
+
+
-    
-    def rename(self, oldkey, newkey):
@@ -387 +385 @@
-        
-        if oldname != newname:
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
+
-                           (temptable.qname, ", ".join(selfields), self.qname))
-
-
-
-
+
+
-    
-    def _grab_new_ids(self, idkeys, conn):
@@ -479 +473 @@
-
-
+class SQLiteConnectionManager(geniusql.ConnectionManager):
+    
+    default_isolation = "SERIALIZABLE"
+    isolation_levels = ["SERIALIZABLE"]
+    
+    def __init__(self, db, poolsize=10):
+        self.transactions = {}
+        self.db = db
+        self.poolsize = poolsize
+        if self.db.name == ":memory:":
+            # "Multiple connections to ":memory:" within a single process
+            # create a fresh database each time"
+            # http://www.sqlite.org/cvstrac/wiki?p=InMemoryDatabase
+            # So we need to give :memory: databases a SingleConnection.
+            self._factory = geniusql.SingleConnection(self._get_conn, self._del_conn)
+        else:
+            return geniusql.ConnectionManager.__init__(self, db, poolsize)
+    
+    if _cursor_required:
+        def _get_conn(self):
+            # SQLite should create the DB if missing.
+            # valid _sqlite3 kwargs: "database", "timeout", "detect_types",
+            # "isolation_level", "check_same_thread", "factory",
+            # "cached_statements".
+            # Instead of "timeout", we re-use the old
+            # deadlock_timeout code inside execute.
+            conn = _sqlite.connect(database=self.db.name, check_same_thread=False)
+##            # None sets autocommit mode on.
+##            conn.isolation_level = None
+            conn.text_factory = str
+            return conn.cursor()
+    else:
+        def _get_conn(self):
+            return _sqlite.connect(self.db.name, self.db.mode)
+    
+    def isolate(self, conn, isolation=None):
+        """Set the isolation level of the given connection.
+        
+        If 'isolation' is None, our default_isolation will be used for new
+        connections. Valid values for the 'isolation' argument may be native
+        values for your particular database. However, it is recommended you
+        pass items from the global 'levels' list instead; these will be
+        automatically replaced with native values.
+        
+        For many databases, this must be executed after START TRANSACTION.
+        """
+        if isolation is None:
+            isolation = self.default_isolation
+        
+        if isinstance(isolation, geniusql.IsolationLevel):
+            # Map the given IsolationLevel object to a native value.
+            # This base class uses the four ANSI names as native values.
+            isolation = isolation.name
+        
+        if isolation not in self.isolation_levels:
+            raise ValueError("IsolationLevel %r not allowed by %s. "
+                             "Try one of %r instead."
+                             % (isolation, self.__class__.__name__,
+                                self.isolation_levels))
+        
+        # Nothing to do here, since we only allow one level.
+        pass
+    
+    def start(self, isolation=None):
+        """Start a transaction."""
+        conn = self.get(started=True)
+        self.db.execute("BEGIN;", conn)
+        self.isolate(conn, isolation)
+    
+    def rollback(self):
+        """Roll back the current transaction."""
+        key = self.id()
+        if key in self.transactions:
+            self.db.execute("ROLLBACK;", self.transactions[key])
+            del self.transactions[key]
+    
+    def commit(self):
+        """Commit the current transaction."""
+        key = self.id()
+        if key in self.transactions:
+            self.db.execute("COMMIT;", self.transactions[key])
+            del self.transactions[key]
+
+
-class SQLiteDatabase(geniusql.Database):
-    
@@ -488 +566 @@
-    adapterfromdb = AdapterFromSQLite()
-    typeadapter = TypeAdapterSQLite()
+    connectionmanager = SQLiteConnectionManager
-    
-    tableclass = SQLiteTable
@@ -512 +591 @@
-    
-    def _get_tables(self, conn=None):
-
+
+
-        # Note that we set Table.created here, since these already exist in the DB.
-        return [self.tableclass(row[0], self.quote(row[0]),
@@ -519 +599 @@
-    
-    def _get_table(self, tablename, conn=None):
-
-name = '%s' AND type = 'table';" % tablename
+name = 
+'%s' AND type = 'table';" % tablename, conn
-        # Note that we set Table.created here, since these already exist in the DB.
-        for name, in data:
@@ -568 +648 @@
-    def _get_indices(self, tablename, conn=None):
-        data, _ = self.fetch("SELECT name, tbl_name, sql FROM sqlite_master "
-
+, conn
-        indices = []
-        for row in data:
@@ -670 +750 @@
-            pk = ""
-        
-
-
-
+
-                         (table.qname, ", ".join(fields), pk))
-    
-    
-    self.execute
+
+
+self.execute_ddl
-                             (index.qname, table.qname,
-                              self.quote(index.colname)))
-
-
-
-
-
-
-
+
+
+
+
+
-    
-    def _rename(self, oldtable, newtable):
-        if _rename_table_support:
-
-
+_ddl
+    
-        else:
-            raise NotImplementedError
@@ -710 +786 @@
-        return "[" + name + "]"
-    
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
-
+
+
-    
-    def drop_database(self):
-disconnect
+connections.shutdown
-        if self.name != ":memory:":
-            # This should accept relative or absolute paths
@@ -746 +796 @@
-        self.clear()
-    
-
-
-
-
-
-
-
+
-        if not isinstance(exc, _sqlite.OperationalError):
-            return False
-        return exc.args[0] == 'database is locked'
-    
-    def isolate(self, conn, isolation=None):
-        """Set the isolation level of the given connection.
-        
-        If 'isolation' is None, our default_isolation will be used for new
-        connections. Valid values for the 'isolation' argument may be native
-        values for your particular database. However, it is recommended you
-        pass items from the global 'levels' list instead; these will be
-        automatically replaced with native values.
-        
-        For many databases, this must be executed after START TRANSACTION.
-        """
-        if isolation is None:
-            isolation = self.default_isolation
-        
-        if isinstance(isolation, geniusql.IsolationLevel):
-            # Map the given IsolationLevel object to a native value.
-            # This base class uses the four ANSI names as native values.
-            isolation = isolation.name
-        
-        if isolation not in self.isolation_levels:
-            raise ValueError("IsolationLevel %r not allowed by %s. "
-                             "Try one of %r instead."
-                             % (isolation, self.__class__.__name__,
-                                self.isolation_levels))
-        
-        # Nothing to do here, since we only allow one level.
-        pass
-    
-    def start(self, isolation=None):
-        """Start a transaction."""
-        conn = self.get_transaction(new=True)
-        self.execute("BEGIN;", conn)
-        self.isolate(conn, isolation)
-    
-    def rollback(self):
-        """Roll back the current transaction."""
-        key = self.transaction_key()
-        if key in self.transactions:
-            self.execute("ROLLBACK;", self.transactions[key])
-            del self.transactions[key]
-    
-    def commit(self):
-        """Commit the current transaction."""
-        key = self.transaction_key()
-        if key in self.transactions:
-            self.execute("COMMIT;", self.transactions[key])
-            del self.transactions[key]
-    
-    deadlock_timeout = 20
-    
@@ -810 +806 @@
-        try:
-            if conn is None:
-
+s.get
-            if isinstance(query, unicode):
-                query = query.encode(self.adaptertosql.encoding)
@@ -822 +818 @@
-                    if ((msg.startswith("no such") or
-                         msg == "database schema has changed")):
-
-
+
-                            # Bah. Shut down all connections and get a new one,
-                            # since some previous connection changed the schema.
-
-
+s
+s._factory
-                            continue
-lock
+timeout
-                        if time.time() - start < self.deadlock_timeout:
-                            time.sleep(0.000001)

trunk/geniusql/select.py

@@ -2 +2 @@
-
-from geniusql import errors
-
-from dejavu import logic, codewalk
-
@@ -275 +274 @@
-    
-    def _compare_constants(self, op1, op2):
-
+
+
+
+
+
-        col = getattr(op1, "col", None)
-        if col:

trunk/geniusql/test/zoo_fixture.py

@@ -1111 +1111 @@
-    except (AttributeError, NotImplementedError):
-        pass
-disconnect
+connections.shutdown
-
-def run(DB_class, name, opts):