parent
90712aff7d
commit
49a3fc0a78
@ -0,0 +1,13 @@
|
||||
from engine.ast import Context, ast_node
|
||||
import engine.ddl
|
||||
|
||||
def initialize():
|
||||
return Context()
|
||||
|
||||
def generate(ast, cxt):
|
||||
for k in ast.keys():
|
||||
if k in ast_node.types.keys():
|
||||
root = ast_node.types[k](None, ast, cxt)
|
||||
|
||||
|
||||
__all__ = ["generate"]
|
||||
@ -0,0 +1,65 @@
|
||||
from typing import List
|
||||
|
||||
|
||||
class TableInfo:
|
||||
def __init__(self, table_name, cols, cxt:'Context'):
|
||||
# statics
|
||||
self.table_name = table_name
|
||||
self.columns = dict() # column_name, type
|
||||
for c in cols:
|
||||
self.columns[c['name']] = ((list(c['type'].keys()))[0], c)
|
||||
k9name = self.table_name + c['name']
|
||||
if k9name in cxt.k9cols_byname: # duplicate names?
|
||||
root = cxt.k9cols_byname[k9name]
|
||||
k9name = k9name + root[1]
|
||||
root[1] += 1
|
||||
cxt.k9cols[c] = k9name
|
||||
cxt.k9cols_byname[k9name] = (c, 1)
|
||||
# runtime
|
||||
self.n_cols = 0 # number of cols
|
||||
self.order = [] # assumptions
|
||||
|
||||
cxt.tables_byname[self.table_name] = self # construct reverse map
|
||||
|
||||
def get_k9colname(self, cxt:'Context', col_name):
|
||||
return cxt.k9cols[self.columns[col_name][1]] # well, this is gnarly.. will change later
|
||||
|
||||
class Context:
|
||||
def __init__(self):
|
||||
self.tables:List[TableInfo] = []
|
||||
self.tables_byname = dict()
|
||||
self.k9cols = dict()
|
||||
self.k9cols_byname = dict()
|
||||
|
||||
self.k9code = ''
|
||||
|
||||
def add_table(self, table_name, cols):
|
||||
tbl = TableInfo(table_name, cols, self)
|
||||
self.tables.append(tbl)
|
||||
return tbl
|
||||
|
||||
def emit(self, codelet):
|
||||
self.k9code += codelet + '\n'
|
||||
|
||||
def __str__(self):
|
||||
return self.k9code
|
||||
|
||||
class ast_node:
|
||||
types = dict()
|
||||
def __init__(self, parent:"ast_node", node, context:Context = None):
|
||||
self.context = parent.context if context is None else context
|
||||
self.produce(node)
|
||||
self.enumerate(node)
|
||||
self.consume(node)
|
||||
|
||||
def emit(self, code):
|
||||
self.context.emit(code)
|
||||
|
||||
name = 'null'
|
||||
|
||||
def produce(self, _):
|
||||
pass
|
||||
def enumerate(self, _):
|
||||
pass
|
||||
def consume(self, _):
|
||||
pass
|
||||
@ -0,0 +1,22 @@
|
||||
from engine.ast import TableInfo, ast_node
|
||||
class create_table(ast_node):
|
||||
name = 'create_table'
|
||||
def produce(self, node):
|
||||
ct = node[self.name]
|
||||
tbl = self.context.add_table(ct['name'], ct['columns'])
|
||||
# create tables in k9
|
||||
for c in ct['columns']:
|
||||
self.emit(f"{tbl.get_k9colname((list(c['name'].keys())))[0]}:()")
|
||||
|
||||
class insert_into(ast_node):
|
||||
name = 'insert'
|
||||
def produce(self, node):
|
||||
ct = node[self.name]
|
||||
table:TableInfo = self.context.tables_byname[ct]
|
||||
|
||||
|
||||
import sys, inspect
|
||||
|
||||
for name, cls in inspect.getmembers(sys.modules[__name__]):
|
||||
if inspect.isclass(cls) and issubclass(cls, ast_node):
|
||||
ast_node.types[name] = cls
|
||||
@ -1,602 +0,0 @@
|
||||
# encoding: utf-8
|
||||
#
|
||||
# This Source Code Form is subject to the terms of the Mozilla Public
|
||||
# License, v. 2.0. If a copy of the MPL was not distributed with this file,
|
||||
# You can obtain one at http://mozilla.org/MPL/2.0/.
|
||||
#
|
||||
# Author: Beto Dealmeida (beto@dealmeida.net)
|
||||
#
|
||||
|
||||
from __future__ import absolute_import, division, unicode_literals
|
||||
|
||||
import re
|
||||
|
||||
from mo_dots import split_field
|
||||
from mo_future import first, is_text, string_types, text
|
||||
from mo_parsing import listwrap
|
||||
|
||||
from mo_sql_parsing.keywords import RESERVED, join_keywords, precedence
|
||||
from mo_sql_parsing.utils import binary_ops, is_set_op
|
||||
|
||||
MAX_PRECEDENCE = 100
|
||||
VALID = re.compile(r"^[a-zA-Z_]\w*$")
|
||||
|
||||
|
||||
def is_keyword(identifier):
|
||||
try:
|
||||
RESERVED.parse_string(identifier)
|
||||
return True
|
||||
except Exception:
|
||||
return False
|
||||
|
||||
|
||||
def should_quote(identifier):
|
||||
"""
|
||||
Return true if a given identifier should be quoted.
|
||||
|
||||
This is usually true when the identifier:
|
||||
|
||||
- is a reserved word
|
||||
- contain spaces
|
||||
- does not match the regex `[a-zA-Z_]\\w*`
|
||||
|
||||
"""
|
||||
return identifier != "*" and (not VALID.match(identifier) or is_keyword(identifier))
|
||||
|
||||
|
||||
def escape(ident, ansi_quotes, should_quote):
|
||||
"""
|
||||
Escape identifiers.
|
||||
|
||||
ANSI uses double quotes, but many databases use back quotes.
|
||||
|
||||
"""
|
||||
|
||||
def esc(identifier):
|
||||
if not should_quote(identifier):
|
||||
return identifier
|
||||
|
||||
quote = '"' if ansi_quotes else "`"
|
||||
identifier = identifier.replace(quote, 2 * quote)
|
||||
return "{0}{1}{2}".format(quote, identifier, quote)
|
||||
|
||||
return ".".join(esc(f) for f in split_field(ident))
|
||||
|
||||
|
||||
def Operator(_op):
|
||||
op_prec = precedence[binary_ops[_op]]
|
||||
op = " {0} ".format(_op).replace("_", " ").upper()
|
||||
|
||||
def func(self, json, prec):
|
||||
acc = []
|
||||
|
||||
if isinstance(json, dict):
|
||||
# {VARIABLE: VALUE} FORM
|
||||
k, v = first(json.items())
|
||||
json = [k, {"literal": v}]
|
||||
|
||||
for i, v in enumerate(listwrap(json)):
|
||||
if i == 0:
|
||||
acc.append(self.dispatch(v, op_prec + 0.25))
|
||||
else:
|
||||
acc.append(self.dispatch(v, op_prec))
|
||||
if prec >= op_prec:
|
||||
return op.join(acc)
|
||||
else:
|
||||
return f"({op.join(acc)})"
|
||||
|
||||
return func
|
||||
|
||||
|
||||
def isolate(expr, sql, prec):
|
||||
"""
|
||||
RETURN sql IN PARENTHESIS IF PREEDENCE > prec
|
||||
:param expr: expression to isolate
|
||||
:param sql: sql to return
|
||||
:param prec: current precedence
|
||||
"""
|
||||
if is_text(expr):
|
||||
return sql
|
||||
ps = [p for k in expr.keys() for p in [precedence.get(k)] if p is not None]
|
||||
if not ps:
|
||||
return sql
|
||||
elif min(ps) >= prec:
|
||||
return f"({sql})"
|
||||
else:
|
||||
return sql
|
||||
|
||||
|
||||
unordered_clauses = [
|
||||
"with",
|
||||
"distinct_on",
|
||||
"select_distinct",
|
||||
"select",
|
||||
"from",
|
||||
"where",
|
||||
"groupby",
|
||||
"having",
|
||||
]
|
||||
|
||||
ordered_clauses = [
|
||||
"orderby",
|
||||
"limit",
|
||||
"offset",
|
||||
"fetch",
|
||||
]
|
||||
|
||||
|
||||
class Formatter:
|
||||
# infix operators
|
||||
_concat = Operator("||")
|
||||
_mul = Operator("*")
|
||||
_div = Operator("/")
|
||||
_mod = Operator("%")
|
||||
_add = Operator("+")
|
||||
_sub = Operator("-")
|
||||
_neq = Operator("<>")
|
||||
_gt = Operator(">")
|
||||
_lt = Operator("<")
|
||||
_gte = Operator(">=")
|
||||
_lte = Operator("<=")
|
||||
_eq = Operator("=")
|
||||
_or = Operator("or")
|
||||
_and = Operator("and")
|
||||
_binary_and = Operator("&")
|
||||
_binary_or = Operator("|")
|
||||
_like = Operator("like")
|
||||
_not_like = Operator("not like")
|
||||
_rlike = Operator("rlike")
|
||||
_not_rlike = Operator("not rlike")
|
||||
_union = Operator("union")
|
||||
_union_all = Operator("union all")
|
||||
_intersect = Operator("intersect")
|
||||
_minus = Operator("minus")
|
||||
_except = Operator("except")
|
||||
|
||||
def __init__(self, ansi_quotes=True, should_quote=should_quote):
|
||||
self.ansi_quotes = ansi_quotes
|
||||
self.should_quote = should_quote
|
||||
|
||||
def format(self, json):
|
||||
return self.dispatch(json, 50)
|
||||
|
||||
def dispatch(self, json, prec=100):
|
||||
if isinstance(json, list):
|
||||
return self.sql_list(json, prec=precedence["list"])
|
||||
if isinstance(json, dict):
|
||||
if len(json) == 0:
|
||||
return ""
|
||||
elif "value" in json:
|
||||
return self.value(json, prec)
|
||||
elif "join" in json:
|
||||
return self._join_on(json)
|
||||
elif "insert" in json:
|
||||
return self.insert(json)
|
||||
elif json.keys() & set(ordered_clauses):
|
||||
return self.ordered_query(json, prec)
|
||||
elif json.keys() & set(unordered_clauses):
|
||||
return self.unordered_query(json, prec)
|
||||
elif "null" in json:
|
||||
return "NULL"
|
||||
elif "trim" in json:
|
||||
return self._trim(json, prec)
|
||||
elif "extract" in json:
|
||||
return self._extract(json, prec)
|
||||
else:
|
||||
return self.op(json, prec)
|
||||
if isinstance(json, string_types):
|
||||
return escape(json, self.ansi_quotes, self.should_quote)
|
||||
if json == None:
|
||||
return "NULL"
|
||||
|
||||
return text(json)
|
||||
|
||||
def sql_list(self, json, prec=precedence["from"] - 1):
|
||||
sql = ", ".join(self.dispatch(element, prec=MAX_PRECEDENCE) for element in json)
|
||||
if prec >= precedence["from"]:
|
||||
return sql
|
||||
else:
|
||||
return f"({sql})"
|
||||
|
||||
def value(self, json, prec=precedence["from"]):
|
||||
parts = [self.dispatch(json["value"], prec)]
|
||||
if "over" in json:
|
||||
over = json["over"]
|
||||
parts.append("OVER")
|
||||
window = []
|
||||
if "partitionby" in over:
|
||||
window.append("PARTITION BY")
|
||||
window.append(self.dispatch(over["partitionby"]))
|
||||
if "orderby" in over:
|
||||
window.append(self.orderby(over, precedence["window"]))
|
||||
if "range" in over:
|
||||
|
||||
def wordy(v):
|
||||
if v < 0:
|
||||
return [text(abs(v)), "PRECEDING"]
|
||||
elif v > 0:
|
||||
return [text(v), "FOLLOWING"]
|
||||
|
||||
window.append("ROWS")
|
||||
range = over["range"]
|
||||
min = range.get("min")
|
||||
max = range.get("max")
|
||||
|
||||
if min is None:
|
||||
if max is None:
|
||||
window.pop() # not expected, but deal
|
||||
elif max == 0:
|
||||
window.append("UNBOUNDED PRECEDING")
|
||||
else:
|
||||
window.append("BETWEEN")
|
||||
window.append("UNBOUNDED PRECEDING")
|
||||
window.append("AND")
|
||||
window.extend(wordy(max))
|
||||
elif min == 0:
|
||||
if max is None:
|
||||
window.append("UNBOUNDED FOLLOWING")
|
||||
elif max == 0:
|
||||
window.append("CURRENT ROW")
|
||||
else:
|
||||
window.extend(wordy(max))
|
||||
else:
|
||||
if max is None:
|
||||
window.append("BETWEEN")
|
||||
window.extend(wordy(min))
|
||||
window.append("AND")
|
||||
window.append("UNBOUNDED FOLLOWING")
|
||||
elif max == 0:
|
||||
window.extend(wordy(min))
|
||||
else:
|
||||
window.append("BETWEEN")
|
||||
window.extend(wordy(min))
|
||||
window.append("AND")
|
||||
window.extend(wordy(max))
|
||||
|
||||
window = " ".join(window)
|
||||
parts.append(f"({window})")
|
||||
if "name" in json:
|
||||
parts.extend(["AS", self.dispatch(json["name"])])
|
||||
|
||||
return " ".join(parts)
|
||||
|
||||
def op(self, json, prec):
|
||||
if len(json) > 1:
|
||||
raise Exception("Operators should have only one key!")
|
||||
key, value = list(json.items())[0]
|
||||
|
||||
# check if the attribute exists, and call the corresponding method;
|
||||
# note that we disallow keys that start with `_` to avoid giving access
|
||||
# to magic methods
|
||||
attr = f"_{key}"
|
||||
if hasattr(self, attr) and not key.startswith("_"):
|
||||
method = getattr(self, attr)
|
||||
op_prec = precedence.get(key, MAX_PRECEDENCE)
|
||||
if prec >= op_prec:
|
||||
return method(value, op_prec)
|
||||
else:
|
||||
return f"({method(value, op_prec)})"
|
||||
|
||||
# treat as regular function call
|
||||
if isinstance(value, dict) and len(value) == 0:
|
||||
return (
|
||||
key.upper() + "()"
|
||||
) # NOT SURE IF AN EMPTY dict SHOULD BE DELT WITH HERE, OR IN self.format()
|
||||
else:
|
||||
params = ", ".join(self.dispatch(p) for p in listwrap(value))
|
||||
return f"{key.upper()}({params})"
|
||||
|
||||
def _binary_not(self, value, prec):
|
||||
return "~{0}".format(self.dispatch(value))
|
||||
|
||||
def _exists(self, value, prec):
|
||||
return "{0} IS NOT NULL".format(self.dispatch(value, precedence["is"]))
|
||||
|
||||
def _missing(self, value, prec):
|
||||
return "{0} IS NULL".format(self.dispatch(value, precedence["is"]))
|
||||
|
||||
def _collate(self, pair, prec):
|
||||
return "{0} COLLATE {1}".format(
|
||||
self.dispatch(pair[0], precedence["collate"]), pair[1]
|
||||
)
|
||||
|
||||
def _in(self, json, prec):
|
||||
member, set = json
|
||||
if "literal" in set:
|
||||
set = {"literal": listwrap(set["literal"])}
|
||||
sql = (
|
||||
self.dispatch(member, precedence["in"])
|
||||
+ " IN "
|
||||
+ self.dispatch(set, precedence["in"])
|
||||
)
|
||||
if prec < precedence["in"]:
|
||||
sql = f"({sql})"
|
||||
return sql
|
||||
|
||||
def _nin(self, json, prec):
|
||||
member, set = json
|
||||
if "literal" in set:
|
||||
set = {"literal": listwrap(set["literal"])}
|
||||
sql = (
|
||||
self.dispatch(member, precedence["in"])
|
||||
+ " NOT IN "
|
||||
+ self.dispatch(set, precedence["in"])
|
||||
)
|
||||
if prec < precedence["in"]:
|
||||
sql = f"({sql})"
|
||||
return sql
|
||||
|
||||
def _case(self, checks, prec):
|
||||
parts = ["CASE"]
|
||||
for check in checks if isinstance(checks, list) else [checks]:
|
||||
if isinstance(check, dict):
|
||||
if "when" in check and "then" in check:
|
||||
parts.extend(["WHEN", self.dispatch(check["when"])])
|
||||
parts.extend(["THEN", self.dispatch(check["then"])])
|
||||
else:
|
||||
parts.extend(["ELSE", self.dispatch(check)])
|
||||
else:
|
||||
parts.extend(["ELSE", self.dispatch(check)])
|
||||
parts.append("END")
|
||||
return " ".join(parts)
|
||||
|
||||
def _cast(self, json, prec):
|
||||
expr, type = json
|
||||
|
||||
type_name, params = first(type.items())
|
||||
if not params:
|
||||
type = type_name.upper()
|
||||
else:
|
||||
type = {type_name.upper(): params}
|
||||
|
||||
return f"CAST({self.dispatch(expr)} AS {self.dispatch(type)})"
|
||||
|
||||
def _extract(self, json, prec):
|
||||
interval, value = json["extract"]
|
||||
i = self.dispatch(interval).upper()
|
||||
v = self.dispatch(value)
|
||||
return f"EXTRACT({i} FROM {v})"
|
||||
|
||||
def _interval(self, json, prec):
|
||||
amount = self.dispatch(json[0], precedence["and"])
|
||||
type = self.dispatch(json[1], precedence["and"])
|
||||
return f"INTERVAL {amount} {type.upper()}"
|
||||
|
||||
def _literal(self, json, prec=0):
|
||||
if isinstance(json, list):
|
||||
return "({0})".format(", ".join(
|
||||
self._literal(v, precedence["literal"]) for v in json
|
||||
))
|
||||
elif isinstance(json, string_types):
|
||||
return "'{0}'".format(json.replace("'", "''"))
|
||||
else:
|
||||
return str(json)
|
||||
|
||||
def _get(self, json, prec):
|
||||
v, i = json
|
||||
v_sql = self.dispatch(v, prec=precedence["literal"])
|
||||
i_sql = self.dispatch(i)
|
||||
return f"{v_sql}[{i_sql}]"
|
||||
|
||||
def _between(self, json, prec):
|
||||
return "{0} BETWEEN {1} AND {2}".format(
|
||||
self.dispatch(json[0], precedence["between"]),
|
||||
self.dispatch(json[1], precedence["between"]),
|
||||
self.dispatch(json[2], precedence["between"]),
|
||||
)
|
||||
|
||||
def _trim(self, json, prec):
|
||||
c = json.get("characters")
|
||||
d = json.get("direction")
|
||||
v = json["trim"]
|
||||
acc = ["TRIM("]
|
||||
if d:
|
||||
acc.append(d.upper())
|
||||
acc.append(" ")
|
||||
if c:
|
||||
acc.append(self.dispatch(c))
|
||||
acc.append(" ")
|
||||
if c or d:
|
||||
acc.append("FROM ")
|
||||
acc.append(self.dispatch(v))
|
||||
acc.append(")")
|
||||
return "".join(acc)
|
||||
|
||||
def _not_between(self, json, prec):
|
||||
return "{0} NOT BETWEEN {1} AND {2}".format(
|
||||
self.dispatch(json[0], precedence["between"]),
|
||||
self.dispatch(json[1], precedence["between"]),
|
||||
self.dispatch(json[2], precedence["between"]),
|
||||
)
|
||||
|
||||
def _distinct(self, json, prec):
|
||||
return "DISTINCT " + ", ".join(
|
||||
self.dispatch(v, precedence["select"]) for v in listwrap(json)
|
||||
)
|
||||
|
||||
def _select_distinct(self, json, prec):
|
||||
return "SELECT DISTINCT " + ", ".join(self.dispatch(v) for v in listwrap(json))
|
||||
|
||||
def _distinct_on(self, json, prec):
|
||||
return (
|
||||
"DISTINCT ON (" + ", ".join(self.dispatch(v) for v in listwrap(json)) + ")"
|
||||
)
|
||||
|
||||
def _join_on(self, json, prec):
|
||||
detected_join = join_keywords & set(json.keys())
|
||||
if len(detected_join) == 0:
|
||||
raise Exception(
|
||||
'Fail to detect join type! Detected: "{}" Except one of: "{}"'.format(
|
||||
[on_keyword for on_keyword in json if on_keyword != "on"][0],
|
||||
'", "'.join(join_keywords),
|
||||
)
|
||||
)
|
||||
|
||||
join_keyword = detected_join.pop()
|
||||
|
||||
acc = []
|
||||
acc.append(join_keyword.upper())
|
||||
acc.append(self.dispatch(json[join_keyword], precedence["join"]))
|
||||
|
||||
if json.get("on"):
|
||||
acc.append("ON")
|
||||
acc.append(self.dispatch(json["on"]))
|
||||
if json.get("using"):
|
||||
acc.append("USING")
|
||||
acc.append(self.dispatch(json["using"]))
|
||||
return " ".join(acc)
|
||||
|
||||
def ordered_query(self, json, prec):
|
||||
if json.keys() & set(unordered_clauses) - {"from"}:
|
||||
# regular query
|
||||
acc = [self.unordered_query(json, precedence["order"])]
|
||||
else:
|
||||
# set-op expression
|
||||
acc = [self.dispatch(json["from"], precedence["order"])]
|
||||
|
||||
acc.extend(
|
||||
part
|
||||
for clause in ordered_clauses
|
||||
if clause in json
|
||||
for part in [getattr(self, clause)(json, precedence["order"])]
|
||||
if part
|
||||
)
|
||||
sql = " ".join(acc)
|
||||
if prec >= precedence["order"]:
|
||||
return sql
|
||||
else:
|
||||
return f"({sql})"
|
||||
|
||||
def unordered_query(self, json, prec):
|
||||
sql = " ".join(
|
||||
part
|
||||
for clause in unordered_clauses
|
||||
if clause in json
|
||||
for part in [getattr(self, clause)(json, precedence["from"])]
|
||||
if part
|
||||
)
|
||||
if prec >= precedence["from"]:
|
||||
return sql
|
||||
else:
|
||||
return f"({sql})"
|
||||
|
||||
def with_(self, json, prec):
|
||||
if "with" in json:
|
||||
with_ = json["with"]
|
||||
if not isinstance(with_, list):
|
||||
with_ = [with_]
|
||||
parts = ", ".join(
|
||||
"{0} AS ({1})".format(part["name"], self.dispatch(part["value"]))
|
||||
for part in with_
|
||||
)
|
||||
return "WITH {0}".format(parts)
|
||||
|
||||
def select(self, json, prec):
|
||||
param = ", ".join(self.dispatch(s) for s in listwrap(json["select"]))
|
||||
if "top" in json:
|
||||
top = self.dispatch(json["top"])
|
||||
return f"SELECT TOP ({top}) {param}"
|
||||
if "distinct_on" in json:
|
||||
return param
|
||||
else:
|
||||
return f"SELECT {param}"
|
||||
|
||||
def distinct_on(self, json, prec):
|
||||
param = ", ".join(self.dispatch(s) for s in listwrap(json["distinct_on"]))
|
||||
return f"SELECT DISTINCT ON ({param})"
|
||||
|
||||
def select_distinct(self, json, prec):
|
||||
param = ", ".join(self.dispatch(s) for s in listwrap(json["select_distinct"]))
|
||||
return f"SELECT DISTINCT {param}"
|
||||
|
||||
def from_(self, json, prec):
|
||||
is_join = False
|
||||
from_ = json["from"]
|
||||
if isinstance(from_, dict) and is_set_op & from_.keys():
|
||||
source = self.op(from_, precedence["from"])
|
||||
return f"FROM {source}"
|
||||
|
||||
from_ = listwrap(from_)
|
||||
parts = []
|
||||
for v in from_:
|
||||
if join_keywords & set(v):
|
||||
is_join = True
|
||||
parts.append(self._join_on(v, precedence["from"] - 1))
|
||||
else:
|
||||
parts.append(self.dispatch(v, precedence["from"] - 1))
|
||||
joiner = " " if is_join else ", "
|
||||
rest = joiner.join(parts)
|
||||
return f"FROM {rest}"
|
||||
|
||||
def where(self, json, prec):
|
||||
expr = self.dispatch(json["where"])
|
||||
return f"WHERE {expr}"
|
||||
|
||||
def groupby(self, json, prec):
|
||||
param = ", ".join(self.dispatch(s) for s in listwrap(json["groupby"]))
|
||||
return f"GROUP BY {param}"
|
||||
|
||||
def having(self, json, prec):
|
||||
return "HAVING {0}".format(self.dispatch(json["having"]))
|
||||
|
||||
def orderby(self, json, prec):
|
||||
param = ", ".join(
|
||||
(
|
||||
self.dispatch(s["value"], precedence["order"])
|
||||
+ " "
|
||||
+ s.get("sort", "").upper()
|
||||
).strip()
|
||||
for s in listwrap(json["orderby"])
|
||||
)
|
||||
return f"ORDER BY {param}"
|
||||
|
||||
def limit(self, json, prec):
|
||||
num = self.dispatch(json["limit"], precedence["order"])
|
||||
return f"LIMIT {num}"
|
||||
|
||||
def offset(self, json, prec):
|
||||
num = self.dispatch(json["offset"], precedence["order"])
|
||||
return f"OFFSET {num}"
|
||||
|
||||
def fetch(self, json, prec):
|
||||
num = self.dispatch(json["offset"], precedence["order"])
|
||||
return f"FETCH {num} ROWS ONLY"
|
||||
|
||||
def insert(self, json, prec=precedence["from"]):
|
||||
acc = ["INSERT"]
|
||||
if "overwrite" in json:
|
||||
acc.append("OVERWRITE")
|
||||
else:
|
||||
acc.append("INTO")
|
||||
acc.append(json["insert"])
|
||||
|
||||
if "columns" in json:
|
||||
acc.append(self.sql_list(json))
|
||||
if "values" in json:
|
||||
values = json["values"]
|
||||
if all(isinstance(row, dict) for row in values):
|
||||
columns = list(sorted(set(k for row in values for k in row.keys())))
|
||||
acc.append(self.sql_list(columns))
|
||||
if "if exists" in json:
|
||||
acc.append("IF EXISTS")
|
||||
acc.append("VALUES")
|
||||
acc.append(",\n".join(
|
||||
"(" + ", ".join(self._literal(row[c]) for c in columns) + ")"
|
||||
for row in values
|
||||
))
|
||||
else:
|
||||
if "if exists" in json:
|
||||
acc.append("IF EXISTS")
|
||||
acc.append("VALUES")
|
||||
for row in values:
|
||||
acc.append("(" + ", ".join(self._literal(row)) + ")")
|
||||
|
||||
else:
|
||||
if json["if exists"]:
|
||||
acc.append("IF EXISTS")
|
||||
acc.append(self.dispatch(json["query"]))
|
||||
return " ".join(acc)
|
||||
|
||||
|
||||
setattr(Formatter, "with", Formatter.with_)
|
||||
setattr(Formatter, "from", Formatter.from_)
|
||||
@ -0,0 +1,11 @@
|
||||
CREATE TABLE sale(Month INT, sales INT)
|
||||
|
||||
LOAD DATA INFILE "moving_avg.csv"
|
||||
INTO TABLE sale
|
||||
FIELDS TERMINATED BY "\t"
|
||||
|
||||
SELECT Month,avgs(3,sales)
|
||||
FROM sale
|
||||
ASSUMING ASC Month
|
||||
INTO OUTFILE "moving_avg_output.csv"
|
||||
FIELDS TERMINATED BY ","
|
||||
|
@ -0,0 +1,22 @@
|
||||
CREATE TABLE stocks(timestamp INT, price INT)
|
||||
|
||||
INSERT INTO stocks VALUES(1,15)
|
||||
INSERT INTO stocks VALUES(2,19)
|
||||
INSERT INTO stocks VALUES(3,16)
|
||||
INSERT INTO stocks VALUES(4,17)
|
||||
INSERT INTO stocks VALUES(5,15)
|
||||
INSERT INTO stocks VALUES(6,13)
|
||||
INSERT INTO stocks VALUES(7,5)
|
||||
INSERT INTO stocks VALUES(8,8)
|
||||
INSERT INTO stocks VALUES(9,7)
|
||||
INSERT INTO stocks VALUES(10,13)
|
||||
INSERT INTO stocks VALUES(11,11)
|
||||
INSERT INTO stocks VALUES(12,14)
|
||||
INSERT INTO stocks VALUES(13,10)
|
||||
INSERT INTO stocks VALUES(14,5)
|
||||
INSERT INTO stocks VALUES(15,2)
|
||||
INSERT INTO stocks VALUES(16,5)
|
||||
|
||||
SELECT max(price-mins(price))
|
||||
FROM stocks
|
||||
ASSUMING ASC timestamp
|
||||
Loading…
Reference in new issue