Merge branch 'main' into james/proc

Author: James Cor

engine.go

@@ -150,6 +150,8 @@ type Engine struct {
 	Parser            sql.Parser
 }
 
+var _ analyzer.StatementRunner = (*Engine)(nil)
+
 type ColumnWithRawDefault struct {
 	SqlColumn *sql.Column
 	Default   string
@@ -195,6 +197,7 @@ func New(a *analyzer.Analyzer, cfg *Config) *Engine {
 		Parser:            sql.GlobalParser,
 	}
 	ret.ReadOnly.Store(cfg.IsReadOnly)
+	a.Runner = ret
 	return ret
 }
 

enginetest/initialization.go

@@ -91,6 +91,7 @@ func NewEngineWithProvider(_ *testing.T, harness Harness, provider sql.DatabaseP
 	if idh, ok := harness.(IndexDriverHarness); ok {
 		idh.InitializeIndexDriver(engine.Analyzer.Catalog.AllDatabases(NewContext(harness)))
 	}
+	analyzer.Runner = engine
 
 	return engine
 }

enginetest/join_op_tests.go

@@ -229,6 +229,56 @@ var DefaultJoinOpTests = []joinOpTest{
 			},
 		},
 	},
+	{
+		name: "left join null-filter",
+		setup: [][]string{
+			setup.MydbData[0],
+			{
+				"CREATE table xy (x int primary key, y int, z int, index y_idx(y));",
+				"CREATE table ab (a int primary key, b int, c int);",
+				"insert into xy values (1,0,0), (2,null,1), (3,2,2),(4,2,3);",
+				"insert into ab values (0,1,0), (1,2,1), (2,3,2), (3,4,3);",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query:    "select /*+ JOIN_ORDER(ab,xy) */ x from xy left join ab on x = a and z = 5 where a is null order by x ",
+				Expected: []sql.Row{{1}, {2}, {3}, {4}},
+			},
+			{
+				Query:    "select /*+ JOIN_ORDER(xy,ab) */ x from xy left join ab on x = a and z = 5 where a is null order by x ",
+				Expected: []sql.Row{{1}, {2}, {3}, {4}},
+			},
+			// partial return
+			{
+				Query:    "select /*+ JOIN_ORDER(ab,xy) */ x from xy left join ab on x = a and z = 1 where a is null order by x ",
+				Expected: []sql.Row{{1}, {3}, {4}},
+			},
+			{
+				Query:    "select /*+ JOIN_ORDER(xy,ab) */ x from xy left join ab on x = a and z in (1,2) where a is null order by x ",
+				Expected: []sql.Row{{1}, {4}},
+			},
+		},
+	},
+	{
+		name: "type conversion panic bug",
+		setup: [][]string{
+			setup.MydbData[0],
+			{
+				"create table xy (x int primary key, y int, z varchar(10), key (y,z));",
+				"insert into xy values (0,0,'0'), (1,1,'1');",
+				"create table ab (a int primary key, b int);",
+				"insert into ab values (0,0), (1,1);",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				// the literal z should be internally cast to the appropriate string type
+				Query:    "select /*+ JOIN_ORDER(ab,xy) */ count(*) from xy join ab on y = a and z = 0",
+				Expected: []sql.Row{{1}},
+			},
+		},
+	},
 	{
 		name: "partial key null lookup join indexes",
 		setup: [][]string{

sql/analyzer/analyzer.go

@@ -286,6 +286,8 @@ type Analyzer struct {
 	Coster memo.Coster
 	// ExecBuilder converts a sql.Node tree into an executable iterator.
 	ExecBuilder sql.NodeExecBuilder
+	// Runner represents the engine, which is represented as a separate interface to work around circular dependencies
+	Runner StatementRunner
 }
 
 // NewDefault creates a default Analyzer instance with all default Rules and configuration.

sql/analyzer/interpreter.go

@@ -0,0 +1,47 @@
+// Copyright 2022 Dolthub, Inc.
+//
+// Licensed under the Apache License, Version 2.0 (the "License");
+// you may not use this file except in compliance with the License.
+// You may obtain a copy of the License at
+//
+//     http://www.apache.org/licenses/LICENSE-2.0
+//
+// Unless required by applicable law or agreed to in writing, software
+// distributed under the License is distributed on an "AS IS" BASIS,
+// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+// See the License for the specific language governing permissions and
+// limitations under the License.
+
+package analyzer
+
+import (
+	"github.com/dolthub/vitess/go/vt/sqlparser"
+
+	"github.com/dolthub/go-mysql-server/sql/transform"
+
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/plan"
+)
+
+// Interpreter is an interface that implements an interpreter. These are typically used for functions (which may be
+// implemented as a set of operations that are interpreted during runtime).
+type Interpreter interface {
+	SetStatementRunner(ctx *sql.Context, runner StatementRunner) sql.Expression
+}
+
+// StatementRunner is essentially an interface that the engine will implement. We cannot directly reference the engine
+// here as it will cause an import cycle, so this may be updated to suit any function changes that the engine
+// experiences.
+type StatementRunner interface {
+	QueryWithBindings(ctx *sql.Context, query string, parsed sqlparser.Statement, bindings map[string]sqlparser.Expr, qFlags *sql.QueryFlags) (sql.Schema, sql.RowIter, *sql.QueryFlags, error)
+}
+
+// interpreter hands the engine to any interpreter expressions.
+func interpreter(ctx *sql.Context, a *Analyzer, n sql.Node, scope *plan.Scope, sel RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
+	return transform.NodeExprs(n, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
+		if interp, ok := expr.(Interpreter); ok {
+			return interp.SetStatementRunner(ctx, a.Runner), transform.NewTree, nil
+		}
+		return expr, transform.SameTree, nil
+	})
+}

sql/analyzer/resolve_column_defaults.go

@@ -23,29 +23,8 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/types"
 )
 
