relationalai 1.0.0a3__py3-none-any.whl → 1.0.0a5__py3-none-any.whl

relationalai/shims/mm2v0.py

@@ -1,10 +1,11 @@
 from __future__ import annotations
 
 from collections import defaultdict
-from dataclasses import dataclass, field, replace as dc_replace
-from typing import  Dict, Sequence as seq, Iterable
+from dataclasses import dataclass, field
+from typing import  Dict, Sequence as seq
 from enum import Enum
 from math import pi
+from urllib.parse import urlparse
 
 # PyRel imports
 from ..util.naming import sanitize
@@ -12,13 +13,9 @@ from ..semantics.metamodel import metamodel as mm
 from ..semantics.metamodel.builtins import builtins as b, is_abstract
 from ..semantics.metamodel.metamodel_analyzer import Normalize
 # ensure std libs are loaded
-from ..semantics.metamodel.metamodel_analyzer import VarFinder
-from ..semantics.metamodel.rewriter import Walker
-from ..semantics.std import aggregates, common, math, numbers, re, strings, decimals, datetime, floats
-from ..semantics.backends.lqp import annotations as lqp_annotations
 
 # V0 imports
-from v0.relationalai.semantics.metamodel import ir as v0, builtins as v0_builtins, types as v0_types, factory as f
+from v0.relationalai.semantics.metamodel import ir as v0, builtins as v0_builtins, types as v0_types
 from v0.relationalai.semantics.metamodel.util import FrozenOrderedSet, frozen, ordered_set, filter_by_type, OrderedSet
 from v0.relationalai.semantics.internal.internal import literal_value_to_type
 from v0.relationalai.semantics.metamodel.typer import typer as v0_typer
@@ -73,7 +70,10 @@ class Translator():
     maintenance_rules: list[v0.Logical] = field(default_factory=list)
 
     # outputs that are exports
-    exports: set[v0.Output] = field(default_factory=set)
+    exports: dict[v0.Output, mm.Table] = field(default_factory=dict)
+
+    # output column order
+    output_column_order: Dict[v0.Output, int] = field(default_factory=dict)
 
     hoister = Hoister()
     normalize = Normalize()
@@ -141,7 +141,7 @@ class Translator():
     # produces. If there's a quote in the table name, then we take it verbatim, otherwise we lowercase it.
     def translate_table_name(self, table: mm.Table) -> str:
         name = IdentityParser(table.name).identifier
-        name = name.lower() if '"' not in table.name else table.name.replace('"', '_')
+        name = name.lower() if '"' not in table.name else table.name.replace('"', '_').replace("-", "_")
         return sanitize(name)
 
     #-----------------------------------------------------------------------------
@@ -194,9 +194,9 @@ class Translator():
     def translate_overload(self, o: mm.Overload, parent: mm.Relation, ctx) -> v0.Relation:
         # Overloads in v0 are represented as separate Relation nodes with different types
         fields = []
-        for field, typ in zip(parent.fields, o.types):
+        for fld, typ in zip(parent.fields, o.types):
             fields.append(
-                v0.Field(name=field.name, type=self.translate_node(typ, field, ctx), input=field.input) # type: ignore
+                v0.Field(name=fld.name, type=self.translate_node(typ, fld, ctx), input=fld.input) # type: ignore
             )
         return v0.Relation(
             name=parent.name,
@@ -217,7 +217,9 @@ class Translator():
         "like": "like_match",
         "regex_escape": "escape_regex_metachars",
     }
-    for lib in ["core", "aggregates", "common", "datetime", "floats", "math", "numbers", "strings", "re", "lqp"]:
+    for lib in ["core", "aggregates", "constraints", "common", "datetime", "floats", "graph", "math", "numbers", "strings", "re", "lqp"]:
+        if lib not in b._libraries:
+            continue
         for x in b._libraries[lib].data.values():
             v0_name = RENAMES.get(x.name, x.name)
             if v0_name in v0_builtins.builtin_relations_by_name:
@@ -320,7 +322,13 @@ class Translator():
 
     def translate_annotation(self, a: mm.Annotation, parent, ctx) -> v0.Annotation:
         if a.relation.name in v0_builtins.builtin_annotations_by_name:
