sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/firebird/firebirdconnection.py

@@ -0,0 +1,463 @@
+import os
+import re
+import warnings
+from sqlobject import col
+from sqlobject.dbconnection import DBAPI
+
+
+class FirebirdConnection(DBAPI):
+
+    supportTransactions = False
+    dbName = 'firebird'
+    schemes = [dbName]
+
+    limit_re = re.compile(r'^\s*(select )(.*)', re.IGNORECASE)
+
+    def __init__(self, host, db, port='3050', user='sysdba',
+                 password='masterkey', autoCommit=1,
+                 dialect=None, role=None, charset=None, **kw):
+        drivers = kw.pop('driver', None) or 'fdb,kinterbasdb'
+        for driver in drivers.split(','):
+            driver = driver.strip()
+            if not driver:
+                continue
+            try:
+                if driver == 'fdb':
+                    import fdb
+                    self.module = fdb
+                elif driver == 'kinterbasdb':
+                    import kinterbasdb
+                    # See
+                    # http://kinterbasdb.sourceforge.net/dist_docs/usage.html
+                    # for an explanation; in short: use datetime, decimal and
+                    # unicode.
+                    kinterbasdb.init(type_conv=200)
+                    self.module = kinterbasdb
+                elif driver in ('firebirdsql', 'pyfirebirdsql'):
+                    import firebirdsql
+                    self.module = firebirdsql
+                else:
+                    raise ValueError(
+                        'Unknown FireBird driver "%s", '
+                        'expected fdb, kinterbasdb or firebirdsql' % driver)
+            except ImportError:
+                pass
+            else:
+                break
+        else:
+            raise ImportError(
+                'Cannot find an FireBird driver, tried %s' % drivers)
+        self.host = host
+        self.port = port
+        self.db = db
+        self.user = user
+        self.password = password
+        if dialect:
+            self.dialect = int(dialect)
+        else:
+            self.dialect = None
+        self.role = role
+        if charset:
+            # Encoding defined by user in the connection string.
+            self.dbEncoding = charset.replace('-', '')
+        else:
+            self.dbEncoding = charset
+        # Encoding defined during database creation and stored in the database.
+        self.defaultDbEncoding = ''
+        DBAPI.__init__(self, **kw)
+
+    @classmethod
+    def _connectionFromParams(cls, auth, password, host, port, path, args):
+        if not password:
+            password = 'masterkey'
+        if not auth:
+            auth = 'sysdba'
+        # check for alias using
+        if (path[0] == '/') and path[-3:].lower() not in ('fdb', 'gdb'):
+            path = path[1:]
+        path = path.replace('/', os.sep)
+        return cls(host, port=port, db=path, user=auth, password=password,
+                   **args)
+
+    def _runWithConnection(self, meth, *args):
+        if not self.autoCommit:
+            return DBAPI._runWithConnection(self, meth, args)
+        conn = self.getConnection()
+        # @@: Horrible auto-commit implementation.  Just horrible!
+        try:
+            conn.begin()
+        except self.module.ProgrammingError:
+            pass
+        try:
+            val = meth(conn, *args)
+            try:
+                conn.commit()
+            except self.module.ProgrammingError:
+                pass
+        finally:
+            self.releaseConnection(conn)
+        return val
+
+    def _setAutoCommit(self, conn, auto):
+        # Only _runWithConnection does "autocommit", so we don't
+        # need to worry about that.
+        pass
+
+    def makeConnection(self):
+        extra = {}
+        if self.dialect:
+            extra['dialect'] = self.dialect
+        return self.module.connect(
+            host=self.host,
+            port=self.port,
+            database=self.db,
+            user=self.user,
+            password=self.password,
+            role=self.role,
+            charset=self.dbEncoding,
+            **extra
+        )
+
+    def _queryInsertID(self, conn, soInstance, id, names, values):
+        """Firebird uses 'generators' to create new ids for a table.
+        The users needs to create a generator named GEN_<tablename>
+        for each table this method to work."""
+        table = soInstance.sqlmeta.table
+        idName = soInstance.sqlmeta.idName
+        sequenceName = soInstance.sqlmeta.idSequence or 'GEN_%s' % table
+        c = conn.cursor()
+        if id is None:
+            c.execute('SELECT gen_id(%s,1) FROM rdb$database' % sequenceName)
+            id = c.fetchone()[0]
+        names = [idName] + names
+        values = [id] + values
+        q = self._insertSQL(table, names, values)
+        if self.debug:
+            self.printDebug(conn, q, 'QueryIns')
+        c.execute(q)
+        c.close()
+        if self.debugOutput:
+            self.printDebug(conn, id, 'QueryIns', 'result')
+        return id
+
+    @classmethod
+    def _queryAddLimitOffset(cls, query, start, end):
+        """Firebird slaps the limit and offset (actually 'first' and
+        'skip', respectively) statement right after the select."""
+        if not start:
+            limit_str = "SELECT FIRST %i" % end
+        if not end:
+            limit_str = "SELECT SKIP %i" % start
+        else:
+            limit_str = "SELECT FIRST %i SKIP %i" % (end - start, start)
+
+        match = cls.limit_re.match(query)
+        if match and len(match.groups()) == 2:
+            return ' '.join([limit_str, match.group(2)])
+        else:
+            return query
+
+    def createTable(self, soClass):
+        self.query('CREATE TABLE %s (\n%s\n)' %
+                   (soClass.sqlmeta.table, self.createColumns(soClass)))
+        self.query("CREATE GENERATOR GEN_%s" % soClass.sqlmeta.table)
+        return []
+
+    def createReferenceConstraint(self, soClass, col):
+        return None
+
+    def createColumn(self, soClass, col):
+        return col.firebirdCreateSQL()
+
+    def createIDColumn(self, soClass):
+        key_type = {int: "INT", str: "VARCHAR(255)"}[soClass.sqlmeta.idType]
+        return '%s %s NOT NULL PRIMARY KEY' % (soClass.sqlmeta.idName,
+                                               key_type)
+
+    def createIndexSQL(self, soClass, index):
+        return index.firebirdCreateIndexSQL(soClass)
+
+    def joinSQLType(self, join):
+        return 'INT NOT NULL'
+
+    def tableExists(self, tableName):
+        # there's something in the database by this name...let's
+        # assume it's a table.  By default, fb 1.0 stores EVERYTHING
+        # it cares about in uppercase.
+        result = self.queryOne(
+            "SELECT COUNT(rdb$relation_name) FROM rdb$relations "
+            "WHERE rdb$relation_name = '%s'" % tableName.upper())
+        return result[0]
+
+    def addColumn(self, tableName, column):
+        self.query('ALTER TABLE %s ADD %s' %
+                   (tableName,
+                    column.firebirdCreateSQL()))
+
+    def dropTable(self, tableName, cascade=False):
+        self.query("DROP TABLE %s" % tableName)
+        self.query("DROP GENERATOR GEN_%s" % tableName)
+
+    def delColumn(self, sqlmeta, column):
+        self.query('ALTER TABLE %s DROP %s' % (sqlmeta.table, column.dbName))
+
+    def readDefaultEncodingFromDB(self):
+        # Get out if encoding is known allready (can by None as well).
+        if self.defaultDbEncoding == "":
+            self.defaultDbEncoding = str(self.queryOne(
+                "SELECT rdb$character_set_name FROM rdb$database")[0].
+                strip().lower())  # encoding defined during db creation
+            if self.defaultDbEncoding == "none":
+                self.defaultDbEncoding = None
+            if self.dbEncoding != self.defaultDbEncoding:
+                warningText = """\n
+                   Database charset: %s is different """ \
+                   """from connection charset: %s.\n""" % (
+                   self.defaultDbEncoding, self.dbEncoding)
+                warnings.warn(warningText)
+                # TODO: ??? print out the uri string,
+                # so user can see what is going on
+                warningText = """\n
+                   Every CHAR or VARCHAR field can (or, better: must) """ \
+                   """have a character set defined in Firebird.
+                   In the case, field charset is not defined, """ \
+                   """SQLObject try to use a db default encoding instead.
+                   Firebird is unable to transliterate between character sets.
+                   So you must set the correct values on the server """ \
+                   "and on the client if everything is to work smoothely.\n"
+                warnings.warn(warningText)
+
+            if not self.dbEncoding:  # defined by user in the connection string
+                self.dbEncoding = self.defaultDbEncoding
+                warningText = """\n
+                   encoding: %s will be used as default """ \
+                   """for this connection\n""" % self.dbEncoding
+                warnings.warn(warningText)
+
+    def columnsFromSchema(self, tableName, soClass):
+        """
+        Look at the given table and create Col instances (or
+        subclasses of Col) for the fields it finds in that table.
+        """
+
+        self.readDefaultEncodingFromDB()
+
+        fieldQuery = """\
+        SELECT r.RDB$FIELD_NAME AS field_name,
+                CASE f.RDB$FIELD_TYPE
+                when 7 then 'smallint'
+                when 8 then 'integer'
+                when 16 then 'int64'
+                when 9 then 'quad'
+                when 10 then 'float'
+                when 11 then 'd_float'
+                when 17 then 'boolean'
+                when 27 then 'double'
+                when 12 then 'date'
+                when 13 then 'time'
+                when 35 then 'timestamp'
+                when 261 then 'blob'
+                when 37 then 'varchar'
+                when 14 then 'char'
+                when 40 then 'cstring'
+                when 45 then 'blob_id'
+                  ELSE 'UNKNOWN'
+                END AS field_type,
+                case f.rdb$field_type
+                when 7 then
+                case f.rdb$field_sub_type
+                    when 1 then 'numeric'
+                    when 2 then 'decimal'
+                end
+                when 8 then
+                case f.rdb$field_sub_type
+                    when 1 then 'numeric'
+                    when 2 then 'decimal'
+                end
+                when 16 then
+                case f.rdb$field_sub_type
+                    when 1 then 'numeric'
+                    when 2 then 'decimal'
+                    else 'bigint'
+                end
+                when 14 then
+                case f.rdb$field_sub_type
+                    when 0 then 'unspecified'
+                    when 1 then 'binary'
+                    when 3 then 'acl'
+                    else
+                    case
+                        when f.rdb$field_sub_type is null then 'unspecified'
+                    end
+                end
+                when 37 then
+                case f.rdb$field_sub_type
+                    when 0 then 'unspecified'
+                    when 1 then 'text'
+                    when 3 then 'acl'
+                    else
+                    case
+                        when f.rdb$field_sub_type is null then 'unspecified'
+                    end
+                end
+                when 261 then
+                case f.rdb$field_sub_type
+                    when 0 then 'unspecified'
+                    when 1 then 'text'
+                    when 2 then 'blr'
+                    when 3 then 'acl'
+                    when 4 then 'reserved'
+                    when 5 then 'encoded-meta-data'
+                    when 6 then 'irregular-finished-multi-db-tx'
+                    when 7 then 'transactional_description'
+                    when 8 then 'external_file_description'
+                end
+            end as "ActualSubType",
+                f.RDB$FIELD_LENGTH AS field_length,
+                f.RDB$FIELD_PRECISION AS field_precision,
+                f.RDB$FIELD_SCALE AS field_scale,
+                cset.RDB$CHARACTER_SET_NAME AS field_charset,
+                coll.RDB$COLLATION_NAME AS field_collation,
+                r.rdb$default_source,
+                r.RDB$NULL_FLAG AS field_not_null_constraint,
+                r.RDB$DESCRIPTION AS field_description
+           FROM RDB$RELATION_FIELDS r
+           LEFT JOIN RDB$FIELDS f ON r.RDB$FIELD_SOURCE = f.RDB$FIELD_NAME
+           LEFT JOIN RDB$COLLATIONS coll
+                ON f.RDB$COLLATION_ID = coll.RDB$COLLATION_ID
+           LEFT JOIN RDB$CHARACTER_SETS cset
+                ON f.RDB$CHARACTER_SET_ID = cset.RDB$CHARACTER_SET_ID
+          WHERE r.RDB$RELATION_NAME='%s'  -- table name
+        ORDER BY r.RDB$FIELD_POSITION
+        """
+
+        colData = self.queryAll(fieldQuery % tableName.upper())
+        results = []
+        for (field, fieldType, fieldSubtype, fieldLength, fieldPrecision,
+                fieldScale, fieldCharset, collationName, defaultSource,
+                fieldNotNullConstraint, fieldDescription) in colData:
+            field = field.strip().lower()
+            fieldType = fieldType.strip()
+            if fieldCharset:
+                fieldCharset = str(fieldCharset.strip())
+                # 'UNICODE_FSS' is less strict
+                # Firebird/Interbase UTF8 definition
+                if fieldCharset.startswith('UNICODE_FSS'):
+                    fieldCharset = "UTF8"
+            if fieldSubtype:
+                fieldSubtype = fieldSubtype.strip()
+                if fieldType == "int64":
+                    fieldType = fieldSubtype
+
+            # can look like: "DEFAULT 0", "DEFAULT 'default text'", None
+            if defaultSource:
+                defaultSource = defaultSource.split(' ')[1]
+                if defaultSource.startswith("'") and \
+                        defaultSource.endswith("'"):
+                    defaultSource = str(defaultSource[1:-1])
+                elif fieldType in ("integer", "smallint", "bigint"):
+                    defaultSource = int(defaultSource)
+                elif fieldType in ("float", "double"):
+                    defaultSource = float(defaultSource)
+            # TODO: other types for defaultSource
+            #    elif fieldType == "datetime":
+
+            idName = str(soClass.sqlmeta.idName or 'id').upper()
+            if field.upper() == idName:
+                continue
+            if fieldScale:
+                # PRECISION refers to the total number of digits,
+                # and SCALE refers to the number of digits
+                # to the right of the decimal point.
+                # Both numbers can be from 1 to 18 (SQL dialect 1: 1-15),
+                # but SCALE mustbe less than or equal to PRECISION.
+                if fieldScale > fieldLength:
+                    fieldScale = fieldLength
+            colClass, kw = self.guessClass(fieldType, fieldLength,
+                                           fieldCharset, fieldScale)
+            kw['name'] = str(
+                soClass.sqlmeta.style.dbColumnToPythonAttr(field).strip())
+            kw['dbName'] = str(field)
+            kw['notNone'] = not fieldNotNullConstraint
+            kw['default'] = defaultSource
+            results.append(colClass(**kw))
+        return results
+
+    def guessClass(self, t, flength, fCharset, fscale=None):
+        """
+        An internal method that tries to figure out what Col subclass
+        is appropriate given whatever introspective information is
+        available -- both very database-specific.
+        """
+
+        # TODO: check if negative values are allowed for fscale
+
+        if t == 'smallint':        # -32,768 to +32,767, 16 bits
+            return col.IntCol, {}
+        elif t == 'integer':       # -2,147,483,648 to +2,147,483,647, 32 bits
+            return col.IntCol, {}
+        elif t == 'bigint':
+            # -2^63 to 2^63-1 or
+            # -9,223,372,036,854,775,808 to 9,223,372,036,854,775,807, 64 bits
+            return col.IntCol, {}
+        elif t == 'float':
+            # 32 bits, 3.4x10^-38 to 3.4x10^38, 7 digit precision
+            # (7 significant decimals)
+            return col.FloatCol, {}
+        elif t == 'double':
+            # 64 bits, 1.7x10^-308 to 1.7x10^308, 15 digit precision
+            # (15 significant decimals)
+            return col.FloatCol, {}
+        elif t == 'numeric':
+            # Numeric and Decimal are internally stored as smallint,
+            # integer or bigint depending on the size.
+            # They can handle up to 18 digits.
+            if (not flength or not fscale):
+                # If neither PRECISION nor SCALE are specified,
+                # Firebird/InterBase defines the column as INTEGER
+                # instead of NUMERIC and stores only the integer portion
+                # of the value
+                return col.IntCol, {}
+            # check if negative values are allowed for fscale
+            return col.DecimalCol, {'size': flength, 'precision': fscale}
+
+        elif t == 'decimal':
+            # Check if negative values are allowed for fscale
+            return col.DecimalCol, {'size': flength, 'precision': fscale}
+        elif t == 'date':  # 32 bits, 1 Jan 100. to 29 Feb 32768.
+            return col.DateCol, {}
+        elif t == 'time':  # 32 bits, 00:00 to 23:59.9999
+            return col.TimeCol, {}
+        elif t == 'timestamp':  # 64 bits, 1 Jan 100 to 28 Feb 32768.
+            return col.DateTimeCol, {}
+        elif t == 'char':  # 32767 bytes
+            if fCharset and (fCharset != "NONE"):
+                return col.UnicodeCol, {'length': flength, 'varchar': False,
+                                        'dbEncoding': fCharset}
+            elif self.dbEncoding:
+                return col.UnicodeCol, {'length': flength, 'varchar': False,
+                                        'dbEncoding': self.dbEncoding}
+            else:
+                return col.StringCol, {'length': flength, 'varchar': False}
+        elif t == 'varchar':  # 32767 bytes
+            if fCharset and (fCharset != "NONE"):
+                return col.UnicodeCol, {'length': flength, 'varchar': True,
+                                        'dbEncoding': fCharset}
+            elif self.dbEncoding:
+                return col.UnicodeCol, {'length': flength, 'varchar': True,
+                                        'dbEncoding': self.dbEncoding}
+            else:
+                return col.StringCol, {'length': flength, 'varchar': True}
+
+        elif t == 'blob':  # 32GB
+            return col.BLOBCol, {}
+        else:
+            return col.Col, {}
+
+    def createEmptyDatabase(self):
+        self.module.create_database(
+            "CREATE DATABASE '%s' user '%s' password '%s'" %
+            (self.db, self.user, self.password))
+
+    def dropDatabase(self):
+        self.module.drop_database()

