def __init__(self, prop, primaryjoin, secondaryjoin, parentclauses=None):
super(PropertyAliasedClauses, self).__init__(prop.select_table)
self.parentclauses = parentclauses
if parentclauses is not None:
self.path = parentclauses.path + (prop.parent, prop.key)
else:
self.path = (prop.parent, prop.key)
self.prop = prop
if prop.secondary:
self.secondary = prop.secondary.alias()
if parentclauses is not None:
primary_aliasizer = sql_util.ClauseAdapter(
self.secondary).chain(
sql_util.ClauseAdapter(parentclauses.alias))
secondary_aliasizer = sql_util.ClauseAdapter(self.alias).chain(
sql_util.ClauseAdapter(self.secondary))
else:
primary_aliasizer = sql_util.ClauseAdapter(self.secondary)
secondary_aliasizer = sql_util.ClauseAdapter(self.alias).chain(
sql_util.ClauseAdapter(self.secondary))
self.secondaryjoin = secondary_aliasizer.traverse(secondaryjoin,
clone=True)
self.primaryjoin = primary_aliasizer.traverse(primaryjoin,
clone=True)
else:
if parentclauses is not None:
aliasizer = sql_util.ClauseAdapter(self.alias,
exclude=prop.local_side)
aliasizer.chain(
sql_util.ClauseAdapter(parentclauses.alias,
exclude=prop.remote_side))
else:
aliasizer = sql_util.ClauseAdapter(self.alias,
exclude=prop.local_side)
self.primaryjoin = aliasizer.traverse(primaryjoin, clone=True)
self.secondary = None
self.secondaryjoin = None
if prop.order_by:
self.order_by = sql_util.ClauseAdapter(
self.alias).copy_and_process(util.to_list(prop.order_by))
else:
self.order_by = None
def test_adapt_union(self):
u = union(t1.select().where(t1.c.col1 == 4),
t1.select().where(t1.c.col1 == 5)).alias()
assert sql_util.ClauseAdapter(u).traverse(t1) is u
def adapt_list(self, clauses):
return sql_util.ClauseAdapter(self.alias).copy_and_process(clauses)
def adapt_clause(self, clause):
return sql_util.ClauseAdapter(self.alias).traverse(clause, clone=True)
def test_table_to_alias(self):
t1alias = t1.alias('t1alias')
vis = sql_util.ClauseAdapter(t1alias)
ff = vis.traverse(func.count(t1.c.col1).label('foo'))
assert list(_from_objects(ff)) == [t1alias]
self.assert_compile(vis.traverse(select(['*'], from_obj=[t1])),
'SELECT * FROM table1 AS t1alias')
self.assert_compile(
select(['*'], t1.c.col1 == t2.c.col2),
'SELECT * FROM table1, table2 WHERE '
'table1.col1 = table2.col2')
self.assert_compile(
vis.traverse(select(['*'], t1.c.col1 == t2.c.col2)),
'SELECT * FROM table1 AS t1alias, table2 '
'WHERE t1alias.col1 = table2.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2])),
'SELECT * FROM table1 AS t1alias, table2 '
'WHERE t1alias.col1 = table2.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t1)),
'SELECT * FROM table2 WHERE t1alias.col1 = '
'table2.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t2)),
'SELECT * FROM table1 AS t1alias WHERE '
't1alias.col1 = table2.col2')
self.assert_compile(
vis.traverse(case([(t1.c.col1 == 5, t1.c.col2)], else_=t1.c.col1)),
'CASE WHEN (t1alias.col1 = :col1_1) THEN '
't1alias.col2 ELSE t1alias.col1 END')
self.assert_compile(
vis.traverse(
case([(5, t1.c.col2)], value=t1.c.col1, else_=t1.c.col1)),
'CASE t1alias.col1 WHEN :param_1 THEN '
't1alias.col2 ELSE t1alias.col1 END')
s = select(['*'], from_obj=[t1]).alias('foo')
self.assert_compile(
s.select(), 'SELECT foo.* FROM (SELECT * FROM table1) '
'AS foo')
self.assert_compile(
vis.traverse(s.select()),
'SELECT foo.* FROM (SELECT * FROM table1 '
'AS t1alias) AS foo')
self.assert_compile(
s.select(), 'SELECT foo.* FROM (SELECT * FROM table1) '
'AS foo')
ff = vis.traverse(func.count(t1.c.col1).label('foo'))
self.assert_compile(
select([ff]), 'SELECT count(t1alias.col1) AS foo FROM '
'table1 AS t1alias')
assert list(_from_objects(ff)) == [t1alias]
# TODO: self.assert_compile(vis.traverse(select([func.count(t1.c
# .col1).l abel('foo')]), clone=True), "SELECT
# count(t1alias.col1) AS foo FROM table1 AS t1alias")
t2alias = t2.alias('t2alias')
vis.chain(sql_util.ClauseAdapter(t2alias))
self.assert_compile(
vis.traverse(select(['*'], t1.c.col1 == t2.c.col2)),
'SELECT * FROM table1 AS t1alias, table2 '
'AS t2alias WHERE t1alias.col1 = '
't2alias.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2])),
'SELECT * FROM table1 AS t1alias, table2 '
'AS t2alias WHERE t1alias.col1 = '
't2alias.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t1)),
'SELECT * FROM table2 AS t2alias WHERE '
't1alias.col1 = t2alias.col2')
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t2)),
'SELECT * FROM table1 AS t1alias WHERE '
't1alias.col1 = t2alias.col2')
def test_correlation_on_clone(self):
t1alias = t1.alias('t1alias')
t2alias = t2.alias('t2alias')
vis = sql_util.ClauseAdapter(t1alias)
s = select(['*'], from_obj=[t1alias, t2alias]).as_scalar()
assert t2alias in s._froms
assert t1alias in s._froms
self.assert_compile(
select(['*'], t2alias.c.col1 == s),
'SELECT * FROM table2 AS t2alias WHERE '
't2alias.col1 = (SELECT * FROM table1 AS '
't1alias)')
s = vis.traverse(s)
assert t2alias not in s._froms # not present because it's been
# cloned
assert t1alias in s._froms # present because the adapter placed
# it there
# correlate list on "s" needs to take into account the full
# _cloned_set for each element in _froms when correlating
self.assert_compile(
select(['*'], t2alias.c.col1 == s),
'SELECT * FROM table2 AS t2alias WHERE '
't2alias.col1 = (SELECT * FROM table1 AS '
't1alias)')
s = select(['*'], from_obj=[t1alias,
t2alias]).correlate(t2alias).as_scalar()
self.assert_compile(
select(['*'], t2alias.c.col1 == s),
'SELECT * FROM table2 AS t2alias WHERE '
't2alias.col1 = (SELECT * FROM table1 AS '
't1alias)')
s = vis.traverse(s)
self.assert_compile(
select(['*'], t2alias.c.col1 == s),
'SELECT * FROM table2 AS t2alias WHERE '
't2alias.col1 = (SELECT * FROM table1 AS '
't1alias)')
s = CloningVisitor().traverse(s)
self.assert_compile(
select(['*'], t2alias.c.col1 == s),
'SELECT * FROM table2 AS t2alias WHERE '
't2alias.col1 = (SELECT * FROM table1 AS '
't1alias)')
s = select(['*']).where(t1.c.col1 == t2.c.col1).as_scalar()
self.assert_compile(
select([t1.c.col1, s]),
'SELECT table1.col1, (SELECT * FROM table2 '
'WHERE table1.col1 = table2.col1) AS '
'anon_1 FROM table1')
vis = sql_util.ClauseAdapter(t1alias)
s = vis.traverse(s)
self.assert_compile(
select([t1alias.c.col1, s]), 'SELECT t1alias.col1, (SELECT * FROM '
'table2 WHERE t1alias.col1 = table2.col1) '
'AS anon_1 FROM table1 AS t1alias')
s = CloningVisitor().traverse(s)
self.assert_compile(
select([t1alias.c.col1, s]), 'SELECT t1alias.col1, (SELECT * FROM '
'table2 WHERE t1alias.col1 = table2.col1) '
'AS anon_1 FROM table1 AS t1alias')
s = select(['*'
]).where(t1.c.col1 == t2.c.col1).correlate(t1).as_scalar()
self.assert_compile(
select([t1.c.col1, s]),
'SELECT table1.col1, (SELECT * FROM table2 '
'WHERE table1.col1 = table2.col1) AS '
'anon_1 FROM table1')
vis = sql_util.ClauseAdapter(t1alias)
s = vis.traverse(s)
self.assert_compile(
select([t1alias.c.col1, s]), 'SELECT t1alias.col1, (SELECT * FROM '
'table2 WHERE t1alias.col1 = table2.col1) '
'AS anon_1 FROM table1 AS t1alias')
s = CloningVisitor().traverse(s)
self.assert_compile(
select([t1alias.c.col1, s]), 'SELECT t1alias.col1, (SELECT * FROM '
'table2 WHERE t1alias.col1 = table2.col1) '
'AS anon_1 FROM table1 AS t1alias')
def test_table_to_alias(self):
t1alias = t1.alias('t1alias')
vis = sql_util.ClauseAdapter(t1alias)
ff = vis.traverse(func.count(t1.c.col1).label('foo'))
assert list(_from_objects(ff)) == [t1alias]
self.assert_compile(vis.traverse(select(['*'], from_obj=[t1])),
"SELECT * FROM table1 AS t1alias")
self.assert_compile(
select(['*'], t1.c.col1 == t2.c.col2),
"SELECT * FROM table1, table2 WHERE table1.col1 = table2.col2")
self.assert_compile(
vis.traverse(select(['*'], t1.c.col1 == t2.c.col2)),
"SELECT * FROM table1 AS t1alias, table2 WHERE t1alias.col1 = table2.col2"
)
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2])),
"SELECT * FROM table1 AS t1alias, table2 WHERE t1alias.col1 = table2.col2"
)
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t1)),
"SELECT * FROM table2 WHERE t1alias.col1 = table2.col2")
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t2)),
"SELECT * FROM table1 AS t1alias WHERE t1alias.col1 = table2.col2")
s = select(['*'], from_obj=[t1]).alias('foo')
self.assert_compile(s.select(),
"SELECT foo.* FROM (SELECT * FROM table1) AS foo")
self.assert_compile(
vis.traverse(s.select()),
"SELECT foo.* FROM (SELECT * FROM table1 AS t1alias) AS foo")
self.assert_compile(s.select(),
"SELECT foo.* FROM (SELECT * FROM table1) AS foo")
ff = vis.traverse(func.count(t1.c.col1).label('foo'))
self.assert_compile(
select([ff]),
"SELECT count(t1alias.col1) AS foo FROM table1 AS t1alias")
assert list(_from_objects(ff)) == [t1alias]
# TODO:
# self.assert_compile(vis.traverse(select([func.count(t1.c.col1).label('foo')]), clone=True), "SELECT count(t1alias.col1) AS foo FROM table1 AS t1alias")
t2alias = t2.alias('t2alias')
vis.chain(sql_util.ClauseAdapter(t2alias))
self.assert_compile(
vis.traverse(select(['*'], t1.c.col1 == t2.c.col2)),
"SELECT * FROM table1 AS t1alias, table2 AS t2alias WHERE t1alias.col1 = t2alias.col2"
)
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2, from_obj=[t1, t2])),
"SELECT * FROM table1 AS t1alias, table2 AS t2alias WHERE t1alias.col1 = t2alias.col2"
)
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t1)),
"SELECT * FROM table2 AS t2alias WHERE t1alias.col1 = t2alias.col2"
)
self.assert_compile(
vis.traverse(
select(['*'], t1.c.col1 == t2.c.col2,
from_obj=[t1, t2]).correlate(t2)),
"SELECT * FROM table1 AS t1alias WHERE t1alias.col1 = t2alias.col2"
)
def __init__(self, alias, comparator):
self.alias = alias
self.comparator = comparator
self.adapter = sql_util.ClauseAdapter(alias)
def get_join(self,
parent,
primary=True,
secondary=True,
polymorphic_parent=True):
"""return a join condition from the given parent mapper to this PropertyLoader's mapper.
The resulting ClauseElement object is cached and should not be modified directly.
parent
a mapper which has a relation() to this PropertyLoader. A PropertyLoader can
have multiple "parents" when its actual parent mapper has inheriting mappers.
primary
include the primary join condition in the resulting join.
secondary
include the secondary join condition in the resulting join. If both primary
and secondary are returned, they are joined via AND.
polymorphic_parent
if True, use the parent's 'select_table' instead of its 'mapped_table' to produce the join.
"""
try:
return self._parent_join_cache[(parent, primary, secondary,
polymorphic_parent)]
except KeyError:
parent_equivalents = parent._get_equivalent_columns()
secondaryjoin = self.polymorphic_secondaryjoin
if polymorphic_parent:
# adapt the "parent" side of our join condition to the "polymorphic" select of the parent
if self.direction is sync.ONETOMANY:
primaryjoin = sql_util.ClauseAdapter(
parent.select_table,
exclude=self.foreign_keys,
equivalents=parent_equivalents).traverse(
self.polymorphic_primaryjoin, clone=True)
elif self.direction is sync.MANYTOONE:
primaryjoin = sql_util.ClauseAdapter(
parent.select_table,
include=self.foreign_keys,
equivalents=parent_equivalents).traverse(
self.polymorphic_primaryjoin, clone=True)
elif self.secondaryjoin:
primaryjoin = sql_util.ClauseAdapter(
parent.select_table,
exclude=self.foreign_keys,
equivalents=parent_equivalents).traverse(
self.polymorphic_primaryjoin, clone=True)
if secondaryjoin is not None:
if secondary and not primary:
j = secondaryjoin
elif primary and secondary:
j = primaryjoin & secondaryjoin
elif primary and not secondary:
j = primaryjoin
else:
j = primaryjoin
self._parent_join_cache[(parent, primary, secondary,
polymorphic_parent)] = j
return j
