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 __init__(self, script, data_type=OBJECT): Expression.__init__(self, None) if not is_text(script): Log.error("expecting text of a script") self.simplified = True self.script = script self.data_type = data_type
def __init__(self, frum, select=None, edges=None, groupby=None, window=None, where=None, sort=None, limit=None, format=None, chunk_size=None, destination=None): if isinstance(frum, Table): pass else: Expression.__init__(self, frum) self.frum = frum self.select = select self.edges = edges self.groupby = groupby self.window = window self.where = where self.sort = sort self.limit = limit self.format = format self.chunk_size = chunk_size self.destination = destination
def __init__(self, terms, **clauses): Expression.__init__(self, terms) if is_many(terms): # SHORTCUT: ASSUME AN ARRAY OF IS A TUPLE self.terms = self.lang[TupleOp(terms)] else: self.terms = terms
def __init__(self, term, **kwargs): Expression.__init__(self, term) self.value, self.find = term self.default = kwargs.get("default", NULL) self.start = kwargs.get("start", ZERO).partial_eval() if self.start is NULL: self.start = ZERO
def __init__(self, terms, **clauses): Expression.__init__(self, terms) self.terms = terms self.default = coalesce(clauses.get("default"), NULL) self.nulls = coalesce( clauses.get("nulls"), FALSE ) # nulls==True WILL HAVE OP RETURN null ONLY IF ALL OPERANDS ARE null
def __init__(self, path, select=select_nothing, where=TRUE, sort=Null, limit=NULL): Expression.__init__(self, [path, select, where]) self.path = path self.select = select self.where = where self.sort = sort self.limit = limit
def __init__(self, terms, default=NULL): Expression.__init__(self, terms) if len(terms) == 1: self.lhs = terms[0] self.rhs = ONE else: self.lhs, self.rhs = terms self.default = default
def __init__(self, term): Expression.__init__(self, term) if not term: self.expr = self.suffix = None elif is_data(term): self.expr, self.suffix = term.items()[0] else: self.expr, self.suffix = term
def __init__(self, terms): Expression.__init__(self, terms) if terms == None: self.terms = [] elif is_many(terms): self.terms = terms else: self.terms = [terms]
def __init__(self, terms): Expression.__init__(self, terms) if is_sequence(terms): self.lhs, self.rhs = terms elif is_data(terms): self.rhs, self.lhs = terms.items()[0] else: Log.error("logic error")
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, term): Expression.__init__(self, term) if not term: self.expr = NULL self.prefix = NULL elif is_data(term): self.expr, self.prefix = term.items()[0] else: self.expr, self.prefix = term
def __init__(self, term): Expression.__init__(self, term) if is_data(term): self.value, self.length = term.items()[0] else: self.value, self.length = term if is_literal(self.value): Log.note("")
def __init__(self, frum, nests): Expression.__init__(self, nests) self.frum = frum self.nests = nests last = "." for n in reversed(nests): path = n.path.var if not startswith_field(path, last): Log.error("Expecting nests to be reverse nested order") last = path
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 __init__(self, value, prefix, suffix, default=NULL, start=NULL): Expression.__init__(self, []) self.value = value self.prefix = prefix self.suffix = suffix self.default = default self.start = start if is_literal(self.prefix) and is_literal(self.suffix): pass else: Log.error("Expecting literal prefix and suffix only")
def __init__(self, value, prefix, suffix, default=NULL, start=NULL): Expression.__init__(self, []) self.value = value self.prefix = coalesce(prefix, NULL) self.suffix = coalesce(suffix, NULL) self.default = coalesce(default, NULL) self.start = coalesce(start, NULL) if is_literal(self.prefix) and is_literal(self.suffix): pass else: Log.error("Expecting literal prefix and suffix only")
def __init__(self, term): Expression.__init__(self, term) self.var, self.offset = term if is_op(self.var, Variable): if is_op(self.var, Variable) and not any( self.var.var.startswith(p) for p in ["row.", "rows.", "rownum"] ): # VARIABLES ARE INTERPRETED LITERALLY self.var = Literal(self.var.var) else: Log.error("can not handle") else: Log.error("can not handle")
def __init__(self, terms, **clauses): if not is_sequence(terms): Log.error("case expression requires a list of `when` sub-clauses") Expression.__init__(self, terms) if len(terms) == 0: Log.error("Expecting at least one clause") for w in terms[:-1]: if not is_op(w, WhenOp) or w.els_ is not NULL: Log.error( "case expression does not allow `else` clause in `when` sub-clause" ) self.whens = terms
def __init__(self, var): """ :param var: DOT DELIMITED PATH INTO A DOCUMENT """ Expression.__init__(self, None) # if self.lang != self.__class_.lang: # pass self.var = get_property_name(var) jx_type = inserter_type_to_json_type.get(last(split_field(var))) if jx_type: self.data_type = jx_type
def __init__(self, term, **clauses): Expression.__init__(self, [term]) self.when = term self.then = coalesce(clauses.get("then"), NULL) self.els_ = coalesce(clauses.get("else"), NULL) if self.then is NULL: self.data_type = self.els_.type elif self.els_ is NULL: self.data_type = self.then.type elif same_json_type(self.then.type, self.els_.type): self.data_type = merge_json_type(self.then.type, self.els_.type) else: self.data_type = OBJECT
def __init__(self, frum, nests): """ A SEQUENCE OF NESTED (INNER) JOINS FOR A QUERY :param frum: THE TABLE OF DOCUMENTS :param nests: LIST OF INNER JOINS (deepest first) """ Expression.__init__(self, nests) self.frum = frum self.nests = nests last = "." for n in reversed(nests): path = n.path.var if not startswith_field(path, last): Log.error("Expecting nests to be reverse nested order") last = path
def __init__(self, term, **clauses): Expression.__init__(self, [term]) self.when = term self.then = coalesce(clauses.get("then"), NULL) self.els_ = coalesce(clauses.get("else"), NULL) if self.then is NULL: self.data_type = self.els_.type elif self.els_ is NULL: self.data_type = self.then.type elif self.then.type == self.els_.type: self.data_type = self.then.type elif self.then.type in NUMBER_TYPES and self.els_.type in NUMBER_TYPES: self.data_type = NUMBER else: self.data_type = OBJECT
def __init__(self, var, type=None, multi=None): """ :param var: DOT DELIMITED PATH INTO A DOCUMENT :param type: JSON TYPE, IF KNOWN :param multi: NUMBER OF DISTINCT VALUES IN A SLOT """ Expression.__init__(self, None) # if self.lang != self.__class_.lang: # pass self.var = get_property_name(var) if type == None: jx_type = inserter_type_to_json_type.get(last(split_field(var))) if jx_type: self.data_type = jx_type else: self.data_type = type self._many = False if multi and multi > 1: self._many = True
def __init__(self, term): Expression.__init__(self, term) self.value = term
def __init__(self, term): Expression.__init__(self, [term]) self.term = term
def __init__(self, term): Expression.__init__(self, term) self.expr = term
def __init__(self, terms): Expression.__init__(self, terms) self.value, self.start, self.end = terms
def __init__(self, terms): Expression.__init__(self, terms) self.terms = terms