do not convert left and right joins to cross joins when joining on true

Author: angelamayxie

enginetest/join_op_tests.go

@@ -2046,6 +2046,9 @@ WHERE
 			},
 		},
 	},
+	{
+		name: "joining with subquery on empty table",
+	},
 }
 
 var rangeJoinOpTests = []JoinOpTests{

enginetest/memory_engine_test.go

@@ -200,38 +200,116 @@ func TestSingleQueryPrepared(t *testing.T) {
 
 // Convenience test for debugging a single query. Unskip and set to the desired query.
 func TestSingleScript(t *testing.T) {
-	t.Skip()
+	// t.Skip()
 	var scripts = []queries.ScriptTest{
 		{
-			Name:        "AS OF propagates to nested CALLs",
-			SetUpScript: []string{},
+			Name: "hash join with % condition",
+			SetUpScript: []string{
+				"create table t1(c0 int)",
+				"create table t2(c0 int)",
+				"insert into t1 values (1),(2),(3)",
+				"insert into t2 values (4),(5),(6)",
+			},
 			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "create procedure create_proc() create table t (i int primary key, j int);",
+					Query: `select /*+ HASH_JOIN(t1, t2) */ * from t1 join t2 on t1.c0 % 3 = t2.c0 % 3`,
 					Expected: []sql.Row{
-						{types.NewOkResult(0)},
+						{1, 4},
+						{2, 5},
+						{3, 6},
 					},
 				},
+			},
+		},
+		{
+			Skip: true,
+			Assertions: []queries.ScriptTestAssertion{
 				{
-					Query: "call create_proc()",
+					// test cross join used as projected subquery expression
+					Query:    "select 1 as exprAlias, 2, 3, (select exprAlias + count(*) from one_pk_three_idx a cross join one_pk_three_idx b);",
+					Expected: []sql.Row{{1, 2, 3, 65}},
+				},
+				{
+					Query: "SELECT count(*), (SELECT i FROM mytable WHERE i = 1 group by i);",
 					Expected: []sql.Row{
-						{types.NewOkResult(0)},
+						{1, 1},
 					},
 				},
 			},
 		},
+		{
+			Skip:        true,
+			Name:        "strings cast to numbers in log",
+			SetUpScript: []string{},
+			Assertions: []queries.ScriptTestAssertion{
+				{
+					Query:    "select (11 + '11asdf')",
+					Expected: []sql.Row{{float64(22)}},
+				},
+				{
+					Skip:     true,
+					Query:    "select log('10asdf', '100f')",
+					Expected: []sql.Row{{float64(2)}},
+				},
+				{
+					Skip:     true,
+					Query:    "select log('a10asdf', 'b100f')",
+					Expected: []sql.Row{{nil}},
+				},
+			},
+		},
+		{
+			Skip: true,
+			Name: "strings cast to numbers",
+			SetUpScript: []string{
+				//"create table test01(pk varchar(20) primary key)",
+				"create table test01(pk varchar(30))",
+				`insert into test01 values ('  3 12 4'),
+                          ('  3.2 12 4'),('-3.1234'),('-3.1a'),('-5+8'),('+3.1234'),
+                          ('11d'),('11wha?'),('11'),('12'),('1a1'),('a1a1'),('11-5'),
+                          ('3. 12 4'),('5.932887e+07'),('5.932887e+07abc'),('5.932887e7'),('5.932887e7abc')`,
+			},
+			Assertions: []queries.ScriptTestAssertion{
+				{
+					Skip:     true,
+					Query:    "select pk from test01 where pk=11 order by pk",
+					Expected: []sql.Row{{"11"}, {"11-5"}, {"11d"}, {"11wha?"}},
+				},
+				{
+					Query:    "select pk from test01 where pk in (11) order by pk",
+					Expected: []sql.Row{{"11"}, {"11-5"}, {"11d"}, {"11wha?"}},
+				},
+				{
+					Skip:     true,
+					Query:    "select pk from test01 where pk in ('11')",
+					Expected: []sql.Row{{"11"}},
+				},
+				{
+					Skip:     true,
+					Query:    "select log('10asdf', '100f')",
+					Expected: []sql.Row{{float64(2)}},
+				},
+				{
+					Skip:     true,
+					Query:    "select log('a10asdf', 'b100f')",
+					Expected: []sql.Row{{nil}},
+				},
+			},
+		},
 	}
 
 	for _, test := range scripts {
 		harness := enginetest.NewMemoryHarness("", 1, testNumPartitions, true, nil)
-		//harness.UseServer()
+		harness.Setup(setup.SimpleSetup...)
+		// harness.UseServer()
 		engine, err := harness.NewEngine(t)
+		// engine.EngineAnalyzer().Coster = memo.NewLookupBiasedCoster()
 		if err != nil {
 			panic(err)
 		}
 
-		//engine.EngineAnalyzer().Debug = true
-		//engine.EngineAnalyzer().Verbose = true
+		engine.EngineAnalyzer().Debug = true
+		engine.EngineAnalyzer().Verbose = true
 
 		enginetest.TestScriptWithEngine(t, engine, harness, test)
 	}
@@ -922,10 +1000,6 @@ func TestVectorFunctions(t *testing.T) {
 	enginetest.TestVectorFunctions(t, enginetest.NewDefaultMemoryHarness())
 }
 
-func TestVectorType(t *testing.T) {
-	enginetest.TestVectorType(t, enginetest.NewDefaultMemoryHarness())
-}
-
 func TestIndexPrefix(t *testing.T) {
 	enginetest.TestIndexPrefix(t, enginetest.NewDefaultMemoryHarness())
 }
@@ -1001,6 +1075,9 @@ func TestDatabaseCollationWire(t *testing.T) {
 }
 
 func TestTypesOverWire(t *testing.T) {
+	if _, ok := os.LookupEnv("CI_TEST"); !ok {
+		// t.Skip("Skipping test that requires CI_TEST=true")
+	}
 	harness := enginetest.NewDefaultMemoryHarness()
 	enginetest.TestTypesOverWire(t, harness, harness.SessionBuilder())
 }

sql/planbuilder/from.go

@@ -78,6 +78,13 @@ func (b *Builder) isUsingJoin(te *ast.JoinTableExpr) bool {
 		strings.EqualFold(te.Join, ast.NaturalRightJoinStr)
 }
 
+func (b *Builder) canConvertToCrossJoin(te *ast.JoinTableExpr) bool {
+	return !strings.EqualFold(te.Join, ast.LeftJoinStr) &&
+		!strings.EqualFold(te.Join, ast.RightJoinStr) &&
+		(te.Condition.On == nil || te.Condition.On == ast.BoolVal(true)) &&
+		te.Condition.Using == nil
+}
+
 func (b *Builder) buildJoin(inScope *scope, te *ast.JoinTableExpr) (outScope *scope) {
 	b.qFlags.Set(sql.QFlagInnerJoin)
 
@@ -101,7 +108,7 @@ func (b *Builder) buildJoin(inScope *scope, te *ast.JoinTableExpr) (outScope *sc
 	outScope.appendColumnsFromScope(rightScope)
 
 	// cross join
-	if (te.Condition.On == nil || te.Condition.On == ast.BoolVal(true)) && te.Condition.Using == nil {
+	if b.canConvertToCrossJoin(te) {
 		if rast, ok := te.RightExpr.(*ast.AliasedTableExpr); ok && rast.Lateral {
 			var err error
 			outScope.node, err = b.f.buildJoin(leftScope.node, rightScope.node, plan.JoinTypeLateralCross, expression.NewLiteral(true, types.Boolean))