compileExpr compiles the given Expression into an object that evaluates the expression against a provided Record. It returns an error if compilation fails for any reason. This is the "intepreted slow path" of the analytics engine. Because it handles dynamic typing at runtime, overheads are incurr
(e dag.Expr)
| 46 | // are allocated by go libraries and temporary buffers are not used. This will |
| 47 | // change down the road when we implement no-allocation string and IP conversion. |
| 48 | func (b *Builder) compileExpr(e dag.Expr) (expr.Evaluator, error) { |
| 49 | if e == nil { |
| 50 | return nil, errors.New("null expression not allowed") |
| 51 | } |
| 52 | switch e := e.(type) { |
| 53 | case *dag.ArrayExpr: |
| 54 | return b.compileArrayExpr(e) |
| 55 | case *dag.BinaryExpr: |
| 56 | return b.compileBinary(e) |
| 57 | case *dag.CondExpr: |
| 58 | return b.compileConditional(*e) |
| 59 | case *dag.CallExpr: |
| 60 | return b.compileCall(e) |
| 61 | case *dag.DotExpr: |
| 62 | return b.compileDotExpr(e) |
| 63 | case *dag.IndexExpr: |
| 64 | return b.compileIndexExpr(e) |
| 65 | case *dag.IsNullExpr: |
| 66 | return b.compileIsNullExpr(e) |
| 67 | case *dag.MapCallExpr: |
| 68 | return b.compileMapCall(e) |
| 69 | case *dag.MapExpr: |
| 70 | return b.compileMapExpr(e) |
| 71 | case *dag.PrimitiveExpr: |
| 72 | val, err := sup.ParseValue(b.sctx(), e.Value) |
| 73 | if err != nil { |
| 74 | return nil, err |
| 75 | } |
| 76 | return expr.NewLiteral(val), nil |
| 77 | case *dag.RegexpMatchExpr: |
| 78 | return b.compileRegexpMatch(e) |
| 79 | case *dag.RegexpSearchExpr: |
| 80 | return b.compileRegexpSearch(e) |
| 81 | case *dag.RecordExpr: |
| 82 | return b.compileRecordExpr(e) |
| 83 | case *dag.SearchExpr: |
| 84 | return b.compileSearch(e) |
| 85 | case *dag.SetExpr: |
| 86 | return b.compileSetExpr(e) |
| 87 | case *dag.SliceExpr: |
| 88 | return b.compileSliceExpr(e) |
| 89 | case *dag.SubqueryExpr: |
| 90 | return b.compileSubquery(e) |
| 91 | case *dag.ThisExpr: |
| 92 | return expr.NewDottedExpr(b.sctx(), field.Path(e.Path)), nil |
| 93 | case *dag.UnaryExpr: |
| 94 | return b.compileUnary(*e) |
| 95 | default: |
| 96 | return nil, fmt.Errorf("invalid expression type %T", e) |
| 97 | } |
| 98 | } |
| 99 | |
| 100 | func (b *Builder) compileExprWithEmpty(e dag.Expr) (expr.Evaluator, error) { |
| 101 | if e == nil { |
no test coverage detected