-            return getattr(v0_builtins, a.relation.name + "_annotation")  # type: ignore
+            if not a.args:
+                return getattr(v0_builtins, a.relation.name + "_annotation")  # type: ignore
+            else:
+                return v0.Annotation(
+                    relation=getattr(v0_builtins, a.relation.name),  # type: ignore
+                    args=tuple(self.translate_value(arg, a, ctx) for arg in a.args)
+                )
 
         return v0.Annotation(
             relation=self.translate_node(a.relation, a, Context.MODEL), # type: ignore
@@ -335,7 +343,7 @@ class Translator():
         # Abstract types (should be removed once our typer is done because they should not
         # show up in the typed metamodel.)
         b.core.Any: v0_types.Any,
-        # b.core.AnyEntity: v0_types.AnyEntity,
+        b.core.AnyEntity: v0_types.AnyEntity,
         b.core.Number: v0_types.Number, # v0 typer can figure the rest out
         # Concrete types
         b.core.Boolean: v0_types.Bool,
@@ -362,6 +370,7 @@ class Translator():
                 annotations.append(v0_builtins.external_annotation)
                 name = self.translate_table_name(t)
                 fields.insert(0, v0.Field(name="symbol", type=v0_types.Symbol, input=False)) # type: ignore
+            annotations.extend(self.translate_seq(t.annotations, t, ctx))  # type: ignore
 
             type_relation = v0.Relation(
                 name=name,
@@ -372,9 +381,8 @@ class Translator():
             )
             for super_type in t.super_types:
                 super_rel = self.translate_node(super_type, t, Context.TASK)
-                if not super_rel:
+                if not isinstance(super_rel, v0.Relation):
                     continue
-                assert isinstance(super_rel, v0.Relation)
                 v = v0.Var(type=actual_type, name=type_relation.name.lower())
                 self.maintenance_rules.append(v0.Logical(
                     engine=None,
@@ -456,15 +464,15 @@ class Translator():
     def translate_table(self, t: mm.Table, parent, ctx):
         return self.translate_scalartype(t, parent, ctx)
 
-    def rewrite_cdc_args(self, l: mm.Lookup, args, parent, ctx):
+    def rewrite_cdc_args(self, lookup_node: mm.Lookup, args, parent, ctx):
         # If this is a lookup for an external table column,
         # we have to prepend the column symbol to the args
-        root_type = l.relation.fields[0].type
+        root_type = lookup_node.relation.fields[0].type
         if isinstance(root_type, mm.Table):
             self.used_tables.add(root_type)
-            is_table = l.relation == root_type
-            if is_table or l.relation in root_type.columns:
-                sym = "METADATA$KEY" if is_table else l.relation.name
+            is_table = lookup_node.relation == root_type
+            if is_table or lookup_node.relation in root_type.columns:
+                sym = "METADATA$KEY" if is_table else lookup_node.relation.name
                 args = (v0.Literal(type=v0_types.Symbol, value=sym), *args)
         return args
 
@@ -488,22 +496,22 @@ class Translator():
             name=v.name
         )
 
-    def translate_literal(self, l: mm.Literal, parent, ctx) -> v0.Literal:
+    def translate_literal(self, literal_node: mm.Literal, parent, ctx) -> v0.Literal:
         typ = None
-        if l.type is None or is_abstract(l.type):
+        if literal_node.type is None or is_abstract(literal_node.type):
             # force int64 for literals, it can be widened later if needed
-            if  type(l.value) == int:
+            if isinstance(literal_node.value, int):
                 typ = v0_types.Int64
             else:
                 # using v0's map of literal to type
-                typ = literal_value_to_type(l.value)
+                typ = literal_value_to_type(literal_node.value)
         else:
-            typ = self.translate_node(l.type, l, Context.MODEL)
+            typ = self.translate_node(literal_node.type, literal_node, Context.MODEL)
         if type is None:
             pass
         return v0.Literal(
             type=typ, # type: ignore
-            value=l.value
+            value=literal_node.value
         )
 
     # Value = _Union[Var, Literal, Type, Relation, seq["Value"], None]
@@ -531,7 +539,8 @@ class Translator():
         # merge all outputs, accumulating keys and aliases
         keys = ordered_set()
         aliases = ordered_set()
-        for output in outputs:
+        sorted_outputs = sorted(outputs, key=lambda o: self.output_column_order.get(o, -1))
+        for output in sorted_outputs:
             assert isinstance(output, v0.Output)
             children.remove(output)
             if output.keys is not None:
@@ -539,9 +548,15 @@ class Translator():
             aliases.update(output.aliases)
 
         # add a single, merged output
-        is_export = any(output in self.exports for output in outputs)
-        annos = (v0_builtins.export_annotation,) if is_export else ()
-        if is_export and not keys:
+        export_output = next((output for output in outputs if output in self.exports), None)
+        annos = ()
+        if export_output:
+            uri = urlparse(self.exports[export_output].uri)
+            if uri.scheme == "table":
+                fqn = uri.hostname
+                annos = (v0.Annotation(v0_builtins.export, (v0.Literal(type=v0_types.String, value=fqn,),)),)
+
+        if export_output and not keys:
             key_var = v0.Var(type=v0_types.Hash, name="export_key")
             vals = [alias[1] for alias in aliases]
             children.append(v0.Construct(
@@ -564,9 +579,9 @@ class Translator():
     def get_outputs(self, children: seq[v0.Node]) -> list[v0.Output]:
         return list(filter(lambda o: isinstance(o, v0.Output), children)) # type: ignore
 
-    def translate_logical(self, l: mm.Logical, parent, ctx):
+    def translate_logical(self, logical_node: mm.Logical, parent, ctx):
         # first process children
-        children = self.translate_seq(l.body, l, ctx)
+        children = self.translate_seq(logical_node.body, logical_node, ctx)
 
         # inline logicals if possible
         new_children = []
@@ -579,34 +594,45 @@ class Translator():
         children = tuple(new_children)
 
         # compute variables to hoist, wrapping in Default if the logical is optional
-        if l.optional:
-            hoisted = tuple([v0.Default(self.translate_node(v, l, ctx), None) for v in self.hoister.hoisted(l)]) # type: ignore
+        # NOTE: the v0 compiler stack expects the aggregate body to hoist optionally or it doesn't work
+        if logical_node.optional or isinstance(parent, mm.Aggregate):
+            hoisted = tuple([v0.Default(self.translate_node(v, logical_node, ctx), None) for v in self.hoister.hoisted(logical_node)]) # type: ignore
         else:
-            hoisted = tuple([self.translate_node(v, l, ctx) for v in self.hoister.hoisted(l)]) # type: ignore
+            hoisted = tuple([self.translate_node(v, logical_node, ctx) for v in self.hoister.hoisted(logical_node)]) # type: ignore
 
         # Nots can never hoist variables upwards
         if isinstance(parent, mm.Not):
             hoisted = ()
 
+        # Loops can never hoist variables upwards
+        if isinstance(parent, mm.Loop):
+            hoisted = ()
+        # Sequences can never hoist variables upwards
+        if isinstance(parent, mm.Sequence):
+            hoisted = ()
+        # Breaks can never hoist variables upwards
+        if isinstance(parent, mm.Break):
+            hoisted = ()
+
         # if there are no outputs, just return the logical
         outputs = self.get_outputs(children)
         if not outputs:
             return v0.Logical(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(logical_node.reasoner, logical_node, Context.MODEL),
                 hoisted=hoisted, # type: ignore
                 body=children, # type: ignore
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(logical_node.annotations, logical_node, ctx) # type: ignore
             )
 
 
         # if there's a main output here, we need to merge all outputs as a single one
-        has_main_output = any(is_main_output(c) for c in l.body)
+        has_main_output = any(is_main_output(c) for c in logical_node.body)
         if has_main_output:
             return v0.Logical(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(logical_node.reasoner, logical_node, Context.MODEL),
                 hoisted=hoisted, # type: ignore
                 body=self._merge_outputs(children, outputs), # type: ignore
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(logical_node.annotations, logical_node, ctx) # type: ignore
             )
         else:
             # this logical has an output but it's not the main one; so we return the outputs
@@ -623,7 +649,7 @@ class Translator():
             # then it's possible we're filtering an outer variable, but only for this column. If
             # so, we need to alias the output and hoist it.
             # this is important because the LQP stack blows up if there's a logical with no effect
-            if l.optional and not hoisted and not any(isinstance(c, v0.Update) for c in children):
+            if logical_node.optional and not hoisted and not any(isinstance(c, v0.Update) for c in children):
                 # if there are no lookups, then this really is a no-op, just return outputs
                 # LQP blows up with e.g. a match-only logical
                 if not any(isinstance(c, v0.Lookup) for c in children):
@@ -650,6 +676,7 @@ class Translator():
                         keys=output.keys,
                         annotations=output.annotations
                     )
+                    self.output_column_order[new_output] = self.output_column_order.get(output, -1)
                     eq = v0.Lookup(
                         engine=None,
                         relation=v0_builtins.eq,
@@ -667,10 +694,10 @@ class Translator():
             # return outputs + a logical with the other children
             outputs.append(
                 v0.Logical(
-                    engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                    engine=self.translate_reasoner(logical_node.reasoner, logical_node, Context.MODEL),
                     hoisted=hoisted, # type: ignore
                     body=children, # type: ignore
-                    annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                    annotations=self.translate_frozen(logical_node.annotations, logical_node, ctx) # type: ignore
                 ))
             return outputs
 
@@ -718,15 +745,15 @@ class Translator():
             annotations=self.translate_frozen(w.annotations, w, ctx) # type: ignore
         )
 
-    def translate_loop(self, l: mm.Loop, parent, ctx) -> v0.Loop:
+    def translate_loop(self, loop_node: mm.Loop, parent, ctx) -> v0.Loop:
         # TODO - loop is incompatible because over has multiple vars, so this is a best
         # attempt (does not matter much as this is not used in practice)
         return v0.Loop(
-            engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
-            hoisted=self.translate_seq(self.hoister.hoisted(l), l, ctx), # type: ignore
-            iter=self.translate_node(l.over[0], l, ctx), # type: ignore
-            body=self.translate_node(l.body, l, ctx), # type: ignore
-            annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+            engine=self.translate_reasoner(loop_node.reasoner, loop_node, Context.MODEL),
+            hoisted=self.translate_seq(self.hoister.hoisted(loop_node), loop_node, ctx), # type: ignore
+            iter=self.translate_seq(loop_node.over, loop_node, ctx), # type: ignore
+            body=self.translate_node(loop_node.body, loop_node, ctx), # type: ignore
+            annotations=self.translate_frozen(loop_node.annotations, loop_node, ctx) # type: ignore
         )
 
     def translate_break(self, b: mm.Break, parent, ctx) -> v0.Break:
@@ -745,7 +772,6 @@ class Translator():
         assert isinstance(r.domain, mm.Logical)
         assert isinstance(r.check, mm.Logical)
         if not r.domain.body and all(isinstance(c, mm.Lookup) and c.relation is b.constraints.unique_fields for c in r.check.body):
-            return
             v0_reqs = []
             # v0 expects a check with both the domain and the relation in it followed by the unique
             # constraint, so we construct a logical with all of that in it
@@ -754,7 +780,7 @@ class Translator():
                 fields = c.args[0] # tuple of fields
                 assert isinstance(fields, tuple) and all(isinstance(f, mm.Field) for f in fields)
                 first_field = fields[0]
-                if isinstance(first_field.type, mm.Table):
+                if isinstance(first_field.type, mm.Table): #type: ignore
                     # skip union types for now
                     continue
                 assert isinstance(first_field, mm.Field)
@@ -779,17 +805,17 @@ class Translator():
                 ))
             return v0_reqs # type: ignore
 
-        # check = v0.Check(
-        #     check=self.translate_node(r.check, r, ctx), # type: ignore
-        #     error=self.translate_node(r.error, r, ctx) if r.error else None, # type: ignore
-        #     annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
-        # )
-        # return v0.Require(
-        #     engine=self.translate_reasoner(r.reasoner, r, Context.MODEL),
-        #     domain=self.translate_node(r.domain, r, ctx), # type: ignore
-        #     checks=(check,), # type: ignore
-        #     annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
-        # )
+        check = v0.Check(
+            check=self.translate_node(r.check, r, ctx), # type: ignore
+            error=self.translate_node(r.error, r, ctx) if r.error else None, # type: ignore
+            annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
+        )
+        return v0.Require(
+            engine=self.translate_reasoner(r.reasoner, r, Context.MODEL),
+            domain=self.translate_node(r.domain, r, ctx), # type: ignore
+            checks=(check,), # type: ignore
+            annotations=self.translate_frozen(r.annotations, r, ctx) # type: ignore
+        )
         return None
 
     # -----------------------------
@@ -823,56 +849,56 @@ class Translator():
         elif e == mm.Effect.delete:
             return v0.Effect.delete
 
-    def translate_lookup(self, l: mm.Lookup, parent, ctx):
+    def translate_lookup(self, lookup_node: mm.Lookup, parent, ctx):
         # Data Node lookups
-        if isinstance(l.relation, mm.Data):
-            vars = [self.translate_value(l.args[0], l, ctx)]
-            for col in l.relation.columns:
+        if isinstance(lookup_node.relation, mm.Data):
+            vars = [self.translate_value(lookup_node.args[0], lookup_node, ctx)]
+            for col in lookup_node.relation.columns:
                 v = v0.Var(
                     type=self.translate_node(col.fields[-1].type, col, Context.MODEL), # type: ignore
                     name=f"{col.name}"
                 )
                 vars.append(v)
-                assert isinstance(l.args[0], mm.Var)
-                self.column_map[l.args[0]][col] = v
+                assert isinstance(lookup_node.args[0], mm.Var)
+                self.column_map[lookup_node.args[0]][col] = v
             return v0.Data(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
-                data=l.relation.data,
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
+                data=lookup_node.relation.data,
                 vars=frozen(*vars) # type: ignore
             )
-        elif l.args and l.args[0] in self.column_map and l.relation in self.column_map[l.args[0]]: # type: ignore
-            assert isinstance(l.args[0], mm.Var)
-            var = self.translate_value(l.args[1], l, ctx)
-            col_var = self.column_map[l.args[0]][l.relation]  # ensure entry exists
+        elif lookup_node.args and lookup_node.args[0] in self.column_map and lookup_node.relation in self.column_map[lookup_node.args[0]]: # type: ignore
+            assert isinstance(lookup_node.args[0], mm.Var)
+            var = self.translate_value(lookup_node.args[1], lookup_node, ctx)
+            col_var = self.column_map[lookup_node.args[0]][lookup_node.relation]  # ensure entry exists
             if var != col_var:
                 return v0.Lookup(
-                    engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                    engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
                     relation=v0_builtins.eq,
                     args=(var, col_var), # type: ignore
-                    annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                    annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
                 )
             # if this is a data column, we just ignore it as the data node already binds the variables
-            elif isinstance(l.args[0].type, mm.Data):
+            elif isinstance(lookup_node.args[0].type, mm.Data):
                 return None
             # Otherwise we keep the lookup because that's what the LQP stack expect (the lookup gets repeated for
             # each column)
 
 
-        relation, args = self._resolve_reading(l, ctx)
+        relation, args = self._resolve_reading(lookup_node, ctx)
         if relation is None:
             return None
 
 
         # Specific rewrites
-        rewrite = self.rewrite_lookup(l, parent, ctx)
+        rewrite = self.rewrite_lookup(lookup_node, parent, ctx)
         if rewrite is None:
-            args = self.rewrite_cdc_args(l, args, parent, ctx)
+            args = self.rewrite_cdc_args(lookup_node, args, parent, ctx)
             # General translation
             rewrite = v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
                 relation=relation, # type: ignore
                 args=args,
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
 
         return rewrite
@@ -910,8 +936,10 @@ class Translator():
                 annotations=self.translate_frozen(u.annotations, u, ctx) # type: ignore
             )
             table = u.relation.fields[0].type
