sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_sqlbuilder_joins_instances.py

@@ -0,0 +1,90 @@
+from sqlobject import AND, ForeignKey, SQLMultipleJoin, SQLObject, \
+    SQLRelatedJoin, StringCol
+from sqlobject.tests.dbtest import inserts, setupClass
+
+# Testing for expressing join, foreign keys,
+# and instance identity in SQLBuilder expressions.
+
+
+class SBPerson(SQLObject):
+    name = StringCol()
+    addresses = SQLMultipleJoin('SBAddress', joinColumn='personID')
+    sharedAddresses = SQLRelatedJoin('SBAddress',
+                                     addRemoveName='SharedAddress')
+
+
+class SBAddress(SQLObject):
+    city = StringCol()
+    person = ForeignKey('SBPerson')
+    sharedPeople = SQLRelatedJoin('SBPerson')
+
+
+def setup_module(mod):
+    global ppl
+    setupClass([SBPerson, SBAddress])
+    ppl = inserts(SBPerson, [('James',), ('Julia',)], 'name')
+    adds = inserts(SBAddress, [('London', ppl[0].id),
+                               ('Chicago', ppl[1].id),
+                               ('Abu Dhabi', ppl[1].id)],
+                   'city personID')
+    ppl[0].addSharedAddress(adds[0])
+    ppl[0].addSharedAddress(adds[1])
+    ppl[1].addSharedAddress(adds[0])
+
+
+def testJoin():
+    assert list(SBPerson.select(
+        AND(SBPerson.q.id == SBAddress.q.personID,
+            SBAddress.q.city == 'London'))) == \
+        list(SBAddress.selectBy(city='London').throughTo.person)
+
+    assert list(SBAddress.select(
+        AND(SBPerson.q.id == SBAddress.q.personID,
+            SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \
+        list(SBPerson.selectBy(name='Julia').
+             throughTo.addresses.orderBy(SBAddress.q.city))
+
+
+def testRelatedJoin():
+    assert list(SBPerson.selectBy(name='Julia').throughTo.sharedAddresses) == \
+        list(ppl[1].sharedAddresses)
+
+
+def testInstance():
+    assert list(SBAddress.select(
+        AND(SBPerson.q.id == SBAddress.q.personID, SBPerson.q.id == ppl[0].id)
+    )) == list(ppl[0].addresses)
+
+
+def testFK():
+    assert list(SBPerson.select(
+        AND(SBAddress.j.person, SBAddress.q.city == 'London'))) == \
+        list(SBPerson.select(
+            AND(SBPerson.q.id == SBAddress.q.personID,
+                SBAddress.q.city == 'London')))
+
+
+def testRelatedJoin2():
+    assert list(SBAddress.select(
+        AND(SBAddress.j.sharedPeople, SBPerson.q.name == 'Julia'))) == \
+        list(SBPerson.select(
+             SBPerson.q.name == 'Julia').throughTo.sharedAddresses)
+
+
+def testJoin2():
+    assert list(SBAddress.select(
+        AND(SBPerson.j.addresses,
+            SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \
+        list(SBAddress.select(
+            AND(SBPerson.q.id == SBAddress.q.personID,
+                SBPerson.q.name == 'Julia')).orderBy(SBAddress.q.city)) == \
+        list(SBPerson.selectBy(name='Julia').throughTo.
+             addresses.orderBy(SBAddress.q.city))
+
+
+def testFK2():
+    assert list(SBAddress.select(
+        AND(SBAddress.j.person, SBPerson.q.name == 'Julia'))) == \
+        list(SBAddress.select(
+            AND(SBPerson.q.id == SBAddress.q.personID,
+                SBPerson.q.name == 'Julia')))

sqlobject/tests/test_sqlite.py

@@ -0,0 +1,160 @@
+import math
+import threading
+import pytest
+from sqlobject import SQLObject, StringCol, FloatCol
+from sqlobject.compat import string_type
+from sqlobject.sqlbuilder import Select
+from sqlobject.tests.dbtest import getConnection, setupClass, supports
+from sqlobject.tests.dbtest import setSQLiteConnectionFactory
+from .test_basic import SOTestSO1
+
+
+try:
+    connection = getConnection()
+except (AttributeError, NameError):
+    # The module was imported during documentation building
+    pass
+else:
+    if connection.dbName != "sqlite":
+        pytestmark = pytest.mark.skip("These tests require SQLite")
+
+
+class SQLiteFactoryTest(SQLObject):
+    name = StringCol()
+
+
+def test_sqlite_factory():
+    setupClass(SQLiteFactoryTest)
+    factory = [None]
+
+    def SQLiteConnectionFactory(sqlite):
+        class MyConnection(sqlite.Connection):
+            pass
+        factory[0] = MyConnection
+        return MyConnection
+
+    setSQLiteConnectionFactory(SQLiteFactoryTest, SQLiteConnectionFactory)
+
+    conn = SQLiteFactoryTest._connection.makeConnection()
+    assert factory[0]
+    assert isinstance(conn, factory[0])
+
+
+def test_sqlite_factory_str():
+    setupClass(SQLiteFactoryTest)
+    factory = [None]
+
+    def SQLiteConnectionFactory(sqlite):
+        class MyConnection(sqlite.Connection):
+            pass
+        factory[0] = MyConnection
+        return MyConnection
+
+    from sqlobject.sqlite import sqliteconnection
+    sqliteconnection.SQLiteConnectionFactory = SQLiteConnectionFactory
+
+    setSQLiteConnectionFactory(SQLiteFactoryTest, "SQLiteConnectionFactory")
+
+    conn = SQLiteFactoryTest._connection.makeConnection()
+    assert factory[0]
+    assert isinstance(conn, factory[0])
+    del sqliteconnection.SQLiteConnectionFactory
+
+
+def test_sqlite_aggregate():
+    setupClass(SQLiteFactoryTest)
+
+    def SQLiteConnectionFactory(sqlite):
+        class MyConnection(sqlite.Connection):
+            def __init__(self, *args, **kwargs):
+                super(MyConnection, self).__init__(*args, **kwargs)
+                self.create_aggregate("group_concat", 1, self.group_concat)
+
+            class group_concat:
+                def __init__(self):
+                    self.acc = []
+
+                def step(self, value):
+                    if isinstance(value, string_type):
+                        self.acc.append(value)
+                    else:
+                        self.acc.append(str(value))
+
+                def finalize(self):
+                    self.acc.sort()
+                    return ", ".join(self.acc)
+
+        return MyConnection
+
+    setSQLiteConnectionFactory(SQLiteFactoryTest, SQLiteConnectionFactory)
+
+    SQLiteFactoryTest(name='sqlobject')
+    SQLiteFactoryTest(name='sqlbuilder')
+    assert SQLiteFactoryTest.select(orderBy="name").\
+        accumulateOne("group_concat", "name") == \
+        "sqlbuilder, sqlobject"
+
+
+def do_select():
+    list(SOTestSO1.select())
+
+
+def test_sqlite_threaded():
+    setupClass(SOTestSO1)
+    t = threading.Thread(target=do_select)
+    t.start()
+    t.join()
+    # This should reuse the same connection as the connection
+    # made above (at least will with most database drivers, but
+    # this will cause an error in SQLite):
+    do_select()
+
+
+def test_empty_string():
+    setupClass(SOTestSO1)
+    test = SOTestSO1(name=None, passwd='')
+    assert test.name is None
+    assert test.passwd == ''
+
+
+def test_memorydb():
+    if not supports("memorydb"):
+        pytest.skip("memorydb isn't supported")
+    if not connection._memory:
+        pytest.skip("The connection isn't memorydb")
+    setupClass(SOTestSO1)
+    connection.close()  # create a new connection to an in-memory database
+    SOTestSO1.setConnection(connection)
+    SOTestSO1.createTable()
+
+
+def test_list_databases():
+    assert 'main' in connection.listDatabases()
+
+
+def test_list_tables():
+    setupClass(SOTestSO1)
+    assert SOTestSO1.sqlmeta.table in connection.listTables()
+
+
+class SQLiteTruedivTest(SQLObject):
+    value = FloatCol()
+
+
+def test_truediv():
+    setupClass(SQLiteTruedivTest)
+
+    if SQLiteTruedivTest._connection.dbName == "sqlite":
+        def SQLiteConnectionFactory(sqlite):
+            class MyConnection(sqlite.Connection):
+                def __init__(self, *args, **kwargs):
+                    super(MyConnection, self).__init__(*args, **kwargs)
+                    self.create_function("floor", 1, math.floor)
+            return MyConnection
+
+        setSQLiteConnectionFactory(SQLiteTruedivTest, SQLiteConnectionFactory)
+
+    SQLiteTruedivTest(value=-5.0)
+    assert SQLiteTruedivTest._connection.queryAll(
+        SQLiteTruedivTest._connection.sqlrepr(
+            Select(SQLiteTruedivTest.q.value // 4)))[0][0] == -2

sqlobject/tests/test_sqlmeta_idName.py

@@ -0,0 +1,52 @@
+from sqlobject import MixedCaseStyle, SQLObject, sqlmeta
+from sqlobject.tests.dbtest import setupClass
+
+
+class myid_sqlmeta(sqlmeta):
+    idName = "my_id"
+
+
+class SOTestSqlmeta1(SQLObject):
+    class sqlmeta(myid_sqlmeta):
+        pass
+
+
+class SOTestSqlmeta2(SQLObject):
+    class sqlmeta(sqlmeta):
+        style = MixedCaseStyle(longID=True)
+
+
+class SOTestSqlmeta3(SQLObject):
+    class sqlmeta(myid_sqlmeta):
+        style = MixedCaseStyle(longID=True)
+
+
+class SOTestSqlmeta4(SQLObject):
+    class sqlmeta(myid_sqlmeta):
+        idName = None
+        style = MixedCaseStyle(longID=True)
+
+
+class longid_sqlmeta(sqlmeta):
+    idName = "my_id"
+    style = MixedCaseStyle(longID=True)
+
+
+class SOTestSqlmeta5(SQLObject):
+    class sqlmeta(longid_sqlmeta):
+        pass
+
+
+class SOTestSqlmeta6(SQLObject):
+    class sqlmeta(longid_sqlmeta):
+        idName = None
+
+
+def test_sqlmeta_inherited_idName():
+    setupClass([SOTestSqlmeta1, SOTestSqlmeta2])
+    assert SOTestSqlmeta1.sqlmeta.idName == "my_id"
+    assert SOTestSqlmeta2.sqlmeta.idName == "SOTestSqlmeta2ID"
+    assert SOTestSqlmeta3.sqlmeta.idName == "my_id"
+    assert SOTestSqlmeta4.sqlmeta.idName == "SOTestSqlmeta4ID"
+    assert SOTestSqlmeta5.sqlmeta.idName == "my_id"
+    assert SOTestSqlmeta6.sqlmeta.idName == "SOTestSqlmeta6ID"

sqlobject/tests/test_sqlobject_admin.py

@@ -0,0 +1,38 @@
+# These tests are not enabled yet, but here are some working examples
+# of using createSQL so far.
+
+from sqlobject import SQLObject, StringCol
+
+
+class SOTest1(SQLObject):
+    class sqlmeta:
+        createSQL = "CREATE SEQUENCE db_test1_seq;"
+    test1 = StringCol()
+
+
+class SOTest2(SQLObject):
+    class sqlmeta:
+        createSQL = ["CREATE SEQUENCE db_test2_seq;",
+                     "ALTER TABLE test2 ADD CHECK(test2 != '');"]
+    test2 = StringCol()
+
+
+class SOTest3(SQLObject):
+    class sqlmeta:
+        createSQL = {'postgres': 'CREATE SEQUENCE db_test3_seq;',
+                     'mysql': 'CREATE SEQUENCE db_test3_seq;'}
+    test3 = StringCol()
+
+
+class SOTest4(SQLObject):
+    class sqlmeta:
+        createSQL = {'postgres': ['CREATE SEQUENCE db_test4_seq;',
+                                  "ALTER TABLE test4 ADD CHECK(test4 != '');"],
+                     'mysql': 'CREATE SEQUENCE db_test4_seq;'}
+    test4 = StringCol()
+
+
+class SOTest5(SQLObject):
+    class sqlmeta:
+        createSQL = {'mysql': 'CREATE SEQUENCE db_test5_seq;'}
+    test5 = StringCol()

sqlobject/tests/test_string_id.py

@@ -0,0 +1,79 @@
+from sqlobject import SQLObject, StringCol, sqlmeta
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# String ID test
+########################################
+
+
+class SOStringID(SQLObject):
+
+    class sqlmeta(sqlmeta):
+        table = 'so_string_id'
+        idType = str
+    val = StringCol(alternateID=True)
+
+    mysqlCreate = """
+    CREATE TABLE IF NOT EXISTS so_string_id (
+      id VARCHAR(50) PRIMARY KEY,
+      val TEXT
+    )
+    """
+
+    postgresCreate = """
+    CREATE TABLE so_string_id (
+      id VARCHAR(50) PRIMARY KEY,
+      val TEXT
+    )
+    """
+
+    sybaseCreate = """
+    CREATE TABLE so_string_id (
+      id VARCHAR(50) UNIQUE,
+      val VARCHAR(50) NULL
+    )
+    """
+
+    firebirdCreate = """
+    CREATE TABLE so_string_id (
+      id VARCHAR(50) NOT NULL PRIMARY KEY,
+      val BLOB SUB_TYPE TEXT
+    )
+    """
+
+    mssqlCreate = """
+    CREATE TABLE so_string_id (
+      id VARCHAR(50) PRIMARY KEY,
+      val varchar(4000)
+    )
+    """
+
+    sqliteCreate = postgresCreate
+
+    mysqlDrop = """
+    DROP TABLE IF EXISTS so_string_id
+    """
+
+    postgresDrop = """
+    DROP TABLE so_string_id
+    """
+
+    sqliteDrop = postgresDrop
+    firebirdDrop = postgresDrop
+    mssqlDrop = postgresDrop
+
+
+def test_stringID():
+    setupClass(SOStringID)
+    t1 = SOStringID(id='hey', val='whatever')
+    t2 = SOStringID.byVal('whatever')
+    assert t1 == t2
+    assert t1.val == t2.val
+    assert t1.val == 'whatever'
+
+    t1 = SOStringID(id='you', val='nowhere')
+    t2 = SOStringID.get('you')
+    assert t1 == t2
+    assert t1.val == t2.val
+    assert t1.val == 'nowhere'

sqlobject/tests/test_style.py

@@ -0,0 +1,36 @@
+from sqlobject import ForeignKey, SQLObject, StringCol, sqlmeta, styles
+from sqlobject.tests.dbtest import setupClass
+
+
+class AnotherStyle(styles.MixedCaseUnderscoreStyle):
+    def pythonAttrToDBColumn(self, attr):
+        if attr.lower().endswith('id'):
+            return 'id' + styles.MixedCaseUnderscoreStyle.\
+                pythonAttrToDBColumn(self, attr[:-2])
+        else:
+            return styles.MixedCaseUnderscoreStyle.\
+                pythonAttrToDBColumn(self, attr)
+
+
+class SOStyleTest1(SQLObject):
+    a = StringCol()
+    st2 = ForeignKey('SOStyleTest2')
+
+    class sqlmeta(sqlmeta):
+        style = AnotherStyle()
+
+
+class SOStyleTest2(SQLObject):
+    b = StringCol()
+
+    class sqlmeta(sqlmeta):
+        style = AnotherStyle()
+
+
+def test_style():
+    setupClass([SOStyleTest2, SOStyleTest1])
+    st1 = SOStyleTest1(a='something', st2=None)
+    st2 = SOStyleTest2(b='whatever')
+    st1.st2 = st2
+    assert st1.sqlmeta.columns['st2ID'].dbName == 'idst2'
+    assert st1.st2 == st2

sqlobject/tests/test_subqueries.py

@@ -0,0 +1,142 @@
+from sqlobject import ForeignKey, SQLObject, StringCol
+from sqlobject.sqlbuilder import EXISTS, IN, LEFTOUTERJOINOn, NOTEXISTS, \
+    Outer, Select
+from sqlobject.tests.dbtest import setupClass
+
+
+########################################
+# Subqueries (subselects)
+########################################
+
+
+class SOTestIn1(SQLObject):
+    col1 = StringCol()
+
+
+class SOTestIn2(SQLObject):
+    col2 = StringCol()
+
+
+class SOTestOuter(SQLObject):
+    fk = ForeignKey('SOTestIn1')
+
+
+def setup():
+    setupClass(SOTestIn1)
+    setupClass(SOTestIn2)
+
+
+def insert():
+    setup()
+    SOTestIn1(col1=None)
+    SOTestIn1(col1='')
+    SOTestIn1(col1="test")
+    SOTestIn2(col2=None)
+    SOTestIn2(col2='')
+    SOTestIn2(col2="test")
+
+
+def test_1syntax_in():
+    setup()
+    select = SOTestIn1.select(IN(SOTestIn1.q.col1, Select(SOTestIn2.q.col2)))
+    assert str(select) == \
+        "SELECT so_test_in1.id, so_test_in1.col1 " \
+        "FROM so_test_in1 WHERE so_test_in1.col1 IN " \
+        "(SELECT so_test_in2.col2 FROM so_test_in2)"
+
+    select = SOTestIn1.select(IN(SOTestIn1.q.col1, SOTestIn2.select()))
+    assert str(select) == \
+        "SELECT so_test_in1.id, so_test_in1.col1 " \
+        "FROM so_test_in1 WHERE so_test_in1.col1 IN " \
+        "(SELECT so_test_in2.id FROM so_test_in2 WHERE 1 = 1)"
+
+
+def test_2perform_in():
+    insert()
+    select = SOTestIn1.select(IN(SOTestIn1.q.col1, Select(SOTestIn2.q.col2)))
+    assert select.count() == 2
+
+
+def test_3syntax_exists():
+    setup()
+    select = SOTestIn1.select(NOTEXISTS(
+        Select(SOTestIn2.q.col2,
+               where=(Outer(SOTestIn1).q.col1 == SOTestIn2.q.col2))))
+    assert str(select) == \
+        "SELECT so_test_in1.id, so_test_in1.col1 " \
+        "FROM so_test_in1 WHERE NOT EXISTS " \
+        "(SELECT so_test_in2.col2 FROM so_test_in2 " \
+        "WHERE ((so_test_in1.col1) = (so_test_in2.col2)))"
+
+    setupClass(SOTestOuter)
+    select = SOTestOuter.select(NOTEXISTS(
+        Select(SOTestIn1.q.col1,
+               where=(Outer(SOTestOuter).q.fk == SOTestIn1.q.id))))
+    assert str(select) == \
+        "SELECT so_test_outer.id, so_test_outer.fk_id " \
+        "FROM so_test_outer WHERE NOT EXISTS " \
+        "(SELECT so_test_in1.col1 FROM so_test_in1 " \
+        "WHERE ((so_test_outer.fk_id) = (so_test_in1.id)))"
+
+
+def test_4perform_exists():
+    insert()
+    select = SOTestIn1.select(EXISTS(
+        Select(SOTestIn2.q.col2,
+               where=(Outer(SOTestIn1).q.col1 == SOTestIn2.q.col2))))
+    assert len(list(select)) == 2
+
+    setupClass(SOTestOuter)
+    select = SOTestOuter.select(NOTEXISTS(
+        Select(SOTestIn1.q.col1,
+               where=(Outer(SOTestOuter).q.fkID == SOTestIn1.q.id))))
+    assert len(list(select)) == 0
+
+
+def test_4syntax_direct():
+    setup()
+    select = SOTestIn1.select(SOTestIn1.q.col1 == Select(SOTestIn2.q.col2,
+                              where=(SOTestIn2.q.col2 == "test")))
+    assert str(select) == \
+        "SELECT so_test_in1.id, so_test_in1.col1 " \
+        "FROM so_test_in1 WHERE ((so_test_in1.col1) = " \
+        "(SELECT so_test_in2.col2 FROM so_test_in2 " \
+        "WHERE ((so_test_in2.col2) = ('test'))))"
+
+
+def test_4perform_direct():
+    insert()
+    select = SOTestIn1.select(SOTestIn1.q.col1 == Select(SOTestIn2.q.col2,
+                              where=(SOTestIn2.q.col2 == "test")))
+    assert select.count() == 1
+
+
+def test_5perform_direct():
+    insert()
+    select = SOTestIn1.select(SOTestIn1.q.col1 == Select(SOTestIn2.q.col2,
+                              where=(SOTestIn2.q.col2 == "test")))
+    assert select.count() == 1
+
+
+def test_6syntax_join():
+    insert()
+    j = LEFTOUTERJOINOn(SOTestIn2, SOTestIn1,
+                        SOTestIn1.q.col1 == SOTestIn2.q.col2)
+    select = SOTestIn1.select(SOTestIn1.q.col1 == Select(SOTestIn2.q.col2,
+                              where=(SOTestIn2.q.col2 == "test"), join=j))
+    assert str(select) == \
+        "SELECT so_test_in1.id, so_test_in1.col1 " \
+        "FROM so_test_in1 WHERE ((so_test_in1.col1) = " \
+        "(SELECT so_test_in2.col2 FROM so_test_in2 " \
+        "LEFT OUTER JOIN so_test_in1 ON " \
+        "((so_test_in1.col1) = (so_test_in2.col2)) " \
+        "WHERE ((so_test_in2.col2) = ('test'))))"
+
+
+def test_6perform_join():
+    insert()
+    j = LEFTOUTERJOINOn(SOTestIn2, SOTestIn1,
+                        SOTestIn1.q.col1 == SOTestIn2.q.col2)
+    select = SOTestIn1.select(SOTestIn1.q.col1 == Select(SOTestIn2.q.col2,
+                              where=(SOTestIn2.q.col2 == "test"), join=j))
+    assert select.count() == 1