velocity-python 0.0.35__py3-none-any.whl → 0.0.64__py3-none-any.whl

velocity/db/core/transaction.py

@@ -1,4 +1,5 @@
-import re
+import traceback
+
 from velocity.db.core.row import Row
 from velocity.db.core.table import Table
 from velocity.db.core.result import Result
@@ -6,13 +7,14 @@ from velocity.db.core.column import Column
 from velocity.db.core.database import Database
 from velocity.db.core.sequence import Sequence
 from velocity.misc.db import randomword
-import traceback
-
 
 debug = False
 
 
-class Transaction(object):
+class Transaction:
+    """
+    Encapsulates a single transaction in the database (connection + commit/rollback).
+    """
 
     def __init__(self, engine, connection=None):
         self.engine = engine
@@ -23,7 +25,7 @@ class Transaction(object):
         c = self.engine.config
         server = c.get("host", c.get("server"))
         database = c.get("database")
-        return "{}.transaction({}:{})".format(self.engine.sql.server, server, database)
+        return f"{self.engine.sql.server}.transaction({server}:{database})"
 
     def __enter__(self):
         return self
@@ -31,104 +33,89 @@ class Transaction(object):
     def __exit__(self, exc_type, exc_val, exc_tb):
         if exc_type:
             if debug:
-                print("Transaction.__exit__")
-            tb_str = "".join(traceback.format_exception(exc_type, exc_val, exc_tb))
-            if debug:
-                print(tb_str)
+                print("Transaction.__exit__ - an exception occurred.")
+                traceback.print_exc()
             self.rollback()
         self.close()
 
     def cursor(self):
+        """
+        Retrieves a database cursor, opening a connection if necessary.
+        """
         if not self.connection:
-            if debug:
-                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(f"*** {id(self)} --> transaction.cursor()")
         return self.connection.cursor()
 
     def close(self):
+        """
+        Commits (if needed) and closes the connection.
+        """
         if self.connection:
             self.commit()
             if debug:
-                print(
-                    "<<< {} close connection to {database}".format(
-                        id(self), **self.engine.config
-                    )
-                )
+                print(f"<<< {id(self)} close connection.")
             self.connection.close()
+            self.connection = None
 
     def execute(self, sql, parms=None, single=False, cursor=None):
-        return self._execute(sql, parms=parms, single=single, cursor=cursor)
+        return self._execute(sql, parms, single, cursor)
 
     def _execute(self, sql, parms=None, single=False, cursor=None):
         if single:
             cursor = None
         if not self.connection:
-            if debug:
-                print(
-                    ">>> {} open connection to {database}".format(
-                        id(self), **self.engine.config
-                    )
-                )
             self.connection = self.engine.connect()
-        action = re.search(r"(\w+)", sql, re.I)
-        if action:
-            action = action.group().lower()
-        else:
-            action = "None"
-        if debug:
-            print(action)
-            print(id(self), "------------>", sql, "::", parms)
-            print()
+
         if single:
             self.commit()
             self.connection.autocommit = True
+
         if not cursor:
             cursor = self.cursor()
+
         try:
             if parms:
                 cursor.execute(sql, parms)
             else:
                 cursor.execute(sql)
         except:
-            self.engine.ProcessError(sql, parms)
+            self.engine.process_error(sql, parms)
+
         if single:
             self.connection.autocommit = False
+
         return Result(cursor, self, sql, parms)
 
     def server_execute(self, sql, parms=None):
+        """
+        Executes SQL using an existing cursor, typically for server-side usage.
+        """
         return self._execute(sql, parms, cursor=self.cursor())
 
     def commit(self):
+        """
+        Commits the current transaction if there's an open connection.
+        """
         if self.connection:
             if debug:
-                print(
-                    "{} --- connection commit {database}".format(
-                        id(self), **self.engine.config
-                    )
-                )
+                print(f"{id(self)} --- connection commit.")
             self.connection.commit()
 
     def rollback(self):
+        """
+        Rolls back the current transaction if there's an open connection.
+        """
         if self.connection:
             if debug:
-                print(
-                    "{} --- connection rollback {database}".format(
-                        id(self), **self.engine.config
-                    )
-                )
+                print(f"{id(self)} --- connection rollback.")
             self.connection.rollback()
 
     def create_savepoint(self, sp=None, cursor=None):
+        """
+        Creates a savepoint named `sp`. If none given, uses a random name.
+        """
         if not sp:
             sp = randomword()
         sql, vals = self.engine.sql.create_savepoint(sp)
@@ -137,83 +124,94 @@ class Transaction(object):
         return sp
 
     def release_savepoint(self, sp=None, cursor=None):
+        """
+        Releases the given savepoint.
+        """
         sql, vals = self.engine.sql.release_savepoint(sp)
         if sql:
             self._execute(sql, vals, cursor=cursor)
 
     def rollback_savepoint(self, sp=None, cursor=None):
