def compile_sqlite_sign(element, compiler, **kw):
args = list(element.clauses)
if len(args) != 1:
raise CompileError("Sign function takes exactly one argument.")
return ("CASE WHEN {0} < 0 THEN -1 "
"ELSE CASE WHEN {0} > 0 THEN 1 "
"ELSE 0 END END".format(compiler.process(args[0])))
def check_match_clause(clause):
left_tuple = []
right_tuple = []
match_operators = []
if isinstance(clause.type, MatchType):
left_tuple.append(clause.left)
right_tuple.append(clause.right)
match_operators.append(clause.operator)
elif isinstance(clause, Function):
if clause.name.lower() == "match":
if len(clause.clauses) == 2:
func_left, func_right = clause.clauses
elif len(clause.clauses) == 1:
func_left = None
func_right, = clause.clauses
else:
raise CompileError(
"Invalid arguments count for MATCH clause")
left_tuple.append(func_left)
right_tuple.append(func_right)
elif isinstance(clause, ClauseList):
for xclause in clause.clauses:
l, r, m = check_match_clause(xclause)
left_tuple.extend(l)
right_tuple.extend(r)
match_operators.extend(m)
return left_tuple, right_tuple, match_operators
def _process_match(self, expr):
def ensure_column(clause):
if not isinstance(clause, ColumnClause):
raise CompileError("Invalid source for MATCH clause.")
negative = False
# unpack MATCH clause
if isinstance(expr, Grouping):
expr = expr.element
if isinstance(expr, UnaryExpression):
if expr.operator not in (operator.inv, operator.not_):
raise CompileError("Invalid unary operator for MATCH clause. "
"MATCH clause only supports NOT operator.")
negative = True
expr = expr.element
if isinstance(expr, Grouping):
expr = expr.element
if isinstance(expr, BooleanClauseList):
if expr.operator is not operator.or_:
raise CompileError(
"Invalid boolean operator for MATCH clause. "
"MATCH clause only supports OR operator.")
expr = expr.clauses
if isinstance(expr, (list, tuple)):
for expr_column in expr:
ensure_column(expr_column)
columns = u"({0})".format(','.join(map(self.process, expr)))
else:
ensure_column(expr)
columns = self.process(expr)
if negative:
columns = u"!{0}".format(columns)
return columns
def visit_primary_key_constraint(self, constraint):
if constraint.name is None:
raise CompileError("Can't create primary key without a name.")
return DDLCompiler.visit_primary_key_constraint(self, constraint)
def ensure_column(clause):
if not isinstance(clause, ColumnClause):
raise CompileError("Invalid source for MATCH clause.")