def to_esfilter(self, schema): output = OrOp("or", [ AndOp("and", [self.when, BooleanOp("boolean", self.then)]), AndOp("and", [NotOp("not", self.when), BooleanOp("boolean", self.els_)]) ]).partial_eval() return output.to_esfilter(schema)
def to_esfilter(self, schema): output = OrOp("or", [ AndOp("and", [self.when, BooleanOp("boolean", self.then)]), AndOp("and", [NotOp("not", self.when), BooleanOp("boolean", self.els_)]) ]).partial_eval() return output.to_esfilter(schema)
def to_esfilter(self, schema): if self.type == BOOLEAN: return OrOp("or", [AndOp("and", [w.when, w.then]) for w in self.whens[:-1]] + self.whens[-1:]).partial_eval().to_esfilter(schema) else: Log.error("do not know how to handle") return ScriptOp( "script", self.to_es_script(schema).script(schema)).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 + ") " + 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): v = StringOp("string", self.value).partial_eval().to_ruby(schema).expr l = NumberOp("number", self.length).partial_eval().to_ruby(schema).expr expr = "(" + v + ").substring((int)Math.max(0, (int)Math.min(" + v + ".length(), " + l + ")))" return Ruby(miss=OrOp( "or", [self.value.missing(), self.length.missing()]), type=STRING, expr=expr, frum=self)
def to_es14_script(self, schema, not_null=False, boolean=False, many=True): v = StringOp("string", self.value).partial_eval().to_es14_script(schema).expr l = NumberOp("number", self.length).partial_eval().to_es14_script(schema).expr expr = "(" + v + ").substring((int)Math.max(0, (int)Math.min(" + v + ".length(), " + l + ")))" return EsScript( miss=OrOp("or", [self.value.missing(), self.length.missing()]), type=STRING, expr=expr, frum=self )
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_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): 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_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().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_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): 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_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)