sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/sybase/sybaseconnection.py

@@ -0,0 +1,183 @@
+from sqlobject.dbconnection import DBAPI
+from sqlobject import col
+
+
+class SybaseConnection(DBAPI):
+
+    supportTransactions = False
+    dbName = 'sybase'
+    schemes = [dbName]
+    NumericType = None
+
+    def __init__(self, db, user, password='', host='localhost', port=None,
+                 locking=1, **kw):
+        db = db.strip('/')
+        import Sybase
+        Sybase._ctx.debug = 0
+        if SybaseConnection.NumericType is None:
+            from Sybase import NumericType
+            SybaseConnection.NumericType = NumericType
+            from sqlobject.converters import registerConverter, IntConverter
+            registerConverter(NumericType, IntConverter)
+        self.module = Sybase
+        self.locking = int(locking)
+        self.host = host
+        self.port = port
+        self.db = db
+        self.user = user
+        self.password = password
+        autoCommit = kw.get('autoCommit')
+        if autoCommit:
+            autoCommit = int(autoCommit)
+        else:
+            autoCommit = None
+        kw['autoCommit'] = autoCommit
+        DBAPI.__init__(self, **kw)
+
+    @classmethod
+    def _connectionFromParams(cls, user, password, host, port, path, args):
+        return cls(user=user, password=password,
+                   host=host or 'localhost', port=port, db=path, **args)
+
+    def insert_id(self, conn):
+        """
+        Sybase adapter/cursor does not support the
+        insert_id method.
+        """
+        c = conn.cursor()
+        c.execute('SELECT @@IDENTITY')
+        result = c.fetchone()[0]
+        c.close()
+        return result
+
+    def makeConnection(self):
+        return self.module.connect(self.host, self.user, self.password,
+                                   database=self.db,
+                                   auto_commit=self.autoCommit,
+                                   locking=self.locking)
+
+    HAS_IDENTITY = """
+       SELECT col.name, col.status, obj.name
+       FROM syscolumns col
+       JOIN sysobjects obj
+       ON obj.id = col.id
+       WHERE obj.name = '%s'
+             AND (col.status & 0x80) = 0x80
+    """
+
+    def _hasIdentity(self, conn, table):
+        query = self.HAS_IDENTITY % table
+        c = conn.cursor()
+        c.execute(query)
+        r = c.fetchone()
+        c.close()
+        return r is not None
+
+    def _queryInsertID(self, conn, soInstance, id, names, values):
+        table = soInstance.sqlmeta.table
+        idName = soInstance.sqlmeta.idName
+        c = conn.cursor()
+        if id is not None:
+            names = [idName] + names
+            values = [id] + values
+
+        has_identity = self._hasIdentity(conn, table)
+        identity_insert_on = False
+        if has_identity and (id is not None):
+            identity_insert_on = True
+            c.execute('SET IDENTITY_INSERT %s ON' % table)
+
+        if names and values:
+            q = self._insertSQL(table, names, values)
+        else:
+            q = "INSERT INTO %s DEFAULT VALUES" % table
+        if self.debug:
+            self.printDebug(conn, q, 'QueryIns')
+        c.execute(q)
+        if has_identity and identity_insert_on:
+            c.execute('SET IDENTITY_INSERT %s OFF' % table)
+        c.close()
+        if id is None:
+            id = self.insert_id(conn)
+        if self.debugOutput:
+            self.printDebug(conn, id, 'QueryIns', 'result')
+        return id
+
+    @classmethod
+    def _queryAddLimitOffset(cls, query, start, end):
+        # XXX Sybase doesn't support OFFSET
+        if end:
+            return "SET ROWCOUNT %i %s SET ROWCOUNT 0" % (end, query)
+        return query
+
+    def createReferenceConstraint(self, soClass, col):
+        return None
+
+    def createColumn(self, soClass, col):
+        return col.sybaseCreateSQL()
+
+    def createIDColumn(self, soClass):
+        key_type = {int: "NUMERIC(18,0)", str: "TEXT"}[soClass.sqlmeta.idType]
+        return '%s %s IDENTITY UNIQUE' % (soClass.sqlmeta.idName, key_type)
+
+    def createIndexSQL(self, soClass, index):
+        return index.sybaseCreateIndexSQL(soClass)
+
+    def joinSQLType(self, join):
+        return 'NUMERIC(18,0) NOT NULL'
+
+    SHOW_TABLES = "SELECT name FROM sysobjects WHERE type='U'"
+
+    def tableExists(self, tableName):
+        for (table,) in self.queryAll(self.SHOW_TABLES):
+            if table.lower() == tableName.lower():
+                return True
+        return False
+
+    def addColumn(self, tableName, column):
+        self.query('ALTER TABLE %s ADD COLUMN %s' %
+                   (tableName,
+                    column.sybaseCreateSQL()))
+
+    def delColumn(self, sqlmeta, column):
+        self.query(
+            'ALTER TABLE %s DROP COLUMN %s' % (sqlmeta.table, column.dbName))
+
+    SHOW_COLUMNS = ('SELECT '
+                    'COLUMN_NAME, DATA_TYPE, IS_NULLABLE, COLUMN_DEFAULT '
+                    'FROM INFORMATION_SCHEMA.COLUMNS '
+                    'WHERE TABLE_NAME = \'%s\'')
+
+    def columnsFromSchema(self, tableName, soClass):
+        colData = self.queryAll(self.SHOW_COLUMNS
+                                % tableName)
+        results = []
+        for field, t, nullAllowed, default in colData:
+            if field == soClass.sqlmeta.idName:
+                continue
+            colClass, kw = self.guessClass(t)
+            kw['name'] = soClass.sqlmeta.style.dbColumnToPythonAttr(field)
+            kw['dbName'] = field
+            kw['notNone'] = not nullAllowed
+            kw['default'] = default
+            # @@ skip key...
+            # @@ skip extra...
+            kw['forceDBName'] = True
+            results.append(colClass(**kw))
+        return results
+
+    def _setAutoCommit(self, conn, auto):
+        conn.auto_commit = auto
+
+    def guessClass(self, t):
+        if t.startswith('int'):
+            return col.IntCol, {}
+        elif t.startswith('varchar'):
+            return col.StringCol, {'length': int(t[8:-1])}
+        elif t.startswith('char'):
+            return col.StringCol, {'length': int(t[5:-1]),
+                                   'varchar': False}
+        elif t.startswith('datetime'):
+            return col.DateTimeCol, {}
+        else:
+            return col.Col, {}

