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