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)