fix: mysql delete join panic (#2197)

* fix:mysql delete join panic

* fix: test

Author: nusr

internal/compiler/output_columns.go

@@ -404,9 +404,7 @@ func sourceTables(qc *QueryCatalog, node ast.Node) ([]*Table, error) {
 	var list *ast.List
 	switch n := node.(type) {
 	case *ast.DeleteStmt:
-		list = &ast.List{
-			Items: []ast.Node{n.Relation},
-		}
+		list = n.Relations
 	case *ast.InsertStmt:
 		list = &ast.List{
 			Items: []ast.Node{n.Relation},

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

@@ -0,0 +1,25 @@
+CREATE TABLE author (
+  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+  name VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE book (
+  id INT UNSIGNED AUTO_INCREMENT PRIMARY KEY,
+  title VARCHAR(255) NOT NULL
+);
+
+CREATE TABLE author_book (
+  author_id INT UNSIGNED NOT NULL,
+  book_id INT UNSIGNED NOT NULL,
+  CONSTRAINT `pk-author_book` PRIMARY KEY (author_id, book_id),
+  CONSTRAINT `fk-author_book-author-id` FOREIGN KEY (author_id) REFERENCES author (id),
+  CONSTRAINT `fk-author_book-book-id` FOREIGN KEY (book_id) REFERENCES book (id)
+);
+
+/* name: RemoveAllAuthorsFromTheGreatGatsby :exec */
+DELETE author_book
+FROM
+  author_book
+  INNER JOIN book ON book.id = author_book.book_id
+WHERE
+  book.title = 'The Great Gatsby';

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

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

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

@@ -0,0 +1,43 @@
+CREATE TABLE primary_table (
+        id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+        user_id bigint(20) unsigned NOT NULL,
+        PRIMARY KEY (id)
+);
+
+CREATE TABLE join_table (
+        id bigint(20) unsigned NOT NULL AUTO_INCREMENT,
+        primary_table_id bigint(20) unsigned NOT NULL,
+        other_table_id bigint(20) unsigned NOT NULL,
+        is_active tinyint(1) NOT NULL DEFAULT '0',
+        PRIMARY KEY (id)
+);
+
+-- name: DeleteJoin :exec
+DELETE jt.*,
+pt.*
+FROM
+        join_table as jt
+        JOIN primary_table as pt ON jt.primary_table_id = pt.id
+WHERE
+        jt.id = ?
+        AND pt.user_id = ?;
+
+-- name: DeleteLeftJoin :exec
+DELETE jt.*,
+pt.*
+FROM
+        join_table as jt
+        LEFT JOIN primary_table as pt ON jt.primary_table_id = pt.id
+WHERE
+        jt.id = ?
+        AND pt.user_id = ?;
+
+-- name: DeleteRightJoin :exec
+DELETE jt.*,
+pt.*
+FROM
+        join_table as jt
+        RIGHT JOIN primary_table as pt ON jt.primary_table_id = pt.id
+WHERE
+        jt.id = ?
+        AND pt.user_id = ?;

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

@@ -0,0 +1,11 @@
+{
+	"version": "1",
+	"packages": [
+		{
+			"path": "db",
+			"engine": "mysql",
+			"schema": "query.sql",
+			"queries": "query.sql"
+		}
+	]
+}

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

@@ -318,14 +318,11 @@ func (c *cc) convertDeleteStmt(n *pcast.DeleteStmt) *ast.DeleteStmt {
 	if len(rels.Items) != 1 {
 		panic("expected one range var")
 	}
-	rel := rels.Items[0]
-	rangeVar, ok := rel.(*ast.RangeVar)
-	if !ok {
-		panic("expected range var")
-	}
+	relations := &ast.List{}
+	convertToRangeVarList(rels, relations)
 
 	return &ast.DeleteStmt{
-		Relation:      rangeVar,
+		Relations:     relations,
 		WhereClause:   c.convert(n.Where),
 		ReturningList: &ast.List{},
 		WithClause:    c.convertWithClause(n.With),
@@ -1140,22 +1137,24 @@ func (c *cc) convertSetOprType(n *pcast.SetOprType) (op ast.SetOperation, all bo
 // into a tree. It is called for UNION, INTERSECT or EXCLUDE operation.
 //
 // Given an union with the following nodes:
-//     [Select{1}, Select{2}, Select{3}, Select{4}]
+//
+//	[Select{1}, Select{2}, Select{3}, Select{4}]
 //
 // The function will return:
-//     Select{
-//         Larg: Select{
-//             Larg: Select{
-//                 Larg: Select{1},
-//                 Rarg: Select{2},
-//                 Op: Union
-//             },
-//             Rarg: Select{3},
-//             Op: Union,
-//         },
-//         Rarg: Select{4},
-//         Op: Union,
-//     }
+//
+//	Select{
+//	    Larg: Select{
+//	        Larg: Select{
+//	            Larg: Select{1},
+//	            Rarg: Select{2},
+//	            Op: Union
+//	        },
+//	        Rarg: Select{3},
+//	        Op: Union,
+//	    },
+//	    Rarg: Select{4},
+//	    Op: Union,
+//	}
 func (c *cc) convertSetOprSelectList(n *pcast.SetOprSelectList) ast.Node {
 	selectStmts := make([]*ast.SelectStmt, len(n.Selects))
 	for i, node := range n.Selects {

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

@@ -1435,7 +1435,9 @@ func convertDeleteStmt(n *pg.DeleteStmt) *ast.DeleteStmt {
 		return nil
 	}
 	return &ast.DeleteStmt{
-		Relation:      convertRangeVar(n.Relation),
+		Relations: &ast.List{
+			Items: []ast.Node{convertRangeVar(n.Relation)},
+		},
 		UsingClause:   convertSlice(n.UsingClause),
 		WhereClause:   convertNode(n.WhereClause),
 		ReturningList: convertSlice(n.ReturningList),

internal/endtoend/testdata/delete_join/mysql/db/models.go

@@ -158,8 +158,12 @@ func (c *cc) convertDelete_stmtContext(n *parser.Delete_stmtContext) ast.Node {
 			relation.Alias = &ast.Alias{Aliasname: &alias}
 		}
 
+		relations := &ast.List{}
+
+		relations.Items = append(relations.Items, relation)
+
 		delete := &ast.DeleteStmt{
-			Relation:      relation,
+			Relations:     relations,
 			ReturningList: c.convertReturning_caluseContext(n.Returning_clause()),
 			WithClause:    nil,
 		}