sqlobject 3.13.1__py2.py3-none-any.whl

sqlobject/tests/test_select.py

@@ -0,0 +1,218 @@
+import pytest
+from sqlobject import IntCol, LIKE, RLIKE, SQLObject, \
+    SQLObjectIntegrityError, SQLObjectNotFound, StringCol
+from sqlobject.sqlbuilder import func
+from .dbtest import raises, setupClass, supports, setSQLiteConnectionFactory
+
+
+class IterTest(SQLObject):
+    name = StringCol(dbName='name_col', length=200)
+
+
+names = ('a', 'b', 'c')
+
+
+def setupIter():
+    setupClass(IterTest)
+    for n in names:
+        IterTest(name=n)
+
+
+def test_00_normal():
+    setupIter()
+    count = 0
+    for test in IterTest.select():
+        count += 1
+    assert count == len(names)
+
+
+def test_00b_lazy():
+    setupIter()
+    count = 0
+    for test in IterTest.select(lazyColumns=True):
+        count += 1
+    assert count == len(names)
+
+
+def test_01_turn_to_list():
+    count = 0
+    for test in list(IterTest.select()):
+        count += 1
+    assert count == len(names)
+
+
+def test_02_generator():
+    all = IterTest.select()
+    count = 0
+    for i, test in enumerate(all):
+        count += 1
+    assert count == len(names)
+
+
+def test_03_ranged_indexed():
+    all = IterTest.select()
+    count = 0
+    for i in range(all.count()):
+        all[i]  # test it's there
+        count += 1
+    assert count == len(names)
+
+
+def test_04_indexed_ended_by_exception():
+    if not supports('limitSelect'):
+        pytest.skip("limitSelect isn't supported")
+    all = IterTest.select()
+    count = 0
+    try:
+        while 1:
+            all[count]
+            count += 1
+            # Stop the test if it's gone on too long
+            if count > len(names):
+                break
+    except IndexError:
+        pass
+    assert count == len(names)
+
+
+def test_05_select_limit():
+    setupIter()
+    assert len(list(IterTest.select(limit=2))) == 2
+    raises(AssertionError, IterTest.select(limit=2).count)
+
+
+def test_06_contains():
+    setupIter()
+    assert len(list(IterTest.select(IterTest.q.name.startswith('a')))) == 1
+    assert len(list(IterTest.select(IterTest.q.name.contains('a')))) == 1
+    assert len(list(IterTest.select(
+        IterTest.q.name.contains(func.lower('A'))))) == 1
+    assert len(list(IterTest.select(IterTest.q.name.contains("a'b")))) == 0
+    assert len(list(IterTest.select(IterTest.q.name.endswith('a')))) == 1
+
+
+def test_07_contains_special():
+    setupClass(IterTest)
+    a = IterTest(name='\\test')
+    b = IterTest(name='100%')
+    c = IterTest(name='test_')
+    assert list(IterTest.select(IterTest.q.name.startswith('\\'))) == [a]
+    assert list(IterTest.select(IterTest.q.name.contains('%'))) == [b]
+    assert list(IterTest.select(IterTest.q.name.endswith('_'))) == [c]
+
+
+def test_select_getOne():
+    setupClass(IterTest)
+    a = IterTest(name='a')
+    b = IterTest(name='b')
+    assert IterTest.selectBy(name='a').getOne() == a
+    assert IterTest.select(IterTest.q.name == 'b').getOne() == b
+    assert IterTest.selectBy(name='c').getOne(None) is None
+    raises(SQLObjectNotFound, IterTest.selectBy(name="c").getOne)
+    IterTest(name='b')
+    raises(SQLObjectIntegrityError, IterTest.selectBy(name="b").getOne)
+    raises(SQLObjectIntegrityError, IterTest.selectBy(name="b").getOne, None)
+
+
+def test_selectBy():
+    setupClass(IterTest)
+    IterTest(name='a')
+    IterTest(name='b')
+    assert IterTest.selectBy().count() == 2
+
+
+def test_selectBy_kwargs():
+    setupClass(IterTest)
+    raises(TypeError, IterTest, nonexistant='b')
+
+
+class UniqTest(SQLObject):
+    name = StringCol(dbName='name_col', unique=True, length=100)
+
+
+def test_by_uniq():
+    setupClass(UniqTest)
+    a = UniqTest(name='a')
+    b = UniqTest(name='b')
+    assert UniqTest.byName('a') is a
+    assert UniqTest.byName('b') is b
+
+
+class Counter2(SQLObject):
+
+    n1 = IntCol(notNull=True)
+    n2 = IntCol(notNull=True)
+
+
+class TestSelect:
+
+    def setup_method(self, meth):
+        setupClass(Counter2)
+        for i in range(10):
+            for j in range(10):
+                Counter2(n1=i, n2=j)
+
+    def counterEqual(self, counters, value):
+        assert [(c.n1, c.n2) for c in counters] == value
+
+    def accumulateEqual(self, func, counters, value):
+        assert func([c.n1 for c in counters]) == value
+
+    def test_1(self):
+        self.accumulateEqual(sum, Counter2.select(orderBy='n1'),
+                             sum(range(10)) * 10)
+
+    def test_2(self):
+        self.accumulateEqual(len, Counter2.select('all'), 100)
+
+
+def test_select_LIKE():
+    setupClass(IterTest)
+    IterTest(name='sqlobject')
+    IterTest(name='sqlbuilder')
+    assert IterTest.select(LIKE(IterTest.q.name, "sql%")).count() == 2
+    assert IterTest.select(LIKE(IterTest.q.name, "sqlb%")).count() == 1
+    assert IterTest.select(LIKE(IterTest.q.name, "sqlb%")).count() == 1
+    assert IterTest.select(LIKE(IterTest.q.name, "sqlx%")).count() == 0
+
+
+def test_select_RLIKE():
+    if not supports('rlike'):
+        pytest.skip("rlike isn't supported")
+
+    setupClass(IterTest)
+
+    if IterTest._connection.dbName == "sqlite":
+        # Implement regexp() function for SQLite
+        import re
+
+        def regexp(regexp, test):
+            return bool(re.search(regexp, test))
+
+        def SQLiteConnectionFactory(sqlite):
+            class MyConnection(sqlite.Connection):
+                def __init__(self, *args, **kwargs):
+                    super(MyConnection, self).__init__(*args, **kwargs)
+                    self.create_function("regexp", 2, regexp)
+            return MyConnection
+
+        setSQLiteConnectionFactory(IterTest, SQLiteConnectionFactory)
+
+    IterTest(name='sqlobject')
+    IterTest(name='sqlbuilder')
+    assert IterTest.select(RLIKE(IterTest.q.name, "^sql.*$")).count() == 2
+    assert IterTest.select(RLIKE(IterTest.q.name, "^sqlb.*$")).count() == 1
+    assert IterTest.select(RLIKE(IterTest.q.name, "^sqlb.*$")).count() == 1
+    assert IterTest.select(RLIKE(IterTest.q.name, "^sqlx.*$")).count() == 0
+
+
+def test_select_sqlbuilder():
+    setupClass(IterTest)
+    IterTest(name='sqlobject')
+    IterTest.select(IterTest.q.name == u'sqlobject')
+
+
+def test_select_perConnection():
+    setupClass(IterTest)
+    IterTest(name='a')
+    assert not IterTest.select().getOne().sqlmeta._perConnection

