def test_bulk_update_future_synchronize_evaluate(self):
sess = self._fixture_data()
eq_(
set(row.temperature
for row in sess.execute(future_select(Report.temperature))),
{80.0, 75.0, 85.0},
)
temps = sess.execute(future_select(Report)).scalars().all()
eq_(set(t.temperature for t in temps), {80.0, 75.0, 85.0})
sess.execute(
update(Report).filter(Report.temperature >= 80).values(
{
"temperature": Report.temperature + 6
}, ).execution_options(synchronize_session="evaluate"))
eq_(
set(row.temperature
for row in sess.execute(future_select(Report.temperature))),
{86.0, 75.0, 91.0},
)
# test synchronize session as well
eq_(set(t.temperature for t in temps), {86.0, 75.0, 91.0})
def test_bulk_update_future_synchronize_fetch(self):
sess = self._fixture_data()
eq_(
set(row.temperature
for row in sess.execute(future_select(Report.temperature))),
{80.0, 75.0, 85.0},
)
temps = sess.execute(future_select(Report)).scalars().all()
eq_(set(t.temperature for t in temps), {80.0, 75.0, 85.0})
# MARKMARK
# omitting the criteria so that the UPDATE affects three out of
# four shards
sess.execute(
update(Report).values({
"temperature": Report.temperature + 6
}, ).execution_options(synchronize_session="fetch"))
eq_(
set(row.temperature
for row in sess.execute(future_select(Report.temperature))),
{86.0, 81.0, 91.0},
)
# test synchronize session as well
eq_(set(t.temperature for t in temps), {86.0, 81.0, 91.0})
def test_roundtrip_future(self):
sess = self._fixture_data()
tokyo = (sess.execute(
future_select(WeatherLocation).filter_by(
city="Tokyo")).scalars().one())
eq_(tokyo.city, "Tokyo")
asia_and_europe = sess.execute(
future_select(WeatherLocation).filter(
WeatherLocation.continent.in_(["Europe", "Asia"]))).scalars()
eq_(
{c.city
for c in asia_and_europe},
{"Tokyo", "London", "Dublin"},
)
def test_filter_by_no_property(self):
assert_raises_message(
exc.InvalidRequestError,
'Entity namespace for "mytable" has no property "foo"',
future_select(table1).filter_by,
foo="bar",
)
def test_orm_query_new_style_using_embedded_lambdas(n):
"""new style ORM select() of the full entity w/ embedded lambdas."""
session = Session(bind=engine)
for id_ in random.sample(ids, n):
stmt = future_select(lambda: Customer).where(
lambda: Customer.id == id_)
session.execute(stmt).scalar_one()
def test_core_just_statement_construct_plus_cache_key(n):
for i in range(n):
stmt = future_select(Customer.__table__).where(
Customer.id == bindparam("id")
)
stmt._generate_cache_key()
def test_join_nofrom_explicit_left_side_implicit_onclause(self):
stmt = future_select(parent).join_from(parent, child)
self.assert_compile(
stmt,
"SELECT parent.id, parent.data FROM parent JOIN child "
"ON parent.id = child.parent_id",
)
def test_orm_query_new_style_ext_lambdas_cols_only(n):
"""new style ORM query w/ external lambdas against columns."""
s = Session(bind=engine)
for id_ in random.sample(ids, n):
stmt = lambdas.lambda_stmt(lambda: future_select(
Customer.id, Customer.name, Customer.description)) + (
lambda s: s.filter(Customer.id == id_))
s.execute(stmt).one()
def test_join_froms_explicit_left_side_explicit_onclause(self):
stmt = (future_select(table1).select_from(table1).join_from(
table1, table2, table1.c.myid == table2.c.otherid))
self.assert_compile(
stmt,
"SELECT mytable.myid, mytable.name, mytable.description "
"FROM mytable JOIN myothertable "
"ON mytable.myid = myothertable.otherid",
)
def test_bulk_delete_future_synchronize_fetch(self):
sess = self._fixture_data()
temps = sess.execute(future_select(Report)).scalars().all()
eq_(set(t.temperature for t in temps), {80.0, 75.0, 85.0})
sess.execute(
delete(Report).filter(Report.temperature >= 80).execution_options(
synchronize_session="fetch"))
eq_(
set(row.temperature
for row in sess.execute(future_select(Report.temperature))),
{75.0},
)
# test synchronize session as well
for t in temps:
assert inspect(t).deleted is (t.temperature >= 80)
def test_query_explicit_shard_via_bind_opts(self):
sess = self._fixture_data()
stmt = future_select(WeatherLocation).filter(WeatherLocation.id == 1)
tokyo = (sess.execute(stmt, bind_arguments={
"shard_id": "asia"
}).scalars().first())
eq_(tokyo.city, "Tokyo")
def test_temp_table(self, connection):
table_name = "#tmp"
t = Table(
table_name,
self.metadata,
Column("id", Integer, primary_key=True),
Column("txt", String(50)),
)
t.create(connection)
connection.execute(t.insert({"txt": "temp table test"}))
result = connection.scalar(future_select(t.c.id))
eq_(result, 1)
connection.execute(text(f"DROP TABLE {table_name}"))
def test_future_selects_w_orm_joins(self):
User, Address, Keyword, Order, Item = self.classes(
"User", "Address", "Keyword", "Order", "Item")
a1 = aliased(Address)
self._run_cache_key_fixture(
lambda: (
future_select(User).join(User.addresses),
future_select(User).join(User.orders),
future_select(User).join(User.addresses).join(User.orders),
future_select(User).join(Address, User.addresses),
future_select(User).join(a1, User.addresses),
future_select(User).join(User.addresses.of_type(a1)),
future_select(User).join(Address, User.addresses).join_from(
User, Order),
future_select(User).join(Address, User.addresses).join_from(
User, User.orders),
future_select(User.id, Order.id).select_from(
orm_join(User, Order, User.orders)),
),
compare_values=True,
)
def test_bulk_update_evaluate(self):
Edge, Point = (self.classes.Edge, self.classes.Point)
sess = self._fixture()
e1 = sess.execute(
future_select(Edge).filter(Edge.start == Point(14, 5))
).scalar_one()
eq_(e1.end, Point(2, 7))
stmt = (
update(Edge)
.filter(Edge.start == Point(14, 5))
.values({Edge.end: Point(16, 10)})
)
sess.execute(stmt)
eq_(e1.end, Point(16, 10))
def test_joins_w_filter_by(self):
stmt = (future_select(parent).filter_by(
data="p1").join(child).filter_by(data="c1").join_from(
table1, table2,
table1.c.myid == table2.c.otherid).filter_by(otherid=5))
self.assert_compile(
stmt,
"SELECT parent.id, parent.data FROM parent JOIN child "
"ON parent.id = child.parent_id, mytable JOIN myothertable "
"ON mytable.myid = myothertable.otherid "
"WHERE parent.data = :data_1 AND child.data = :data_2 "
"AND myothertable.otherid = :otherid_1",
checkparams={
"data_1": "p1",
"data_2": "c1",
"otherid_1": 5
},
)
def test_wp_objects(self):
Person, Manager, Engineer, Boss = self.classes("Person", "Manager",
"Engineer", "Boss")
self._run_cache_key_fixture(
lambda: (
inspect(with_polymorphic(Person, [Manager, Engineer])),
inspect(with_polymorphic(Person, [Manager])),
inspect(with_polymorphic(Person, [Manager, Engineer, Boss])),
inspect(
with_polymorphic(Person, [Manager, Engineer], flat=True)),
inspect(
with_polymorphic(
Person,
[Manager, Engineer],
future_select(Person).outerjoin(Manager).outerjoin(
Engineer).subquery(),
)),
),
compare_values=True,
)
def test_bulk_update_sql(self):
Edge, Point = (self.classes.Edge, self.classes.Point)
sess = self._fixture()
e1 = sess.execute(
future_select(Edge).filter(Edge.start == Point(14, 5))
).scalar_one()
eq_(e1.end, Point(2, 7))
stmt = (
update(Edge)
.filter(Edge.start == Point(14, 5))
.values({Edge.end: Point(16, 10)})
)
self.assert_compile(
stmt,
"UPDATE edges SET x2=:x2, y2=:y2 WHERE edges.x1 = :x1_1 "
"AND edges.y1 = :y1_1",
params={"x2": 16, "x1_1": 14, "y2": 10, "y1_1": 5},
dialect="default",
)