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
3
Example 1
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)
3
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))
3
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)
3
Example 4
def __get__(self, obj, cls):
try:
mapper = class_mapper(cls)
if mapper:
return Query(mapper, session=self.session())
except UnmappedClassError:
return None
0
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()
0
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()
0
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()
0
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()
0
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)
0
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)
0
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)
0
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)
0
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)
0
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)
0
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)
0
Example 16
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()
0
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')))