def equality(ctx, x, y):
if util.is_empty(x) or util.is_empty(y):
return False
if type(x[0]) in DATETIME_NODES_LIST or type(y[0]) in DATETIME_NODES_LIST:
return datetime_equality(ctx, x, y)
return x == y
def indexer_expression(ctx, parentData, node):
coll_node = node["children"][0]
idx_node = node["children"][1]
coll = engine.do_eval(ctx, parentData, coll_node)
idx = engine.do_eval(ctx, parentData, idx_node)
if util.is_empty(idx):
return []
idxNum = int(idx[0])
if coll is not None and util.is_some(
idxNum) and len(coll) > idxNum and idxNum >= 0:
return [coll[idxNum]]
return []
def doInvoke(ctx, fn_name, data, raw_params):
if isinstance(fn_name, list) and len(fn_name) == 1:
fn_name = fn_name[0]
if type(fn_name) != str or not fn_name in invocations:
raise Exception("Not implemented: " + str(fn_name))
invocation = invocations[fn_name]
if not "arity" in invocation:
if raw_params is None or util.is_empty(raw_params):
res = invocation["fn"](ctx, util.arraify(data))
return util.arraify(res)
raise Exception(fn_name + " expects no params")
paramsNumber = 0
if isinstance(raw_params, list):
paramsNumber = len(raw_params)
if not paramsNumber in invocation["arity"]:
raise Exception(fn_name + " wrong arity: got " + str(paramsNumber))
params = []
argTypes = invocation["arity"][paramsNumber]
for i in range(0, paramsNumber):
tp = argTypes[i]
pr = raw_params[i]
params.append(make_param(ctx, data, tp, pr))
params.insert(0, data)
params.insert(0, ctx)
if "nullable" in invocation:
if any(util.is_nullable(x) for x in params):
return []
res = invocation["fn"](*params)
return util.arraify(res)
def is_empty(x):
if util.is_number(x):
return False
return util.is_empty(x)
def empty_fn(ctx, value):
return util.is_empty(value)
def exists_macro(ctx, coll, expr=None):
vec = coll
if expr is not None:
return exists_macro(ctx, filtering.where_macro(ctx, coll, expr))
return not util.is_empty(vec)