-            if isinstance(table, mm.Table) and not table.uri.startswith("dataframe://"):
-                self.exports.add(out)
+            assert isinstance(table, mm.Table)
+            if not table.uri.startswith("dataframe://"):
+                self.exports[out] = table
+            self.output_column_order[out] = table.columns.index(u.relation)
             return out
         else:
             relation, args = self._resolve_reading(u, ctx)
@@ -943,14 +971,14 @@ class Translator():
 
         # hoist the return variables (those that are not inputs to the aggregation)
         return_args = []
-        for field, arg in zip(a.aggregation.fields, a.args):
-            if not field.input:
+        for fld, arg in zip(a.aggregation.fields, a.args):
+            if not fld.input:
                 return_args.append(arg)
         hoisted=self.translate_seq(return_args, a, ctx)
 
         # body must contain the aggregate body plus the aggregate itself
         body = self.translate_node(a.body, a, ctx)
-        body = list(body.body if isinstance(body, v0.Logical) else [body])
+        body = [body]
 
         # construct the aggregate node
         engine = self.translate_reasoner(a.reasoner, a, Context.MODEL)
@@ -964,13 +992,13 @@ class Translator():
         if a.aggregation == b.aggregates.rank:
             assert isinstance(args[0], tuple)
             assert isinstance(args[1], tuple)
