You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
109 lines
4.0 KiB
109 lines
4.0 KiB
from reconstruct.ast import ast_node
|
|
from reconstruct.storage import ColRef
|
|
from engine.types import *
|
|
|
|
class expr(ast_node):
|
|
name='expr'
|
|
|
|
def __init__(self, parent, node, *, c_code = None):
|
|
from reconstruct.ast import projection
|
|
|
|
self.type = None
|
|
self.raw_col = None
|
|
self.inside_agg = False
|
|
self.is_special = False
|
|
if(type(parent) is expr):
|
|
self.inside_agg = parent.inside_agg
|
|
if(type(parent) is not expr):
|
|
self.root = self
|
|
self.c_code = type(parent) is projection
|
|
else:
|
|
self.root = parent.root
|
|
self.c_code = parent.c_code
|
|
|
|
if type(c_code) is bool:
|
|
self.c_code = c_code
|
|
|
|
ast_node.__init__(self, parent, node, None)
|
|
|
|
def init(self, _):
|
|
from reconstruct.ast import projection
|
|
parent = self.parent
|
|
self.isvector = parent.isvector if type(parent) is expr else False
|
|
self.is_compound = parent.is_compound if type(parent) is expr else False
|
|
if type(parent) in [projection, expr]:
|
|
self.datasource = parent.datasource
|
|
else:
|
|
self.datasource = self.context.datasource
|
|
self.udf_map = parent.context.udf_map
|
|
self.func_maps = {**builtin_func, **self.udf_map}
|
|
self.operators = {**builtin_operators, **self.udf_map}
|
|
def produce(self, node):
|
|
from engine.utils import enlist
|
|
if type(node) is dict:
|
|
for key, val in node.items():
|
|
if key in self.operators:
|
|
op = self.operators[key]
|
|
|
|
val = enlist(val)
|
|
exp_vals = [expr(self, v, c_code = self.c_code) for v in val]
|
|
str_vals = [e.sql for e in exp_vals]
|
|
type_vals = [e.type for e in exp_vals]
|
|
|
|
self.type = op.return_type(*type_vals)
|
|
self.sql = op(self.c_code, *str_vals)
|
|
special_func = [*self.context.udf_map.keys(), "maxs", "mins", "avgs", "sums"]
|
|
if key in special_func and not self.is_special:
|
|
self.is_special = True
|
|
p = self.parent
|
|
while type(p) is expr and not p.is_special:
|
|
p.is_special = True
|
|
p = p.parent
|
|
else:
|
|
print(f'Undefined expr: {key}{val}')
|
|
|
|
elif type(node) is str:
|
|
p = self.parent
|
|
while type(p) is expr and not p.isvector:
|
|
p.isvector = True
|
|
p = p.parent
|
|
if self.datasource is not None:
|
|
self.raw_col = self.datasource.parse_col_names(node)
|
|
self.raw_col = self.raw_col if type(self.raw_col) is ColRef else None
|
|
if self.raw_col is not None:
|
|
self.sql = self.raw_col.name
|
|
self.type = self.raw_col.type
|
|
else:
|
|
self.sql = node
|
|
self.type = StrT
|
|
if self.c_code and self.datasource is not None:
|
|
self.sql = f'{{y(\"{self.sql}\")}}'
|
|
elif type(node) is bool:
|
|
self.type = IntT
|
|
if self.c_code:
|
|
self.sql = '1' if node else '0'
|
|
else:
|
|
self.sql = 'TRUE' if node else 'FALSE'
|
|
else:
|
|
self.sql = f'{node}'
|
|
if type(node) is int:
|
|
self.type = LongT
|
|
elif type(node) is float:
|
|
self.type = DoubleT
|
|
|
|
def finalize(self, y):
|
|
if self.c_code:
|
|
x = self.is_special
|
|
self.sql = eval('f\'' + self.sql + '\'')
|
|
|
|
def __str__(self):
|
|
return self.sql
|
|
def __repr__(self):
|
|
return self.__str__()
|
|
def eval(self):
|
|
x = self.c_code
|
|
y = lambda x: x
|
|
return eval('f\'' + self.sql + '\'')
|
|
|
|
import engine.expr as cexpr
|