def test_table_overrides_metadata_create(self, connection):
metadata = self.metadata
Sequence("s1", metadata=metadata)
s2 = Sequence("s2", metadata=metadata)
s3 = Sequence("s3")
t = Table("t", metadata, Column("c", Integer, s3, primary_key=True))
assert s3.metadata is metadata
t.create(connection, checkfirst=True)
s3.drop(connection)
# 't' is created, and 's3' won't be
# re-created since it's linked to 't'.
# 's1' and 's2' are, however.
metadata.create_all(connection)
assert self._has_sequence(connection, "s1")
assert self._has_sequence(connection, "s2")
assert not self._has_sequence(connection, "s3")
s2.drop(connection)
assert self._has_sequence(connection, "s1")
assert not self._has_sequence(connection, "s2")
metadata.drop_all(connection)
assert not self._has_sequence(connection, "s1")
assert not self._has_sequence(connection, "s2")
def test_path_registry(self):
metadata = MetaData()
a = Table(
"a",
metadata,
Column("id", Integer, primary_key=True),
Column("foo", Integer),
Column("bar", Integer),
)
b = Table(
"b",
metadata,
Column("id", Integer, primary_key=True),
Column("a_id", ForeignKey("a.id")),
)
m1 = mapper(A, a, properties={"bs": relationship(B)})
mapper(B, b)
@profile_memory()
def go():
ma = sa.inspect(aliased(A))
m1._path_registry[m1.attrs.bs][ma][m1.attrs.bar]
go()
clear_mappers()
def define_tables(cls, metadata):
Table(
"left",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("data", String(30)),
)
Table(
"right",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("data", String(30)),
)
Table(
"secondary",
metadata,
Column("left_id", Integer, ForeignKey("left.id"),
primary_key=True),
Column("right_id",
Integer,
ForeignKey("right.id"),
primary_key=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)),
)
Table(
"date_table",
metadata,
Column(
"date_id",
DateTime,
default=text("current_timestamp"),
primary_key=True,
),
)
def test_no_embed_in_sql(self):
"""Using a DefaultGenerator, Sequence, DefaultClause
in the columns, where clause of a select, or in the values
clause of insert, update, raises an informative error"""
t = Table(
"some_table",
MetaData(),
Column("id", Integer),
Column("col4", String()),
)
for const in (
sa.Sequence("y"),
sa.ColumnDefault("y"),
sa.DefaultClause("y"),
):
assert_raises_message(
sa.exc.ArgumentError,
"SQL expression object expected, got object of type "
"<.* 'list'> instead",
t.select,
[const],
)
assert_raises_message(
sa.exc.InvalidRequestError,
"cannot be used directly as a column expression.",
str,
t.insert().values(col4=const),
)
assert_raises_message(
sa.exc.InvalidRequestError,
"cannot be used directly as a column expression.",
str,
t.update().values(col4=const),
)
def test_many_discarded_relationships(self):
"""a use case that really isn't supported, nonetheless we can
guard against memleaks here so why not"""
m1 = MetaData()
t1 = Table("t1", m1, Column("id", Integer, primary_key=True))
t2 = Table(
"t2",
m1,
Column("id", Integer, primary_key=True),
Column("t1id", ForeignKey("t1.id")),
)
class T1(object):
pass
t1_mapper = mapper(T1, t1)
@testing.emits_warning()
@profile_memory()
def go():
class T2(object):
pass
t2_mapper = mapper(T2, t2)
t1_mapper.add_property("bar", relationship(t2_mapper))
s1 = Session()
# this causes the path_registry to be invoked
s1.query(t1_mapper)._compile_context()
go()
def define_tables(cls, metadata):
Table(
"users",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("name", String(50)),
test_needs_fk=True,
)
Table(
"user_items",
metadata,
Column("user_id", ForeignKey("users.id"), primary_key=True),
Column("item_id", ForeignKey("items.id"), primary_key=True),
test_needs_fk=True,
)
Table(
"items",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("name", String(50)),
test_needs_fk=True,
)
def define_tables(cls, metadata):
Table(
"a",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("x", Integer),
Column("y", Integer),
)
Table(
"b",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("a_id", ForeignKey("a.id")),
Column("x", Integer),
Column("y", Integer),
)
Table(
"c",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("b_id", ForeignKey("b.id")),
Column("x", Integer),
Column("y", Integer),
)
def test_reflect_table_comment(self):
local_parent = Table(
"parent",
self.metadata,
Column("q", Integer),
comment="my local comment",
)
local_parent.create(testing.db)
insp = inspect(testing.db)
eq_(
insp.get_table_comment("parent",
schema=testing.config.test_schema),
{"text": "my table comment"},
)
eq_(
insp.get_table_comment("parent", ),
{"text": "my local comment"},
)
eq_(
insp.get_table_comment(
"parent", schema=testing.db.dialect.default_schema_name),
{"text": "my local comment"},
)
def define_tables(cls, metadata):
Table(
"a",
metadata,
Column("id1", Integer, primary_key=True),
Column("id2", Integer, primary_key=True),
)
Table(
"b_sameorder",
metadata,
Column("id", Integer, primary_key=True),
Column("a_id1", Integer),
Column("a_id2", Integer),
ForeignKeyConstraint(["a_id1", "a_id2"], ["a.id1", "a.id2"]),
)
Table(
"b_differentorder",
metadata,
Column("id", Integer, primary_key=True),
Column("a_id1", Integer),
Column("a_id2", Integer),
ForeignKeyConstraint(["a_id1", "a_id2"], ["a.id1", "a.id2"]),
)
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(
"datas",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("a", Integer, nullable=False),
)
Table(
"foo",
metadata,
Column("data_id",
Integer,
ForeignKey("datas.id"),
primary_key=True),
Column("bar", Integer),
)
Table(
"stats",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("data_id", Integer, ForeignKey("datas.id")),
Column("somedata", Integer, nullable=False),
)
def define_tables(cls, metadata):
Table(
"descriptions",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("d1", String(20)),
Column("d2", String(20)),
)
Table(
"values",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column(
"description_id",
Integer,
ForeignKey("descriptions.id"),
nullable=False,
),
Column("v1", String(20)),
Column("v2", String(20)),
)
def define_tables(cls, metadata):
Table(
"items",
metadata,
Column(
"item_id",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
Column("name", String(40)),
)
Table(
"item_keywords",
metadata,
Column("item_id", Integer, ForeignKey("items.item_id")),
Column("keyword_id", Integer, ForeignKey("keywords.keyword_id")),
Column("data", String(40)),
)
Table(
"keywords",
metadata,
Column(
"keyword_id",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
Column("name", String(40)),
)
def test_reflect_nvarchar(self):
metadata = self.metadata
Table(
"tnv",
metadata,
Column("nv_data", sqltypes.NVARCHAR(255)),
Column("c_data", sqltypes.NCHAR(20)),
)
metadata.create_all()
m2 = MetaData(testing.db)
t2 = Table("tnv", m2, autoload=True)
assert isinstance(t2.c.nv_data.type, sqltypes.NVARCHAR)
assert isinstance(t2.c.c_data.type, sqltypes.NCHAR)
if testing.against("oracle+cx_oracle"):
assert isinstance(
t2.c.nv_data.type.dialect_impl(testing.db.dialect),
cx_oracle._OracleUnicodeStringNCHAR,
)
assert isinstance(
t2.c.c_data.type.dialect_impl(testing.db.dialect),
cx_oracle._OracleNChar,
)
data = u("m’a réveillé.")
with testing.db.connect() as conn:
conn.execute(t2.insert(), dict(nv_data=data, c_data=data))
nv_data, c_data = conn.execute(t2.select()).first()
eq_(nv_data, data)
eq_(c_data, data + (" " * 7)) # char is space padded
assert isinstance(nv_data, util.text_type)
assert isinstance(c_data, util.text_type)
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(
"users",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("name", String(30), nullable=False),
Column("some_update", String(30), onupdate="im the update"),
)
Table(
"addresses",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("user_id", None, ForeignKey("users.id")),
Column("email_address", String(50), nullable=False),
)
Table(
"foobar",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("user_id", None, ForeignKey("users.id")),
Column("data", String(30)),
Column("some_update", String(30), onupdate="im the other update"),
)
def define_tables(cls, metadata):
Table("a", metadata, Column("id", Integer, primary_key=True))
Table(
"b",
metadata,
Column("id", Integer, primary_key=True),
Column("aid", ForeignKey("a.id"), nullable=True),
)
Table(
"c",
metadata,
Column("id", Integer, primary_key=True),
Column("aid", ForeignKey("a.id"), nullable=False),
)
Table(
"d",
metadata,
Column("id", Integer, primary_key=True),
Column("aid",
ForeignKey("a.id", ondelete="cascade"),
nullable=False),
)
Table(
"e",
metadata,
Column("id", Integer, primary_key=True),
Column("aid",
ForeignKey("a.id", ondelete="set null"),
nullable=True),
)
def define_tables(cls, metadata):
Table(
"users",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("name", String(50)),
test_needs_fk=True,
)
Table(
"addresses",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("email", String(50)),
Column("user_id", Integer, ForeignKey("users.id")),
test_needs_fk=True,
)
Table(
"imhandles",
metadata,
Column(
"id", Integer, primary_key=True, test_needs_autoincrement=True
),
Column("user_id", Integer),
Column("network", String(50)),
Column("handle", String(50)),
test_needs_fk=True,
)
def define_tables(cls, metadata):
Table(
"single",
metadata,
Column("id", Integer, primary_key=True),
Column("type", String(10)),
test_needs_fk=True,
)
Table(
"joined_base",
metadata,
Column("id", Integer, primary_key=True),
Column("type", String(10)),
test_needs_fk=True,
)
Table(
"joined_inh",
metadata,
Column("id",
Integer,
ForeignKey("joined_base.id"),
primary_key=True),
test_needs_fk=True,
)
FixtureTest.define_tables(metadata)
def define_tables(cls, metadata):
Table(
"base",
metadata,
Column("uid", String(30), primary_key=True),
Column("x", String(30)),
)
Table(
"derived",
metadata,
Column("uid", String(30), ForeignKey("base.uid"),
primary_key=True),
Column("y", String(30)),
)
Table(
"derivedII",
metadata,
Column("uid", String(30), ForeignKey("base.uid"),
primary_key=True),
Column("z", String(30)),
)
Table(
"comments",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("uid", String(30), ForeignKey("base.uid")),
Column("comment", String(30)),
)
def define_tables(cls, metadata):
Table(
"departments",
metadata,
Column(
"department_id",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
Column("name", String(50)),
)
Table(
"employees",
metadata,
Column(
"person_id",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
Column("name", String(50)),
Column(
"department_id",
Integer,
ForeignKey("departments.department_id"),
),
)
def test_reflect_remote_synonyms(self):
meta = MetaData(testing.db)
parent = Table(
"ptable",
meta,
autoload=True,
schema=testing.config.test_schema,
oracle_resolve_synonyms=True,
)
child = Table(
"ctable",
meta,
autoload=True,
schema=testing.config.test_schema,
oracle_resolve_synonyms=True,
)
self.assert_compile(
parent.join(child),
"%(test_schema)s.ptable JOIN "
"%(test_schema)s.ctable "
"ON %(test_schema)s.ptable.id = "
"%(test_schema)s.ctable.parent_id" %
{"test_schema": testing.config.test_schema},
)
select([parent,
child]).select_from(parent.join(child)).execute().fetchall()
def test_long_type(self):
metadata = self.metadata
t = Table("t", metadata, Column("data", oracle.LONG))
metadata.create_all(testing.db)
testing.db.execute(t.insert(), data="xyz")
eq_(testing.db.scalar(select([t.c.data])), "xyz")
def define_tables(cls, metadata):
Table(
"owners",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("data", String(30)),
)
Table(
"categories",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("name", String(20)),
)
Table(
"tests",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("owner_id",
Integer,
ForeignKey("owners.id"),
nullable=False),
Column(
"category_id",
Integer,
ForeignKey("categories.id"),
nullable=False,
),
)
Table(
"options",
metadata,
Column("test_id",
Integer,
ForeignKey("tests.id"),
primary_key=True),
Column("owner_id",
Integer,
ForeignKey("owners.id"),
primary_key=True),
Column(
"someoption",
sa.Boolean,
server_default=sa.false(),
nullable=False,
),
)
def define_tables(cls, metadata):
Table("table1", metadata, Column("id", Integer, primary_key=True))
Table(
"table2",
metadata,
Column("t1id", Integer, ForeignKey("table1.id"), primary_key=True),
Column("num", Integer, primary_key=True),
)
def define_tables(cls, metadata):
Table("Table1", metadata, Column("ID", Integer, primary_key=True))
Table(
"Table2",
metadata,
Column("T1ID", Integer, ForeignKey("Table1.ID"), primary_key=True),
Column("NUM", Integer, primary_key=True),
)
def _setup(self, test_collection_class):
"""Build a relationship situation using the given
test_collection_class factory"""
global metadata, slides_table, bullets_table, Slide, Bullet
slides_table = Table(
"test_Slides",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("name", String(128)),
)
bullets_table = Table(
"test_Bullets",
metadata,
Column("id",
Integer,
primary_key=True,
test_needs_autoincrement=True),
Column("slide_id", Integer, ForeignKey("test_Slides.id")),
Column("position", Integer),
Column("text", String(128)),
)
class Slide(object):
def __init__(self, name):
self.name = name
def __repr__(self):
return '<Slide "%s">' % self.name
class Bullet(object):
def __init__(self, text):
self.text = text
def __repr__(self):
return '<Bullet "%s" pos %s>' % (self.text, self.position)
mapper(
Slide,
slides_table,
properties={
"bullets":
relationship(
Bullet,
lazy="joined",
collection_class=test_collection_class,
backref="slide",
order_by=[bullets_table.c.position],
)
},
)
mapper(Bullet, bullets_table)
metadata.create_all()
def _unhashable_fixture(self, metadata, load_on_pending=False):
class MyHashType(sa.TypeDecorator):
impl = sa.String(100)
def process_bind_param(self, value, dialect):
return ";".join(
"%s=%s" % (k, v)
for k, v in sorted(value.items(), key=lambda key: key[0]))
def process_result_value(self, value, dialect):
return dict(elem.split("=", 1) for elem in value.split(";"))
category = Table(
"category",
metadata,
Column("id", Integer, primary_key=True),
Column("data", MyHashType()),
)
article = Table(
"article",
metadata,
Column("id", Integer, primary_key=True),
Column("data", MyHashType()),
)
class Category(fixtures.ComparableEntity):
pass
class Article(fixtures.ComparableEntity):
pass
mapper(Category, category)
mapper(
Article,
article,
properties={
"category":
relationship(
Category,
primaryjoin=orm.foreign(article.c.data) == category.c.data,
load_on_pending=load_on_pending,
)
},
)
metadata.create_all()
sess = Session(autoflush=False)
data = {"im": "unhashable"}
a1 = Article(id=1, data=data)
c1 = Category(id=1, data=data)
if load_on_pending:
sess.add(c1)
else:
sess.add_all([c1, a1])
sess.flush()
if load_on_pending:
sess.add(a1)
return Category, Article, sess, a1, c1
def define_tables(cls, metadata):
Table("person", metadata,
Column("id", cls.StringAsInt, primary_key=True))
Table(
"pets",
metadata,
Column("id", Integer, primary_key=True),
Column("person_id", Integer),
)