sqlobject/tests/__init__.py

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

sqlobject/tests/dbtest.py

@@ -0,0 +1,363 @@
+"""
+The framework for making database tests.
+"""
+from __future__ import print_function
+
+import logging
+import os
+import sys
+from pytest import raises, skip
+import sqlobject
+from sqlobject.col import use_microseconds
+import sqlobject.conftest as conftest
+
+if sys.platform[:3] == "win":
+    def getcwd():
+        return os.getcwd().replace('\\', '/')
+else:
+    getcwd = os.getcwd
+
+"""
+supportsMatrix defines what database backends support what features.
+Each feature has a name, if you see a key like '+featureName' then
+only the databases listed support the feature.  Conversely,
+'-featureName' means all databases *except* the ones listed support
+the feature.  The databases are given by their SQLObject string name,
+separated by spaces.
+
+The function supports(featureName) returns True or False based on this,
+and you can use it like::
+
+    def test_featureX():
+        if not supports('featureX'):
+            pytest.skip("Doesn't support featureX")
+"""
+supportsMatrix = {
+    '-blobData': 'mssql',
+    '-decimalColumn': 'mssql',
+    '-dropTableCascade': 'sybase mssql mysql',
+    '-emptyTable': 'mssql',
+    '+exceptions': 'mysql postgres sqlite',
+    '-expressionIndex': 'mysql sqlite firebird mssql',
+    '-limitSelect': 'mssql',
+    '+memorydb': 'sqlite',
+    '+rlike': 'mysql postgres sqlite',
+    '+schema': 'postgres',
+    '-transactions': ' ',
+}
+
+
+def setupClass(soClasses, force=False):
+    """
+    Makes sure the classes have a corresponding and correct table.
+    This won't recreate the table if it already exists.  It will check
+    that the table is properly defined (in case you change your table
+    definition).
+
+    You can provide a single class or a list of classes; if a list
+    then classes will be created in the order you provide, and
+    destroyed in the opposite order.  So if class A depends on class
+    B, then do setupClass([B, A]) and B won't be destroyed or cleared
+    until after A is destroyed or cleared.
+
+    If force is true, then the database will be recreated no matter
+    what.
+    """
+    # global hub
+    if not isinstance(soClasses, (list, tuple)):
+        soClasses = [soClasses]
+    connection = getConnection()
+    for soClass in soClasses:
+        # This would be an alternate way to register connections:
+        # try:
+        #    hub
+        # except NameError:
+        #    hub = sqlobject.dbconnection.ConnectionHub()
+        # soClass._connection = hub
+        # hub.threadConnection = connection
+        # hub.processConnection = connection
+        soClass._connection = connection
+    installOrClear(soClasses, force=force)
+    return soClasses
+
+
+def speedupSQLiteConnection(connection):
+    connection.query("PRAGMA synchronous=OFF")
+    connection.query("PRAGMA count_changes=OFF")
+    connection.query("PRAGMA journal_mode=MEMORY")
+    connection.query("PRAGMA temp_store=MEMORY")
+
+installedDBFilename = os.path.join(getcwd(), 'dbs_data.tmp')
+
+installedDBTracker = sqlobject.connectionForURI(
+    'sqlite:///' + installedDBFilename)
+speedupSQLiteConnection(installedDBTracker)
+
+
+def getConnection(**kw):
+    name = getConnectionURI()
+    conn = sqlobject.connectionForURI(name, **kw)
+    if conftest.option.show_sql:
+        conn.debug = True
+    if conftest.option.show_sql_output:
+        conn.debugOutput = True
+    if (conn.dbName == 'postgres') and (conn.driver == 'pg8000') \
+            and conn._pool is not None:
+        conn._pool = None
+    if (conn.dbName == 'sqlite') and not conn._memory:
+        speedupSQLiteConnection(conn)
+    return conn
+
+
+def getConnectionURI():
+    name = conftest.option.Database
+    if name in conftest.connectionShortcuts:
+        name = conftest.connectionShortcuts[name]
+    return name
+
+try:
+    connection = getConnection()
+except Exception as e:
+    # At least this module should be importable...
+    # The module was imported during documentation building
+    if 'sphinx' not in sys.modules:
+        print("Could not open database: %s" % e, file=sys.stderr)
+else:
+    if (connection.dbName == 'firebird'):
+        use_microseconds(False)
+
+
+class InstalledTestDatabase(sqlobject.SQLObject):
+    """
+    This table is set up in SQLite (always, regardless of --Database) and
+    tracks what tables have been set up in the 'real' database.  This
+    way we don't keep recreating the tables over and over when there
+    are multiple tests that use a table.
+    """
+
+    _connection = installedDBTracker
+    table_name = sqlobject.StringCol(notNull=True)
+    createSQL = sqlobject.StringCol(notNull=True)
+    connectionURI = sqlobject.StringCol(notNull=True)
+
+    @classmethod
+    def installOrClear(cls, soClasses, force=False):
+        cls.setup()
+        reversed = list(soClasses)[:]
+        reversed.reverse()
+        # If anything needs to be dropped, they all must be dropped
+        # But if we're forcing it, then we'll always drop
+        if force:
+            any_drops = True
+        else:
+            any_drops = False
+        for soClass in reversed:
+            table = soClass.sqlmeta.table
+            if not soClass._connection.tableExists(table):
+                continue
+            items = list(cls.selectBy(
+                table_name=table,
+                connectionURI=soClass._connection.uri()))
+            if items:
+                instance = items[0]
+                sql = instance.createSQL
+            else:
+                sql = None
+            newSQL, constraints = soClass.createTableSQL()
+            if sql != newSQL:
+                if sql is not None:
+                    instance.destroySelf()
+                any_drops = True
+                break
+        for soClass in reversed:
+            if soClass._connection.tableExists(soClass.sqlmeta.table):
+                if any_drops:
+                    cls.drop(soClass)
+                else:
+                    cls.clear(soClass)
+        for soClass in soClasses:
+            table = soClass.sqlmeta.table
+            if not soClass._connection.tableExists(table):
+                cls.install(soClass)
+
+    @classmethod
+    def install(cls, soClass):
+        """
+        Creates the given table in its database.
+        """
+        sql = getattr(soClass, soClass._connection.dbName + 'Create',
+                      None)
+        all_extra = []
+        if sql:
+            soClass._connection.query(sql)
+        else:
+            sql, extra_sql = soClass.createTableSQL()
+            soClass.createTable(applyConstraints=False)
+            all_extra.extend(extra_sql)
+        cls(table_name=soClass.sqlmeta.table,
+            createSQL=sql,
+            connectionURI=soClass._connection.uri())
+        for extra_sql in all_extra:
+            soClass._connection.query(extra_sql)
+
+    @classmethod
+    def drop(cls, soClass):
+        """
+        Drops a the given table from its database
+        """
+        sql = getattr(soClass, soClass._connection.dbName + 'Drop', None)
+        if sql:
+            soClass._connection.query(sql)
+        else:
+            soClass.dropTable()
+
+    @classmethod
+    def clear(cls, soClass):
+        """
+        Removes all the rows from a table.
+        """
+        soClass.clearTable()
+
+    @classmethod
+    def setup(cls):
+        """
+        This sets up *this* table.
+        """
+        if not cls._connection.tableExists(cls.sqlmeta.table):
+            cls.createTable()
+
+installOrClear = InstalledTestDatabase.installOrClear
+
+
+class Dummy(object):
+
+    """
+    Used for creating fake objects; a really poor 'mock object'.
+    """
+
+    def __init__(self, **kw):
+        for name, value in kw.items():
+            setattr(self, name, value)
+
+
+def inserts(cls, data, schema=None):
+    """
+    Creates a bunch of rows.
+
+    You can use it like::
+
+        inserts(Person, [{'fname': 'blah', 'lname': 'doe'}, ...])
+
+    Or::
+
+        inserts(Person, [('blah', 'doe')], schema=
+                ['fname', 'lname'])
+
+    If you give a single string for the `schema` then it'll split
+    that string to get the list of column names.
+    """
+    if schema:
+        if isinstance(schema, str):
+            schema = schema.split()
+        keywordData = []
+        for item in data:
+            itemDict = {}
+            for name, value in zip(schema, item):
+                itemDict[name] = value
+            keywordData.append(itemDict)
+        data = keywordData
+    results = []
+    for args in data:
+        results.append(cls(**args))
+    return results
+
+
+def supports(feature):
+    dbName = connection.dbName
+    support = supportsMatrix.get('+' + feature, None)
+    notSupport = supportsMatrix.get('-' + feature, None)
+    if support is not None and dbName in support.split():
+        return True
+    elif support:
+        return False
+    if notSupport is not None and dbName in notSupport.split():
+        return False
+    elif notSupport:
+        return True
+    assert notSupport is not None or support is not None, (
+        "The supportMatrix does not list this feature: %r"
+        % feature)
+
+
+# To avoid name clashes:
+_inserts = inserts
+
+
+def setSQLiteConnectionFactory(TableClass, factory):
+    from sqlobject.sqlite.sqliteconnection import SQLiteConnection
+    conn = TableClass._connection
+    TableClass._connection = SQLiteConnection(
+        filename=conn.filename,
+        name=conn.name, debug=conn.debug, debugOutput=conn.debugOutput,
+        cache=conn.cache, style=conn.style, autoCommit=conn.autoCommit,
+        debugThreading=conn.debugThreading, registry=conn.registry,
+        factory=factory
+    )
+    speedupSQLiteConnection(TableClass._connection)
+    installOrClear([TableClass])
+
+
+def deprecated_module():
+    sqlobject.main.warnings_level = None
+    sqlobject.main.exception_level = None
+
+
+def setup_module(mod):
+    # modules with '_old' test backward compatible methods, so they
+    # don't get warnings or errors.
+    mod_name = str(mod.__name__)
+    if mod_name.endswith('/py'):
+        mod_name = mod_name[:-3]
+    if mod_name.endswith('_old'):
+        sqlobject.main.warnings_level = None
+        sqlobject.main.exception_level = None
+    else:
+        sqlobject.main.warnings_level = None
+        sqlobject.main.exception_level = 0
+
+
+def teardown_module(mod=None):
+    sqlobject.main.warnings_level = None
+    sqlobject.main.exception_level = 0
+
+
+def setupLogging():
+    fmt = '[%(asctime)s] %(name)s %(levelname)s: %(message)s'
+    formatter = logging.Formatter(fmt)
+    hdlr = logging.StreamHandler(sys.stderr)
+    hdlr.setFormatter(formatter)
+    hdlr.setLevel(logging.NOTSET)
+    logger = logging.getLogger()
+    logger.addHandler(hdlr)
+
+
+def setupCyclicClasses(*classes):
+    if not supports('dropTableCascade'):
+        skip("dropTableCascade isn't supported")
+    conn = getConnection()
+    for soClass in classes:
+        soClass.setConnection(conn)
+        soClass.dropTable(ifExists=True, cascade=True)
+
+    constraints = []
+    for soClass in classes:
+        constraints += soClass.createTable(ifNotExists=True,
+                                           applyConstraints=False)
+    for constraint in constraints:
+        conn.query(constraint)
+
+
+__all__ = ['Dummy', 'deprecated_module', 'getConnection', 'getConnectionURI',
+           'inserts', 'raises', 'setupClass', 'setupCyclicClasses',
+           'setupLogging', 'setup_module', 'supports', 'teardown_module',
+           ]

