Luce packages
LuceLuce BaseLuciaOS

dymokomi/luce-prism

Source of release 0.6.1

0.6.1 / tests / compatibility / query_data.lucb

from luce_prism import prism
import interop
from luce_std import math
from compatibility.query import plan, compare, filtered, paths

func orders() -> interop.Reference[prism.Document]!:
    return try prism.Document.parse("#prisma 4.0\ndef table \"orders\" { def order \"o1\" { str region = \"west\" float amount = 100 } def order \"o2\" { str region = \"west\" float amount = 50 } def order \"o3\" { str region = \"east\" float amount = 200 } def order \"o4\" { str region = \"east\" float amount = 25 } def order \"o5\" { str region = \"west\" } }")

func scalar_aggregates() -> !:
    let doc = try orders()
    defer doc.release()
    var query = try prism.Query(doc, "/orders/*")
    defer query.close()
    assert(try query.count() == 5)
    assert(try query.aggregate("amount", prism.Aggregate.sum) == 375.0)
    assert(try query.aggregate("amount", prism.Aggregate.average) == 93.75)
    assert(try query.aggregate("amount", prism.Aggregate.minimum) == 25.0)
    assert(try query.aggregate("amount", prism.Aggregate.maximum) == 200.0)

func aggregate_with_filter() -> !:
    let doc = try orders()
    defer doc.release()
    let query = try filtered(doc, try compare("region", try prism.Value.text("west")))
    defer query.release()
    assert(try query.value().count() == 3)
    assert(try query.value().aggregate("amount", prism.Aggregate.sum) == 150.0)

func group_by_sum_and_count() -> !:
    let doc = try orders()
    defer doc.release()
    var query = try prism.Query(doc, "/orders/*")
    defer query.close()
    let sums = try query.aggregate_by(["region"], "amount", prism.Aggregate.sum)
    defer sums.release()
    assert(try sums.value().get("west") == 150.0 and try sums.value().get("east") == 225.0)
    let counts = try query.aggregate_by(["region"], "amount", prism.Aggregate.count)
    defer counts.release()
    assert(try counts.value().get("west") == 3.0 and try counts.value().get("east") == 2.0)
    let maxes = try query.aggregate_by(["region"], "amount", prism.Aggregate.maximum)
    defer maxes.release()
    assert(try maxes.value().get("west") == 100.0 and try maxes.value().get("east") == 200.0)

func aggregate_of_no_numeric_rows_is_nullopt() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row \"x\" { str label = \"a\" } }")
    defer doc.release()
    var query = try prism.Query(doc, "/t/*")
    defer query.close()
    assert(try query.aggregate("missing", prism.Aggregate.sum) == none)
    assert(try query.aggregate("label", prism.Aggregate.average) == none)
    assert(try query.aggregate("label", prism.Aggregate.minimum) == none)
    let sums = try query.aggregate_by(["label"], "missing", prism.Aggregate.sum)
    defer sums.release()
    assert(try sums.value().get("a") == 0.0)
    let averages = try query.aggregate_by(["label"], "missing", prism.Aggregate.average)
    defer averages.release()
    assert(averages.value().count() == 0)

func statistical_aggregates() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row { float x = 2 } def row { float x = 4 } def row { float x = 4 } def row { float x = 4 } def row { float x = 5 } def row { float x = 5 } def row { float x = 7 } def row { float x = 9 } }")
    defer doc.release()
    var query = try prism.Query(doc, "/t/*")
    defer query.close()
    assert(try query.aggregate("x", prism.Aggregate.median) == 4.5)
    assert(try query.aggregate("x", prism.Aggregate.variance) == 4.0)
    assert(try query.aggregate("x", prism.Aggregate.standard_deviation) == 2.0)
    assert(try query.distinct_count("x") == 5)

