sqlalchemy.orm.Query

Here are the examples of the python api sqlalchemy.orm.Query taken from open source projects. By voting up you can indicate which examples are most useful and appropriate.

17 Examples 7

Example 1

Project: aiorest-ws Source File: test_serializers.py
Function: test_run_validation
    def test_run_validation(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True,
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        data = {
            'name': 'admin',
            'addresses': [],
            'gender': 'male'
        }
        instance = UserSerializer(data, allow_null=True)

        self.assertEqual(instance.run_validation(data), data)

Example 2

Project: aiorest-ws Source File: test_serializers.py
    def test_run_validation_returns_empty_value(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        instance = UserSerializer(allow_null=True)

        self.assertIsNone(instance.run_validation(None))

Example 3

Project: OpenTAXII Source File: sqldb_helper.py
    def __init__(self, db_connection, base_model, session_options=None):

        self.engine = engine.create_engine(db_connection, convert_unicode=True)

        self.Query = orm.Query
        self.session = self.create_scoped_session(session_options)
        self.Model = self.extend_base_model(base_model)

Example 4

Project: kit Source File: orm.py
Function: get
  def __get__(self, obj, cls):
    try:
      mapper = class_mapper(cls)
      if mapper:
        return Query(mapper, session=self.session())
    except UnmappedClassError:
      return None

Example 5

Project: aiorest-ws Source File: test_serializers.py
    @override_settings(SQLALCHEMY_SESSION=SESSION)
    def test_create_with_relation_data(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        session = SESSION()
        address = self.TestModelSerializerAddressModel(email='[email protected]')
        session.add(address)
        session.commit()
        data = {
            'name': 'admin_with_email',
            'addresses': [{'id': address.id}, ],
            'gender': 'male'
        }
        instance = UserSerializer(data=data)
        instance.is_valid(raise_exception=True)
        instance.create(instance.validated_data)
        user = session \
            .query(self.TestModelSerializerUserModel) \
            .filter(self.TestModelSerializerUserModel.name == data['name']) \
            .first()

        self.assertIsNotNone(user)
        self.assertIsInstance(user, self.TestModelSerializerUserModel)
        self.assertEqual(user.name, data['name'])
        self.assertEqual(user.gender, data['gender'])
        self.assertEqual(user.addresses[0].id, address.id)

        session.delete(user)
        session.delete(address)
        session.commit()
        session.close()

Example 6

Project: aiorest-ws Source File: test_serializers.py
    @override_settings(SQLALCHEMY_SESSION=SESSION)
    def test_create_raise_type_error(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        session = SESSION()
        address = self.TestModelSerializerAddressModel(email='[email protected]')
        session.add(address)
        session.commit()
        data = {
            'name': 'admin_with_email',
            'addresses': [{'id': address.id}, ],
            'gender': 'male'

        }
        instance = UserSerializer(data=data)
        instance.is_valid(raise_exception=True)

        self.assertRaises(TypeError, instance.create, data)

        session.delete(address)
        session.commit()
        session.close()

Example 7

Project: aiorest-ws Source File: test_serializers.py
    @override_settings(SQLALCHEMY_SESSION=SESSION)
    def test_update_with_relations(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        session = SESSION()
        address = self.TestModelSerializerAddressModel(email='[email protected]')
        session.add(address)
        session.commit()
        data = {
            'name': 'admin_for_update_v1',
            'addresses': [],
            'gender': 'male'
        }
        instance = UserSerializer(data=data)
        instance.is_valid(raise_exception=True)
        instance.save()
        user = session \
            .query(self.TestModelSerializerUserModel) \
            .filter(self.TestModelSerializerUserModel.name == data['name']) \
            .first()

        self.assertIsNotNone(user)
        self.assertIsInstance(user, self.TestModelSerializerUserModel)
        self.assertEqual(user.name, data['name'])
        self.assertEqual(user.gender, data['gender'])

        data = {
            'name': 'admin_for_update_v2',
            'addresses': [{'id': address.id}, ],
            'gender': 'male'
        }
        instance = UserSerializer(user, data=data, partial=True)
        instance.is_valid(raise_exception=True)
        updated_user = instance.save()

        self.assertIsNotNone(updated_user)
        self.assertIsInstance(updated_user, self.TestModelSerializerUserModel)
        self.assertEqual(updated_user.name, data['name'])
        self.assertEqual(updated_user.gender, data['gender'])
        self.assertEqual(len(updated_user.addresses), 1)
        self.assertEqual(updated_user.addresses[0].id, address.id)

        session.delete(address)
        session.delete(user)
        session.commit()
        session.close()

Example 8

Project: aiorest-ws Source File: test_serializers.py
    @override_settings(SQLALCHEMY_SESSION=SESSION)
    def test_update_raises_validate_error_for_object_does_not_exist(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True
            )

            class Meta:
                model = self.TestModelSerializerUserModel

        session = SESSION()
        address = self.TestModelSerializerAddressModel(email='[email protected]')
        session.add(address)
        session.commit()
        data = {
            'name': 'admin_for_update_v1',
            'addresses': [],
            'gender': 'male'
        }
        instance = UserSerializer(data=data)
        instance.is_valid(raise_exception=True)
        instance.save()
        user = session \
            .query(self.TestModelSerializerUserModel) \
            .filter(self.TestModelSerializerUserModel.name == data['name']) \
            .first()

        self.assertIsNotNone(user)
        self.assertIsInstance(user, self.TestModelSerializerUserModel)
        self.assertEqual(user.name, data['name'])
        self.assertEqual(user.gender, data['gender'])

        data = {
            'name': 'admin_for_update_v2',
            'addresses': [{'id': address.id}, ],
            'gender': 'male'
        }
        instance = UserSerializer(user, data=data, partial=True)
        instance.is_valid(raise_exception=True)
        session.delete(user)
        session.commit()

        self.assertRaises(ValidationError, instance.save)

        session.delete(address)
        session.commit()
        session.close()

Example 9

Project: aiorest-ws Source File: test_serializers.py
    def test_run_validation_raises_error_for_assert(self):

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True,
            )

            class Meta:
                model = self.TestModelSerializerUserModel

            def validate(self, data):
                return None  # suppose, that something happens wrong

        data = {
            'name': 'admin',
            'addresses': [],
            'gender': 'male'
        }
        instance = UserSerializer(data, allow_null=True)

        self.assertRaises(ValidationError, instance.run_validation, data)

Example 10

Project: aiorest-ws Source File: test_serializers.py
    def test_run_validation_raises_error_for_validation_error(self):

        class AdminNameValidator(BaseValidator):
            def __call__(self, data):
                if data['name'] == 'admin':
                    raise ValidationError("Permission denied.")

        class UserSerializer(ModelSerializer):
            addresses = serializers.PrimaryKeyRelatedField(
                queryset=Query(self.TestModelSerializerAddressModel),
                many=True,
            )

            class Meta:
                model = self.TestModelSerializerUserModel
                validators = [AdminNameValidator(), ]

        data = {
            'name': 'admin',
            'addresses': [],
            'gender': 'male'
        }
        instance = UserSerializer(data, allow_null=True)

        self.assertRaises(ValidationError, instance.run_validation, data)

Example 11

Project: etlalchemy Source File: literal_value_generator.py
def dump_to_sql_statement(statement, fp, bind=None, table_name=None):
    """
    print a query, with values filled in
    for debugging purposes *only*
    for security, you should always separate queries from their values
    please also note that this function is quite slow
    """
    import sqlalchemy.orm
    if isinstance(statement, sqlalchemy.orm.Query):
        if bind is None:
            bind = statement.session.get_bind(
                    statement._mapper_zero_or_none()
            )
        statement = statement.statement
    elif bind is None:
        bind = statement.bind

    dialect = bind.dialect
    compiler = statement._compiler(dialect)

    class LiteralCompiler(compiler.__class__):
        def visit_bindparam(
                self, bindparam, within_columns_clause=False,
                literal_binds=False, **kwargs
        ):
            return super(LiteralCompiler, self).render_literal_bindparam(
                    bindparam, within_columns_clause=within_columns_clause,
                    literal_binds=literal_binds, **kwargs
            )

        def render_literal_value(self, value, type_):
            return generate_literal_value(value, dialect, type_)

    compiler = LiteralCompiler(dialect, statement)

    stmt = compiler.process(statement) + ";\n"
    if dialect.name.lower() == "mssql":
        stmt = "SET IDENTITY_INSERT {0} ON ".format(table_name) + stmt

    fp.write(stmt)

Example 12

Project: SickGear Source File: assertions.py
    def assert_compile(self, clause, result, params=None,
                        checkparams=None, dialect=None,
                        checkpositional=None,
                        use_default_dialect=False,
                        allow_dialect_select=False,
                        literal_binds=False):
        if use_default_dialect:
            dialect = default.DefaultDialect()
        elif allow_dialect_select:
            dialect = None
        else:
            if dialect is None:
                dialect = getattr(self, '__dialect__', None)

            if dialect is None:
                dialect = config.db.dialect
            elif dialect == 'default':
                dialect = default.DefaultDialect()
            elif isinstance(dialect, util.string_types):
                dialect = url.URL(dialect).get_dialect()()


        kw = {}
        compile_kwargs = {}

        if params is not None:
            kw['column_keys'] = list(params)

        if literal_binds:
            compile_kwargs['literal_binds'] = True

        if isinstance(clause, orm.Query):
            context = clause._compile_context()
            context.statement.use_labels = True
            clause = context.statement

        if compile_kwargs:
            kw['compile_kwargs'] = compile_kwargs

        c = clause.compile(dialect=dialect, **kw)

        param_str = repr(getattr(c, 'params', {}))

        if util.py3k:
            param_str = param_str.encode('utf-8').decode('ascii', 'ignore')
            print(("\nSQL String:\n" + util.text_type(c) + param_str).encode('utf-8'))
        else:
            print("\nSQL String:\n" + util.text_type(c).encode('utf-8') + param_str)


        cc = re.sub(r'[\n\t]', '', util.text_type(c))

        eq_(cc, result, "%r != %r on dialect %r" % (cc, result, dialect))

        if checkparams is not None:
            eq_(c.construct_params(params), checkparams)
        if checkpositional is not None:
            p = c.construct_params(params)
            eq_(tuple([p[x] for x in c.positiontup]), checkpositional)

Example 13

Project: sqlalchemy Source File: assertions.py
    def assert_compile(self, clause, result, params=None,
                       checkparams=None, dialect=None,
                       checkpositional=None,
                       check_prefetch=None,
                       use_default_dialect=False,
                       allow_dialect_select=False,
                       literal_binds=False,
                       schema_translate_map=None):
        if use_default_dialect:
            dialect = default.DefaultDialect()
        elif allow_dialect_select:
            dialect = None
        else:
            if dialect is None:
                dialect = getattr(self, '__dialect__', None)

            if dialect is None:
                dialect = config.db.dialect
            elif dialect == 'default':
                dialect = default.DefaultDialect()
            elif dialect == 'default_enhanced':
                dialect = default.StrCompileDialect()
            elif isinstance(dialect, util.string_types):
                dialect = url.URL(dialect).get_dialect()()

        kw = {}
        compile_kwargs = {}

        if schema_translate_map:
            kw['schema_translate_map'] = schema_translate_map

        if params is not None:
            kw['column_keys'] = list(params)

        if literal_binds:
            compile_kwargs['literal_binds'] = True

        if isinstance(clause, orm.Query):
            context = clause._compile_context()
            context.statement.use_labels = True
            clause = context.statement

        if compile_kwargs:
            kw['compile_kwargs'] = compile_kwargs

        c = clause.compile(dialect=dialect, **kw)

        param_str = repr(getattr(c, 'params', {}))

        if util.py3k:
            param_str = param_str.encode('utf-8').decode('ascii', 'ignore')
            print(
                ("\nSQL String:\n" +
                 util.text_type(c) +
                 param_str).encode('utf-8'))
        else:
            print(
                "\nSQL String:\n" +
                util.text_type(c).encode('utf-8') +
                param_str)

        cc = re.sub(r'[\n\t]', '', util.text_type(c))

        eq_(cc, result, "%r != %r on dialect %r" % (cc, result, dialect))

        if checkparams is not None:
            eq_(c.construct_params(params), checkparams)
        if checkpositional is not None:
            p = c.construct_params(params)
            eq_(tuple([p[x] for x in c.positiontup]), checkpositional)
        if check_prefetch is not None:
            eq_(c.prefetch, check_prefetch)

Example 14

Project: blaze Source File: utils.py
def literalquery(statement, dialect=None):
    """Generate an SQL expression string with bound parameters rendered inline
    for the given SQLAlchemy statement.

    WARNING: This method of escaping is insecure, incomplete, and for debugging
    purposes only. Executing SQL statements with inline-rendered user values is
    extremely insecure.
    """
    if isinstance(statement, sqlalchemy.orm.Query):
        if dialect is None:
            dialect = statement.session.get_bind(
                statement._mapper_zero_or_none()
            ).dialect
        statement = statement.statement
    if dialect is None:
        dialect = getattr(statement.bind, 'dialect', None)
    if dialect is None:
        from sqlalchemy.dialects import mysql
        dialect = mysql.dialect()

    Compiler = type(statement._compiler(dialect))

    class LiteralCompiler(Compiler):
        visit_bindparam = Compiler.render_literal_bindparam

        def render_literal_value(self, value, type_):
            if isinstance(value, (Decimal, long)):
                return str(value)
            elif isinstance(value, datetime):
                return repr(str(value))
            else:  # fallback
                value = super(LiteralCompiler, self).render_literal_value(
                    value, type_,
                )
                if isinstance(value, unicode):
                    return value.encode('UTF-8')
                else:
                    return value

    return LiteralCompiler(dialect, statement)

Example 15

Project: kokoropy Source File: assertions.py
    def assert_compile(self, clause, result, params=None,
                       checkparams=None, dialect=None,
                       checkpositional=None,
                       use_default_dialect=False,
                       allow_dialect_select=False,
                       literal_binds=False):
        if use_default_dialect:
            dialect = default.DefaultDialect()
        elif allow_dialect_select:
            dialect = None
        else:
            if dialect is None:
                dialect = getattr(self, '__dialect__', None)

            if dialect is None:
                dialect = config.db.dialect
            elif dialect == 'default':
                dialect = default.DefaultDialect()
            elif isinstance(dialect, util.string_types):
                dialect = url.URL(dialect).get_dialect()()

        kw = {}
        compile_kwargs = {}

        if params is not None:
            kw['column_keys'] = list(params)

        if literal_binds:
            compile_kwargs['literal_binds'] = True

        if isinstance(clause, orm.Query):
            context = clause._compile_context()
            context.statement.use_labels = True
            clause = context.statement

        if compile_kwargs:
            kw['compile_kwargs'] = compile_kwargs

        c = clause.compile(dialect=dialect, **kw)

        param_str = repr(getattr(c, 'params', {}))

        if util.py3k:
            param_str = param_str.encode('utf-8').decode('ascii', 'ignore')
            print(
                ("\nSQL String:\n" +
                 util.text_type(c) +
                 param_str).encode('utf-8'))
        else:
            print(
                "\nSQL String:\n" +
                util.text_type(c).encode('utf-8') +
                param_str)

        cc = re.sub(r'[\n\t]', '', util.text_type(c))

        eq_(cc, result, "%r != %r on dialect %r" % (cc, result, dialect))

        if checkparams is not None:
            eq_(c.construct_params(params), checkparams)
        if checkpositional is not None:
            p = c.construct_params(params)
            eq_(tuple([p[x] for x in c.positiontup]), checkpositional)

Example 16

Project: kit Source File: orm.py
Function: fast_count
  def fast_count(self):
    """Fast counting, bypassing subqueries.

    By default SQLAlchemy count queries use subqueries (which are very slow
    on MySQL). This method is useful when counting over large numbers of rows
    (10k and more), as the following benchmark shows (~250k rows):

    .. code:: python

      In [1]: %time Cat.q.count()
      CPU times: user 0.01 s, sys: 0.00 s, total: 0.01 s
      Wall time: 1.36 s
      Out[1]: 281992L

      In [2]: %time Cat.c.scalar()
      CPU times: user 0.00 s, sys: 0.00 s, total: 0.00 s
      Wall time: 0.06 s
      Out[2]: 281992L

    """
    models = query_to_models(self)
    if len(models) != 1:
      # initial query is over more than one model
      # not clear how to implement the count in that case
      raise ValueError('Fast count unavailable for this query.')
    # can't use self.__class__ because of appender queries, which come
    # with their own session
    count_query = Query(func.count(), session=self.session)
    count_query = count_query.select_from(models[0])
    count_query._criterion = self._criterion
    return count_query.scalar()

Example 17

Project: refstack Source File: test_db.py
    def test_to_dict(self):
        fake_query_result = mock.Mock()
        fake_query_result.keys.return_value = ('fake_id',)
        fake_query_result.index = 1
        fake_query_result.fake_id = 12345
        self.assertEqual({'fake_id': 12345}, api._to_dict(fake_query_result))

        fake_query_result_list = [fake_query_result]
        self.assertEqual([{'fake_id': 12345}],
                         api._to_dict(fake_query_result_list))

        fake_query = mock.Mock(spec=sqlalchemy.orm.Query)
        fake_query.all.return_value = fake_query_result
        self.assertEqual({'fake_id': 12345}, api._to_dict(fake_query))

        fake_model = mock.Mock(spec=models.RefStackBase)
        fake_model.default_allowed_keys = ('fake_id', 'meta',
                                           'child', 'childs')
        fake_child = mock.Mock(spec=models.RefStackBase)
        fake_child.iteritems.return_value = {'child_id': 42}.items()
        fake_child.default_allowed_keys = ('child_id',)
        fake_child.metadata_keys = {}
        actuall_dict = {'fake_id': 12345,
                        'meta': [{'meta_key': 'answer',
                                  'value': 42}],
                        'child': fake_child,
                        'childs': [fake_child]}
        fake_model.iteritems.return_value = actuall_dict.items()
        fake_model.metadata_keys = {'meta': {'key': 'meta_key',
                                             'value': 'value'}}

        self.assertEqual({'fake_id': 12345,
                          'meta': {'answer': 42},
                          'child': {'child_id': 42},
                          'childs': [{'child_id': 42}]},
                         api._to_dict(fake_model))

        fake_model = mock.Mock(spec=models.RefStackBase)
        fake_model.default_allowed_keys = ('meta', 'beta')
        fake_model.metadata_keys = {}
        fake_model.iteritems.return_value = {'meta': 1, 'beta': 2}.items()
        self.assertEqual([{'meta': 1}],
                         api._to_dict([fake_model], allowed_keys=('meta')))