dymokomi/luce-prism
Source of release 0.6.0
0.6.0 / tests / compatibility / query.lucb
## Ports of the original named query cases, using the original shared fixture.
from luce_prism import prism
import interop
import memory
import ownership
pub func plan(doc: interop.Reference[prism.Document], pattern: str = "") -> interop.Reference[prism.Query]!:
return try interop.Reference[prism.Query].adopt(try new prism.Query(doc, pattern) in memory.heap, prism.query_type, memory.heap)
pub func compare(field: str, value: interop.Reference[prism.Value], op: prism.Comparison = prism.Comparison.equal) -> interop.Reference[prism.Predicate]!:
defer value.release()
return try prism.Predicate.field(field, op, value)
pub func filtered(doc: interop.Reference[prism.Document], predicate: interop.Reference[prism.Predicate]) -> interop.Reference[prism.Query]!:
defer predicate.release()
var query = try prism.Query(doc)
defer query.close()
return try query.filter(predicate)
pub func paths(query: interop.Reference[prism.Query], expected: const str[]) -> !:
defer query.release()
let rows = try query.value().select()
defer rows.release()
if rows.value().count() != expected.length:
print(f"wrong query row count: {rows.value().count()}, expected {expected.length}")
assert(rows.value().count() == expected.length)
for i in 0..<expected.length:
assert(try rows.value().path_at(i) == expected[i])
func check(doc: interop.Reference[prism.Document], predicate: interop.Reference[prism.Predicate], expected: const str[]) -> !:
try paths(try filtered(doc, predicate), expected)
func fixture() -> interop.Reference[prism.Document]!:
return try prism.Document.load("tests/fixtures/query_cases.prisma")
func query_by_type_and_filters() -> !:
let doc = try fixture()
defer doc.release()
let issue = try prism.Predicate.by_type("issue")
defer issue.release()
let open = try compare("status", try prism.Value.text("open"))
defer open.release()
let high = try compare("sev", try prism.Value.text("high"))
defer high.release()
try check(doc, issue.clone(), ["/t/a", "/t/b", "/t/c", "/t/d"])
try check(doc, open.clone(), ["/t/a", "/t/b", "/t/d", "/t/n1"])
let both = try issue.value().both(open)
defer both.release()
try check(doc, both.clone(), ["/t/a", "/t/b", "/t/d"])
try check(doc, try both.value().both(high), ["/t/a"])
func query_numeric_compare_and_f32_int_trap() -> !:
let doc = try fixture()
defer doc.release()
try check(doc, try compare("score", try prism.Value.integer(1)), ["/t/a"])
try check(doc, try compare("weight", try prism.Value.integer(3), prism.Comparison.greater), ["/t/a", "/t/c"])
try check(doc, try compare("weight", try prism.Value.integer(3), prism.Comparison.less), ["/t/b", "/t/d"])
try check(doc, try compare("score", try prism.Value.number(2.0), prism.Comparison.greater), ["/t/c"])
let two = try compare("weight", try prism.Value.integer(2))
defer two.release()
let nine = try compare("weight", try prism.Value.integer(9))
defer nine.release()
try check(doc, try two.value().either(nine), ["/t/b", "/t/c", "/t/d"])
func query_null_safety_ne_vs_not_eq() -> !:
let doc = try fixture()
defer doc.release()
try check(doc, try compare("sev", try prism.Value.text("high"), prism.Comparison.not_equal), ["/t/b", "/t/c"])
let high = try compare("sev", try prism.Value.text("high"))
defer high.release()
try check(doc, try high.value().negate(), ["/t", "/t/b", "/t/c", "/t/d", "/t/n1"])
try check(doc, try prism.Predicate.exists("sev"), ["/t/a", "/t/b", "/t/c"])
var empty: str[]
try check(doc, try compare("weight", try prism.Value.text("5")), empty)
try check(doc, try prism.Predicate.is_null("sev"), ["/t", "/t/d", "/t/n1"])
func query_order_reverse_limit() -> !:
let doc = try fixture()
defer doc.release()
let issues = try filtered(doc, try prism.Predicate.by_type("issue"))
defer issues.release()
let ordered = try issues.value().order_by("weight")
defer ordered.release()
try paths(ordered.clone(), ["/t/b", "/t/d", "/t/a", "/t/c"])
try paths(try ordered.value().reverse(), ["/t/c", "/t/a", "/t/d", "/t/b"])
try paths(try issues.value().order_by("sev"), ["/t/a", "/t/b", "/t/c", "/t/d"])
try paths(try issues.value().limit(2), ["/t/a", "/t/b"])
var empty: str[]
try paths(try issues.value().limit(0), empty)
assert(try issues.value().count() == 4)
func query_terminals() -> !:
let doc = try fixture()
defer doc.release()
let issues = try filtered(doc, try prism.Predicate.by_type("issue"))
defer issues.release()
assert(try issues.value().count() == 4 and try issues.value().any())
let empty = try filtered(doc, try compare("status", try prism.Value.text("nope")))
defer empty.release()
assert(not try empty.value().any() and try empty.value().first() == none)
let zero = try issues.value().limit(0)
defer zero.release()
assert(not try zero.value().any())
let note = try filtered(doc, try prism.Predicate.by_type("note"))
defer note.release()
assert(try note.value().first() == "/t/n1")
assert(try note.value().one() == "/t/n1")
let note_zero = try note.value().limit(0)
defer note_zero.release()
assert(try note_zero.value().one() == "/t/n1")
func query_one_throws_on_zero_or_many() -> !:
let doc = try fixture()
defer doc.release()
for kind in ["issue", "nope"]:
let query = try filtered(doc, try prism.Predicate.by_type(kind))
defer query.release()
var rejected = false
_ = query.value().one() catch failure:
assert(failure.code == prism.invalid)
rejected = true
recover ""
assert(rejected)
func query_group_by() -> !:
let doc = try fixture()
defer doc.release()
let query = try filtered(doc, try prism.Predicate.by_type("issue"))
defer query.release()
let groups = try query.value().group_by("status")
defer groups.release()
assert(groups.value().count() == 2)
assert(try groups.value().key_at(0) == "done" and try groups.value().row_count(0) == 1)
assert(try groups.value().key_at(1) == "open" and try groups.value().row_count(1) == 3)
let rows = try groups.value().rows(1)
defer rows.release()
assert(try rows.value().path_at(2) == "/t/d")
var rejected = false
let invalid = query.value().group_by("weight") catch failure:
assert(failure.code == prism.invalid)
rejected = true
recover groups.clone()
invalid.release()
assert(rejected)
func query_structural_predicates() -> !:
let doc = try fixture()
defer doc.release()
try check(doc, try prism.Predicate.under("/t"), ["/t/a", "/t/b", "/t/c", "/t/d", "/t/n1"])
try check(doc, try prism.Predicate.name_is("a"), ["/t/a"])
let query = try plan(doc, "/t/*")
defer query.release()
let predicate = try prism.Predicate.by_type("issue")
defer predicate.release()
let issues = try query.value().filter(predicate)
defer issues.release()
assert(try issues.value().count() == 4)
var empty: str[]
try paths(try plan(doc, "/nope/*"), empty)
try paths(try plan(doc, "/a//bad"), empty)
func query_le_ge_contains_startswith_and_orderby_type() -> !:
let doc = try fixture()
defer doc.release()
try check(doc, try compare("weight", try prism.Value.integer(2), prism.Comparison.less_equal), ["/t/b", "/t/d"])
try check(doc, try compare("weight", try prism.Value.integer(9), prism.Comparison.greater_equal), ["/t/c"])
try check(doc, try prism.Predicate.contains("title", "ixtur"), ["/t"])
try check(doc, try prism.Predicate.starts_with("status", "op"), ["/t/a", "/t/b", "/t/d", "/t/n1"])
var query = try prism.Query(doc)
defer query.close()
try paths(try query.order_by("type"), ["/t/a", "/t/b", "/t/c", "/t/d", "/t/n1", "/t"])
struct Counter:
var scans: usize
var notes_only: bool
var retained: interop.Reference[prism.Row]?
pub func invoke(row: interop.Reference[prism.Row]) -> interop.Outcome[bool]:
self.scans += 1
if let previous = self.retained:
previous.release()
self.retained = row.clone()
return interop.Outcome[bool].success(interop.Owned[bool](not self.notes_only or row.value().type_name() == "note"))
pub func close():
if let row = self.retained:
row.release()
self.retained = none
pub func trace(visit: func(ownership.Object*, void*) -> unit, context: void*):
if let row = self.retained:
row.trace(visit, context)
let counter_type = interop.Type[Counter]("Query test counter", Counter.close, Counter.trace, closeable = true)
func custom(counter: interop.Reference[Counter]) -> interop.Reference[prism.Predicate]!:
let callback = try interop.Callback[interop.Reference[prism.Row], bool].bind_mutating(counter, Counter.invoke)
defer callback.release()
return try prism.Predicate.custom(callback)
func query_metadata_predicates_and_element_lambda() -> !:
let doc = try fixture()
defer doc.release()
try check(doc, try prism.Predicate.metadata("owner", "dy"), ["/t/a"])
try check(doc, try prism.Predicate.has_metadata("owner"), ["/t/a", "/t/c"])
let counter = try interop.Reference[Counter].adopt(try new Counter(notes_only = true) in memory.heap, counter_type, memory.heap)
defer counter.release()
try check(doc, try custom(counter), ["/t/n1"])
try doc.value().remove("/t")
let retained = counter.value().retained else error(prism.invalid, "query callback did not retain a row")
assert(retained.value().path() == "/t/n1")
func query_is_lazy_and_short_circuits() -> !:
let doc = try fixture()
defer doc.release()
let counter = try interop.Reference[Counter].adopt(try new Counter() in memory.heap, counter_type, memory.heap)
defer counter.release()
let query = try filtered(doc, try custom(counter))
defer query.release()
assert(counter.value().scans == 0)
assert(try query.value().count() == 6 and counter.value().scans == 6)
counter.value().scans = 0
assert(try query.value().first() == "/t" and counter.value().scans == 1)
counter.value().scans = 0
assert(try query.value().any() and counter.value().scans == 1)
counter.value().scans = 0
let ordered = try query.value().order_by("weight")
defer ordered.release()
_ = try ordered.value().first()
assert(counter.value().scans == 6)
counter.value().scans = 0
let limited = try query.value().limit(2)
defer limited.release()
assert(try limited.value().count() == 2 and counter.value().scans == 2)
try doc.value().add("/later", "note")
assert(try query.value().count() == 7)
func query_empty_document() -> !:
let doc = try prism.Document.parse("#prisma 4.0\n")
defer doc.release()
var query = try prism.Query(doc)
defer query.close()
assert(try query.count() == 0 and not try query.any() and try query.first() == none)
var empty: str[]
try check(doc, try prism.Predicate.by_type("issue"), empty)
try check(doc, try compare("x", try prism.Value.integer(1)), empty)
func query_reads_through_overlay() -> !:
let base = try prism.Document.parse("#prisma 4.0\ndef row \"a\" { int x = 1 } def row \"b\" { int x = 2 }")
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 }")
defer layer.release()
let doc = try base.value().overlay(layer)
defer doc.release()
var query = try prism.Query(doc)
defer query.close()
assert(try query.count() == 2)
assert(try query.first() == "/a")
assert(try query.any())
try paths(try plan(doc), ["/a", "/c"])
try check(doc, try compare("x", try prism.Value.integer(9)), ["/a"])
var missing: str[]
try check(doc, try compare("x", try prism.Value.integer(2)), missing)
try check(doc, try prism.Predicate.by_type("row"), ["/a", "/c"])
assert(try query.aggregate("x", prism.Aggregate.sum) == 12.0)
let ordered = try query.order_by("x")
defer ordered.release()
assert(try ordered.value().first() == "/c")
let selection = try query.select()
defer selection.release()
assert(selection.value().count() == 2 and try selection.value().path_at(1) == "/c")
let value = try selection.value().get(0, "x")
defer value.release()
assert(try value.value().integer_at() == 9)
pub func exercise_callback() -> !:
let doc = try prism.Document.parse("#prisma 4.0\ndef row \"a\" { int x = 1 } def row \"b\" { int x = 2 }")
defer doc.release()
let counter = try interop.Reference[Counter].adopt(try new Counter() in memory.heap, counter_type, memory.heap)
defer counter.release()
let query = try filtered(doc, try custom(counter))
defer query.release()
assert(try query.value().count() == 2)
pub func run() -> !:
try query_by_type_and_filters()
try query_numeric_compare_and_f32_int_trap()
try query_null_safety_ne_vs_not_eq()
try query_order_reverse_limit()
try query_terminals()
try query_one_throws_on_zero_or_many()
try query_group_by()
try query_structural_predicates()
try query_le_ge_contains_startswith_and_orderby_type()
try query_metadata_predicates_and_element_lambda()
try query_is_lazy_and_short_circuits()
try query_empty_document()
try query_reads_through_overlay()
print("PASS 12 legacy query cases, lazy terminals, stable ordering and overlay read-through")