func multi_key_group_by() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row \"a\" { str region = \"west\" str tier = \"gold\" float amt = 100 } def row \"b\" { str region = \"west\" str tier = \"gold\" float amt = 50 } def row \"c\" { str region = \"west\" str tier = \"silver\" float amt = 30 } def row \"d\" { str region = \"east\" str tier = \"gold\" float amt = 200 } }")
    defer doc.release()
    var query = try prism.Query(doc, "/t/*")
    defer query.close()
    let sums = try query.aggregate_by(["region", "tier"], "amt", prism.Aggregate.sum)
    defer sums.release()
    assert(sums.value().count() == 3)
    let west: u8[9] = ['w', 'e', 's', 't', 31, 'g', 'o', 'l', 'd']
    let east: u8[9] = ['e', 'a', 's', 't', 31, 'g', 'o', 'l', 'd']
    assert(try sums.value().get((str)west) == 150.0)
    assert(try sums.value().get((str)east) == 200.0)

func issues() -> interop.Reference[prism.Document]!:
    return try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def issue \"i1\" { str status = \"open\" float sev = 1 } def issue \"i2\" { str status = \"open\" float sev = 2 } def issue \"i3\" { str status = \"done\" float sev = 1 } def issue \"i4\" { str status = \"open\" float sev = 3 } def issue \"i5\" {} }")

func index_equals_matches_the_scan() -> !:
    let doc = try issues()
    defer doc.release()
    var index = try prism.FieldIndex(doc, "status")
    defer index.close()
    assert(index.key_count() == 2)
    let value = try prism.Value.text("open")
    defer value.release()
    let indexed = try index.equals(value)
    defer indexed.release()
    let query = try filtered(doc, try compare("status", value.clone()))
    defer query.release()
    let scanned = try query.value().select()
    defer scanned.release()
    assert(indexed.value().count() == 3 and scanned.value().count() == 3)
    for i in 0..<indexed.value().count():
        assert(try indexed.value().path_at(i) == try scanned.value().path_at(i))
    try doc.value().remove("/t")
    let snapshot = try index.equals(value)
    defer snapshot.release()
    assert(snapshot.value().count() == 3)

func index_matches_numerically_like_the_query() -> !:
    let doc = try issues()
    defer doc.release()
    var index = try prism.FieldIndex(doc, "sev")
    defer index.close()
    let integer = try prism.Value.integer(1)
    defer integer.release()
    let floating = try prism.Value.number(1.0)
    defer floating.release()
    for value in [integer, floating]:
        let rows = try index.equals(value)
        defer rows.release()
        assert(rows.value().count() == 2)
        assert(try rows.value().path_at(0) == "/t/i1" and try rows.value().path_at(1) == "/t/i3")

func index_misses_and_unindexed() -> !:
    let doc = try issues()
    defer doc.release()
    var index = try prism.FieldIndex(doc, "status")
    defer index.close()
    let missing = try prism.Value.text("nope")
    defer missing.release()
    assert(not try index.contains(missing))
    let empty = try index.equals(missing)
    defer empty.release()
    assert(empty.value().count() == 0)
    var count: usize = 0
    for name in ["done", "open"]:
        let value = try prism.Value.text(name)
        defer value.release()
        assert(try index.contains(value))
        let rows = try index.equals(value)
        defer rows.release()
        count += rows.value().count()
    assert(count == 4)

func big_ids() -> interop.Reference[prism.Document]!:
    return try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row \"a\" { int64 id = 9007199254740992 } def row \"b\" { int64 id = 9007199254740993 } def row \"c\" { int64 id = 9007199254740999 } }")

func eq_distinguishes_large_int_ids() -> !:
    let doc = try big_ids()
    defer doc.release()
    try paths(try filtered(doc, try compare("id", try prism.Value.integer(9007199254740992))), ["/t/a"])
    try paths(try filtered(doc, try compare("id", try prism.Value.integer(9007199254740993))), ["/t/b"])
    try paths(try filtered(doc, try compare("id", try prism.Value.integer(9007199254740993), prism.Comparison.less)), ["/t/a"])