sqlobject/tests/test_select_through.py

@@ -0,0 +1,63 @@
+import pytest
+from sqlobject import ForeignKey, SQLMultipleJoin, SQLObject, SQLRelatedJoin, \
+    StringCol
+from sqlobject.tests.dbtest import inserts, setupClass
+
+
+# Tests retrieving objects through a join/fk on a selectResults
+
+
+class SRThrough1(SQLObject):
+    three = ForeignKey('SRThrough3')
+    twos = SQLMultipleJoin('SRThrough2', joinColumn='oneID')
+
+
+class SRThrough2(SQLObject):
+    one = ForeignKey('SRThrough1')
+    threes = SQLRelatedJoin('SRThrough3', addRemoveName='Three')
+
+
+class SRThrough3(SQLObject):
+    name = StringCol()
+    ones = SQLMultipleJoin('SRThrough1', joinColumn='threeID')
+    twos = SQLRelatedJoin('SRThrough2')
+
+
+def setup_module(mod):
+    global ones, twos, threes
+    setupClass([SRThrough3, SRThrough1, SRThrough2])
+    threes = inserts(SRThrough3,
+                     [('a',), ('b',), ('c',)],
+                     'name')
+    ones = inserts(SRThrough1,
+                   [(threes[0].id,), (threes[0].id,), (threes[2].id,)],
+                   'threeID')
+    twos = inserts(SRThrough2,
+                   [(ones[0].id,), (ones[1].id,), (ones[2].id,)],
+                   'oneID')
+    twos[0].addThree(threes[0])
+    twos[0].addThree(threes[1])
+
+
+def testBadRef():
+    with pytest.raises(AttributeError):
+        threes[0].throughTo.four
+
+
+def testThroughFK():
+    assert list(threes[0].ones.throughTo.three) == [threes[0]]
+
+
+def testThroughMultipleJoin():
+    assert list(threes[0].ones.throughTo.twos) == [twos[0], twos[1]]
+
+
+def testThroughRelatedJoin():
+    assert list(threes[0].twos.throughTo.threes) == [threes[0], threes[1]]
+    assert list(
+        SRThrough3.select(SRThrough3.q.id == threes[0].id).throughTo.twos) == \
+        list(threes[0].twos)
+
+
+def testThroughFKAndJoin():
+    assert list(threes[0].ones.throughTo.three.throughTo.twos) == [twos[0]]

