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 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 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.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 _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 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 __str__(self):
Mapping = Flavor.get().function_mapping.get(self.__class__)
if Mapping:
return str(Mapping(*self.args))
return self._function
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 _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 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
