def compile_query(self):
query = compile_query(self.reiz_ql, limit=None, offset=0)
query.filters = IR.combine_filters(
query.filters,
IR.filter(
IR.attribute(IR.attribute(None, "_module"), "filename"),
IR.literal(self.expected_filename),
"=",
),
)
return IR.construct(query)
def compile_reference(node, state):
obtained_type = state.field_info.type
if pointer := state.scope.lookup(node.name):
expected_type = pointer.field_info.type
state.ensure(node, expected_type is obtained_type)
left = state.compute_path()
right = pointer.compute_path()
if issubclass(expected_type, ast.expr):
left = IR.attribute(left, "_tag")
right = IR.attribute(right, "_tag")
return IR.filter(left, right, "=")
def serialize_project(node, context):
return IR.select(
node.kind_name,
filters=IR.filter(
IR.attribute(None, "name"), IR.literal(node.name), "="
),
limit=1,
)
def compute_path(self, allow_missing=False):
parent, *parents = self.get_ordered_parents()
def get_pointer(state, allow_missing):
pointer = state.pointer
if allow_missing:
pointer = IR.optional(pointer)
return pointer
base = get_pointer(parent, allow_missing)
if not parent.is_flag_set("in for loop"):
base = IR.attribute(None, base)
for parent in parents:
base = IR.typed(base, parent.match)
base = IR.attribute(base, get_pointer(parent, allow_missing))
return base
def serialize_sequence(sequence, context):
ir_set = IR.set([serialize(value, context) for value in sequence])
if all(isinstance(item, _BASIC_SET_TYPES) for item in sequence):
# {1, 2, 3} / {<ast::op>'Add', <ast::op>'Sub', ...}
return ir_set
else:
# Inserting a sequence of AST objects would require special
# attention to calculate the index property.
target = IR.name("item")
scope = IR.namespace({"items": ir_set})
loop = IR.loop(
target,
IR.call("enumerate", [IR.name("items")]),
IR.select(
IR.attribute(target, 1),
selections=[
IR.assign(IR.property("index"), IR.attribute(target, 0))
],
),
)
return IR.add_namespace(scope, loop)
def aggregate_array(state):
# If we are in a nested list search (e.g: Call(args=[Call(args=[Name()])]))
# we can't directly use `ORDER BY @index` since the EdgeDB can't quite infer
# which @index are we talking about.
if len(state.parents) >= 1:
path = IR.attribute(
IR.typed(IR.name(_COMPILER_WORKAROUND_FOR_TARGET), state.match),
state.pointer,
)
body = IR.loop(
IR.name(_COMPILER_WORKAROUND_FOR_TARGET),
state.parents[-1].compute_path(allow_missing=True),
IR.select(path, order=IR.property("index")),
)
else:
body = IR.select(state.compute_path(), order=IR.property("index"))
return IR.call("array_agg", [body])
@guarded(Insertion.FAILED, ignored_exceptions=(InternalDatabaseError, ))
def insert_file(context):
if context.is_cached():
return Insertion.CACHED
if not (tree := context.as_ast()):
return Insertion.SKIPPED
with context.connection.transaction():
module = apply_ast(tree, context)
module_select = IR.select(tree.kind_name,
filters=IR.object_ref(module),
limit=1)
update_filter = IR.filter(
IR.attribute(None, "id"),
IR.call("array_unpack",
[IR.cast("array<uuid>", IR.variable("ids"))]),
"IN",
)
for base_type in Schema.module_annotated_types:
update = IR.update(
base_type.kind_name,
filters=update_filter,
assignments={"_module": module_select},
)
context.connection.query(IR.construct(update),
ids=context.reference_pool)
logger.info("%r has been inserted successfully", context.filename)
context.cache()