-            v0_agg = v0.Rank(engine, projection, group, args[0], tuple(l.value for l in args[1]), args[-1], 0, annotations,) # type: ignore
+            v0_agg = v0.Rank(engine, projection, group, args[0], tuple(lit.value for lit in args[1]), args[-1], 0, annotations,) # type: ignore
         elif a.aggregation == b.aggregates.limit:
             assert isinstance(args[0], v0.Literal)
             assert isinstance(args[1], tuple)
             assert isinstance(args[2], tuple)
             result = v0.Var(type=v0_types.Int64, name="limit_result")
-            v0_agg = v0.Rank(engine, projection, group, args[1], tuple(l.value for l in args[2]), result, args[0].value, annotations,) # type: ignore
+            v0_agg = v0.Rank(engine, projection, group, args[1], tuple(lit.value for lit in args[2]), result, args[0].value, annotations,) # type: ignore
         else:
             v0_agg = v0.Aggregate(engine, aggregation, projection, group, args, annotations) # type: ignore
 
@@ -1077,7 +1105,7 @@ class Translator():
     # Library-specific rewrites
     # -----------------------------------------------------------------------------
 
-    def adjust_index(self, l: mm.Lookup, indices: list[int], ctx, args=None, no_outputs=False):
+    def adjust_index(self, lookup_node: mm.Lookup, indices: list[int], ctx, args=None, no_outputs=False):
         """ Rewrite the lookup such that the args at `indices` are adjusted to convert from
         0-based indexing (as in the mm) to 1-based indexing (as in v0's backend).
 
@@ -1085,16 +1113,16 @@ class Translator():
         it to the lookup. If the field is output, we create a tmp var to hold the result
         of the lookup, and then create a subsequent task to decrement the tmp var by 1.
 
-        `args` can be used to provide a different set of args than l.args, in case they need
+        `args` can be used to provide a different set of args than lookup_node.args, in case they need
         reordering (e.g. strings.split).
         """
         if args is None:
