velocity-python 0.0.27__py3-none-any.whl → 0.0.29__py3-none-any.whl

velocity/db/core/transaction.py

@@ -10,20 +10,19 @@ from velocity.misc.db import randomword
 
 debug = False
 
+
 class Transaction(object):
 
     def __init__(self, engine, connection=None):
         self.engine = engine
         self.connection = connection
+        self.__pg_types = {}
 
     def __str__(self):
         c = self.engine.config
-        server = c.get('host',c.get('server'))
-        database = c.get('database')
-        return "{}.transaction({}:{})".format(
-            self.engine.sql.server,
-            server,
-            database)
+        server = c.get("host", c.get("server"))
+        database = c.get("database")
+        return "{}.transaction({}:{})".format(self.engine.sql.server, server, database)
 
     def __enter__(self):
         return self
@@ -36,17 +35,29 @@ class Transaction(object):
     def cursor(self):
         if not self.connection:
             if debug:
-                print('>>> {} open connection to {database}'.format(id(self), **self.engine.config))
+                print(
+                    ">>> {} open connection to {database}".format(
+                        id(self), **self.engine.config
+                    )
+                )
             self.connection = self.engine.connect()
         if debug:
-           print("*** {} open {database}.transaction.connection.cursor".format(id(self), **self.engine.config))
+            print(
+                "*** {} open {database}.transaction.connection.cursor".format(
+                    id(self), **self.engine.config
+                )
+            )
         return self.connection.cursor()
 
     def close(self):
         if self.connection:
             self.commit()
             if debug:
-                print('<<< {} close connection to {database}'.format(id(self), **self.engine.config))
+                print(
+                    "<<< {} close connection to {database}".format(
+                        id(self), **self.engine.config
+                    )
+                )
             self.connection.close()
 
     def execute(self, sql, parms=None, single=False, cursor=None):
@@ -57,16 +68,20 @@ class Transaction(object):
             cursor = None
         if not self.connection:
             if debug:
-                print('>>> {} open connection to {database}'.format(id(self), **self.engine.config))
+                print(
+                    ">>> {} open connection to {database}".format(
+                        id(self), **self.engine.config
+                    )
+                )
             self.connection = self.engine.connect()
-        action = re.search(r'(\w+)', sql, re.I)
+        action = re.search(r"(\w+)", sql, re.I)
         if action:
             action = action.group().lower()
         else:
-            action = 'None'
+            action = "None"
         if debug:
             print(action)
-            print(id(self), '------------>', sql, '::', parms)
+            print(id(self), "------------>", sql, "::", parms)
             print()
         if single:
             self.commit()
@@ -79,10 +94,10 @@ class Transaction(object):
             else:
                 cursor.execute(sql)
         except:
-            self.engine.ProcessError(sql,parms)
+            self.engine.ProcessError(sql, parms)
         if single:
             self.connection.autocommit = False
-        return Result(cursor)
+        return Result(cursor, self, sql, parms)
 
     def server_execute(self, sql, parms=None):
         return self._execute(sql, parms, cursor=self.cursor())
@@ -90,13 +105,21 @@ class Transaction(object):
     def commit(self):
         if self.connection:
             if debug:
-                print('{} --- connection commit {database}'.format(id(self), **self.engine.config))
+                print(
+                    "{} --- connection commit {database}".format(
+                        id(self), **self.engine.config
+                    )
+                )
             self.connection.commit()
 
     def rollback(self):
         if self.connection:
             if debug:
-                print('{} --- connection rollback {database}'.format(id(self), **self.engine.config))
+                print(
+                    "{} --- connection rollback {database}".format(
+                        id(self), **self.engine.config
+                    )
+                )
             self.connection.rollback()
 
     def create_savepoint(self, sp=None, cursor=None):
@@ -126,28 +149,28 @@ class Transaction(object):
     def sequence(self, name):
         return Sequence(self, name)
 
-    def row(self, tablename, pk):
+    def row(self, tablename, pk, lock=None):
         """
         Returns exactly one row based on primary key.
         raise exception if primary key not provided.
         """
-        return Row(self.table(tablename), pk)
+        return Row(self.table(tablename), pk, lock=lock)
 
-    def get(self, tablename, where):
+    def get(self, tablename, where, lock=None):
         """
         Search for row. return row if 1 found.
         raise exception if duplicates found.
         return new if not found. (creates new/use find otherwise)
         """
-        return self.table(tablename).get(where)
+        return self.table(tablename).get(where, lock=lock)
 
-    def find(self, tablename, where):
+    def find(self, tablename, where, lock=None):
         """
         Search for row. return row if 1 found.
         raise exception if duplicates found.
         return {} if not found. (Does not create new)
         """
-        return self.table(tablename).find(where)
+        return self.table(tablename).find(where, lock=lock)
 
     def column(self, tablename, colname):
         return Column(self.table(tablename), colname)
@@ -162,13 +185,12 @@ class Transaction(object):
         self.connection.set_isolation_level(0)
         sql = ["VACUUM"]
         if full:
-            sql.append('FULL')
+            sql.append("FULL")
         if analyze:
-            sql.append('ANALYZE')
-        self.execute(' '.join(sql))
-        print(self.current_database())
+            sql.append("ANALYZE")
+        self.execute(" ".join(sql))
         if reindex:
-            database = self.engine.config.get('database')
+            database = self.engine.config.get("database")
             self.execute("REINDEX DATABASE {}".format(database))
         self.connection.set_isolation_level(old_isolation_level)
 
@@ -176,10 +198,11 @@ class Transaction(object):
         sql, vals = self.engine.sql.tables()
         result = self.execute(sql, vals)
         return ["%s.%s" % x for x in result.as_tuple()]
-    
+
+    @property
     def pg_types(self):
         if not self.__pg_types:
             sql, vals = "select oid,typname from pg_type", ()
             result = self.execute(sql, vals)
-            self.__pg_types =  dict(result.as_tuple())
-        return self.__pg_types
+            self.__pg_types = dict(result.as_tuple())
+        return self.__pg_types