func int_three_still_equals_float_three() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"t\" { def row \"i\" { int64 v = 3 } def row \"f\" { float v = 3 } def row \"h\" { float v = 3.5 } }")
    defer doc.release()
    try paths(try filtered(doc, try compare("v", try prism.Value.integer(3))), ["/t/i", "/t/f"])
    try paths(try filtered(doc, try compare("v", try prism.Value.number(3.0))), ["/t/i", "/t/f"])
    try paths(try filtered(doc, try compare("v", try prism.Value.number(3.5))), ["/t/h"])

func nunique_counts_large_ints_exactly() -> !:
    let doc = try big_ids()
    defer doc.release()
    var query = try prism.Query(doc, "/t/*")
    defer query.close()
    assert(try query.distinct_count("id") == 3)
    try doc.value().add("/t/d", "row")
    let value = try prism.Value.integer(9007199254740993)
    defer value.release()
    try doc.value().set("/t/d", "id", value)
    assert(try query.distinct_count("id") == 3)

func field_index_distinguishes_large_ints() -> !:
    let doc = try big_ids()
    defer doc.release()
    var index = try prism.FieldIndex(doc, "id")
    defer index.close()
    assert(index.key_count() == 3)
    let ids = [9007199254740992, 9007199254740993]
    let expected_paths = ["/t/a", "/t/b"]
    for i in 0..<ids.length:
        let value = try prism.Value.integer(ids[i])
        defer value.release()
        let rows = try index.equals(value)
        defer rows.release()
        assert(rows.value().count() == 1 and try rows.value().path_at(0) == expected_paths[i])

func join_on_large_int_keys_matches_exactly() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"l\" { def row \"x\" { int64 k = 9007199254740992 } def row \"y\" { int64 k = 9007199254740993 } } def table \"r\" { def row \"p\" { int64 k = 9007199254740993 } }")
    defer doc.release()
    let left = try plan(doc, "/l/*")
    defer left.release()
    let right = try plan(doc, "/r/*")
    defer right.release()
    let pairs = try prism.join_on(left, "k", right, "k")
    defer pairs.release()
    assert(pairs.value().count() == 1)
    assert(try pairs.value().left_path(0) == "/l/y" and try pairs.value().right_path(0) == "/r/p")

func shop() -> interop.Reference[prism.Document]!:
    return try prism.Document.parse("#prisma 4.0\ndef table \"customers\" { def customer \"c1\" { str region = \"west\" float id = 1 } def customer \"c2\" { str region = \"east\" float id = 2 } } def table \"orders\" { def order \"o1\" { str region = \"west\" connect customer = </customers/c1.id> } def order \"o2\" { str region = \"east\" connect customer = </customers/c2.id> } def order \"o3\" { str region = \"west\" connect customer = </customers/c1.id> } }")

func equality_hash_join() -> !:
    let doc = try shop()
    defer doc.release()
    let left = try plan(doc, "/orders/*")
    defer left.release()
    let right = try plan(doc, "/customers/*")
    defer right.release()
    let pairs = try prism.join_on(left, "region", right, "region")
    defer pairs.release()
    assert(pairs.value().count() == 3)
    for i in 0..<(usize)3:
        let a = try pairs.value().left_row(i) else error(prism.invalid, "missing left row")
        defer a.release()
        let b = try pairs.value().right_row(i) else error(prism.invalid, "missing right row")
        defer b.release()
        let x = try a.value().get("region")
        defer x.release()
        let y = try b.value().get("region")
        defer y.release()
        assert(try x.value().text_at() == try y.value().text_at())

func connection_join_follows_foreign_key() -> !:
    let doc = try shop()
    defer doc.release()
    let left = try plan(doc, "/orders/*")
    defer left.release()
    let pairs = try prism.join_by_connection(doc, left, "customer")
    defer pairs.release()
    assert(pairs.value().count() == 3)
    let expected = ["/customers/c1", "/customers/c2", "/customers/c1"]
    for i in 0..<expected.length:
        assert(try pairs.value().right_path(i) == expected[i])

