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))