def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) param = Flavor.get().param def format(arg): if isinstance(arg, basestring): return param else: return str(arg) return self._function + '(' + ', '.join(map(format, self.args)) + ')'
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.string, self.position, self.characters)) param = Flavor.get().param def format(arg): if isinstance(arg, basestring): return param else: return str(arg) return self._function + "(%s %s FROM %s)" % (self.position, format(self.characters), format(self.string))
def __str__(self): flavor = Flavor.get() Mapping = flavor.function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.field, self.zone)) param = flavor.param return '%s AT TIME ZONE %s' % (str(self.field), param)
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) return (self._function + '(' + ' '.join( chain(*zip(self._keywords, map(self._format, self.args))))[1:] + ')')
def _format(self, operand, param=None): if param is None: param = Flavor.get().param if isinstance(operand, Expression): return str(operand) elif isinstance(operand, (Select, CombiningQuery)): return '(' + operand + ')' # return '(%s)' % operand elif isinstance(operand, (list, tuple)): subStrings = [] for o in operand: subStrings.append(self._format(o, param)) joinedString = "" for joiningIndex in range(len(subStrings)): joinedString = joinedString + subStrings[joiningIndex] if joiningIndex != len(subStrings) - 1: joinedString = joinedString + ", " return '(' + joinedString + ')' elif isinstance(operand, array): subStrings = (param,) * len(operand) joinedString = "" for joiningIndex in range(len(subStrings)): joinedString = joinedString + subStrings[joiningIndex] if joiningIndex != len(subStrings) - 1: joinedString = joinedString + ", " return '(' + joinedString + ')' else: return param
def __str__(self): flavor = Flavor.get() Mapping = flavor.function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.field, self.zone)) param = flavor.param return str(self.field) + " AT TIME ZONE " + param
def test_select_union_flavor(self): flavor = Flavor.get() prev = flavor.quote_character flavor.quote_character = '`' self._test_select_union_quote('`') flavor.quote_character = prev Flavor.set(flavor)
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) param = Flavor.get().param def format(arg): if isinstance(arg, basestring): return param else: return str(arg) return (self._function + '(' + ' '.join(chain(*zip( self._keywords, map(format, self.args))))[1:] + ')')
def __str__(self): quantifier = 'DISTINCT ' if self.distinct else '' has_filter = Flavor.get().filter_ expression = self.expression if self.filter_ and not has_filter: from sql.conditionals import Case expression = Case((self.filter_, self._case_expression)) order_by = '' if self.order_by: order_by = ' ORDER BY %s' % ', '.join(map(str, self.order_by)) aggregate = '%s(%s%s%s)' % (self._sql, quantifier, expression, order_by) within = '' if self.within: within = (' WITHIN GROUP (ORDER BY %s)' % ', '.join(map(str, self.within))) filter_ = '' if self.filter_ and has_filter: filter_ = ' FILTER (WHERE %s)' % self.filter_ window = '' if self.window: if self.window.has_alias: window = ' OVER "%s"' % self.window.alias else: window = ' OVER (%s)' % self.window return aggregate + within + filter_ + window
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(self.field, self.zone).params if isinstance(self.zone, Expression): return self.field.params + self.zone.params else: return self.field.params + (self.zone,)
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) return (self._function + '(' + ' '.join(chain(*zip( self._keywords, map(self._format, self.args))))[1:] + ')')
def __str__(self): param = Flavor.get().param def format(value): if isinstance(value, basestring): return param else: return str(value) return (self._conditional + '(' + ', '.join(map(format, self.values)) + ')')
def _format(self, operand): param = Flavor.get().param if isinstance(operand, Expression): return str(operand) elif isinstance(operand, (Select, CombiningQuery)): return '(%s)' % operand elif isinstance(operand, (list, tuple)): return '(' + ', '.join(self._format(o) for o in operand) + ')' else: return param
def __str__(self): flavor = Flavor.get() Mapping = flavor.function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.field, self.zone)) if isinstance(self.zone, Expression): zone = str(self.zone) else: zone = flavor.param return '%s AT TIME ZONE %s' % (str(self.field), zone)
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(*self.args).params p = () for arg in (self.characters, self.string): if isinstance(arg, basestring): p += (arg,) elif hasattr(arg, "params"): p += arg.params return p
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(*self.args).params p = () for arg in self.args: if isinstance(arg, Expression): p += arg.params else: p += (arg,) return p
def create_sql_sequence(self, number_next=None): 'Create the SQL sequence' cursor = Transaction().connection.cursor() param = Flavor.get().param if self.type != 'incremental': return if number_next is None: number_next = self.number_next cursor.execute('CREATE SEQUENCE "' + self._sql_sequence_name + '" INCREMENT BY ' + param + ' START WITH ' + param, (self.number_increment, number_next))
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(*self.args).params p = [] for arg in self.args: if isinstance(arg, Expression): p.extend(arg.params) else: p.append(arg) return tuple(p)
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(self.string, self.position, self.characters).params p = [] for arg in (self.characters, self.string): if isinstance(arg, basestring): p.append(arg) elif hasattr(arg, 'params'): p.extend(arg.params) return tuple(p)
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) subStrings = map(self._format, self.args) joinedString = "" for joiningIndex in range(len(subStrings)): joinedString = joinedString + subStrings[joiningIndex] if joiningIndex != len(subStrings) - 1: joinedString = joinedString + ", " return self._function + '(' + joinedString + ')'
def _format(operand): param = Flavor.get().param if isinstance(operand, Column): return str(operand) elif isinstance(operand, Select): return '(%s)' % operand elif isinstance(operand, (list, tuple)): return '(' + ', '.join((param,) * len(operand)) + ')' elif operand is None: return '' else: return param
def __str__(self): flavor = Flavor.get() Mapping = flavor.function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.string, self.position, self.characters)) param = flavor.param def format(arg): if isinstance(arg, basestring): return param else: return str(arg) return self._function + "(" + self.position + " " + format(self.characters) + " FROM " + format(self.string) + ")"
def _format(self, operand, param=None): if param is None: param = Flavor.get().param if isinstance(operand, Expression): return str(operand) elif isinstance(operand, (Select, CombiningQuery)): return "(%s)" % operand elif isinstance(operand, (list, tuple)): return "(" + ", ".join(self._format(o, param) for o in operand) + ")" elif isinstance(operand, array): return "(" + ", ".join((param,) * len(operand)) + ")" else: return param
def params(self): has_filter = Flavor.get().filter_ p = [] if self.filter_ and not has_filter: p.extend(self.filter_.params) p.extend(self._case_expression.params) else: p.extend(self.expression.params) if self.within: for expression in self.within: p.extend(expression.params) if self.filter_ and has_filter: p.extend(self.filter_.params) return tuple(p)
def __str__(self): flavor = Flavor.get() Mapping = flavor.function_mapping.get(self.__class__) if Mapping: return str(Mapping(self.string, self.position, self.characters)) param = flavor.param def format(arg): if isinstance(arg, basestring): return param else: return str(arg) return self._function + '(%s %s FROM %s)' % ( self.position, format(self.characters), format(self.string))
def _format(self, operand, param=None): if param is None: param = Flavor.get().param if isinstance(operand, Expression): return str(operand) elif isinstance(operand, (Select, CombiningQuery)): return '(%s)' % operand elif isinstance(operand, (list, tuple)): return '(' + ', '.join(self._format(o, param) for o in operand) + ')' elif isinstance(operand, array): return '(' + ', '.join((param, ) * len(operand)) + ')' else: return param
def __str__(self): case = 'CASE ' param = Flavor.get().param for cond, result in self.whens: case += 'WHEN ' + str(cond) if isinstance(result, basestring): result = param case += ' THEN ' + str(result) + ' ' if self.else_ is not None: else_ = self.else_ if isinstance(self.else_, basestring): else_ = param case += 'ELSE ' + str(else_) + ' ' case += 'END' return case
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) subStrings = list(chain(*zip( self._keywords, map(self._format, self.args)))) joinedString = "" for joiningIndex in range(len(subStrings)): joinedString = joinedString + subStrings[joiningIndex] if joiningIndex != len(subStrings) - 1: joinedString = joinedString + " " return (self._function + '(' + joinedString[1:] + ')')
def __str__(self): flavor = Flavor.get() param = flavor.param function = { 'BOTH': 'TRIM', 'LEADING': 'LTRIM', 'TRAILING': 'RTRIM', }[self.position] def format(arg): if isinstance(arg, str): return param else: return str(arg) return function + '(%s, %s)' % ( format(self.string), format(self.characters))
def update_sql_sequence(self, number_next=None): 'Update the SQL sequence' TableHandler = backend.get('TableHandler') cursor = Transaction().connection.cursor() param = Flavor.get().param exist = TableHandler.sequence_exist(self._sql_sequence_name) if self.type != 'incremental': if exist: self.delete_sql_sequence() return if not exist: self.create_sql_sequence(number_next) return if number_next is None: number_next = self.number_next cursor.execute('ALTER SEQUENCE "' + self._sql_sequence_name + '" INCREMENT BY ' + param + ' RESTART WITH ' + param, (self.number_increment, number_next))
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(self.field, self.zone).params return self.field.params + (self.zone, )
def _operator(self): if Flavor.get().ilike: return "ILIKE" else: return "LIKE"
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) return self._function
def test_column(self): self._test_column_with_quote(Flavor.get().quote_character)
def test_select_union(self): self._test_select_union_quote(Flavor.get().quote_character)
def _operator(self): if Flavor.get().ilike: return 'NOT ILIKE' else: return 'NOT LIKE'
def _operands(self): operands = super(ILike, self)._operands if not Flavor.get().ilike: from .functions import Upper operands = tuple(Upper(o) for o in operands) return operands
def _operator(self): # '%' must be escaped with format paramstyle if Flavor.get().paramstyle == 'format': return '%%' else: return '%'
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) return self._function + '(' + ', '.join( map(self._format, self.args)) + ')'
def params(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return Mapping(self.field, self.zone).params return self.field.params + (self.zone,)
def __str__(self): Mapping = Flavor.get().function_mapping.get(self.__class__) if Mapping: return str(Mapping(*self.args)) param = Flavor.get().param return "%s AT TIME ZONE %s" % (str(self.field), param)
def test_flavor(self): flavor = Flavor.get() prev = flavor.quote_character flavor.quote_character = '`' self.assertEqual(str(As(self.column, 'foo')), '`foo`') flavor.quote_character = prev
def test_flavor(self): flavor = Flavor.get() prev = flavor.quote_character flavor.quote_character = '`' self._test_column_with_quote('`') flavor.quote_character = prev