fix(engine/sqlite): support -> and ->> operators (#2927)

* fix(engine/sqlite): support -> and ->> operators

close #2919

There are still cases where the type inference part does not work properly,
but this can be worked around with explicit CAST.

* chore: remove infer

Author: orisano

internal/compiler/output_columns.go

@@ -158,11 +158,11 @@ func (c *Compiler) outputColumns(qc *QueryCatalog, node ast.Node) ([]*Column, er
 			if res.Name != nil {
 				name = *res.Name
 			}
-			switch {
-			case lang.IsComparisonOperator(astutils.Join(n.Name, "")):
+			switch op := astutils.Join(n.Name, ""); {
+			case lang.IsComparisonOperator(op):
 				// TODO: Generate a name for these operations
 				cols = append(cols, &Column{Name: name, DataType: "bool", NotNull: true})
-			case lang.IsMathematicalOperator(astutils.Join(n.Name, "")):
+			case lang.IsMathematicalOperator(op):
 				cols = append(cols, &Column{Name: name, DataType: "int", NotNull: true})
 			default:
 				cols = append(cols, &Column{Name: name, DataType: "any", NotNull: false})

internal/compiler/resolve.go

@@ -145,7 +145,7 @@ func (comp *Compiler) resolveCatalogRefs(qc *QueryCatalog, rvs []*ast.RangeVar,
 				// TODO: Move this to database-specific engine package
 				dataType := "any"
 				if astutils.Join(n.Name, ".") == "||" {
-					dataType = "string"
+					dataType = "text"
 				}
 
 				defaultP := named.NewParam("")

internal/endtoend/testdata/json_param_type/sqlite/go/db.go

@@ -0,0 +1,2 @@
+-- name: FindByAddress :one
+SELECT * FROM "user" WHERE "metadata"->>'address1' = ?1 LIMIT 1;

internal/endtoend/testdata/json_param_type/sqlite/go/models.go

@@ -0,0 +1,4 @@
+CREATE TABLE "user" (
+    "id" INT,
+    "metadata" TEXT
+);

internal/endtoend/testdata/json_param_type/sqlite/go/query.sql.go

@@ -0,0 +1,9 @@
+version: "2"
+sql:
+  - engine: "sqlite"
+    schema: "schema.sql"
+    queries: "query.sql"
+    gen:
+      go:
+        package: "querytest"
+        out: "go"

internal/endtoend/testdata/json_param_type/sqlite/query.sql

@@ -764,19 +764,19 @@ func (c *cc) convertLiteral(n *parser.Expr_literalContext) ast.Node {
 	return todo("convertLiteral", n)
 }
 
-func (c *cc) convertMathOperationNode(n *parser.Expr_math_opContext) ast.Node {
+func (c *cc) convertBinaryNode(n *parser.Expr_binaryContext) ast.Node {
 	return &ast.A_Expr{
 		Name: &ast.List{
 			Items: []ast.Node{
-				&ast.String{Str: "+"}, // todo: Convert operation types
+				&ast.String{Str: n.GetChild(1).(antlr.TerminalNode).GetText()},
 			},
 		},
 		Lexpr: c.convert(n.Expr(0)),
 		Rexpr: c.convert(n.Expr(1)),
 	}
 }
 
-func (c *cc) convertBinaryNode(n *parser.Expr_binaryContext) ast.Node {
+func (c *cc) convertBoolNode(n *parser.Expr_boolContext) ast.Node {
 	return &ast.BoolExpr{
 		// TODO: Set op
 		Args: &ast.List{
@@ -1163,14 +1163,14 @@ func (c *cc) convert(node node) ast.Node {
 	case *parser.Expr_literalContext:
 		return c.convertLiteral(n)
 
-	case *parser.Expr_binaryContext:
-		return c.convertBinaryNode(n)
+	case *parser.Expr_boolContext:
+		return c.convertBoolNode(n)
 
 	case *parser.Expr_listContext:
 		return c.convertExprListContext(n)
 
-	case *parser.Expr_math_opContext:
-		return c.convertMathOperationNode(n)
+	case *parser.Expr_binaryContext:
+		return c.convertBinaryNode(n)
 
 	case *parser.Expr_in_selectContext:
 		return c.convertInSelectNode(n)

internal/endtoend/testdata/json_param_type/sqlite/schema.sql

@@ -35,6 +35,8 @@ COMMA:     ',';
 ASSIGN:    '=';
 STAR:      '*';
 PLUS:      '+';
+PTR2:      '->>';
+PTR:       '->';
 MINUS:     '-';
 TILDE:     '~';
 PIPE2:     '||';