sqlobject/include/__init__.py

@@ -0,0 +1 @@
+#

sqlobject/include/hashcol.py

@@ -0,0 +1,109 @@
+import sqlobject.col
+from sqlobject.compat import PY2, string_type
+
+
+__all__ = ['HashCol']
+
+
+class DbHash:
+    """
+    Presents a comparison object for hashes, allowing plain text to be
+    automagically compared with the base content
+    """
+
+    def __init__(self, hash, hashMethod):
+        self.hash = hash
+        self.hashMethod = hashMethod
+
+    def _get_key(self, other):
+        """Create the hash of the other class"""
+        if not isinstance(other, string_type):
+            raise TypeError(
+                "A hash may only be compared with a string, or None.")
+        return self.hashMethod(other)
+
+    def __eq__(self, other):
+        if other is None:
+            if self.hash is None:
+                return True
+            return False
+        other_key = self._get_key(other)
+        return other_key == self.hash
+
+    def __lt__(self, other):
+        if other is None:
+            return False
+        other_key = self._get_key(other)
+        return other_key < self.hash
+
+    def __gt__(self, other):
+        if other is None:
+            if self.hash is None:
+                return False
+            return True
+        other_key = self._get_key(other)
+        return other_key > self.hash
+
+    def __le__(self, other):
+        if other is None:
+            if self.hash is None:
+                return True
+            return False
+        other_key = self._get_key(other)
+        return other_key <= self.hash
+
+    def __ge__(self, other):
+        if other is None:
+            return True
+        other_key = self._get_key(other)
+        return other_key >= self.hash
+
+    def __repr__(self):
+        return "<DbHash>"
+
+
+class HashValidator(sqlobject.col.StringValidator):
+    """Provides formal SQLObject validation services for the HashCol"""
+
+    def to_python(self, value, state):
+        """ Passes out a hash object. """
+        if value is None:
+            return None
+        return DbHash(hash=value, hashMethod=self.hashMethod)
+
+    def from_python(self, value, state):
+        """Store the given value as a MD5 hash, or None if specified"""
+        if value is None:
+            return None
+        return self.hashMethod(value)
+
+
+class SOHashCol(sqlobject.col.SOStringCol):
+    """The internal HashCol definition. By default, enforces a md5 digest"""
+
+    def __init__(self, **kw):
+        if 'hashMethod' not in kw:
+            from hashlib import md5
+            if PY2:
+                self.hashMethod = lambda v: md5(v).hexdigest()
+            else:
+                self.hashMethod = lambda v: md5(v.encode('utf8')).hexdigest()
+            if 'length' not in kw:
+                kw['length'] = 32
+        else:
+            self.hashMethod = kw['hashMethod']
+            del kw['hashMethod']
+        super(SOHashCol, self).__init__(**kw)
+
+    def createValidators(self):
+        return [HashValidator(name=self.name, hashMethod=self.hashMethod)] + \
+            super(SOHashCol, self).createValidators()
+
+
+class HashCol(sqlobject.col.StringCol):
+    """
+    End-user HashCol class. May be instantiated with 'hashMethod', a function
+    which returns the string hash of any other string (i.e. basestring)
+    """
+
+    baseClass = SOHashCol

