def partial_eval(self):
term = self.lang[self.term].partial_eval()
if is_literal(term):
if is_text(term.value):
return self.lang[Literal(len(term.value))]
else:
return NULL
else:
return self.lang[LengthOp(term)]
def define(cls, expr):
term = expr.get('prefix')
if not term:
return PrefixOp(NULL, NULL)
elif is_data(term):
expr, const = first(term.items())
return PrefixOp(Variable(expr), Literal(const))
else:
return PrefixOp(*term)
def partial_eval(self):
value = self.value.partial_eval()
superset = self.superset.partial_eval()
if superset is NULL:
return FALSE
elif is_literal(value) and is_literal(superset):
return self.lang[Literal(self())]
else:
return self.lang[InOp([value, superset])]
def partial_eval(self, lang):
default = self.default.partial_eval(lang)
rhs = self.rhs.partial_eval(lang)
if rhs is ZERO:
return default
lhs = self.lhs.partial_eval(lang)
if is_literal(lhs) and is_literal(rhs):
return Literal(builtin_ops[self.op](lhs.value, rhs.value))
return self.__class__([lhs, rhs], default=default)
def partial_eval(self, lang):
lhs = self.lhs.partial_eval(lang)
rhs = self.rhs.partial_eval(lang)
default = self.default.partial_eval(lang)
if is_literal(lhs) and is_literal(rhs):
if lhs is NULL or rhs is NULL:
return NULL
return Literal(builtin_ops[self.op](lhs.value, rhs.value))
return self.__class__([lhs, rhs], default=default)
def partial_eval(self, lang):
term = self.term.partial_eval(lang)
if is_literal(term):
if is_text(term.value):
return (Literal(len(term.value)))
else:
return NULL
else:
return (LengthOp(term))
def __init__(self, terms, separator=Literal(""), default=NULL):
if not is_many(terms):
Log.error("Expecting many terms")
if not is_literal(separator):
Log.error("Expecting a literal separator")
Expression.__init__(self, terms + [separator, default])
self.terms = terms
self.separator = separator
self.default = default
def __init__(self, terms, **clauses):
Expression.__init__(self, terms)
if is_data(terms):
self.terms = first(terms.items())
else:
self.terms = terms
self.separator = clauses.get(str("separator"), Literal(""))
self.default = clauses.get(str("default"), NULL)
if not is_literal(self.separator):
Log.error("Expecting a literal separator")
def define(cls, expr):
term = expr.get("prefix")
if not term:
return PrefixOp(NULL, NULL)
elif is_data(term):
expr, const = first(term.items())
return PrefixOp(Variable(expr), Literal(const))
else:
expr, const = term
return PrefixOp(jx_expression(expr), jx_expression(const))
def __new__(cls, term, *args):
Expression.__new__(cls, *args)
field, comparisons = term # comparisons IS A Literal()
return cls.lang[
AndOp(
[
getattr(cls.lang, operators[op])([field, Literal(value)])
for op, value in comparisons.value.items()
]
)
]
def missing(self):
v = self.value.to_es_script(not_null=True)
find = self.find.to_es_script(not_null=True)
index = v + ".indexOf(" + find + ", " + self.start.to_es_script() + ")"
return self.lang[AndOp([
self.default.missing(),
OrOp([
self.value.missing(),
self.find.missing(),
EqOp([ScriptOp(index), Literal(-1)]),
]),
])]
def partial_eval(self, lang):
value = self.value.partial_eval(lang)
superset = self.superset.partial_eval(lang)
if superset is NULL:
return FALSE
elif value is NULL:
return NULL
elif is_literal(value) and is_literal(superset):
return Literal(value() in superset())
elif is_op(value, NestedOp):
return NestedOp(value.path, None, AndOp([BasicInOp([value.select, superset]), value.where])).exists().partial_eval(lang)
else:
return lang.BasicInOp([value, superset])
def partial_eval(self):
minimum = None
terms = []
for t in self.terms:
simple = t.partial_eval()
if simple is NULL:
pass
elif is_op(simple, Literal):
minimum = MIN([minimum, simple.value])
else:
terms.append(simple)
if len(terms) == 0:
if minimum == None:
return NULL
else:
return Literal(minimum)
else:
if minimum == None:
output = self.lang[UnionOp(terms)]
else:
output = self.lang[UnionOp([Literal(minimum)] + terms)]
return output
def partial_eval(self, lang):
maximum = None
terms = []
for t in self.terms:
simple = t.partial_eval(lang)
if simple is NULL:
pass
elif is_literal(simple):
maximum = MAX([maximum, simple.value])
else:
terms.append(simple)
if len(terms) == 0:
if maximum == None:
return NULL
else:
return Literal(maximum)
else:
if maximum == None:
output = (MaxOp(terms))
else:
output = (MaxOp([Literal(maximum)] + terms))
return output
def partial_eval(self, lang):
minimum = None
terms = []
for t in self.terms:
simple = t.partial_eval(lang)
if is_op(simple, NullOp):
pass
elif is_literal(simple):
minimum = MIN([minimum, simple.value])
else:
terms.append(simple)
if len(terms) == 0:
if minimum == None:
return NULL
else:
return Literal(minimum)
else:
if minimum == None:
output = (MinOp(terms))
else:
output = (MinOp([Literal(minimum)] + terms))
return output
def partial_eval(self):
if self.expr is None:
return TRUE
if not is_literal(self.suffix) and self.suffix.type == STRING:
Log.error("can only hanlde literal suffix ")
return WhenOp(
self.lang[AndOp([self.expr.exists(), self.suffix.exists()])],
**{
"then": self.lang[
RegExpOp([self.expr, Literal(".*" + re.escape(self.suffix.value))])
],
"else": FALSE,
}
).partial_eval()
def partial_eval(self):
acc = None
terms = []
for t in self.terms:
simple = t.partial_eval()
if simple is NULL:
pass
elif is_op(simple, Literal):
if acc is None:
acc = simple.value
else:
acc = builtin_ops[self.op](acc, simple.value)
else:
terms.append(simple)
if len(terms) == 0:
if acc == None:
return self.default.partial_eval()
else:
return Literal(acc)
else:
if acc is not None:
terms.append(Literal(acc))
return self.__class__(terms)
def partial_eval(self):
term = self.term
if term.type is IS_NULL:
return NULL
term = self.lang[FirstOp(term)].partial_eval()
if is_op(term, StringOp):
return term.term.partial_eval()
elif is_op(term, CoalesceOp):
return self.lang[CoalesceOp(
[self.lang[StringOp(t)].partial_eval() for t in term.terms])]
elif is_literal(term):
if term.type == STRING:
return term
else:
return self.lang[Literal(mo_json.value2json(term.value))]
return self
def partial_eval(self, lang):
term = self.term
if term.type is IS_NULL:
return NULL
term = (FirstOp(term)).partial_eval(lang)
if is_op(term, StringOp):
return term.term.partial_eval(lang)
elif is_op(term, CoalesceOp):
return CoalesceOp([
(StringOp(t)).partial_eval(lang) for t in term.terms
])
elif is_literal(term):
if term.type == STRING:
return term
else:
return (Literal(mo_json.value2json(term.value)))
return self
def partial_eval(self):
term = self.lang[FirstOp(self.term)].partial_eval()
if is_literal(term):
if term is NULL:
return NULL
elif term is FALSE:
return ZERO
elif term is TRUE:
return ONE
v = term.value
if isinstance(v, (text, Date)):
return self.lang[Literal(float(v))]
elif isinstance(v, (int, float)):
return term
else:
Log.error("can not convert {{value|json}} to number", value=term.value)
elif is_op(term, CaseOp): # REWRITING
return self.lang[
CaseOp(
[
WhenOp(t.when, **{"then": NumberOp(t.then)})
for t in term.whens[:-1]
]
+ [NumberOp(term.whens[-1])]
)
].partial_eval()
elif is_op(term, WhenOp): # REWRITING
return self.lang[
WhenOp(
term.when,
**{"then": NumberOp(term.then), "else": NumberOp(term.els_)}
)
].partial_eval()
elif is_op(term, CoalesceOp):
return self.lang[CoalesceOp([NumberOp(t) for t in term.terms])]
return self.lang[NumberOp(term)]
def __init__(self, term):
if is_data(term):
term = term['date'] # FOR WHEN WE MIGHT DO Literal({"date":term})
self.date = term
Literal.__init__(self, float(Date(self.date)))
def __init__(self, op=None, term=None):
Literal.__init__(self, False)
def partial_eval(self, lang):
if all(is_literal(t) for t in self.terms):
return (Literal([t.value for t in self.terms]))
return self
def __init__(self, op=None, term=None):
Literal.__init__(self, True)
def partial_eval(self):
if all(is_literal(t) for t in self.terms):
return self.lang[Literal([t.value for t in self.terms])]
return self
def __new__(cls, terms):
if is_op(terms[0], Variable) and is_op(terms[1], Literal):
name, value = terms
if not is_many(value.value):
return (EqOp([name, Literal([value.value])]))
return object.__new__(cls)