func join_skips_unmatched_rows() -> !:
    let doc = try shop()
    defer doc.release()
    try doc.value().add("/orders/o4", "order")
    let north = try prism.Value.text("north")
    defer north.release()
    try doc.value().set("/orders/o4", "region", north)
    let left = try plan(doc, "/orders/*")
    defer left.release()
    let right = try plan(doc, "/customers/*")
    defer right.release()
    let eq = try prism.join_on(left, "region", right, "region")
    defer eq.release()
    let connection = try prism.join_by_connection(doc, left, "customer")
    defer connection.release()
    assert(eq.value().count() == 3 and connection.value().count() == 3)

func join_types() -> !:
    let doc = try prism.Document.parse("#prisma 4.0\ndef table \"o\" { def order \"a\" { str r = \"west\" } def order \"b\" { str r = \"north\" } } def table \"c\" { def cust \"c1\" { str r = \"west\" } def cust \"c2\" { str r = \"east\" } def cust \"noKey\" {} }")
    defer doc.release()
    let left = try plan(doc, "/o/*")
    defer left.release()
    let right = try plan(doc, "/c/*")
    defer right.release()
    let kinds = [prism.JoinType.inner, prism.JoinType.left, prism.JoinType.right, prism.JoinType.outer, prism.JoinType.anti]
    let counts: usize[5] = [1, 2, 2, 3, 1]
    for i in 0..<kinds.length:
        let pairs = try prism.join_on(left, "r", right, "r", kinds[i])
        defer pairs.release()
        assert(pairs.value().count() == counts[i])
        if kinds[i] == prism.JoinType.anti:
            assert(try pairs.value().left_path(0) == "/o/b" and try pairs.value().right_path(0) == none)
        if kinds[i] == prism.JoinType.left or kinds[i] == prism.JoinType.outer:
            assert(try pairs.value().left_path(1) == "/o/b" and try pairs.value().right_path(1) == none)

func overlay_field_index_and_join() -> !:
    let base = try prism.Document.parse("#prisma 4.0\ndef row \"a\" { int x = 1 } def row \"b\" { int x = 2 } def node \"src\" { float out = 1 } def node \"dst\" { connect in = </src.out> }")
    defer base.release()
    let layer = try prism.Document.parse("#prisma 4.0\nover row \"a\" { int x = 9 } delete \"/b\" def row \"c\" { int x = 3 } connect </dst.in> = </a.x>")
    defer layer.release()
    let doc = try base.value().overlay(layer)
    defer doc.release()
    var index = try prism.FieldIndex(doc, "x")
    defer index.close()
    let nine = try prism.Value.integer(9)
    defer nine.release()
    let rows = try index.equals(nine)
    defer rows.release()
    assert(rows.value().count() == 1 and try rows.value().path_at(0) == "/a")
    let two = try prism.Value.integer(2)
    defer two.release()
    let gone = try index.equals(two)
    defer gone.release()
    assert(gone.value().count() == 0)
    let left = try plan(doc, "/dst")
    defer left.release()
    let joined = try prism.join_by_connection(doc, left, "in")
    defer joined.release()
    assert(joined.value().count() == 1)
    assert(try joined.value().left_path(0) == "/dst")
    assert(try joined.value().right_path(0) == "/a")

pub func run() -> !:
    try scalar_aggregates()
    try aggregate_with_filter()
    try group_by_sum_and_count()
    try aggregate_of_no_numeric_rows_is_nullopt()
    try statistical_aggregates()
    try multi_key_group_by()
    try index_equals_matches_the_scan()
    try index_matches_numerically_like_the_query()
    try index_misses_and_unindexed()
    try eq_distinguishes_large_int_ids()
    try int_three_still_equals_float_three()
    try nunique_counts_large_ints_exactly()
    try field_index_distinguishes_large_ints()
    try join_on_large_int_keys_matches_exactly()
    try equality_hash_join()
    try connection_join_follows_foreign_key()
    try join_skips_unmatched_rows()
    try join_types()
    try overlay_field_index_and_join()
    print("PASS 18 legacy aggregate, index and join cases, including exact large integer keys")