def test_insert_identity(self):
Thing = self.classes.Thing
s = fixture_session()
t1, t2 = (Thing(foo=5), Thing(foo=10))
s.add_all([t1, t2])
with assert_engine(testing.db) as asserter:
s.flush()
eq_(t1.id, 1)
eq_(t2.id, 2)
asserter.assert_(
Conditional(
testing.db.dialect.implicit_returning,
[
Conditional(
testing.db.dialect.insert_executemany_returning,
[
CompiledSQL(
"INSERT INTO test (foo) VALUES (%(foo)s) "
"RETURNING test.id",
[{"foo": 5}, {"foo": 10}],
dialect="postgresql",
),
],
[
CompiledSQL(
"INSERT INTO test (foo) VALUES (%(foo)s) "
"RETURNING test.id",
[{"foo": 5}],
dialect="postgresql",
),
CompiledSQL(
"INSERT INTO test (foo) VALUES (%(foo)s) "
"RETURNING test.id",
[{"foo": 10}],
dialect="postgresql",
),
],
)
],
[
CompiledSQL(
"INSERT INTO test (foo) VALUES (:foo)",
[{"foo": 5}],
),
CompiledSQL(
"INSERT INTO test (foo) VALUES (:foo)",
[{"foo": 10}],
),
],
)
)
def test_update_computed(self, eager):
if eager:
Thing = self.classes.Thing
else:
Thing = self.classes.ThingNoEager
s = Session()
t1, t2 = (Thing(id=1, foo=1), Thing(id=2, foo=2))
s.add_all([t1, t2])
s.flush()
t1.foo = 5
t2.foo = 6
with assert_engine(testing.db) as asserter:
s.flush()
eq_(t1.bar, 5 + 42)
eq_(t2.bar, 6 + 42)
if eager and testing.db.dialect.implicit_returning:
asserter.assert_(
CompiledSQL(
"UPDATE test SET foo=%(foo)s "
"WHERE test.id = %(test_id)s "
"RETURNING test.bar",
[{
"foo": 5,
"test_id": 1
}],
dialect="postgresql",
),
CompiledSQL(
"UPDATE test SET foo=%(foo)s "
"WHERE test.id = %(test_id)s "
"RETURNING test.bar",
[{
"foo": 6,
"test_id": 2
}],
dialect="postgresql",
),
)
elif eager:
asserter.assert_(
CompiledSQL(
"UPDATE test SET foo=:foo WHERE test.id = :test_id",
[{
"foo": 5,
"test_id": 1
}],
),
CompiledSQL(
"UPDATE test SET foo=:foo WHERE test.id = :test_id",
[{
"foo": 6,
"test_id": 2
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 1
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 2
}],
),
)
else:
asserter.assert_(
CompiledSQL(
"UPDATE test SET foo=:foo WHERE test.id = :test_id",
[{
"foo": 5,
"test_id": 1
}, {
"foo": 6,
"test_id": 2
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 1
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 2
}],
),
)
def test_insert_computed(self, eager):
if eager:
Thing = self.classes.Thing
else:
Thing = self.classes.ThingNoEager
s = Session()
t1, t2 = (Thing(id=1, foo=5), Thing(id=2, foo=10))
s.add_all([t1, t2])
with assert_engine(testing.db) as asserter:
s.flush()
eq_(t1.bar, 5 + 42)
eq_(t2.bar, 10 + 42)
if eager and testing.db.dialect.implicit_returning:
asserter.assert_(
CompiledSQL(
"INSERT INTO test (id, foo) VALUES (%(id)s, %(foo)s) "
"RETURNING test.bar",
[{
"foo": 5,
"id": 1
}],
dialect="postgresql",
),
CompiledSQL(
"INSERT INTO test (id, foo) VALUES (%(id)s, %(foo)s) "
"RETURNING test.bar",
[{
"foo": 10,
"id": 2
}],
dialect="postgresql",
),
)
else:
asserter.assert_(
CompiledSQL(
"INSERT INTO test (id, foo) VALUES (:id, :foo)",
[{
"foo": 5,
"id": 1
}, {
"foo": 10,
"id": 2
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 1
}],
),
CompiledSQL(
"SELECT test.bar AS test_bar FROM test "
"WHERE test.id = :param_1",
[{
"param_1": 2
}],
),
)
def test_subclass_loadattr(self, first_option, second_option,
second_argument, expect_load):
Parent, Entity, SubEntity = self.classes("Parent", "Entity",
"SubEntity")
stmt = select(Parent)
will_lazyload = first_option in (defaultload, lazyload)
if second_argument == "name":
second_argument = SubEntity.name
opt = first_option(Parent.entity.of_type(SubEntity))
elif second_argument == "id":
opt = first_option(Parent.entity)
second_argument = Entity.id
else:
opt = first_option(Parent.entity)
if second_option is None:
sub_opt = opt
elif second_option == "raise":
sub_opt = opt.defer(second_argument, raiseload=True)
else:
sub_opt = getattr(opt, second_option)(second_argument)
stmt = stmt.options(sub_opt)
session = fixture_session()
result = session.execute(stmt).scalars()
parent_obj = result.first()
entity_id = parent_obj.__dict__["entity_id"]
with assertsql.assert_engine(testing.db) as asserter_:
if expect_load:
eq_(parent_obj.entity.name, "some name")
else:
with expect_raises_message(
exc.InvalidRequestError,
"'SubEntity.name' is not available due to raiseload=True",
):
parent_obj.entity.name
expected = []
if will_lazyload:
expected.append(
CompiledSQL(
"SELECT entity.id AS entity_id, "
"entity.type AS entity_type FROM entity "
"WHERE entity.id = :pk_1",
[{
"pk_1": entity_id
}],
))
if second_option in ("load_only", None) or (
second_option == "undefer"
and first_option in (defaultload, lazyload)):
# load will be a mapper optimized load for the name alone
expected.append(
CompiledSQL(
"SELECT sub_entity.name AS sub_entity_name "
"FROM sub_entity "
"WHERE :param_1 = sub_entity.id",
[{
"param_1": entity_id
}],
))
elif second_option == "defer":
# load will be a deferred load. this is because the explicit
# call to the deferred load put a deferred loader on the attribute
expected.append(
CompiledSQL(
"SELECT sub_entity.name AS sub_entity_name "
"FROM sub_entity "
"WHERE :param_1 = sub_entity.id",
[{
"param_1": entity_id
}],
))
asserter_.assert_(*expected)
