def to_es_script(self, schema): if len(self.terms) == 0: return self.default.to_es_script(schema) acc = [] separator = StringOp("string", self.separator).partial_eval() sep = separator.to_es_script(schema).expr for t in self.terms: val = WhenOp( "when", t.missing(), **{ "then": Literal("literal", ""), "else": EsScript(type=STRING, expr=sep + "+" + StringOp(None, t).partial_eval().to_es_script(schema).expr, frum=t) # "else": ConcatOp("concat", [sep, t]) } ) acc.append("(" + val.partial_eval().to_es_script(schema).expr + ")") expr_ = "(" + "+".join(acc) + ").substring(" + LengthOp("length", separator).to_es_script(schema).expr + ")" if isinstance(self.default, NullOp): return EsScript( miss=self.missing(), type=STRING, expr=expr_, frum=self ) else: return EsScript( miss=self.missing(), type=STRING, expr="((" + expr_ + ").length==0) ? (" + self.default.to_es_script(schema).expr + ") : (" + expr_ + ")", frum=self )
def to_ruby(self, schema): if len(self.terms) == 0: return self.default.to_ruby(schema) acc = [] separator = StringOp("string", self.separator).partial_eval() sep = separator.to_ruby(schema).expr for t in self.terms: val = WhenOp( "when", t.missing(), **{ "then": Literal("literal", ""), "else": Ruby(type=STRING, expr=sep + "+" + StringOp(None, t).partial_eval().to_ruby(schema).expr, frum=t) # "else": ConcatOp("concat", [sep, t]) }) acc.append("(" + val.partial_eval().to_ruby(schema).expr + ")") expr_ = "(" + "+".join(acc) + ").substring(" + LengthOp( "length", separator).to_ruby(schema).expr + ")" if isinstance(self.default, NullOp): return Ruby(miss=self.missing(), type=STRING, expr=expr_, frum=self) else: return Ruby(miss=self.missing(), type=STRING, expr="((" + expr_ + ").length==0) ? (" + self.default.to_ruby(schema).expr + ") : (" + expr_ + ")", frum=self)
def to_ruby(self, schema): output = CaseOp("case", [ WhenOp("when", self.lhs.missing(), **{"then": NotOp("not", self.rhs.missing())}), WhenOp("when", self.rhs.missing(), **{"then": NotOp("not", self.lhs.missing())}), NotOp("not", BasicEqOp("eq", [self.lhs, self.rhs])) ]).partial_eval().to_ruby(schema) return output
def to_painless(self, schema): return CaseOp("case", [ WhenOp("when", self.lhs.missing(), ** {"then": NotOp("not", self.rhs.missing())}), WhenOp("when", self.rhs.missing(), ** {"then": NotOp("not", self.lhs.missing())}), NotOp("not", BasicEqOp("eq", [self.lhs, self.rhs])) ]).partial_eval().to_painless(schema)
def partial_eval(self): lhs = self.lhs.partial_eval() rhs = self.rhs.partial_eval() if is_literal(lhs) and is_literal(rhs): return TRUE if builtin_ops["eq"](lhs.value, rhs.value) else FALSE else: rhs_missing = rhs.missing().partial_eval() return CaseOp([ WhenOp(lhs.missing(), **{"then": rhs_missing}), WhenOp(rhs_missing, **{"then": FALSE}), SqlEqOp([lhs, rhs]) ]).partial_eval()
def partial_eval(self): lhs = self.lhs.partial_eval() rhs = self.rhs.partial_eval() if isinstance(lhs, Literal) and isinstance(rhs, Literal): return TRUE if builtin_ops["eq"](lhs.value, rhs.value) else FALSE else: rhs_missing = rhs.missing().partial_eval() return CaseOp("case", [ WhenOp("when", lhs.missing(), **{"then": rhs_missing}), WhenOp("when", rhs_missing, **{"then": FALSE}), SqlEqOp("eq", [lhs, rhs]) ]).partial_eval()
def to_ruby(self, schema): acc = self.whens[-1].partial_eval().to_ruby(schema) for w in reversed(self.whens[0:-1]): acc = WhenOp("when", w.when, **{ "then": w.then, "else": acc }).partial_eval().to_ruby(schema) return acc
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): acc = self.whens[-1].partial_eval().to_es14_script(schema) for w in reversed(self.whens[0:-1]): acc = WhenOp( "when", w.when, **{"then": w.then, "else": acc} ).partial_eval().to_es14_script(schema) return acc
def to_ruby(self, schema): lhs = NumberOp("number", self.lhs).partial_eval().to_ruby(schema).expr rhs = NumberOp("number", self.rhs).partial_eval().to_ruby(schema).expr script = "(" + lhs + ") " + BinaryOp.operators[self.op] + " (" + rhs + ")" missing = OrOp("or", [self.lhs.missing(), self.rhs.missing()]) return WhenOp( "when", missing, **{ "then": self.default, "else": Ruby(type=NUMBER, expr=script, frum=self) }).partial_eval().to_ruby(schema)
def to_ruby(self, schema): op, unit = MultiOp.operators[self.op] if self.nulls: calc = op.join( "((" + t.missing().to_ruby(schema).expr + ") ? " + unit + " : (" + NumberOp("number", t).partial_eval().to_ruby(schema).expr + "))" for t in self.terms) return WhenOp( "when", AndOp("and", [t.missing() for t in self.terms]), **{ "then": self.default, "else": Ruby(type=NUMBER, expr=calc, frum=self) }).partial_eval().to_ruby(schema) else: calc = op.join("(" + NumberOp("number", t).to_ruby(schema).expr + ")" for t in self.terms) return WhenOp( "when", OrOp("or", [t.missing() for t in self.terms]), **{ "then": self.default, "else": Ruby(type=NUMBER, expr=calc, frum=self) }).partial_eval().to_ruby(schema)
def to_esfilter(self, schema): if isinstance(self.lhs, Variable) and isinstance(self.rhs, Literal): rhs = self.rhs.value lhs = self.lhs.var cols = schema.leaves(lhs) if cols: lhs = cols[0].es_column if isinstance(rhs, list): if len(rhs) == 1: return {"term": {lhs: rhs[0]}} else: return {"terms": {lhs: rhs}} else: return {"term": {lhs: rhs}} else: return CaseOp("case", [ WhenOp("when", self.lhs.missing(), **{"then": self.rhs.missing()}), WhenOp("when", self.rhs.missing(), **{"then": FALSE}), BasicEqOp("eq", [self.lhs, self.rhs]) ]).partial_eval().to_esfilter(schema)
def to_ruby(self, schema): lhs = NumberOp("number", self.lhs).partial_eval().to_ruby(schema).expr rhs = NumberOp("number", self.rhs).partial_eval().to_ruby(schema).expr script = "(" + lhs + ") " + InequalityOp.operators[ self.op] + " (" + rhs + ")" output = WhenOp( "when", OrOp("or", [self.lhs.missing(), self.rhs.missing()]), **{ "then": FALSE, "else": Ruby(type=BOOLEAN, expr=script, frum=self) }).partial_eval().to_ruby(schema) return output
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): op, unit = _painless_operators[self.op] if self.nulls: calc = op.join( "((" + t.missing().to_es14_script(schema).expr + ") ? " + unit + " : (" + NumberOp("number", t).partial_eval().to_es14_script(schema).expr + "))" for t in self.terms ) return WhenOp( "when", AndOp("and", [t.missing() for t in self.terms]), **{"then": self.default, "else": EsScript(type=NUMBER, expr=calc, frum=self)} ).partial_eval().to_es14_script(schema) else: calc = op.join( "(" + NumberOp("number", t).to_es14_script(schema).expr + ")" for t in self.terms ) return WhenOp( "when", OrOp("or", [t.missing() for t in self.terms]), **{"then": self.default, "else": EsScript(type=NUMBER, expr=calc, frum=self)} ).partial_eval().to_es14_script(schema)
def to_painless(self, schema): value = self.term.to_painless(schema) if value.many: return BooleanOp("boolean", Painless( miss=value.miss, type=value.type, expr="(" + value.expr + ")[0]", frum=value.frum )).to_painless(schema) elif value.type == BOOLEAN: miss = value.miss value.miss = FALSE return WhenOp("when", miss, **{"then": FALSE, "else": value}).partial_eval().to_painless(schema) else: return NotOp("not", value.miss).partial_eval().to_painless(schema)
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): lhs = NumberOp("number", self.lhs).partial_eval().to_es14_script(schema).expr rhs = NumberOp("number", self.rhs).partial_eval().to_es14_script(schema).expr script = "(" + lhs + ") " + BinaryOp.operators[self.op] + " (" + rhs + ")" missing = OrOp("or", [self.lhs.missing(), self.rhs.missing()]) return WhenOp( "when", missing, **{ "then": self.default, "else": EsScript(type=NUMBER, expr=script, frum=self) } ).partial_eval().to_es14_script(schema)
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): lhs = NumberOp("number", self.lhs).partial_eval().to_es14_script(schema).expr rhs = NumberOp("number", self.rhs).partial_eval().to_es14_script(schema).expr script = "(" + lhs + ") " + InequalityOp.operators[self.op] + " (" + rhs + ")" output = WhenOp( "when", OrOp("or", [self.lhs.missing(), self.rhs.missing()]), **{ "then": FALSE, "else": EsScript(type=BOOLEAN, expr=script, frum=self) } ).partial_eval().to_es14_script(schema) return output
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): lhs = NumberOp("number", self.lhs).partial_eval() rhs = NumberOp("number", self.rhs).partial_eval() script = "(" + lhs.to_es14_script(schema).expr + ") / (" + rhs.to_es14_script(schema).expr + ")" output = WhenOp( "when", OrOp("or", [self.lhs.missing(), self.rhs.missing(), EqOp("eq", [self.rhs, ZERO])]), **{ "then": self.default, "else": EsScript(type=NUMBER, expr=script, frum=self) } ).partial_eval().to_es14_script(schema) return output
def to_ruby(self, schema): lhs = self.lhs.to_ruby(schema) rhs = self.rhs.to_ruby(schema) script = "(int)Math.floor(((double)(" + lhs + ") / (double)(" + rhs + ")).doubleValue())*(" + rhs + ")" output = WhenOp( "when", OrOp("or", [self.lhs.missing(), self.rhs.missing(), EqOp("eq", [self.rhs, ZERO])]), **{ "then": self.default, "else": ScriptOp("script", script) } ).to_ruby(schema) return output
def to_ruby(self, schema): lhs = NumberOp("number", self.lhs).partial_eval() rhs = NumberOp("number", self.rhs).partial_eval() script = "(" + lhs.to_ruby(schema).expr + ") / (" + rhs.to_ruby(schema).expr + ")" output = WhenOp( "when", OrOp("or", [self.lhs.missing(), self.rhs.missing(), EqOp("eq", [self.rhs, ZERO])]), **{ "then": self.default, "else": Ruby(type=NUMBER, expr=script, frum=self) } ).partial_eval().to_ruby(schema) return output
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): value = self.term.to_es14_script(schema) if value.many: return BooleanOp("boolean", EsScript( miss=value.miss, type=value.type, expr="(" + value.expr + ")[0]", frum=value.frum )).to_es14_script(schema) elif value.type == BOOLEAN: miss = value.miss value.miss = FALSE return WhenOp("when", miss, **{"then": FALSE, "else": value}).partial_eval().to_es14_script(schema) else: return NotOp("not", value.miss).partial_eval().to_es14_script(schema)
def to_sql(self, schema, not_null=False, boolean=False): test = SqlInstrOp( [SqlSubstrOp([self.value, AddOp([self.start, ONE]), NULL]), self.find]).partial_eval() if boolean: return test.to_sql(schema) else: offset = SubOp([self.start, ONE]).partial_eval() index = AddOp([test, offset]).partial_eval() temp = index.to_sql(schema) return WhenOp(EqOp([test, ZERO]), **{ "then": self.default, "else": index }).partial_eval().to_sql(schema)
def to_sql(self, schema, not_null=False, boolean=False): test = SqlInstrOp("substr", [ SqlSubstrOp( "substr", [self.value, MultiOp("add", [self.start, ONE]), NULL]), self.find ]).partial_eval() if boolean: return test.to_sql(schema) else: offset = BinaryOp("sub", [self.start, ONE]).partial_eval() index = MultiOp("add", [test, offset]).partial_eval() temp = index.to_sql(schema) return WhenOp("when", EqOp("eq", [test, ZERO]), **{ "then": self.default, "else": index }).partial_eval().to_sql(schema)
def to_es_script(self, schema): lhs = self.lhs.partial_eval().to_es_script(schema) rhs = self.rhs.partial_eval().to_es_script(schema) if rhs.frum is ONE: script = "(int)Math.floor(" + lhs.expr + ")" else: script = "Math.floor((" + lhs.expr + ") / (" + rhs.expr + "))*(" + rhs.expr + ")" output = WhenOp( "when", OrOp("or", [lhs.miss, rhs.miss, EqOp("eq", [self.rhs, ZERO])]), **{ "then": self.default, "else": EsScript(type=NUMBER, expr=script, frum=self, miss=FALSE) }).to_es_script(schema) return output
def to_ruby(self, schema): return CaseOp("case", [ WhenOp("when", self.lhs.missing(), **{"then": self.rhs.missing()}), WhenOp("when", self.rhs.missing(), **{"then": FALSE}), BasicEqOp("eq", [self.lhs, self.rhs]) ]).partial_eval().to_ruby(schema)
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): return CaseOp("case", [ WhenOp("when", self.lhs.missing(), **{"then": NotOp("not", self.rhs.missing())}), WhenOp("when", self.rhs.missing(), **{"then": NotOp("not", self.lhs.missing())}), NotOp("not", BasicEqOp("eq", [self.lhs, self.rhs])) ]).partial_eval().to_es14_script(schema)