sqlobject/tests/test_setters.py

@@ -0,0 +1,23 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.tests.dbtest import setupClass
+
+
+class SOTestSetters(SQLObject):
+    firstName = StringCol(length=50, dbName='fname_col', default=None)
+    lastName = StringCol(length=50, dbName='lname_col', default=None)
+
+    def _set_name(self, v):
+        firstName, lastName = v.split()
+        self.firstName = firstName
+        self.lastName = lastName
+
+    def _get_name(self):
+        return "%s %s" % (self.firstName, self.lastName)
+
+
+def test_create():
+    setupClass(SOTestSetters)
+    t = SOTestSetters(name='John Doe')
+    assert t.firstName == 'John'
+    assert t.lastName == 'Doe'
+    assert t.name == 'John Doe'

sqlobject/tests/test_slice.py

@@ -0,0 +1,59 @@
+import pytest
+from sqlobject import IntCol, SQLObject
+from sqlobject.tests.dbtest import setupClass, supports
+
+
+########################################
+# Slicing tests
+########################################
+
+
+def listrange(*args):
+    """Always return a list, for py3k compatibility"""
+    return list(range(*args))
+
+
+class Counter(SQLObject):
+
+    number = IntCol(notNull=True)
+
+
+class TestSlice:
+
+    def setup_method(self, meth):
+        setupClass(Counter)
+        for i in range(100):
+            Counter(number=i)
+
+    def counterEqual(self, counters, value):
+        if not supports('limitSelect'):
+            pytest.skip("limitSelect isn't supported")
+        assert [c.number for c in counters] == value
+
+    def test_slice(self):
+        self.counterEqual(
+            Counter.select(None, orderBy='number'), listrange(100))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='number')[10:20],
+            listrange(10, 20))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='number')[20:30][:5],
+            listrange(20, 25))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='number')[20:30][1:5],
+            listrange(21, 25))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='number')[:-10],
+            listrange(0, 90))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='number', reversed=True),
+            listrange(99, -1, -1))
+
+        self.counterEqual(
+            Counter.select(None, orderBy='-number'),
+            listrange(99, -1, -1))

sqlobject/tests/test_sorting.py