-// Resolving column defaults is a multi-phase process, with different analyzer rules for each phase.
-//
-//   - parseColumnDefaults: Some integrators (dolt but not GMS) store their column defaults as strings, which we need to
-//     parse into expressions before we can analyze them any further.
-//   - resolveColumnDefaults: Once we have an expression for a default value, it may contain expressions that need
-//     simplification before further phases of processing can take place.
-//
-// After this stage, expressions in column default values are handled by the normal analyzer machinery responsible for
-// resolving expressions, including things like columns and functions. Every node that needs to do this for its default
-// values implements `sql.Expressioner` to expose such expressions. There is custom logic in `resolveColumns` to help
-// identify the correct indexes for column references, which can vary based on the node type.
-//
-// Finally there are cleanup phases:
-//   - validateColumnDefaults: ensures that newly created column defaults from a DDL statement are legal for the type of
-//     column, various other business logic checks to match MySQL's logic.
-//   - stripTableNamesFromDefault: column defaults headed for storage or serialization in a query result need the table
-//     names in any GetField expressions stripped out so that they serialize to strings without such table names. Table
-//     names in GetField expressions are expected in much of the rest of the analyzer, so we do this after the bulk of
-//     analyzer work.
-//
-// The `information_schema.columns` table also needs access to the default values of every column in the database, and
-// because it's a table it can't implement `sql.Expressioner` like other node types. Instead it has special handling
-// here, as well as in the `resolve_functions` rule.
+// validateColumnDefaults ensures that newly created column defaults from a DDL statement are legal for the type of
+// column, various other business logic checks to match MySQL's logic.
 func validateColumnDefaults(ctx *sql.Context, _ *Analyzer, n sql.Node, _ *plan.Scope, _ RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
 	span, ctx := ctx.Span("validateColumnDefaults")
 	defer span.End()

sql/analyzer/rule_ids.go

@@ -65,6 +65,7 @@ const (
 	assignRoutinesId             // assignRoutines
 	modifyUpdateExprsForJoinId   // modifyUpdateExprsForJoin
 	applyForeignKeysId           // applyForeignKeys
+	interpreterId                // interpreter
 
 	// validate
 	validateResolvedId          // validateResolved

sql/analyzer/ruleid_string.go

@@ -92,6 +92,7 @@ var OnceAfterDefault = []Rule{
 	{assignRoutinesId, assignRoutines},
 	{modifyUpdateExprsForJoinId, modifyUpdateExprsForJoin},
 	{applyForeignKeysId, applyForeignKeys},
+	{interpreterId, interpreter},
 }
 
 // DefaultValidationRules to apply while analyzing nodes.

sql/analyzer/rules.go

@@ -16,6 +16,7 @@ package sql
 
 import (
 	"fmt"
+	"io"
 	"strings"
 
 	"github.com/dolthub/vitess/go/mysql"
@@ -1068,6 +1069,15 @@ func (w WrappedInsertError) Error() string {
 	return w.Cause.Error()
 }
 
+// Format implements fmt.Formatter
+func (w WrappedInsertError) Format(s fmt.State, verb rune) {
+	if fmtErr, ok := w.Cause.(fmt.Formatter); ok {
+		fmtErr.Format(s, verb)
+		return
+	}
+	_, _ = io.WriteString(s, w.Error())
+}
+
 // IgnorableError is used propagate information about an error that needs to be ignored and does not interfere with
 // any update accumulators
 type IgnorableError struct {