From 32283995d6d8bfe91f23873d07a57447fce43fcf Mon Sep 17 00:00:00 2001 From: Tim Voronov Date: Fri, 8 Nov 2024 15:05:43 -0500 Subject: [PATCH] Updates --- pkg/compiler/compiler_bench_test.go | 7 ++ pkg/compiler/compiler_exec_test.go | 139 +++++++++++++++++++++++++++- pkg/compiler/visitor.go | 13 ++- pkg/runtime/env_options.go | 8 +- 4 files changed, 157 insertions(+), 10 deletions(-) diff --git a/pkg/compiler/compiler_bench_test.go b/pkg/compiler/compiler_bench_test.go index 7043ffcd..72daf760 100644 --- a/pkg/compiler/compiler_bench_test.go +++ b/pkg/compiler/compiler_bench_test.go @@ -98,3 +98,10 @@ func BenchmarkForNested(b *testing.B) { RETURN {[prop]: val} `) } + +func BenchmarkForTernary(b *testing.B) { + RunBenchmark(b, ` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i IN 1..5 RETURN i*2) + `) +} diff --git a/pkg/compiler/compiler_exec_test.go b/pkg/compiler/compiler_exec_test.go index aa40ec32..e5638229 100644 --- a/pkg/compiler/compiler_exec_test.go +++ b/pkg/compiler/compiler_exec_test.go @@ -430,7 +430,15 @@ func TestRegexpOperator(t *testing.T) { }) } -func TestAllArrayOperator(t *testing.T) { +func TestInOperator(t *testing.T) { + RunUseCases(t, []UseCase{ + Case("RETURN 1 IN [1,2,3]", true), + Case("RETURN 4 IN [1,2,3]", false), + Case("RETURN 1 NOT IN [1,2,3]", false), + }) +} + +func TestArrayAllOperator(t *testing.T) { RunUseCases(t, []UseCase{ Case("RETURN [1,2,3] ALL IN [1,2,3]", true, "All elements are in"), }) @@ -829,21 +837,144 @@ func TestFor(t *testing.T) { }) } +func TestForTernaryExpression(t *testing.T) { + RunUseCases(t, []UseCase{ + CaseArray(` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i IN 1..5 RETURN i*2)`, + []any{2, 4, 6, 8, 10}), + CaseArray(` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i IN 1..5 T::FAIL() RETURN i*2)?`, + []any{}), + CaseArray(` + LET foo = FALSE + RETURN foo ? (FOR i IN 1..5 RETURN i) : (FOR i IN 1..5 RETURN i*2)`, + []any{2, 4, 6, 8, 10}), + CaseArray(` + LET foo = FALSE + RETURN foo ? (FOR i IN 1..5 RETURN T::FAIL()) : (FOR i IN 1..5 RETURN T::FAIL())?`, + []any{}), + CaseArray(` + LET foo = TRUE + RETURN foo ? (FOR i IN 1..5 RETURN T::FAIL())? : (FOR i IN 1..5 RETURN T::FAIL())`, + []any{}), + CaseArray(` + LET foo = FALSE + LET res = foo ? TRUE : (FOR i IN 1..5 RETURN i*2) + RETURN res`, + []any{2, 4, 6, 8, 10}), + Case(` + LET foo = TRUE + LET res = foo ? TRUE : (FOR i IN 1..5 RETURN i*2) + RETURN res`, + true), + CaseArray(` + LET foo = FALSE + LET res = foo ? TRUE : (FOR i IN 1..5 RETURN i*2) + RETURN res`, + []any{2, 4, 6, 8, 10}), + CaseArray(` + LET foo = FALSE + LET res = foo ? (FOR i IN 1..5 RETURN i) : (FOR i IN 1..5 RETURN i*2) + RETURN res`, + []any{2, 4, 6, 8, 10}), + CaseArray(` + LET foo = TRUE + LET res = foo ? (FOR i IN 1..5 RETURN i) : (FOR i IN 1..5 RETURN i*2) + RETURN res`, + []any{1, 2, 3, 4, 5}), + Case(` + LET res = LENGTH((FOR i IN 1..5 RETURN T::FAIL())?) ? TRUE : FALSE + RETURN res`, + false), + Case(` + LET res = (FOR i IN 1..5 RETURN i)? ? TRUE : FALSE + RETURN res +`, + true), + }) +} + func TestForWhile(t *testing.T) { - var counter int64 + var untilCounter int + counter := -1 RunUseCases(t, []UseCase{ CaseArray("FOR i WHILE false RETURN i", []any{}), CaseArray("FOR i WHILE UNTIL(5) RETURN i", []any{0, 1, 2, 3, 4}), + CaseArray(` + FOR i WHILE COUNTER() < 5 + LET y = i + 1 + FOR x IN 1..y + RETURN i * x + `, []any{0, 1, 2, 2, 4, 6, 3, 6, 9, 12, 4, 8, 12, 16, 20}), }, runtime.WithFunctions(map[string]core.Function{ "UNTIL": func(ctx context.Context, args ...core.Value) (core.Value, error) { - if counter < int64(values.ToInt(args[0])) { - counter++ + if untilCounter < int(values.ToInt(args[0])) { + untilCounter++ return values.True, nil } return values.False, nil }, + "COUNTER": func(ctx context.Context, args ...core.Value) (core.Value, error) { + counter++ + return values.NewInt(counter), nil + }, + })) +} + +func TestForTernaryWhileExpression(t *testing.T) { + counter := -1 + RunUseCases(t, []UseCase{ + CaseArray(` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i WHILE false RETURN i*2) + `, []any{}), + CaseArray(` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i WHILE T::FAIL() RETURN i*2)? + `, []any{}), + CaseArray(` + LET foo = FALSE + RETURN foo ? TRUE : (FOR i WHILE COUNTER() < 10 RETURN i*2)`, + []any{0, 2, 4, 6, 8, 10, 12, 14, 16, 18}), + }, runtime.WithFunctions(map[string]core.Function{ + "COUNTER": func(ctx context.Context, args ...core.Value) (core.Value, error) { + counter++ + return values.NewInt(counter), nil + }, + })) +} + +func TestForDoWhile(t *testing.T) { + counter := -1 + counter2 := -1 + + RunUseCases(t, []UseCase{ + CaseArray(` + FOR i DO WHILE false + RETURN i + `, []any{0}), + CaseArray(` + FOR i DO WHILE COUNTER() < 10 + RETURN i`, []any{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10}), + CaseArray(` + FOR i WHILE COUNTER2() < 5 + LET y = i + 1 + FOR x IN 1..y + RETURN i * x + `, []any{0, 0, 0, 0, 0, 0, 1, 2, 3, 4, 0, 2, 4, 6, 8, 0, 3, 6, 9, 12, 0, 4, 8, 12, 16}), + }, runtime.WithFunctions(map[string]core.Function{ + "COUNTER": func(ctx context.Context, args ...core.Value) (core.Value, error) { + counter++ + return values.NewInt(counter), nil + }, + "COUNTER2": func(ctx context.Context, args ...core.Value) (core.Value, error) { + counter2++ + return values.NewInt(counter), nil + }, })) } diff --git a/pkg/compiler/visitor.go b/pkg/compiler/visitor.go index fc756dce..89a7b404 100644 --- a/pkg/compiler/visitor.go +++ b/pkg/compiler/visitor.go @@ -278,7 +278,6 @@ func (v *visitor) VisitForExpressionBody(ctx *fql.ForExpressionBodyContext) inte func (v *visitor) VisitForExpressionClause(ctx *fql.ForExpressionClauseContext) interface{} { if c := ctx.LimitClause(); c != nil { - // TODO: Implement return c.Accept(v) } @@ -902,12 +901,16 @@ func (v *visitor) VisitPredicate(ctx *fql.PredicateContext) interface{} { // TODO: Implement me panic(core.Error(core.ErrNotImplemented, "array operator")) } else if op := ctx.InOperator(); op != nil { - opcode = runtime.OpIn - } else if op := ctx.LikeOperator(); op != nil { - if op.(*fql.LikeOperatorContext).Not() != nil { - opcode = runtime.OpNotLike + if op.Not() == nil { + opcode = runtime.OpIn } else { + opcode = runtime.OpNotIn + } + } else if op := ctx.LikeOperator(); op != nil { + if op.(*fql.LikeOperatorContext).Not() == nil { opcode = runtime.OpLike + } else { + opcode = runtime.OpNotLike } } diff --git a/pkg/runtime/env_options.go b/pkg/runtime/env_options.go index bf280dac..20dc0fa5 100644 --- a/pkg/runtime/env_options.go +++ b/pkg/runtime/env_options.go @@ -10,7 +10,13 @@ func WithParams(params []core.Value) EnvironmentOption { func WithFunctions(functions map[string]core.Function) EnvironmentOption { return func(env *Environment) { - env.functions = functions + if env.functions == nil { + env.functions = make(map[string]core.Function) + } + + for name, function := range functions { + env.functions[name] = function + } } }