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)