sqlobject/tests/test_ForeignKey.py

@@ -0,0 +1,133 @@
+from formencode import validators
+from sqlobject import ForeignKey, IntCol, SQLObject, StringCol
+from sqlobject.tests.dbtest import getConnection, InstalledTestDatabase, \
+    raises, setupClass, setupCyclicClasses
+
+
+class SOTestComposerKey(SQLObject):
+    name = StringCol()
+    id2 = IntCol(default=None, unique=True)
+
+
+class SOTestWorkKey(SQLObject):
+    class sqlmeta:
+        idName = "work_id"
+
+    composer = ForeignKey('SOTestComposerKey', cascade=True)
+    title = StringCol()
+
+
+class SOTestWorkKey2(SQLObject):
+    title = StringCol()
+
+
+class SOTestOtherColumn(SQLObject):
+    key1 = ForeignKey('SOTestComposerKey', default=None)
+    key2 = ForeignKey('SOTestComposerKey', refColumn='id2', default=None)
+
+
+def test1():
+    setupClass([SOTestComposerKey, SOTestWorkKey])
+
+    c = SOTestComposerKey(name='Mahler, Gustav')
+    w1 = SOTestWorkKey(composer=c, title='Symphony No. 9')
+    w2 = SOTestWorkKey(composer=None, title=None)
+
+    # Select by usual way
+    s = SOTestWorkKey.selectBy(composerID=c.id, title='Symphony No. 9')
+    assert s.count() == 1
+    assert s[0] == w1
+    # selectBy object.id
+    s = SOTestWorkKey.selectBy(composer=c.id, title='Symphony No. 9')
+    assert s.count() == 1
+    assert s[0] == w1
+    # selectBy object
+    s = SOTestWorkKey.selectBy(composer=c, title='Symphony No. 9')
+    assert s.count() == 1
+    assert s[0] == w1
+    # selectBy id
+    s = SOTestWorkKey.selectBy(id=w1.id)
+    assert s.count() == 1
+    assert s[0] == w1
+    # is None handled correctly?
+    s = SOTestWorkKey.selectBy(composer=None, title=None)
+    assert s.count() == 1
+    assert s[0] == w2
+
+    s = SOTestWorkKey.selectBy()
+    assert s.count() == 2
+
+    # select with objects
+    s = SOTestWorkKey.select(SOTestWorkKey.q.composerID == c.id)
+    assert s.count() == 1
+    assert s[0] == w1
+    s = SOTestWorkKey.select(SOTestWorkKey.q.composer == c.id)
+    assert s.count() == 1
+    assert s[0] == w1
+    s = SOTestWorkKey.select(SOTestWorkKey.q.composerID == c)
+    assert s.count() == 1
+    assert s[0] == w1
+    s = SOTestWorkKey.select(SOTestWorkKey.q.composer == c)
+    assert s.count() == 1
+    assert s[0] == w1
+    s = SOTestWorkKey.select(
+        (SOTestWorkKey.q.composer == c)
+        & (SOTestWorkKey.q.title == 'Symphony No. 9'))
+    assert s.count() == 1
+    assert s[0] == w1
+
+
+def test2():
+    SOTestWorkKey._connection = getConnection()
+    InstalledTestDatabase.drop(SOTestWorkKey)
+    setupClass([SOTestComposerKey, SOTestWorkKey2], force=True)
+    SOTestWorkKey2.sqlmeta.addColumn(ForeignKey('SOTestComposerKey'),
+                                     changeSchema=True)
+
+
+def test_otherColumn():
+    setupClass([SOTestComposerKey, SOTestOtherColumn])
+    test_composer1 = SOTestComposerKey(name='Test1')
+    test_composer2 = SOTestComposerKey(name='Test2', id2=2)
+    test_fkey = SOTestOtherColumn(key1=test_composer1)
+    test_other = SOTestOtherColumn(key2=test_composer2.id2)
+    getConnection().cache.clear()
+    assert test_fkey.key1 == test_composer1
+    assert test_other.key2 == test_composer2
+
+
+class SOTestFKValidationA(SQLObject):
+    name = StringCol()
+    bfk = ForeignKey("SOTestFKValidationB")
+    cfk = ForeignKey("SOTestFKValidationC", default=None)
+
+
+class SOTestFKValidationB(SQLObject):
+    name = StringCol()
+    afk = ForeignKey("SOTestFKValidationA")
+
+
+class SOTestFKValidationC(SQLObject):
+    class sqlmeta:
+        idType = str
+    name = StringCol()
+
+
+def test_foreignkey_validation():
+    setupCyclicClasses(SOTestFKValidationA, SOTestFKValidationB,
+                       SOTestFKValidationC)
+    a = SOTestFKValidationA(name="testa", bfk=None)
+    b = SOTestFKValidationB(name="testb", afk=a)
+    c = SOTestFKValidationC(id='testc', name="testc")
+    a.bfk = b
+    a.cfk = c
+    assert a.bfk == b
+    assert a.cfk == c
+    assert b.afk == a
+
+    raises(validators.Invalid,
+           SOTestFKValidationA, name="testa", bfk='testb', cfk='testc')
+
+    a = SOTestFKValidationA(name="testa", bfk=1, cfk='testc')
+    assert a.bfkID == 1
+    assert a.cfkID == 'testc'