Fix UNNEST bulk insert column mapping

Author: myers

server/ast/select_clause.go

@@ -15,8 +15,9 @@
 package ast
 
 import (
-	"github.com/dolthub/go-mysql-server/sql/expression"
+	"strings"
 
+	"github.com/dolthub/go-mysql-server/sql/expression"
 	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
 
 	"github.com/dolthub/doltgresql/postgres/parser/sem/tree"
@@ -158,6 +159,36 @@ PostJoinRewrite:
 				}
 			}
 		}
+		// Handle multi-argument UNNEST: UNNEST(arr1, arr2, ...) produces a table with one column per array,
+		// where corresponding elements are "zipped" together. PostgreSQL pads shorter arrays with NULLs.
+		// We transform: SELECT * FROM UNNEST(arr1, arr2)
+		// Into:         SELECT * FROM (SELECT unnest(arr1), unnest(arr2)) AS unnest
+		// GMS's ProjectRowWithNestedIters handles multiple SRFs by zipping them together correctly.
+		if tableFuncExpr, ok := from[i].(*vitess.TableFuncExpr); ok {
+			if strings.EqualFold(tableFuncExpr.Name, "unnest") && len(tableFuncExpr.Exprs) > 1 {
+				selectExprs := make(vitess.SelectExprs, 0, len(tableFuncExpr.Exprs))
+				for _, argExpr := range tableFuncExpr.Exprs {
+					selectExprs = append(selectExprs, &vitess.AliasedExpr{
+						Expr: &vitess.FuncExpr{
+							Name:  vitess.NewColIdent("unnest"),
+							Exprs: vitess.SelectExprs{argExpr},
+						},
+					})
+				}
+				alias := tableFuncExpr.Alias
+				if alias.IsEmpty() {
+					alias = vitess.NewTableIdent("unnest")
+				}
+				from[i] = &vitess.AliasedTableExpr{
+					Expr: &vitess.Subquery{
+						Select: &vitess.Select{
+							SelectExprs: selectExprs,
+						},
+					},
+					As: alias,
+				}
+			}
+		}
 	}
 	distinct := node.Distinct
 	var distinctOn vitess.Exprs

testing/go/functions_test.go

@@ -1552,6 +1552,36 @@ func TestArrayFunctions(t *testing.T) {
 				},
 			},
 		},
+		{
+			Name: "multi-argument unnest",
+			Assertions: []ScriptTestAssertion{
+				{
+					// Basic multi-argument UNNEST with equal-length arrays
+					Query:    `SELECT * FROM UNNEST(ARRAY['a','b','c'], ARRAY[1,2,3])`,
+					Expected: []sql.Row{{"a", int64(1)}, {"b", int64(2)}, {"c", int64(3)}},
+				},
+				{
+					// Multi-argument UNNEST with unequal-length arrays (shorter padded with NULL)
+					Query:    `SELECT * FROM UNNEST(ARRAY['a','b'], ARRAY[1,2,3])`,
+					Expected: []sql.Row{{"a", int64(1)}, {"b", int64(2)}, {nil, int64(3)}},
+				},
+				{
+					// Multi-argument UNNEST with empty array
+					Query:    `SELECT * FROM UNNEST(ARRAY['a','b'], ARRAY[]::int[])`,
+					Expected: []sql.Row{{"a", nil}, {"b", nil}},
+				},
+				{
+					// Multi-argument UNNEST with three arrays (booleans come as "t"/"f" strings from PostgreSQL wire protocol)
+					Query:    `SELECT * FROM UNNEST(ARRAY[1,2], ARRAY['x','y'], ARRAY[true,false])`,
+					Expected: []sql.Row{{int64(1), "x", "t"}, {int64(2), "y", "f"}},
+				},
+				{
+					// Multi-argument UNNEST with alias
+					Query:    `SELECT u.* FROM UNNEST(ARRAY['a','b'], ARRAY[1,2]) AS u`,
+					Expected: []sql.Row{{"a", int64(1)}, {"b", int64(2)}},
+				},
+			},
+		},
 		{
 			Name:        "array_to_string",
 			SetUpScript: []string{},

testing/go/insert_test.go

@@ -293,5 +293,27 @@ ON CONFLICT (id) do update set c1 = $4`,
 				},
 			},
 		},
+		{
+			Name: "insert from unnest",
+			SetUpScript: []string{
+				`CREATE TABLE "django_content_type" (id serial primary key, app_label varchar, model varchar)`,
+			},
+			Assertions: []ScriptTestAssertion{
+				{
+					Query: `INSERT INTO "django_content_type" ("app_label", "model")
+SELECT * FROM UNNEST(('{debug_app,debug_app}')::varchar[],
+                     ('{debugmodel1,debugmodel2}')::varchar[])
+RETURNING "django_content_type"."id"`,
+					Expected: []sql.Row{{1}, {2}},
+				},
+				{
+					Query: `SELECT "app_label", "model" FROM "django_content_type" ORDER BY "id"`,
+					Expected: []sql.Row{
+						{"debug_app", "debugmodel1"},
+						{"debug_app", "debugmodel2"},
+					},
+				},
+			},
+		},
 	})
 }