+        """
+        Rolls back to the given savepoint.
+        """
         sql, vals = self.engine.sql.rollback_savepoint(sp)
         if sql:
             self._execute(sql, vals, cursor=cursor)
 
     def database(self, name=None):
+        """
+        Returns a Database object for the given database name or the current one.
+        """
         return Database(self, name)
 
     def table(self, tablename):
+        """
+        Returns a Table object for the given table name.
+        """
         return Table(self, tablename)
 
     def sequence(self, name):
+        """
+        Returns a Sequence object for the given sequence name.
+        """
         return Sequence(self, name)
 
     def row(self, tablename, pk, lock=None):
         """
-        Returns exactly one row based on primary key.
-        raise exception if primary key not provided.
+        Returns a Row for the given table & primary key condition.
         """
         return Row(self.table(tablename), pk, lock=lock)
 
     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)
+        Shortcut to table.get().
         """
         return self.table(tablename).get(where, lock=lock)
 
     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)
+        Shortcut to table.find().
         """
         return self.table(tablename).find(where, lock=lock)
 
     def column(self, tablename, colname):
+        """
+        Returns a Column object for (table=tablename, column=colname).
+        """
         return Column(self.table(tablename), colname)
 
     def current_database(self):
+        """
+        Returns the current database name from the server.
+        """
         sql, vals = self.engine.sql.current_database()
         return self.execute(sql, vals).scalar()
 
-    def vacuum(self, analyze=True, full=False, reindex=True):
-        self.connection = self.engine.connect()
-        old_isolation_level = self.connection.isolation_level
-        self.connection.set_isolation_level(0)
-        sql = ["VACUUM"]
-        if full:
-            sql.append("FULL")
-        if analyze:
-            sql.append("ANALYZE")
-        self.execute(" ".join(sql))
-        if reindex:
-            database = self.engine.config.get("database")
-            self.execute("REINDEX DATABASE {}".format(database))
-        self.connection.set_isolation_level(old_isolation_level)
-
     def tables(self):
+        """
+        Returns a list of tables in the current database as "schema.table" strings.
+        """
         sql, vals = self.engine.sql.tables()
         result = self.execute(sql, vals)
-        return ["%s.%s" % x for x in result.as_tuple()]
+        return [f"{x[0]}.{x[1]}" for x in result.as_tuple()]
 
     @property
     def pg_types(self):
+        """
+        Cached mapping of OID -> type name for columns.
+        """
         if not self.__pg_types:
-            sql, vals = "select oid,typname from pg_type", ()
+            sql = "select oid, typname from pg_type"
+            vals = ()
             result = self.execute(sql, vals)
             self.__pg_types = dict(result.as_tuple())
         return self.__pg_types
 
     def switch_to_database(self, name):
+        """
+        Closes the current connection, changes config, and lazily reconnects for the new DB.
+        """
         if self.connection:
             self.connection.close()
             self.connection = None

velocity/db/servers/mysql.py

@@ -144,6 +144,10 @@ class SQL:
     LockTimeoutErrorCodes = []
     DatabaseObjectExistsErrorCodes = []
 
+    def get_error(self, e):
+        error_code, error_mesg = e.args[:2]
+        return error_code, error_mesg
+
     @classmethod
     def __has_pointer(cls, columns):
         if columns:

velocity/db/servers/postgres/__init__.py

@@ -0,0 +1,19 @@
+import os
+import psycopg2
+from .sql import SQL
+from velocity.db.core import engine
+
+default_config = {
+    "database": os.environ["DBDatabase"],
+    "host": os.environ["DBHost"],
+    "port": os.environ["DBPort"],
+    "user": os.environ["DBUser"],
+    "password": os.environ["DBPassword"],
+}
+
+
+def initialize(config=None, **kwargs):
+    if not config:
+        config = default_config.copy()
+    config.update(kwargs)
+    return engine.Engine(psycopg2, config, SQL)

velocity/db/servers/postgres/operators.py

@@ -0,0 +1,23 @@
+OPERATORS = {
+    "<>": "<>",
+    "!=": "<>",
+    "!><": "NOT BETWEEN",
+    ">!<": "NOT BETWEEN",
+    "><": "BETWEEN",
+    "%%": "ILIKE",
+    "!%%": "NOT ILIKE",
+    "==": "=",
+    "<=": "<=",
+    ">=": ">=",
+    "<": "<",
+    ">": ">",
+    "!~*": "!~*",
+    "~*": "~*",
+    "!~": "!~",
+    "%": "LIKE",
+    "!%": "NOT LIKE",
+    "~": "~",
+    "=": "=",
+    "!": "<>",
+    "#": "ILIKE",
+}