def test_unicode_warnings(self):
metadata = MetaData(testing.db)
table1 = Table(
'mytable', metadata,
Column('col1',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('col2', Unicode(30)))
metadata.create_all()
i = [1]
@testing.emits_warning()
@profile_memory
def go():
# execute with a non-unicode object. a warning is emitted,
# this warning shouldn't clog up memory.
testing.db.execute(table1.select().where(table1.c.col2 == 'foo%d' %
i[0]))
i[0] += 1
try:
go()
finally:
metadata.drop_all()
def test_compileonattr_rel_backref_b(self):
m = MetaData()
t1 = Table('t1', m,
Column('id', Integer, primary_key=True),
Column('x', Integer))
t2 = Table('t2', m,
Column('id', Integer, primary_key=True),
Column('t1_id', Integer, ForeignKey('t1.id')))
class Base(object):
def __init__(self): pass
class Base_AKW(object):
def __init__(self, *args, **kwargs): pass
for base in object, Base, Base_AKW:
class A(base): pass
class B(base): pass
mapper(A, t1)
mapper(B, t2, properties=dict(a=relationship(A, backref='bs')))
a = A()
b = B()
b.a = a
session = create_session()
session.add(a)
assert b in session, 'base: %s' % base
def define_tables(cls, metadata):
import json
class JSONEncodedDict(TypeDecorator):
impl = VARCHAR(50)
def process_bind_param(self, value, dialect):
if value is not None:
value = json.dumps(value)
return value
def process_result_value(self, value, dialect):
if value is not None:
value = json.loads(value)
return value
MutationDict = cls._type_fixture()
MutationDict.associate_with(JSONEncodedDict)
Table('foo', metadata,
Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
Column('data', JSONEncodedDict),
Column('unrelated_data', String(50))
)
def setup(self):
meta = MetaData(testing.db)
global table, GoofyType
class GoofyType(TypeDecorator):
impl = String
def process_bind_param(self, value, dialect):
if value is None:
return None
return "FOO" + value
def process_result_value(self, value, dialect):
if value is None:
return None
return value + "BAR"
table = Table(
'tables', meta,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('persons', Integer),
Column('full', Boolean), Column('goofy', GoofyType(50)))
table.create(checkfirst=True)
def define_tables(cls, metadata):
Table(
"data",
metadata,
Column('pk1', String(10), primary_key=True),
Column('pk2', String(10), primary_key=True),
)
def test_compileonattr_rel_backref_a(self):
m = MetaData()
t1 = Table('t1', m,
Column('id', Integer, primary_key=True),
Column('x', Integer))
t2 = Table('t2', m,
Column('id', Integer, primary_key=True),
Column('t1_id', Integer, ForeignKey('t1.id')))
class Base(object):
def __init__(self, *args, **kwargs):
pass
for base in object, Base:
class A(base): pass
class B(base): pass
mapper(A, t1, properties=dict(bs=relationship(B, backref='a')))
mapper(B, t2)
b = B()
assert b.a is None
a = A()
b.a = a
session = create_session()
session.add(b)
assert a in session, "base is %s" % base
def _run_test(self, *arg, **kw):
metadata = self.metadata
implicit_returning = kw.pop('implicit_returning', True)
kw['primary_key'] = True
if kw.get('autoincrement', True):
kw['test_needs_autoincrement'] = True
t = Table('x',
metadata,
Column('y', self.MyInteger, *arg, **kw),
Column('data', Integer),
implicit_returning=implicit_returning)
t.create()
r = t.insert().values(data=5).execute()
# we don't pre-fetch 'server_default'.
if 'server_default' in kw and (
not testing.db.dialect.implicit_returning
or not implicit_returning):
eq_(r.inserted_primary_key, [None])
else:
eq_(r.inserted_primary_key, ['INT_1'])
r.close()
eq_(t.select().execute().first(), ('INT_1', 5))
def test_default_exec(self):
metadata = MetaData(testing.db)
t1 = Table(
't1',
metadata,
Column(u'special_col',
Integer,
Sequence('special_col'),
primary_key=True),
Column('data',
String(50)) # to appease SQLite without DEFAULT VALUES
)
metadata.create_all()
try:
engine = metadata.bind
# reset the identifier preparer, so that we can force it to cache
# a unicode identifier
engine.dialect.identifier_preparer = engine.dialect.preparer(
engine.dialect)
select([column(u'special_col')]).select_from(t1).execute().close()
assert isinstance(
engine.dialect.identifier_preparer.format_sequence(
Sequence('special_col')), unicode)
# now execute, run the sequence. it should run in u"Special_col.nextid" or similar as
# a unicode object; cx_oracle asserts that this is None or a String (postgresql lets it pass thru).
# ensure that executioncontext._exec_default() is encoding.
t1.insert().execute(data='foo')
finally:
metadata.drop_all()
def define_tables(cls, metadata):
Table(
'test_table', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('data', Integer))
def define_tables(cls, metadata):
Table('foo', metadata,
Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
Column('x', Integer),
Column('y', Integer),
Column('unrelated_data', String(50))
)
def test_int_default_none_on_insert_reflected(self):
metadata = self.metadata
t = Table('x', metadata,
Column('y', Integer,
server_default='5', primary_key=True),
Column('data', String(10)),
implicit_returning=False
)
metadata.create_all()
m2 = MetaData(metadata.bind)
t2 = Table('x', m2, autoload=True, implicit_returning=False)
r = t2.insert().execute(data='data')
eq_(r.inserted_primary_key, [None])
if testing.against('sqlite'):
eq_(
t2.select().execute().fetchall(),
[(1, 'data')]
)
else:
eq_(
t2.select().execute().fetchall(),
[(5, 'data')]
)
def test_mapped_managerattr(self):
t = Table('t', MetaData(),
Column('id', Integer, primary_key=True),
Column(instrumentation.ClassManager.MANAGER_ATTR, Integer))
class T(object): pass
assert_raises(KeyError, mapper, T, t)
def test_autoincrement_fk_disqualifies(self):
m = MetaData()
y = Table('y', m, Column('id', Integer(), primary_key=True))
x = Table(
'x', m,
Column('id', Integer(), ForeignKey('y.id'), primary_key=True))
assert x._autoincrement_column is None
def define_tables(cls, metadata):
Table('employees', metadata,
Column('employee_id', Integer, primary_key=True,
test_needs_autoincrement=True),
Column('type', String(1), nullable=False),
Column('data', String(50)),
)
def define_tables(cls, metadata):
if testing.against('oracle'):
fk_args = dict(deferrable=True, initially='deferred')
elif testing.against('mysql'):
fk_args = {}
else:
fk_args = dict(onupdate='cascade')
Table(
'users',
metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True),
)
Table(
'addresses',
metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column('user_id', Integer, ForeignKey('users.id', **fk_args)),
)
def test_create_drop_bound(self):
for meta in (MetaData, ThreadLocalMetaData):
for bind in (testing.db, testing.db.connect()):
metadata = meta()
table = Table('test_table', metadata, Column('foo', Integer))
metadata.bind = bind
assert metadata.bind is table.bind is bind
metadata.create_all()
assert table.exists()
metadata.drop_all()
table.create()
table.drop()
assert not table.exists()
metadata = meta()
table = Table('test_table', metadata, Column('foo', Integer))
metadata.bind = bind
assert metadata.bind is table.bind is bind
metadata.create_all()
assert table.exists()
metadata.drop_all()
table.create()
table.drop()
assert not table.exists()
if isinstance(bind, engine.Connection):
bind.close()
def test_type(self):
m = MetaData()
t = Table('sometable', m, Column('col1', Integer),
Column('col2', Float))
assert isinstance(t.c.col1.label('hi').type, Integer)
assert isinstance(
select([t.c.col2]).as_scalar().label('lala').type, Float)
def define_tables(self, meta):
Table('user_t', meta, Column('id', Integer, primary_key=True),
Column('name', String(50)))
Table('stuff', meta, Column('id', Integer, primary_key=True),
Column('date', sa.Date),
Column('user_id', Integer, ForeignKey('user_t.id')))
def test_collection_setstate(self):
"""test a particular cycle that requires CollectionAdapter
to not rely upon InstanceState to deserialize."""
m = MetaData()
c1 = Table('c1', m,
Column('parent_id', String,
ForeignKey('p.id'), primary_key=True)
)
c2 = Table('c2', m,
Column('parent_id', String,
ForeignKey('p.id'), primary_key=True)
)
p = Table('p', m,
Column('id', String, primary_key=True)
)
mapper(Parent, p, properties={
'children1':relationship(Child1),
'children2':relationship(Child2)
})
mapper(Child1, c1)
mapper(Child2, c2)
obj = Parent()
screen1 = Screen(obj)
screen1.errors = [obj.children1, obj.children2]
screen2 = Screen(Child2(), screen1)
pickle.loads(pickle.dumps(screen2))
def define_tables(cls, metadata):
Table(
'parent', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('data', String(10)))
Table(
'base', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('type', String(10)),
Column('related_id', Integer, ForeignKey('related.id')))
Table(
'sub', metadata,
Column('id', Integer, ForeignKey('base.id'), primary_key=True),
Column('data', String(10)),
Column('parent_id',
Integer,
ForeignKey('parent.id'),
nullable=False))
Table(
'related', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('data', String(10)))
def test_mapper_reset(self):
metadata = MetaData(testing.db)
table1 = Table(
"mytable", metadata,
Column('col1',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('col2', String(30)))
table2 = Table(
"mytable2", metadata,
Column('col1',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('col2', String(30)),
Column('col3', Integer, ForeignKey("mytable.col1")))
@profile_memory
def go():
m1 = mapper(
A,
table1,
properties={"bs": relationship(B, order_by=table2.c.col1)})
m2 = mapper(B, table2)
m3 = mapper(A, table1, non_primary=True)
sess = create_session()
a1 = A(col2="a1")
a2 = A(col2="a2")
a3 = A(col2="a3")
a1.bs.append(B(col2="b1"))
a1.bs.append(B(col2="b2"))
a3.bs.append(B(col2="b3"))
for x in [a1, a2, a3]:
sess.add(x)
sess.flush()
sess.expunge_all()
alist = sess.query(A).order_by(A.col1).all()
eq_([
A(col2="a1", bs=[B(col2="b1"), B(col2="b2")]),
A(col2="a2", bs=[]),
A(col2="a3", bs=[B(col2="b3")])
], alist)
for a in alist:
sess.delete(a)
sess.flush()
sess.close()
clear_mappers()
metadata.create_all()
try:
go()
finally:
metadata.drop_all()
assert_no_mappers()
def setup(self):
meta = MetaData(testing.db)
global table, seq
seq = Sequence('tid_seq')
table = Table('tables', meta,
Column('id', Integer, seq, primary_key=True),
Column('data', String(50)))
table.create(checkfirst=True)
def define_tables(cls, metadata):
t2 = Table('t2', metadata,
Column('nextid', Integer))
Table('t1', metadata,
Column('id', Integer, primary_key=True,
default=sa.select([func.max(t2.c.nextid)]).as_scalar()),
Column('data', String(30)))
def define_tables(cls, metadata):
Table(
't', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('data', String(50)),
Column('def_', String(50), server_default='def1'))
class Child(Base):
__tablename__ = 'child'
__table_args__ = {'mysql_engine':'InnoDB'}
id= Column(Integer, primary_key=True, test_needs_autoincrement=True)
parent_id = Column(Integer, ForeignKey('parent.id'))
parent = relationship(Parent, backref=backref("children"))
def define_tables(cls, metadata):
data = Table(
'data', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column('counter', Integer, nullable=False, default=0))
def define_tables(cls, metadata):
Table('users', metadata,
Column('id', Integer, primary_key=True, test_needs_autoincrement=True),
Column('name', String(30)),
Column('type', String(30)))
Table('email_users', metadata,
Column('id', Integer, ForeignKey('users.id'), primary_key=True),
Column('email_address', String(30)))
def define_tables(cls, metadata):
global t1
t1 = Table(
't1', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('data', String(50)))
def define_tables(cls, metadata):
Table(
'users', metadata,
Column('id',
Integer,
primary_key=True,
test_needs_autoincrement=True), Column('name', String(32)),
Column('age', Integer))
def define_tables(cls, metadata):
Table(
"aitable", metadata,
Column('id',
Integer,
Sequence('ai_id_seq', optional=True),
primary_key=True), Column('int1', Integer),
Column('str1', String(20)))
def test_incomplete_key(self):
c = Column(Integer)
assert c.name is None
assert c.key is None
c.name = 'named'
t = Table('t', MetaData(), c)
assert c.name == 'named'
assert c.name == c.key
def test_uninitialized_column_copy_events(self):
msgs = []
def write(c, t):
msgs.append("attach %s.%s" % (t.name, c.name))
c1 = Column('foo', String())
m = MetaData()
for i in xrange(3):
cx = c1.copy()
# as of 0.7, these events no longer copy. its expected
# that listeners will be re-established from the
# natural construction of things.
cx._on_table_attach(write)
t = Table('foo%d' % i, m, cx)
eq_(msgs, ['attach foo0.foo', 'attach foo1.foo', 'attach foo2.foo'])
def __init__(self, type, **kw):
Column.__init__(self, type, **kw)