-            args = l.args
+            args = lookup_node.args
         # vars to hold the result from the v0 lookup
         tmps = {}
         for i in indices:
-            index_type = l.relation.fields[i].type
-            tmps[i] = mm.Var(type=index_type, name=f"tmp")
+            index_type = lookup_node.relation.fields[i].type
+            tmps[i] = mm.Var(type=index_type, name="tmp")
         # insert tmp at index
         replaced_args = []
         for i, arg in enumerate(args):
@@ -1103,37 +1131,37 @@ class Translator():
             else:
                 replaced_args.append(arg)
         # translate the lookup
-        args = tuple(self.translate_value(arg, l, ctx) for arg in replaced_args)
-        args = self.rewrite_cdc_args(l, args, l, ctx)
+        args = tuple(self.translate_value(arg, lookup_node, ctx) for arg in replaced_args)
+        args = self.rewrite_cdc_args(lookup_node, args, lookup_node, ctx)
         lookup = v0.Lookup(
-            engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
-            relation=self.translate_node(l.relation), # type: ignore
+            engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
+            relation=self.translate_node(lookup_node.relation), # type: ignore
             args=args,
-            annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+            annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
         )
         # subtract 1 from the index to convert from 1-based to 0-based
         tasks = []
         for index in indices:
