def build_single_included(self, fields, path):
relationships = path_to_relationships(path, self.model)
cls = relationships[-1].mapper.class_
subalias = sa.orm.aliased(cls)
subquery = select_correlated_expression(
self.model,
subalias.id,
path,
subalias,
self.from_obj,
correlate=False).with_only_columns(split_if_composite(
subalias.id)).distinct()
alias = sa.orm.aliased(cls)
expr = self.build_included_json_object(alias, fields)
query = sa.select([expr], from_obj=alias).where(
alias.id.in_(subquery)).distinct()
if cls is self.model:
query = query.where(
alias.id.notin_(
sa.select(split_if_composite(get_attrs(self.from_obj).id),
from_obj=self.from_obj)))
return query
def test_with_non_aggregate_function(self, session, User, Article):
aggregate = select_correlated_expression(
Article, sa.func.json_build_object('name', User.name),
'comments.author', User)
query = session.query(
Article.id, aggregate.label('author_json')).order_by(Article.id)
result = query.all()
assert result == [(1, {'name': 'User 1'})]
def test_returns_correct_results(self, session, model_mapping, model_key,
related_model_key, path, result):
model = model_mapping[model_key]
alias = sa.orm.aliased(model_mapping[related_model_key])
aggregate = select_correlated_expression(
model, sa.func.count(sa.distinct(alias.id)), path, alias)
query = session.query(model.id,
aggregate.label('count')).order_by(model.id)
assert query.all() == result
def build_relationship_data(self, relationship, alias):
identifier = self.query_builder.build_resource_identifier(alias, alias)
expr = sa.func.json_build_object(*identifier).label('json_object')
query = select_correlated_expression(
self.model,
expr,
relationship.key,
alias,
get_selectable(self.from_obj),
order_by=relationship.order_by).alias('relationships')
return query
def test_order_by_intermediate_table_column(self, session, model_mapping,
group_user_tbl):
model = model_mapping['users']
alias = sa.orm.aliased(model_mapping['groups'])
aggregate = select_correlated_expression(
model,
sa.func.json_build_object('id', alias.id),
'groups',
alias,
order_by=[group_user_tbl.c.user_id]).alias('test')
# Just check that the query execution doesn't fail because of wrongly
# constructed aliases
assert session.execute(aggregate)
def build_relationship_data(self, relationship, alias):
identifier = self.query_builder.build_resource_identifier(
alias,
alias
)
expr = sa.func.json_build_object(*identifier).label('json_object')
query = select_correlated_expression(
self.model,
expr,
relationship.key,
alias,
get_selectable(self.from_obj),
order_by=self.build_order_by(relationship, alias)
).alias('relationships')
return query
def build_single_included(self, fields, path):
relationships = path_to_relationships(path, self.model)
cls = relationships[-1].mapper.class_
alias = sa.orm.aliased(cls)
expr = self.build_included_json_object(alias, fields)
query = select_correlated_expression(self.model,
expr,
path,
alias,
self.from_obj,
correlate=False).distinct()
if cls is self.model:
query = query.where(
alias.id.notin_(
sa.select([get_attrs(self.from_obj).id],
from_obj=self.from_obj)))
return query
def test_order_by_intermediate_table_column(
self,
session,
model_mapping,
group_user_tbl
):
model = model_mapping['users']
alias = sa.orm.aliased(model_mapping['groups'])
aggregate = select_correlated_expression(
model,
sa.func.json_build_object('id', alias.id),
'groups',
alias,
order_by=[group_user_tbl.c.user_id]
).alias('test')
# Just check that the query execution doesn't fail because of wrongly
# constructed aliases
assert session.execute(aggregate)
def test_with_non_aggregate_function(
self,
session,
user_cls,
article_cls
):
aggregate = select_correlated_expression(
article_cls,
sa.func.json_build_object('name', user_cls.name),
'comments.author',
user_cls
)
query = session.query(
article_cls.id,
aggregate.label('author_json')
).order_by(article_cls.id)
result = query.all()
assert result == [
(1, {'name': 'User 1'})
]
def test_returns_correct_results(
self,
session,
model_mapping,
model_key,
related_model_key,
path,
result
):
model = model_mapping[model_key]
alias = sa.orm.aliased(model_mapping[related_model_key])
aggregate = select_correlated_expression(
model,
sa.func.count(sa.distinct(alias.id)),
path,
alias
)
query = session.query(
model.id,
aggregate.label('count')
).order_by(model.id)
assert query.all() == result
def build_single_included(self, fields, path):
relationships = path_to_relationships(path, self.model)
cls = relationships[-1].mapper.class_
alias = sa.orm.aliased(cls)
expr = self.build_included_json_object(alias, fields)
query = select_correlated_expression(
self.model,
expr,
path,
alias,
get_selectable(self.from_obj),
correlate=False
).distinct()
if cls is self.model:
query = query.where(
alias.id.notin_(
sa.select(
[get_attrs(self.from_obj).id],
from_obj=self.from_obj
)
)
)
return query
