resolve aliases in subqueries in function arguments

enginetest/queries/queries.go

@@ -5142,6 +5142,42 @@ Select * from (
 			{"b"},
 		},
 	},
+	{
+		Query: `SELECT if(1, 123, 456)`,
+		Expected: []sql.Row{
+			{123},
+		},
+	},
+	{
+		Query: `SELECT if(0, 123, 456)`,
+		Expected: []sql.Row{
+			{456},
+		},
+	},
+	{
+		Query: `SELECT if(0, "abc", 456)`,
+		Expected: []sql.Row{
+			{456},
+		},
+	},
+	{
+		Query: `SELECT if(1, "abc", 456)`,
+		Expected: []sql.Row{
+			{"abc"},
+		},
+	},
+	{
+		Query: `SELECT 1 as foo, if((select foo), "a", "b")`,
+		Expected: []sql.Row{
+			{1, "a"},
+		},
+	},
+	{
+		Query: `SELECT 0 as foo, if((select foo), "a", "b")`,
+		Expected: []sql.Row{
+			{0, "b"},
+		},
+	},
 	{
 		Query: `SELECT if(NULL, "a", "b")`,
 		Expected: []sql.Row{

server/handler_test.go

@@ -188,6 +188,28 @@ func TestHandlerOutput(t *testing.T) {
 		require.Equal(t, sqltypes.Float64, result.Rows[0][0].Type())
 		require.Equal(t, []byte("1"), result.Rows[0][0].ToBytes())
 	})
+
+	t.Run("if() type is correct", func(t *testing.T) {
+		handler.ComInitDB(dummyConn, "test")
+		var result *sqltypes.Result
+		err := handler.ComQuery(dummyConn, "select if(1, 123, 'def')", func(res *sqltypes.Result, more bool) error {
+			result = res
+			return nil
+		})
+		require.NoError(t, err)
+		require.Equal(t, 1, len(result.Rows))
+		require.Equal(t, sqltypes.Text, result.Rows[0][0].Type())
+		require.Equal(t, []byte("123"), result.Rows[0][0].ToBytes())
+
+		err = handler.ComQuery(dummyConn, "select if(0, 123, 456)", func(res *sqltypes.Result, more bool) error {
+			result = res
+			return nil
+		})
+		require.NoError(t, err)
+		require.Equal(t, 1, len(result.Rows))
+		require.Equal(t, sqltypes.Int64, result.Rows[0][0].Type())
+		require.Equal(t, []byte("456"), result.Rows[0][0].ToBytes())
+	})
 }
 
 func TestHandlerComPrepare(t *testing.T) {

sql/analyzer/reorder_projections.go

@@ -123,6 +123,30 @@ func reorderProjection(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Sc
 	})
 }
 
+// findDeferredColumns is a function that searches through a projection's expressions and checks if there are any
+// subqueries that reference the deferred column. Additionally, we have to check for subqueries in functions arguments
+func findDeferredColumns(exprs ...sql.Expression) []column {
+	var deferredColumns []column
+	for _, e := range exprs {
+		if a, ok := e.(*expression.Alias); ok {
+			e = a.Child
+		}
+
+		switch e := e.(type) {
+		case *plan.Subquery:
+			deferredColumns = append(deferredColumns, findDeferredColumnsAndAliasReferences(e.Query)...)
+		case sql.FunctionExpression:
+			for _, arg := range e.Children() {
+				innerCols := findDeferredColumns(arg)
+				if len(innerCols) > 0 {
+					deferredColumns = append(deferredColumns, innerCols...)
+				}
+			}
+		}
+	}
+	return deferredColumns
+}
+
 func addIntermediateProjections(
 	project *plan.Project,
 	projectedAliases map[string]sql.Expression,
@@ -194,19 +218,7 @@ func addIntermediateProjections(
 	// like a child node in this respect -- it draws its outer scope schema from the child of the node in which it's
 	// embedded. We identify any missing subquery columns by their being deferred or marked as an AliasReference
 	// from a previous analyzer step.
-	var deferredColumns []column
-	for _, e := range project.Projections {
-		if a, ok := e.(*expression.Alias); ok {
-			e = a.Child
-		}
-		s, ok := e.(*plan.Subquery)
-		if !ok {
-			continue
-		}
-
-		deferredColumns = append(deferredColumns, findDeferredColumnsAndAliasReferences(s.Query)...)
-	}
-
+	deferredColumns := findDeferredColumns(project.Projections...)
 	if len(deferredColumns) > 0 {
 		schema := child.Schema()
 		var projections = make([]sql.Expression, 0, len(schema)+len(deferredColumns))

sql/expression/function/if.go

@@ -86,7 +86,13 @@ func (f *If) Eval(ctx *sql.Context, row sql.Row) (interface{}, error) {
 
 // Type implements the Expression interface.
 func (f *If) Type() sql.Type {
-	return f.ifTrue.Type()
+	// if either type is string type, this should be a string type, regardless need to promote
+	typ1 := f.ifTrue.Type()
+	typ2 := f.ifFalse.Type()
+	if types.IsText(typ1) || types.IsText(typ2) {
+		return types.Text
+	}
+	return typ1.Promote()
 }
 
 // CollationCoercibility implements the interface sql.CollationCoercible.

sql/planbuilder/parse_test.go

@@ -19,6 +19,7 @@ import (
 type planTest struct {
 	Query        string
 	ExpectedPlan string
+	Skip         bool
 }
 
 func TestPlanBuilder(t *testing.T) {
@@ -839,6 +840,24 @@ Project
          └─ Table
              ├─ name: xy
              └─ columns: [x y z]
+`,
+		},
+		{
+			Skip:  true, // TODO: we don't correctly put aliases in the scope
+			Query: "select 1 as foo, concat((select foo), 'abc');",
+			ExpectedPlan: `
+Project
+├─ columns: [1 (tinyint) as foo, concat(Subquery
+│   ├─ cacheable: false
+│   └─ Project
+│       ├─ columns: [foo:1!null]
+│       └─ Table
+│           ├─ name: 
+│           └─ columns: []
+│  ,abc (longtext)) as concat((select foo), 'abc')]
+└─ Table
+    ├─ name: 
+    └─ columns: []
 `,
 		},
 	}
@@ -879,6 +898,9 @@ Project
 
 	for _, tt := range tests {
 		t.Run(tt.Query, func(t *testing.T) {
+			if tt.Skip {
+				t.Skip()
+			}
 			stmt, err := sqlparser.Parse(tt.Query)
 			require.NoError(t, err)
 

sql/planbuilder/scope.go

@@ -78,6 +78,10 @@ func (s *scope) getExpr(name string) (columnId, bool) {
 			}
 		}
 	}
+	// TODO: possibly want to look in parent scopes
+	//if !ok && s.parent != nil {
+	//	return s.parent.getExpr(name)
+	//}
 	return id, ok
 }