-            arg = args[index]
+            arg = lookup_node.args[index]
             if isinstance(arg, mm.Literal):
-                if l.relation.fields[index].input:
+                if lookup_node.relation.fields[index].input:
                     new = mm.Literal(arg.type, arg.value + 1) # type: ignore
                 else:
                     new = mm.Literal(arg.type, arg.value + 1) # type: ignore
                 tasks.append(v0.Lookup(
                         engine=None,
-                        relation=v0_builtins.eq, # type: ignore
+                        relation=v0_builtins.eq,
                         args=(
                             self.translate_value(tmps[index], lookup, ctx),
                             self.translate_value(new, lookup, ctx),
                         )
                 ))
-            elif l.relation.fields[index].input:
+            elif lookup_node.relation.fields[index].input:
                 tasks.append(v0.Lookup(
                         engine=None,
-                        relation=v0_builtins.plus, # type: ignore
+                        relation=v0_builtins.plus,
                         args=(
-                            self.translate_value(args[index], lookup, ctx),
+                            self.translate_value(arg, lookup, ctx),
                             v0.Literal(v0_types.Int128, 1),
                             self.translate_value(tmps[index], lookup, ctx),
                         ),
@@ -1146,7 +1174,7 @@ class Translator():
                         args=(
                             self.translate_value(tmps[index], lookup, ctx),
                             v0.Literal(v0_types.Int128, 1),
-                            self.translate_value(args[index], lookup, ctx),
+                            self.translate_value(arg, lookup, ctx),
                         ),
                     )
                 )
@@ -1155,37 +1183,37 @@ class Translator():
 
         return tasks
 
-    def decrement(self, l: mm.Lookup, index: int, ctx):
+    def decrement(self, lookup_node: mm.Lookup, index: int, ctx):
         """ Rewrite the lookup such that the arg at `index` is decremented by 1 before the
         lookup.  """
