def _get_field_strs_and_params(self, fields):
if not isinstance(fields, (list, tuple)):
fields = [fields] # pragma: no cover
strs = []
params = []
for field in fields:
if isinstance(field, basestring):
_field = getattr(self._model_class, field, None)
if not _field:
raise ExpressionError('Cannot find field: `{}`'.format( # noqa pragma: no cover pylint: disable=W
field
))
field = _field
sql, _params = sql_and_params(field)
if _params:
params.extend(_params)
alias_name = getattr(field, 'alias_name', None)
if alias_name:
strs.append(alias_name)
else:
strs.append(sql)
return strs, params
def _get_sql_and_params(self):
pieces = []
params = []
for arg in self.args:
piece, _params = sql_and_params(arg, coerce=repr)
pieces.append(piece)
if _params:
params.extend(_params)
s = '{}({})'.format(self.__class__.__name__.upper(), ', '.join(pieces))
return s, params
def _get_expression_and_params(self, is_having=False, is_on=False):
if is_having:
expressions = self._having_expressions
elif is_on:
expressions = self._on_expressions
else:
expressions = self._expressions
if expressions:
expression = reduce(operator.and_, expressions)
return sql_and_params(expression)
return '', []
def unique_expression_and_params(self):
keys = []
if self.__primary_key__:
keys.extend(self.__primary_key__)
elif self.__unique_keys__: # pragma: no cover
keys = self.__unique_keys__[0] # pragma: no cover
expression = None
for attr_name in keys:
_expression = (getattr(self.__class__,
attr_name) == getattr(self, attr_name))
if expression is None:
expression = _expression
else:
expression &= _expression # pragma: no cover
if expression is None:
return '', [] # pragma: no cover
return sql_and_params(expression)
def get_sql_and_params(self):
params = []
test_str, test_params = sql_and_params(self._test)
s = 'CASE WHEN {}'.format(test_str)
params += test_params
if self._then is not missing:
_str, _params = _get_sql_and_params(self._then)
s += ' THEN {}'.format(_str)
params += _params
if self._else is not missing:
_str, _params = _get_sql_and_params(self._else)
s += ' ELSE {}'.format(_str)
params += _params
s += ' END'
if self.alias_name:
return '({}) AS {}'.format(s, self.alias_name), params
return s, params
def _olo_insert(self):
if not self._olo_is_new:
return False # pragma: no cover
before_create_is_instance_method = getattr(self.before_create,
'__self__', None) is self # noqa pylint: disable=C
if before_create_is_instance_method:
bcr = self.before_create()
attrs = dict(self._data)
_, sql_attrs, db_attrs = self._split_attrs(attrs)
if not before_create_is_instance_method:
bcr = self.before_create(**attrs) # pragma: no cover
if bcr is False:
return False
self._validate_attrs(attrs, parse=True, decrypt=self._olo_decrypt)
db = self._get_db()
expressions, _, _ = self._split_attrs(sql_attrs)
if expressions:
sql_pieces = []
params = []
for exp in expressions:
piece, _ = sql_and_params(exp.left)
_, _params = sql_and_params(exp)
sql_pieces.append(piece)
if _params:
params.extend(_params)
sql = ('INSERT INTO `{table_name}`({columns}) '
'VALUES({values}) ').format(
table_name=self._get_table_name(),
columns=', '.join(sql_pieces),
values=', '.join(['%s'] * len(params)))
try:
id_ = db.execute(sql, params)
if db.autocommit:
db.commit()
except Exception:
if db.autocommit:
db.rollback() # pragma: no cover
raise
pk_name = self.get_singleness_pk_name()
if (hasattr(self.__class__, pk_name)
and pk_name in self.__class__.__fields__
and pk_name not in self._data):
self._data[pk_name] = id_
# need thinking
self._extend_missing_data()
for k, v in db_attrs.iteritems():
field = getattr(self.__class__, k)
field.db_set(self, v)
self._olo_is_new = False
def rollback_handler():
self._olo_is_new = True
def func():
db.commit_beansdb()
after_insert.send(self)
if getattr(self.after_create, '__self__', None) is self:
self.after_create()
else:
self.after_create(self) # pragma: no cover pylint: disable=E
if db.autocommit:
func()
else:
db.add_lazy_func(func)
db.add_rollback_handler(rollback_handler)
return True
def get_sql_and_params(self):
left_str, params = sql_and_params(self.value)
alias_name = getattr(self.value, 'alias_name', None)
if alias_name:
left_str = alias_name
return '{} {}'.format(left_str, self.operator), params