def test_joined_entity(self):
     query = self.session.query(self.TextItem).join(
         self.BlogPost, self.BlogPost.id == self.TextItem.id
     )
     assert list(get_query_entities(query)) == [
         self.TextItem, self.BlogPost
     ]
    def test_joined_aliased_entity(self):
        alias = sa.orm.aliased(self.BlogPost)

        query = self.session.query(self.TextItem).join(
            alias, alias.id == self.TextItem.id
        )
        assert list(get_query_entities(query)) == [self.TextItem, alias]
    def test_with_subquery(self):
        number_of_articles = (sa.select([sa.func.count(self.Article.id)]).select_from(self.Article.__table__)).label(
            "number_of_articles"
        )

        query = self.session.query(self.Article, number_of_articles)
        assert list(get_query_entities(query)) == [self.Article, number_of_articles]
Exemple #4
0
    def test_with_subquery(self):
        number_of_articles = (sa.select(
            [sa.func.count(self.Article.id)], ).select_from(
                self.Article.__table__)).label('number_of_articles')

        query = self.session.query(self.Article, number_of_articles)
        assert get_query_entities(query) == [self.Article, number_of_articles]
    def test_joined_aliased_entity(self):
        alias = sa.orm.aliased(self.BlogPost)

        query = self.session.query(self.TextItem).join(
            alias, alias.id == self.TextItem.id
        )
        assert get_query_entities(query) == [self.TextItem, alias]
 def test_joined_entity(self, session, TextItem, BlogPost):
     query = session.query(TextItem).join(
         BlogPost, BlogPost.id == TextItem.id
     )
     assert get_query_entities(query) == [
         TextItem, sa.inspect(BlogPost)
     ]
 def test_joined_entity(self):
     query = self.session.query(self.TextItem).join(
         self.BlogPost, self.BlogPost.id == self.TextItem.id
     )
     assert list(get_query_entities(query)) == [
         self.TextItem, sa.inspect(self.BlogPost)
     ]
    def test_joined_aliased_entity(self, session, TextItem, BlogPost):
        alias = sa.orm.aliased(BlogPost)

        query = session.query(TextItem).join(
            alias, alias.id == TextItem.id
        )
        assert get_query_entities(query) == [TextItem, alias]
    def test_with_subquery(self, session, Article):
        number_of_articles = (
            sa.select(
                [sa.func.count(Article.id)],
            )
            .select_from(
                Article.__table__
            )
        ).label('number_of_articles')

        query = session.query(Article, number_of_articles)
        assert get_query_entities(query) == [
            Article,
            number_of_articles
        ]
 def test_aliased_entity(self, session, Article):
     alias = sa.orm.aliased(Article)
     query = session.query(alias)
     assert get_query_entities(query) == [alias]
 def test_mapper(self):
     query = self.session.query(sa.inspect(self.TextItem))
     assert list(get_query_entities(query)) == [sa.inspect(self.TextItem)]
Exemple #12
0
 def test_column(self):
     query = self.session.query(self.TextItem.__table__.c.id)
     assert get_query_entities(query) == [self.TextItem.__table__]
Exemple #13
0
 def test_column_entity_with_label(self):
     query = self.session.query(self.Article.id.label('id'))
     assert get_query_entities(query) == [self.Article]
 def test_aliased_entity(self):
     alias = sa.orm.aliased(self.Article)
     query = self.session.query(alias)
     assert list(get_query_entities(query)) == [alias]
Exemple #15
0
 def test_entity(self):
     query = self.session.query(self.TextItem)
     assert get_query_entities(query) == [self.TextItem]
 def test_column(self):
     query = self.session.query(self.TextItem.__table__.c.id)
     assert list(get_query_entities(query)) == [self.TextItem.__table__]
 def test_mapper(self, session, TextItem):
     query = session.query(sa.inspect(TextItem))
     assert get_query_entities(query) == [TextItem]
 def test_entity(self):
     query = self.session.query(self.TextItem)
     assert list(get_query_entities(query)) == [self.TextItem]
 def test_entity(self, session, TextItem):
     query = session.query(TextItem)
     assert get_query_entities(query) == [TextItem]
 def test_aliased_selectable(self, session, TextItem, BlogPost):
     selectable = sa.orm.with_polymorphic(TextItem, [BlogPost])
     query = session.query(selectable)
     assert get_query_entities(query) == [selectable]
 def test_column(self, session, TextItem):
     query = session.query(TextItem.__table__.c.id)
     assert get_query_entities(query) == [TextItem.__table__]
 def test_instrumented_attribute(self, session, TextItem):
     query = session.query(TextItem.id)
     assert get_query_entities(query) == [TextItem]
 def test_instrumented_attribute(self):
     query = self.session.query(self.TextItem.id)
     assert list(get_query_entities(query)) == [sa.inspect(self.TextItem)]
 def test_column_entity_with_label(self, session, Article):
     query = session.query(Article.id.label('id'))
     assert get_query_entities(query) == [Article]
 def test_aliased_selectable(self):
     selectable = sa.orm.with_polymorphic(self.TextItem, [self.BlogPost])
     query = self.session.query(selectable)
     assert list(get_query_entities(query)) == [selectable]
 def test_mapper(self, session, TextItem):
     query = session.query(sa.inspect(TextItem))
     assert get_query_entities(query) == [TextItem]
 def test_column_entity_with_label(self):
     query = self.session.query(self.Article.id.label('id'))
     assert list(get_query_entities(query)) == [sa.inspect(self.Article)]
 def test_entity(self, session, TextItem):
     query = session.query(TextItem)
     assert get_query_entities(query) == [TextItem]
Exemple #29
0
 def test_mapper(self):
     query = self.session.query(sa.inspect(self.TextItem))
     assert get_query_entities(query) == [self.TextItem]