@@ -0,0 +1,80 @@
+from sqlobject import DESC, SQLObject, StringCol, sqlmeta
+from sqlobject.tests.dbtest import inserts, setupClass
+
+
+class Names(SQLObject):
+
+    class sqlmeta(sqlmeta):
+        table = 'names_table'
+        defaultOrder = ['lastName', 'firstName']
+
+    firstName = StringCol(length=30)
+    lastName = StringCol(length=30)
+
+
+def setupNames():
+    setupClass(Names)
+    inserts(Names, [('aj', 'baker'), ('joe', 'robbins'),
+                    ('tim', 'jackson'), ('joe', 'baker'),
+                    ('zoe', 'robbins')],
+            schema='firstName lastName')
+
+
+def nameList(names):
+    result = []
+    for name in names:
+        result.append('%s %s' % (name.firstName, name.lastName))
+    return result
+
+
+def firstList(names):
+    return [n.firstName for n in names]
+
+
+def test_defaultOrder():
+    setupNames()
+    assert nameList(Names.select()) == \
+        ['aj baker', 'joe baker',
+         'tim jackson', 'joe robbins',
+         'zoe robbins']
+
+
+def test_otherOrder():
+    setupNames()
+    assert nameList(Names.select().orderBy(['firstName', 'lastName'])) == \
+        ['aj baker', 'joe baker',
+         'joe robbins', 'tim jackson',
+         'zoe robbins']
+
+
+def test_untranslatedColumnOrder():
+    setupNames()
+    assert nameList(Names.select().orderBy(['first_name', 'last_name'])) == \
+        ['aj baker', 'joe baker',
+         'joe robbins', 'tim jackson',
+         'zoe robbins']
+
+
+def test_singleUntranslatedColumnOrder():
+    setupNames()
+    assert firstList(Names.select().orderBy('firstName')) == \
+        ['aj', 'joe', 'joe', 'tim', 'zoe']
+    assert firstList(Names.select().orderBy('first_name')) == \
+        ['aj', 'joe', 'joe', 'tim', 'zoe']
+    assert firstList(Names.select().orderBy('-firstName')) == \
+        ['zoe', 'tim', 'joe', 'joe', 'aj']
+    assert firstList(Names.select().orderBy(u'-first_name')) == \
+        ['zoe', 'tim', 'joe', 'joe', 'aj']
+    assert firstList(Names.select().orderBy(Names.q.firstName)) == \
+        ['aj', 'joe', 'joe', 'tim', 'zoe']
+    assert firstList(Names.select().orderBy('firstName').reversed()) == \
+        ['zoe', 'tim', 'joe', 'joe', 'aj']
+    assert firstList(Names.select().orderBy('-firstName').reversed()) == \
+        ['aj', 'joe', 'joe', 'tim', 'zoe']
+    assert firstList(Names.select().orderBy(DESC(Names.q.firstName))) == \
+        ['zoe', 'tim', 'joe', 'joe', 'aj']
+    assert firstList(Names.select().orderBy(Names.q.firstName).reversed()) == \
+        ['zoe', 'tim', 'joe', 'joe', 'aj']
+    assert firstList(
+        Names.select().orderBy(DESC(Names.q.firstName)).reversed()) == \
+        ['aj', 'joe', 'joe', 'tim', 'zoe']

sqlobject/tests/test_sqlbuilder.py

