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_insert_from_select_fn_defaults(self, connection):
data = self.tables.data
counter = itertools.count(1)
def foo(ctx):
return next(counter)
table = Table(
"sometable",
self.metadata,
Column("x", Integer),
Column("foo", Integer, default=foo),
Column("y", Integer),
)
table.create(connection)
sel = select([data.c.x, data.c.y])
ins = table.insert().from_select(["x", "y"], sel)
connection.execute(ins)
# counter is only called once!
eq_(
list(connection.execute(table.select().order_by(table.c.x))),
[(2, 1, 5), (7, 1, 12)],
)
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 _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,
)
with testing.db.connect() as conn:
t.create(conn)
r = conn.execute(t.insert().values(data=5))
# 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"])
eq_(conn.execute(t.select()).first(), ("INT_1", 5))
def test_unicode_warnings(self):
metadata = MetaData(self.engine)
table1 = Table(
"mytable",
metadata,
Column(
"col1",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
Column("col2", Unicode(30)),
)
metadata.create_all()
i = [1]
# the times here is cranked way up so that we can see
# pysqlite clearing out its internal buffer and allow
# the test to pass
@testing.emits_warning()
@profile_memory()
def go():
# execute with a non-unicode object. a warning is emitted,
# this warning shouldn't clog up memory.
self.engine.execute(
table1.select().where(table1.c.col2 == "foo%d" % i[0]))
i[0] += 1
try:
go()
finally:
metadata.drop_all()
class Person(Base):
__tablename__ = "person"
id = Column(Integer,
primary_key=True,
test_needs_autoincrement=True)
type = Column(String(50))
name = Column(String(50))
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))
class Person(Base):
__tablename__ = "person"
id = Column(Integer, primary_key=True)
first_name = Column(String(10))
last_name = Column(String(10))
@hybrid.hybrid_property
def name(self):
return self.first_name + " " + self.last_name
@name.setter
def name(self, value):
self.first_name, self.last_name = value.split(" ", 1)
@name.expression
def name(cls):
return func.concat(cls.first_name, " ", cls.last_name)
@name.update_expression
def name(cls, value):
f, l = value.split(" ", 1)
return [(cls.first_name, f), (cls.last_name, l)]
@hybrid.hybrid_property
def uname(self):
return self.name
@hybrid.hybrid_property
def fname(self):
return self.first_name
@hybrid.hybrid_property
def fname2(self):
return self.fname
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()
class Employee(Base):
__tablename__ = "employee"
id = Column(Integer,
primary_key=True,
test_needs_autoincrement=True)
type = Column(String(10))
__mapper_args__ = {"polymorphic_on": type}
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 test_misordered_lastrow(self):
metadata = self.metadata
related = Table(
"related",
metadata,
Column("id", Integer, primary_key=True),
mysql_engine="MyISAM",
)
t6 = Table(
"t6",
metadata,
Column(
"manual_id",
Integer,
ForeignKey("related.id"),
primary_key=True,
),
Column(
"auto_id",
Integer,
primary_key=True,
test_needs_autoincrement=True,
),
mysql_engine="MyISAM",
)
metadata.create_all()
r = related.insert().values(id=12).execute()
id_ = r.inserted_primary_key[0]
eq_(id_, 12)
r = t6.insert().values(manual_id=id_).execute()
eq_(r.inserted_primary_key, [12, 1])
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 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(
"foo",
metadata,
Column("id", Integer, sa.Sequence("foo_id_seq"), primary_key=True),
Column("bar", Integer),
Column("range", Integer),
)
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),
)
class OverrideComparator(Person):
__tablename__ = "override_comp"
id = Column(Integer, ForeignKey("person.id"), primary_key=True)
other = Column(String)
@Person.name.overrides.comparator
def name(self):
return FooComparator(self)
class OverrideExpr(Person):
__tablename__ = "override_expr"
id = Column(Integer, ForeignKey("person.id"), primary_key=True)
other = Column(String)
@Person.name.overrides.expression
def name(self):
return func.concat("Hello", self._name)
class OverrideSetter(Person):
__tablename__ = "override_setter"
id = Column(Integer, ForeignKey("person.id"), primary_key=True)
other = Column(String)
@Person.name.setter
def name(self, value):
self._name = value.upper()
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(
"foo",
metadata,
Column("id", Integer, Sequence("t_id_seq"), primary_key=True),
Column("data", String(50)),
Column("x", Integer),
)
def define_tables(cls, metadata):
Table(
"test",
metadata,
Column("id", Integer, primary_key=True),
Column("foo", Integer),
Column("bar", Integer, Computed("foo + 42")),
)
def define_tables(cls, metadata):
Table(
"graphs",
metadata,
Column("id", Integer, primary_key=True),
Column("version_id", Integer, primary_key=True, nullable=True),
Column("name", String(30)),
)
class DataContainer(ComparableEntity, Base):
__tablename__ = "data_container"
id = Column(Integer,
primary_key=True,
test_needs_autoincrement=True)
name = Column(String(10))
jobs = relationship(Job, order_by=Job.id)
class OverrideGetter(Person):
__tablename__ = "override_getter"
id = Column(Integer, ForeignKey("person.id"), primary_key=True)
other = Column(String)
@Person.name.getter
def name(self):
return "Hello " + self._name
class TestTable(Base):
__tablename__ = "test"
id = Column(Integer, primary_key=True, autoincrement=True)
_some_id = Column("some_id", String)
some_primary_id = column_property(
func.left(_some_id, 6).cast(Integer)
)
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),
)
def setup(self):
self.engine = engines.mock_engine()
self.metadata = MetaData(self.engine)
self.users = Table(
"users",
self.metadata,
Column("user_id", Integer, primary_key=True),
Column("user_name", String(40)),
)
class AbstractFoo(Base):
__abstract__ = True
id = Column(Integer,
primary_key=True,
test_needs_autoincrement=True)
data = Column(MutableDict.as_mutable(JSONEncodedDict))
non_mutable_data = Column(JSONEncodedDict)
unrelated_data = Column(String(50))
