Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.0

0.6.0 / src / query / joins.lucb

## Hash and connection joins over owned row snapshots.
import interop
import memory
import query.scalars
from collections.index import Index
from query.results import Selection, Row, copy_row
from query.query import Query
from document import Document, assemble_element
from model import Element
from animation import resolve_property
from storage import List, Buffer, find_pair
from path import element_path
from types import invalid

pub enum JoinType as u8:
    inner = 0
    left = 1
    right = 2
    outer = 3
    anti = 4

struct Pair:
    var left: usize?
    var right: usize?

pub struct JoinResult:
    var left_rows: Selection = Selection()
    var right_rows: Selection = Selection()
    var pairs: List[Pair]

    pub func init():
        return

    pub func count() -> usize:
        return self.pairs.count

    func at(index: usize) -> Pair!:
        if index >= self.pairs.count:
            error(invalid, "join row index is out of bounds")
        return self.pairs.items[index]

    pub func left_path(index: usize) -> str?!:
        let row = (try self.at(index)).left else return none
        return try self.left_rows.path_at(row)

    pub func right_path(index: usize) -> str?!:
        let row = (try self.at(index)).right else return none
        return try self.right_rows.path_at(row)

    pub func left_row(index: usize) -> interop.Reference[Row]?!:
        let row = (try self.at(index)).left else return none
        return try self.left_rows.row(row)

    pub func right_row(index: usize) -> interop.Reference[Row]?!:
        let row = (try self.at(index)).right else return none
        return try self.right_rows.row(row)

    pub func close():
        self.left_rows.close()
        self.right_rows.close()
        self.pairs.close()

pub let join_result_type = interop.Type[JoinResult]("Prism join result", JoinResult.close, closeable = true)

func key(element: const Element*, field: str) -> Buffer?!:
    let position = element.property(field) else return none
    var value = try resolve_property(&element.properties.items[position], 0.0)
    defer value.close()
    return try scalars.key(&value)

pub func join_on(left: interop.Reference[Query], left_field: str, right: interop.Reference[Query], right_field: str, kind: JoinType = JoinType.inner) -> interop.Reference[JoinResult]!:
    let left_selection = try (try left.get()).select()
    defer left_selection.release()
    let right_selection = try (try right.get()).select()
    defer right_selection.release()
    let left_rows = (try left_selection.get()).view_data()
    let right_rows = (try right_selection.get()).view_data()
    var index: Index
    defer index.close()
    var used: List[bool]
    defer used.close()
    for row in 0..<right_rows.count:
        try used.push(false)
        if let result = try key(&right_rows.items[row], right_field):
            var value = result
            defer value.close()
            _ = try index.add(value.view(), row)
    var result = JoinResult()
    errdefer result.close()
    for element in left_rows.span():
        try result.left_rows.append(&element)
    for element in right_rows.span():
        try result.right_rows.append(&element)
    for row in 0..<left_rows.count:
        var bucket: usize? = none
        if let found = try key(&left_rows.items[row], left_field):
            var value = found
            defer value.close()
            bucket = index.find(value.view())
        if let position = bucket:
            for other in index.buckets.items[position].rows.span():
                used.items[other] = true
                if kind != JoinType.anti:
                    try result.pairs.push(Pair(left = row, right = other))
        elif kind == JoinType.left or kind == JoinType.outer or kind == JoinType.anti:
            try result.pairs.push(Pair(left = row))
    if kind == JoinType.right or kind == JoinType.outer:
        # Legacy right/full joins include only keyable right-hand rows.
        for bucket in index.buckets.span():
            for row in bucket.rows.span():
                if not used.items[row]:
                    try result.pairs.push(Pair(right = row))
    let owned = result
    result = JoinResult()
    return try own_join(owned)

pub func join_by_connection(doc: interop.Reference[Document], left: interop.Reference[Query], slot: str) -> interop.Reference[JoinResult]!:
    let selected = try (try left.get()).select()
    defer selected.release()
    let view = try doc.get()
    var result = JoinResult()
    errdefer result.close()
    for element in (try selected.get()).view_data().span():
        var target: Buffer
        defer target.close()
        try target.text(element.path.view())
        try target.byte('.')
        try target.text(slot)
        if let source = view.incoming_at(target.view()):
            let path = element_path(source)
            if view.contains(path):
                var right = try assemble_element(view, path)
                defer right.close()
                let index = result.pairs.count
                try result.left_rows.append(&element)
                try result.right_rows.append(&right)
                try result.pairs.push(Pair(left = index, right = index))
    let owned = result
    result = JoinResult()
    return try own_join(owned)

func own_join(result: JoinResult) -> interop.Reference[JoinResult]!:
    var owned = result
    let native = new JoinResult() in memory.heap catch failure:
        owned.close()
        error(failure.code, failure.message)
    native[0] = owned
    return try interop.Reference[JoinResult].adopt(native, join_result_type, memory.heap)