@@ -0,0 +1,134 @@
+from sqlobject import IntCol, SQLObject, StringCol
+from sqlobject.compat import PY2
+from sqlobject.sqlbuilder import AND, ANY, CONCAT, Delete, Insert, \
+    SQLOp, Select, Union, Update, const, func, sqlrepr
+from sqlobject.tests.dbtest import getConnection, raises, setupClass
+
+
+class SOTestSQLBuilder(SQLObject):
+    name = StringCol()
+    so_value = IntCol()
+
+
+def test_Select():
+    setupClass(SOTestSQLBuilder)
+
+    select1 = Select([const.id, func.MAX(const.salary)],
+                     staticTables=['employees'])
+    assert sqlrepr(select1) == 'SELECT id, MAX(salary) FROM employees'
+
+    select2 = Select([SOTestSQLBuilder.q.name, SOTestSQLBuilder.q.so_value])
+    assert sqlrepr(select2) == \
+        'SELECT so_test_sql_builder.name, so_test_sql_builder.so_value ' \
+        'FROM so_test_sql_builder'
+
+    union = Union(select1, select2)
+    assert sqlrepr(union) == \
+        'SELECT id, MAX(salary) FROM employees ' \
+        'UNION SELECT so_test_sql_builder.name, ' \
+        'so_test_sql_builder.so_value ' \
+        'FROM so_test_sql_builder'
+
+    union = Union(SOTestSQLBuilder.select().queryForSelect())
+    assert sqlrepr(union) == \
+        'SELECT so_test_sql_builder.id, so_test_sql_builder.name, ' \
+        'so_test_sql_builder.so_value FROM so_test_sql_builder WHERE 1 = 1'
+
+
+def test_empty_AND():
+    assert AND() is None
+    assert AND(True) is True
+
+    # sqlrepr() is needed because AND() returns an SQLExpression that overrides
+    # comparison. The following
+    #     AND('x', 'y') == "foo bar"
+    # is True! (-: Eeek!
+    assert sqlrepr(AND(1, 2)) == sqlrepr(SQLOp("AND", 1, 2)) == "((1) AND (2))"
+    assert sqlrepr(AND(1, 2, '3'), "sqlite") == \
+        sqlrepr(SQLOp("AND", 1, SQLOp("AND", 2, '3')), "sqlite") == \
+        "((1) AND ((2) AND ('3')))"
+
+
+def test_modulo():
+    setupClass(SOTestSQLBuilder)
+    assert sqlrepr(SOTestSQLBuilder.q.so_value % 2 == 0, 'mysql') == \
+        "((MOD(so_test_sql_builder.so_value, 2)) = (0))"
+    assert sqlrepr(SOTestSQLBuilder.q.so_value % 2 == 0, 'sqlite') == \
+        "(((so_test_sql_builder.so_value) % (2)) = (0))"
+
+
+def test_division():
+    SOTestSQLBuilder(name='test', so_value=-11)
+    assert sqlrepr(SOTestSQLBuilder.q.so_value / 4 == -2.75, 'mysql') == \
+        "(((so_test_sql_builder.so_value) / (4)) = (-2.75))"
+    assert sqlrepr(SOTestSQLBuilder.q.so_value // 4 == -3, 'mysql') == \
+        "((FLOOR(((so_test_sql_builder.so_value) / (4)))) = (-3))"
+
+
+def test_str_or_sqlrepr():
+    select = Select(['id', 'name'], staticTables=['employees'],
+                    where='value>0', orderBy='id')
+    assert sqlrepr(select, 'sqlite') == \
+        'SELECT id, name FROM employees WHERE value>0 ORDER BY id'
+
+    select = Select(['id', 'name'], staticTables=['employees'],
+                    where='value>0', orderBy='id', lazyColumns=True)
+    assert sqlrepr(select, 'sqlite') == \
+        'SELECT id FROM employees WHERE value>0 ORDER BY id'
+
+    insert = Insert('employees', values={'id': 1, 'name': 'test'})
+    assert sqlrepr(insert, 'sqlite') == \
+        "INSERT INTO employees (id, name) VALUES (1, 'test')"
+
+    update = Update('employees', {'name': 'test'}, where='id=1')
+    assert sqlrepr(update, 'sqlite') == \
+        "UPDATE employees SET name='test' WHERE id=1"
+
+    update = Update('employees', {'name': 'test', 'age': 42}, where='id=1')
+    assert sqlrepr(update, 'sqlite') == \
+        "UPDATE employees SET age=42, name='test' WHERE id=1"
+
+    delete = Delete('employees', where='id=1')
+    assert sqlrepr(delete, 'sqlite') == \
+        "DELETE FROM employees WHERE id=1"
+
+    raises(TypeError, Delete, 'employees')
+
+    delete = Delete('employees', where=None)
+    assert sqlrepr(delete, 'sqlite') == \
+        "DELETE FROM employees"
+
+
+def test_CONCAT():
+    setupClass(SOTestSQLBuilder)
+    SOTestSQLBuilder(name='test', so_value=42)
+
+    assert sqlrepr(CONCAT('a', 'b'), 'mysql') == "CONCAT('a', 'b')"
+    assert sqlrepr(CONCAT('a', 'b'), 'mssql') == "'a' + 'b'"
+    assert sqlrepr(CONCAT('a', 'b'), 'sqlite') == "'a' || 'b'"
+    assert sqlrepr(CONCAT('prefix', SOTestSQLBuilder.q.name), 'mysql') == \
+        "CONCAT('prefix', so_test_sql_builder.name)"
+    assert sqlrepr(CONCAT('prefix', SOTestSQLBuilder.q.name), 'sqlite') == \
+        "'prefix' || so_test_sql_builder.name"
+
+    select = Select([CONCAT(SOTestSQLBuilder.q.name, '-suffix')],
+                    staticTables=['so_test_sql_builder'])
+    connection = getConnection()
+    rows = connection.queryAll(connection.sqlrepr(select))
+    result = rows[0][0]
+    if not PY2 and not isinstance(result, str):
+        result = result.decode('ascii')
+    assert result == "test-suffix"
+
+
+def test_ANY():
+    setupClass(SOTestSQLBuilder)
+
+    select = Select(
+        [SOTestSQLBuilder.q.name],
+        'value' == ANY(SOTestSQLBuilder.q.so_value),
+    )
+
+    assert sqlrepr(select, 'mysql') == \
+        "SELECT so_test_sql_builder.name FROM so_test_sql_builder " \
+        "WHERE (('value') = ANY (so_test_sql_builder.so_value))"

sqlobject/tests/test_sqlbuilder_dbspecific.py

@@ -0,0 +1,66 @@
+from __future__ import print_function
+
+from sqlobject import BoolCol, SQLObject
+from sqlobject.sqlbuilder import AND, Alias, EXISTS, JOIN, LEFTJOINOn, \
+    Select, sqlrepr
+from sqlobject.tests.dbtest import setupClass
+
+''' Going to test that complex sqlbuilder constructions are never
+    prematurely stringified. A straight-forward approach is to use
+    Bools, since postgresql wants special formatting in queries.
+    The test is whether a call to sqlrepr(x, 'postgres') includes
+    the appropriate bool formatting throughout.
+'''
+
+
+class SBButton(SQLObject):
+    activated = BoolCol()
+
+
+def makeClause():
+    # It's not a comparison, it's an SQLExpression
+    return SBButton.q.activated == True  # noqa
+
+
+def makeSelect():
+    return Select(SBButton.q.id, clause=makeClause())
+
+
+def checkCount(q, c, msg=''):
+    print("STRING:", str(q))
+    print("POSTGR:", sqlrepr(q, 'postgres'))
+    assert sqlrepr(q, 'postgres').count("'t'") == c and \
+        sqlrepr(q, 'postgres') != str(q), msg
+
+
+def testSimple():
+    setupClass(SBButton)
+    checkCount(makeClause(), 1)
+    checkCount(makeSelect(), 1)
+
+
+def testMiscOps():
+    setupClass(SBButton)
+    checkCount(AND(makeClause(), makeClause()), 2)
+    checkCount(AND(makeClause(), EXISTS(makeSelect())), 2)
+
+
+def testAliased():
+    setupClass(SBButton)
+    b = Alias(makeSelect(), 'b')
+    checkCount(b, 1)
+    checkCount(Select(b.q.id), 1)
+
+    # Table1 & Table2 are treated individually in joins
+    checkCount(JOIN(None, b), 1)
+    checkCount(JOIN(b, SBButton), 1)
+    checkCount(JOIN(SBButton, b), 1)
+    checkCount(LEFTJOINOn(None, b, SBButton.q.id == b.q.id), 1)
+    checkCount(LEFTJOINOn(b, SBButton, SBButton.q.id == b.q.id), 1)
+    checkCount(LEFTJOINOn(SBButton, b, SBButton.q.id == b.q.id), 1)
+
+
+def testTablesUsedSResults():
+    setupClass(SBButton)
+
+    checkCount(SBButton.select(makeClause()).queryForSelect(), 1)

sqlobject/tests/test_sqlbuilder_importproxy.py

@@ -0,0 +1,55 @@
+from sqlobject import SQLObject, StringCol
+from sqlobject.sqlbuilder import Alias, ImportProxy, tablesUsedSet
+from sqlobject.views import ViewSQLObject
+
+
+def testSimple():
+    nyi = ImportProxy('NotYetImported')
+    x = nyi.q.name
+
+    class NotYetImported(SQLObject):
+        name = StringCol(dbName='a_name')
+
+    y = nyi.q.name
+
+    assert str(x) == 'not_yet_imported.a_name'
+    assert str(y) == 'not_yet_imported.a_name'
+
+
+def testAddition():
+    nyi = ImportProxy('NotYetImported2')
+    x = nyi.q.name + nyi.q.name
+
+    class NotYetImported2(SQLObject):
+        name = StringCol(dbName='a_name')
+
+    assert str(x) == \
+        '((not_yet_imported2.a_name) + (not_yet_imported2.a_name))'
+
+
+def testOnView():
+    nyi = ImportProxy('NotYetImportedV')
+    x = nyi.q.name
+
+    class NotYetImported3(SQLObject):
+        name = StringCol(dbName='a_name')
+
+    class NotYetImportedV(ViewSQLObject):
+        class sqlmeta:
+            idName = NotYetImported3.q.id
+        name = StringCol(dbName=NotYetImported3.q.name)
+
+    assert str(x) == 'not_yet_imported_v.name'
+
+
+def testAlias():
+    nyi = ImportProxy('NotYetImported4')
+    y = Alias(nyi, 'y')
+    x = y.q.name
+
+    class NotYetImported4(SQLObject):
+        name = StringCol(dbName='a_name')
+
+    assert str(y) == 'not_yet_imported4  y'
+    assert tablesUsedSet(x, None) == set(['not_yet_imported4  y'])
+    assert str(x) == 'y.a_name'