-        x = l.args[index]
+        x = lookup_node.args[index]
         if isinstance(x, mm.Literal):
             # if the arg is a literal, just decrement the literal directly
             new_literal = mm.Literal(type=x.type, value=x.value - 1) # type: ignore
             return v0.Lookup(
                     engine=None,
-                    relation=self.translate_node(l.relation), # type: ignore
-                    args=tuple(self.translate_value(arg, l, ctx) if i != index else self.translate_value(new_literal, l, ctx) for i, arg in enumerate(l.args)),
-                    annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                    relation=self.translate_node(lookup_node.relation), # type: ignore
+                    args=tuple(self.translate_value(arg, lookup_node, ctx) if i != index else self.translate_value(new_literal, lookup_node, ctx) for i, arg in enumerate(lookup_node.args)),
+                    annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
 
         # arg is not a literal, so we need to create a tmp var to store the decremented value
-        tmp = self.translate_value(mm.Var(type=b.core.Number, name="tmp"), l, ctx)
+        tmp = self.translate_value(mm.Var(type=b.core.Number, name="tmp"), lookup_node, ctx)
         # lookup(..., tmp, ...)
         new = v0.Lookup(
                 engine=None,
-                relation=self.translate_node(l.relation), # type: ignore
-                args=tuple(self.translate_value(arg, l, ctx) if i != index else tmp for i, arg in enumerate(l.args)),
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                relation=self.translate_node(lookup_node.relation), # type: ignore
+                args=tuple(self.translate_value(arg, lookup_node, ctx) if i != index else tmp for i, arg in enumerate(lookup_node.args)),
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
         )
         casted = self.cast(new, ctx)
         return (
-            # tmp = l.args[index] - 1
+            # tmp = lookup_node.args[index] - 1
             v0.Lookup(
                 engine=None,
                 relation=v0_builtins.minus, # type: ignore
                 args=(
-                    self.translate_value(l.args[index], l, ctx),
+                    self.translate_value(lookup_node.args[index], lookup_node, ctx),
                     v0.Literal(v0_types.Int128, 1),
                     tmp,
                 ),
@@ -1193,31 +1221,34 @@ class Translator():
             *casted
         )
 
-    def cast(self, l: v0.Lookup, ctx, no_outputs=False):
+    def cast(self, lookup_node: v0.Lookup, ctx, no_outputs=False):
         # note that everything here is in v0
         inputs = []
         outputs = []
         args = []
-        fields = l.relation.fields
+        fields = lookup_node.relation.fields
         # if there are overloads, we need to cast based on the most compatible overload
-        if l.relation.overloads:
+        if lookup_node.relation.overloads:
             inf = float("inf")
             min_cost = inf
-            for overload in l.relation.overloads:
+            for overload in lookup_node.relation.overloads:
                 total = 0
-                for arg, field in zip(l.args, overload.fields):
+                for arg, field in zip(lookup_node.args, overload.fields):
                     if v0_typer.to_type(arg) != field.type:
                         total += 1
                 if total < min_cost:
                     min_cost = total
                     fields = overload.fields
 
-        for arg, field in zip(l.args, fields):
+        for arg, field in zip(lookup_node.args, fields):
             target_type = field.type
             if target_type is None or not isinstance(arg, (v0.Var, v0.Literal)) or arg.type == target_type:
                 args.append(arg)
                 continue
-            if field.input:
+            if isinstance(arg, v0.Literal):
+                # for literals, we can just create a new literal with the target type
+                args.append(v0.Literal(type=target_type, value=arg.value))
+            elif field.input:
                 cast_var = v0.Var(type=target_type, name="cast_var")
                 args.append(cast_var)
                 inputs.append(v0.Lookup(
@@ -1241,16 +1272,16 @@ class Translator():
                 args.append(arg)
 
         lookup = v0.Lookup(
-            engine=l.engine,
-            relation=l.relation,
+            engine=lookup_node.engine,
+            relation=lookup_node.relation,
             args=tuple(args),
-            annotations=l.annotations
+            annotations=lookup_node.annotations
         )
         if no_outputs:
             outputs = []
         return [*inputs, lookup, *outputs]
 
-    def rewrite_lookup(self, l: mm.Lookup, parent, ctx):
+    def rewrite_lookup(self, lookup_node: mm.Lookup, parent, ctx):
         """ Special cases for v1 builtins that either have some different shape in v0 or
         do not exist as a primitive in the engine, so we want to compose the result so that
         LQP works. Return None if no rewrite is needed.
@@ -1263,113 +1294,113 @@ class Translator():
         # -----------------------------------------------------------------------------
         # Common
         # -----------------------------------------------------------------------------
-        if l.relation == b.common.range:
+        if lookup_node.relation == b.common.range:
             # python/PyRel range has inclusive start but exclusive stop, whereas LQP/Rel has
             # inclusive stop, so we have to decrement the stop index by 1
-            # tmp, lookup = self.decrement(l, 1, ctx)
+            # tmp, lookup = self.decrement(lookup_node, 1, ctx)
             # return [tmp] + self.cast(lookup, [v0_types.Int64, v0_types.Int64, v0_types.Int64, v0_types.Int64], ctx)
-            return self.decrement(l, 1, ctx)
+            return self.decrement(lookup_node, 1, ctx)
 
-        elif l.relation == b.core.cast:
+        elif lookup_node.relation == b.core.cast:
             return v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.TASK),
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.TASK),
                 relation=v0_builtins.builtin_relations_by_name["cast"], # type: ignore
                 args=(
-                    self.translate_value(l.args[0], l, Context.MODEL),
-                    self.translate_value(l.args[1], l, Context.TASK),
-                    self.translate_value(l.args[2], l, Context.TASK)
+                    self.translate_value(lookup_node.args[0], lookup_node, Context.MODEL),
+                    self.translate_value(lookup_node.args[1], lookup_node, Context.TASK),
+                    self.translate_value(lookup_node.args[2], lookup_node, Context.TASK)
                 ),
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
 
         # -----------------------------------------------------------------------------
         # Strings
         # -----------------------------------------------------------------------------
 
-        elif l.relation == b.strings.len:
+        elif lookup_node.relation == b.strings.len:
             lookup = v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
                 relation=v0_builtins.builtin_relations_by_name["num_chars"], # type: ignore
                 args=(
-                    self.translate_value(l.args[0], l, ctx),
-                    self.translate_value(l.args[1], l, ctx),
+                    self.translate_value(lookup_node.args[0], lookup_node, ctx),
+                    self.translate_value(lookup_node.args[1], lookup_node, ctx),
                 ),
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
             return self.cast(lookup, ctx)
 
-        elif l.relation == b.strings.split:
+        elif lookup_node.relation == b.strings.split:
             # swap first two args because that's how rel and v0 expect them
-            args = l.args[1], l.args[0], l.args[2], l.args[3]
-            return self.adjust_index(l, [2], ctx, args=args)
+            args = lookup_node.args[1], lookup_node.args[0], lookup_node.args[2], lookup_node.args[3]
+            return self.adjust_index(lookup_node, [2], ctx, args=args)
 
-        elif l.relation == b.strings.substring:
-            return self.adjust_index(l, [1], ctx)
+        elif lookup_node.relation == b.strings.substring:
+            return self.adjust_index(lookup_node, [1], ctx)
 
         # -----------------------------------------------------------------------------
         # RE
         # -----------------------------------------------------------------------------
-        elif l.relation == b.re.regex_match_all:
-            return self.adjust_index(l, [2], ctx)
+        elif lookup_node.relation == b.re.regex_match_all:
+            return self.adjust_index(lookup_node, [2], ctx)
 
         # -----------------------------------------------------------------------------
         # Math
         # -----------------------------------------------------------------------------
-        elif l.relation == b.math.degrees:
+        elif lookup_node.relation == b.math.degrees:
             # degrees(radians, x) = /(radians, (pi/180.0), x)
             return v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
                 relation=v0_builtins.builtin_relations_by_name["/"], # type: ignore
                 args=(
-                    self.translate_value(l.args[0], l, ctx),
+                    self.translate_value(lookup_node.args[0], lookup_node, ctx),
                     v0.Literal(v0_types.Float, pi / 180.0),
-                    self.translate_value(l.args[1], l, ctx)
+                    self.translate_value(lookup_node.args[1], lookup_node, ctx)
                 ),
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
-        elif l.relation == b.math.radians:
+        elif lookup_node.relation == b.math.radians:
             # radians(degrees, x) = /(degrees, (180.0/pi), x)
             return v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
                 relation=v0_builtins.builtin_relations_by_name["/"], # type: ignore
                 args=(
-                    self.translate_value(l.args[0], l, ctx),
+                    self.translate_value(lookup_node.args[0], lookup_node, ctx),
                     v0.Literal(v0_types.Float, 180.0 / pi),
-                    self.translate_value(l.args[1], l, ctx)
+                    self.translate_value(lookup_node.args[1], lookup_node, ctx)
                 ),
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
 
         # -----------------------------------------------------------------------------
         # Datetime
         # -----------------------------------------------------------------------------
         #
-        # elif l.relation == b.datetime.date_range:
-        #     return self.rewrite_date_range(l, parent, ctx)
-        # elif l.relation == b.datetime.datetime_range:
+        # elif lookup_node.relation == b.datetime.date_range:
+        #     return self.rewrite_date_range(lookup_node, parent, ctx)
+        # elif lookup_node.relation == b.datetime.datetime_range:
         #     pass
 
-        elif l.relation == b.datetime.date_add:
+        elif lookup_node.relation == b.datetime.date_add:
             return v0.Lookup(
-                engine=self.translate_reasoner(l.reasoner, l, Context.MODEL),
-                relation=self.translate_relation(l.relation, l, ctx), # type: ignore
-                args=self.translate_seq(l.args, l, ctx), # type: ignore
-                annotations=self.translate_frozen(l.annotations, l, ctx) # type: ignore
+                engine=self.translate_reasoner(lookup_node.reasoner, lookup_node, Context.MODEL),
+                relation=self.translate_relation(lookup_node.relation, lookup_node, ctx), # type: ignore
+                args=self.translate_seq(lookup_node.args, lookup_node, ctx), # type: ignore
+                annotations=self.translate_frozen(lookup_node.annotations, lookup_node, ctx) # type: ignore
             )
 
-        if b.datetime[l.relation.name] is l.relation:
-            return self.adjust_index(l, [], ctx, no_outputs=True)
+        if b.datetime[lookup_node.relation.name] is lookup_node.relation:
+            return self.adjust_index(lookup_node, [], ctx, no_outputs=True)
 
-        v0_rel = self.translate_node(l.relation, l, ctx)
+        v0_rel = self.translate_node(lookup_node.relation, lookup_node, ctx)
         if isinstance(v0_rel, v0.Relation) and any(f.type == v0_types.Int64 for f in v0_rel.fields):
-            return self.adjust_index(l, [], ctx)
+            return self.adjust_index(lookup_node, [], ctx)
 
         return None
 
 
     # TODO - Currently implemented in the std.datetime itself.
     # def rewrite_date_range(self, l: mm.Lookup, parent, ctx: Context):
-    #     start, end, freq, date = l.args
+    #     start, end, freq, date = lookup_node.args
     #     result = []
 
     #     range_end = num_days = mm.Var(type=b.core.Number, name="num_days")