Exemple #30
0
 def test_aliased_entity(self):
     alias = sa.orm.aliased(self.Article)
     query = self.session.query(alias)
     assert get_query_entities(query) == [alias]
Exemple #31
0
 def test_instrumented_attribute(self):
     query = self.session.query(self.TextItem.id)
     assert get_query_entities(query) == [self.TextItem]
Exemple #32
0
def _build_criterion(query):
    main_decl_class = None
    decl_class_by_tablename = {}

    # get main decl class and aliases using in query
    for entity in sau.get_query_entities(query):
        if isinstance(entity, sa.orm.util.AliasedClass):
            name = sa.inspect(entity).name
        elif isinstance(entity, sa.orm.Mapper):
            continue
        else:
            name = sau.functions.get_mapper(entity).tables[0].name
            if main_decl_class is None:
                main_decl_class = entity

        decl_class_by_tablename[name] = entity

    # get other decl classes
    base = sau.functions.get_declarative_base(main_decl_class)
    for c in base._decl_class_registry.values():
        if hasattr(c, '__tablename__'
                   ) and c.__tablename__ not in decl_class_by_tablename:
            decl_class_by_tablename[c.__tablename__] = c

    def _criterion(attr, op, value):
        op = op.lower()

        if '.' in attr:
            (tablename, attr) = attr.split('.', maxsplit=1)
            if tablename in decl_class_by_tablename:
                class_attr = getattr(decl_class_by_tablename[tablename], attr,
                                     None)
            else:
                raise KeyError('not found declarative class: %s' % tablename)
        else:
            class_attr = getattr(main_decl_class, attr, None)

        if class_attr is None:
            raise AttributeError(
                'main declarative class does not have attribute: %s' % attr)

        if op == '==':
            return class_attr == value
        elif op == '!=':
            return class_attr != value
        elif op == '>=':
            return class_attr >= value
        elif op == '>':
            return class_attr > value
        elif op == '<=':
            return class_attr <= value
        elif op == '<':
            return class_attr < value
        elif op == 'in':
            if not isinstance(value, list):
                value = [value]
            return class_attr.in_(value)
        elif op == '!in':
            if not isinstance(value, list):
                value = [value]
            return ~class_attr.in_(value)
        elif op == 'like':
            return class_attr.like(value)
        elif op == '!like':
            return ~class_attr.like(value)
        else:
            raise ValueError('invalid op: %s' % op)

    return _criterion
Exemple #33
0
 def test_aliased_selectable(self):
     selectable = sa.orm.with_polymorphic(self.TextItem, [self.BlogPost])
     query = self.session.query(selectable)
     assert get_query_entities(query) == [selectable]
    def test_joined_aliased_entity(self, session, TextItem, BlogPost):
        alias = sa.orm.aliased(BlogPost)

        query = session.query(TextItem).join(alias, alias.id == TextItem.id)
        assert get_query_entities(query) == [TextItem, alias]
 def test_column(self, session, TextItem):
     query = session.query(TextItem.__table__.c.id)
     assert get_query_entities(query) == [TextItem.__table__]
 def test_column_entity_with_label(self):
     query = self.session.query(self.Article.id.label('id'))
     assert list(get_query_entities(query)) == [sa.inspect(self.Article)]
Exemple #37
0
def construct_filter(query, items, conjunction='and'):
    """ Construct a filter from a combination of filter items

    Args:
        query (sqlalchemy.orm.query.Query): The SQLAlchemy SQL ORM object
        items (list[str]): List of query expressions in form of
            "[KEY][OPERATOR][VALUE...]"
        conjunction (str): Combine the filter items using 'and' or 'or'

    Returns:
        sqlalchemy.orm.query.Query: A query with filter items applied

    Raises:
        KeyError: Raise if column given in filter expression does not exist
    """
    # Find table model
    entities = sau.get_query_entities(query)
    if len(entities) > 1:
        logger.warning('Using first entity from search query ({})'
                       .format(entities[0]))
    table = entities[0]
    base = sau.get_declarative_base(table)

    # Parse expressions
    items = [_convert_expression_operator(item) for item in items]
    exprs = [_parse_expression_filter(item) for item in items]

    filters = []
    joins = set([])
    for key, operator, value in exprs:
        # Preprocess case of linked table
        if '.' in key:
            _tablename, key = key.split('.', maxsplit=1)
            _table = _tablename_to_class(base, _tablename)
            joins.update([t for t in _link_path(TABLES_GRAPH, table, _table)
                          if t is not table])
        else:
            _table = table

        column = getattr(_table, key, None)
        if column is None:
            raise KeyError('Cannot construct filter: column "{}" does not '
                           'exist'.format(key))

        if operator.lower() == 'in':
            value = [convert_query_type(column, v) for v in
                     value.replace(' ', ',').split(',') if v]
            filter_item = column.in_(value)
        else:
            attr = [pattern % operator for pattern in
                    ('%s', '%s_', '__%s__')
                    if hasattr(column, pattern % operator)]
            if not attr:
                raise KeyError('Cannot construct filter: column {} is not '
                               'usable with "{}"'.format(key, operator))
            if value.lower() in ('null', 'none', 'na', 'nan'):
                value = None
            else:
                value = convert_query_type(column, value)
            filter_item = getattr(column, attr[0])(value)
        filters.append(filter_item)

    for join_table in joins:
        query = query.join(join_table)
    if conjunction == 'or':
        return query.filter(sa.or_(*filters))
    else:
        return query.filter(sa.and_(*filters))
 def test_joined_entity(self, session, TextItem, BlogPost):
     query = session.query(TextItem).join(BlogPost,
                                          BlogPost.id == TextItem.id)
     assert get_query_entities(query) == [TextItem, sa.inspect(BlogPost)]