sqlobject/include/tests/__init__.py

@@ -0,0 +1 @@
+#

sqlobject/include/tests/test_hashcol.py

@@ -0,0 +1,84 @@
+from hashlib import sha256, md5
+from sqlobject import AND, IntCol, OR, SQLObject
+from sqlobject.compat import PY2
+from sqlobject.include import hashcol
+from sqlobject.tests.dbtest import setupClass
+
+########################################
+# HashCol test
+########################################
+
+if PY2:
+    def sha256_str(x):
+        return sha256(x).hexdigest()
+
+    def md5_str(x):
+        return md5(x).hexdigest()
+else:
+    def sha256_str(x):
+        return sha256(x.encode('utf8')).hexdigest()
+
+    def md5_str(x):
+        return md5(x.encode('utf8')).hexdigest()
+
+
+class HashTest(SQLObject):
+    so_count = IntCol(alternateID=True)
+    col1 = hashcol.HashCol()
+    col2 = hashcol.HashCol(hashMethod=sha256_str)
+
+
+data = ['test', 'This is more text', 'test 2']
+items = []
+
+
+def setup():
+    global items
+    items = []
+    setupClass(HashTest)
+    for i, s in enumerate(data):
+        items.append(HashTest(so_count=i, col1=s, col2=s))
+
+
+def test_create():
+    setup()
+    for s, item in zip(data, items):
+        assert item.col1 == s
+        assert item.col2 == s
+
+    conn = HashTest._connection
+    rows = conn.queryAll("""
+    SELECT so_count, col1, col2
+    FROM hash_test
+    ORDER BY so_count
+    """)
+    for so_count, col1, col2 in rows:
+        assert md5_str(data[so_count]) == col1
+        assert sha256_str(data[so_count]) == col2
+
+
+def test_select():
+    for i, value in enumerate(data):
+        rows = list(HashTest.select(HashTest.q.col1 == value))
+        assert len(rows) == 1
+        rows = list(HashTest.select(HashTest.q.col2 == value))
+        assert len(rows) == 1
+        # Passing the hash in directly should fail
+        rows = list(HashTest.select(HashTest.q.col2 == sha256_str(value)))
+        assert len(rows) == 0
+        rows = list(HashTest.select(AND(
+            HashTest.q.col1 == value,
+            HashTest.q.col2 == value
+        )))
+        assert len(rows) == 1
+        rows = list(HashTest.selectBy(col1=value))
+        assert len(rows) == 1
+        rows = list(HashTest.selectBy(col2=value))
+        assert len(rows) == 1
+        rows = list(HashTest.selectBy(col1=value, col2=value))
+        assert len(rows) == 1
+    rows = list(HashTest.select(OR(
+        HashTest.q.col1 == 'test 2',
+        HashTest.q.col2 == 'test'
+    )))
+    assert len(rows) == 2