feat: Add MySQL support for BETWEEN arguments (#1265)

Author: timstudd

internal/compiler/find_params.go

@@ -63,6 +63,9 @@ func (p paramSearch) Visit(node ast.Node) astutils.Visitor {
 	case *ast.A_Expr:
 		p.parent = node
 
+	case *ast.BetweenExpr:
+		p.parent = node
+
 	case *ast.FuncCall:
 		p.parent = node
 

internal/compiler/resolve.go

@@ -196,6 +196,44 @@ func resolveCatalogRefs(c *catalog.Catalog, qc *QueryCatalog, rvs []*ast.RangeVa
 				}
 			}
 
+		case *ast.BetweenExpr:
+			if n == nil || n.Expr == nil || n.Left == nil || n.Right == nil {
+				fmt.Println("ast.BetweenExpr is nil")
+				continue
+			}
+
+			var key string
+			if ref, ok := n.Expr.(*ast.ColumnRef); ok {
+				if str, ok := ref.Fields.Items[0].(*ast.String); ok {
+					key = str.Str
+				}
+			}
+
+			number := 0
+			if pr, ok := n.Left.(*ast.ParamRef); ok {
+				number = pr.Number
+			}
+
+			for _, table := range tables {
+				schema := table.Schema
+				if schema == "" {
+					schema = c.DefaultSchema
+				}
+
+				if c, ok := typeMap[schema][table.Name][key]; ok {
+					a = append(a, Parameter{
+						Number: number,
+						Column: &Column{
+							Name:     parameterName(ref.ref.Number, key),
+							DataType: dataType(&c.Type),
+							NotNull:  c.IsNotNull,
+							IsArray:  c.IsArray,
+							Table:    table,
+						},
+					})
+				}
+			}
+
 		case *ast.FuncCall:
 			fun, err := c.ResolveFuncCall(n)
 			if err != nil {

internal/endtoend/testdata/between_args/mysql/go/db.go

@@ -0,0 +1,11 @@
+CREATE TABLE products (
+    id          BIGINT  NOT NULL AUTO_INCREMENT,
+    name        TEXT    NOT NULL,
+    price       INT     NOT NULL,
+    PRIMARY KEY (id)
+);
+
+-- name: GetBetweenPrices :many
+SELECT  *
+FROM    products
+WHERE   price BETWEEN ? AND ?;

internal/endtoend/testdata/between_args/mysql/go/models.go

@@ -0,0 +1,12 @@
+{
+	"version": "1",
+	"packages": [
+	  {
+		"path": "go",
+		"engine": "mysql",
+		"name": "querytest",
+		"schema": "query.sql",
+		"queries": "query.sql"
+	  }
+	]
+}

internal/endtoend/testdata/between_args/mysql/go/query.sql.go

@@ -638,7 +638,13 @@ func (c *cc) convertBeginStmt(n *pcast.BeginStmt) ast.Node {
 }
 
 func (c *cc) convertBetweenExpr(n *pcast.BetweenExpr) ast.Node {
-	return todo(n)
+	return &ast.BetweenExpr{
+		Expr:     c.convert(n.Expr),
+		Left:     c.convert(n.Left),
+		Right:    c.convert(n.Right),
+		Location: n.OriginTextPosition(),
+		Not:      n.Not,
+	}
 }
 
 func (c *cc) convertBinlogStmt(n *pcast.BinlogStmt) ast.Node {

internal/endtoend/testdata/between_args/mysql/query.sql

@@ -0,0 +1,17 @@
+package ast
+
+type BetweenExpr struct {
+	// Expr is the value expression to be compared.
+	Expr Node
+	// Left is the left expression in the between statement.
+	Left Node
+	// Right is the right expression in the between statement.
+	Right Node
+	// Not is true, the expression is "not between".
+	Not      bool
+	Location int
+}
+
+func (n *BetweenExpr) Pos() int {
+	return n.Location
+}

internal/endtoend/testdata/between_args/mysql/sqlc.json

@@ -394,6 +394,9 @@ func (a *application) apply(parent ast.Node, name string, iter *iterator, n ast.
 		a.apply(n, "Refexpr", nil, n.Refexpr)
 		a.apply(n, "Refassgnexpr", nil, n.Refassgnexpr)
 
+	case *ast.BetweenExpr:
+		// pass
+
 	case *ast.BitString:
 		// pass
 

internal/engine/dolphin/convert.go

@@ -478,6 +478,17 @@ func Walk(f Visitor, node ast.Node) {
 			Walk(f, n.Refassgnexpr)
 		}
 
+	case *ast.BetweenExpr:
+		if n.Expr != nil {
+			Walk(f, n.Expr)
+		}
+		if n.Left != nil {
+			Walk(f, n.Left)
+		}
+		if n.Right != nil {
+			Walk(f, n.Right)
+		}
+
 	case *ast.BitString:
 		// pass