[auto-bump] [no-release-notes] dependency by angelamayxie

.github/workflows/test.yml

@@ -18,11 +18,31 @@ jobs:
       uses: actions/setup-go@v5
       with:
         go-version-file: go.mod
+    - name: Install ICU4C (MacOS)
+      if: ${{ matrix.platform == 'macos-latest' }}
+      run: |
+        dir=$(brew --cellar icu4c)
+        dir="$dir"/$(ls "$dir")
+        echo CGO_CPPFLAGS=-I$dir/include >> $GITHUB_ENV
+        echo CGO_LDFLAGS=-L$dir/lib >> $GITHUB_ENV
+    - name: Install ICU4C (Windows)
+      if: ${{ matrix.platform == 'windows-latest' }}
+      uses: msys2/setup-msys2@v2
+      with:
+        path-type: inherit
+        msystem: UCRT64
+        pacboy: icu:p toolchain:p pkg-config:p
     - name: Test
-      if: ${{ matrix.platform != 'ubuntu-latest' }}
+      if: ${{ matrix.platform == 'macos-latest' }}
       run: go test ./...
       env:
         CI_TEST: "true"
+    - name: Test
+      if: ${{ matrix.platform == 'windows-latest' }}
+      shell: msys2 {0}
+      run: go.exe test ./...
+      env:
+        CI_TEST: "true"
     - name: Test
       if: ${{ matrix.platform == 'ubuntu-latest' }}
       run: go test -race ./...

enginetest/join_op_tests.go

@@ -105,6 +105,61 @@ var EngineOnlyJoinOpTests = []joinOpTest{
 }
 
 var DefaultJoinOpTests = []joinOpTest{
+	{
+		// https://github.com/dolthub/dolt/issues/9807
+		name: "FULL OUTER JOIN fails with empty subquery",
+		setup: [][]string{
+			{
+				"CREATE TABLE t(c BOOLEAN);",
+				"INSERT INTO t VALUES (FALSE);",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query: "SELECT * FROM ( SELECT c FROM t WHERE c ) sub1 FULL OUTER JOIN ( SELECT 1 AS c ) sub2 ON 1=1;",
+				Expected: []sql.Row{
+					{nil, 1},
+				},
+			},
+		},
+	},
+	{
+		// https://github.com/dolthub/dolt/issues/9807
+		name: "FULL OUTER JOIN with empty tables",
+		setup: [][]string{
+			{
+				"CREATE TABLE t1 (i INT);",
+				"CREATE TABLE t2 (j INT);",
+				"INSERT INTO t2 VALUES (1);",
+			},
+		},
+		tests: []JoinOpTests{
+			{
+				Query: "SELECT i, j FROM t1 FULL OUTER JOIN t2 ON 1=1;",
+				Expected: []sql.Row{
+					{nil, 1},
+				},
+			},
+			{
+				Query: "SELECT j, i FROM t2 FULL OUTER JOIN t1 ON 1=1;",
+				Expected: []sql.Row{
+					{1, nil},
+				},
+			},
+			{
+				Query: "SELECT i, j FROM t1 FULL OUTER JOIN t2 ON 1=0;",
+				Expected: []sql.Row{
+					{nil, 1},
+				},
+			},
+			{
+				Query: "SELECT j, i FROM t2 FULL OUTER JOIN t1 ON 1=0;",
+				Expected: []sql.Row{
+					{1, nil},
+				},
+			},
+		},
+	},
 	{
 		name: "bug where transitive join edge drops filters",
 		setup: [][]string{
@@ -1922,15 +1977,55 @@ SELECT SUM(x) FROM xy WHERE x IN (
 		},
 	},
 	{
-		name: "where not exists",
+		name: "where exists and where not exists",
 		setup: [][]string{
 			setup.XyData[0],
+			{
+				"create table t(c varchar(500))",
+				"insert into t values ('a'),('a')",
+				"create table u(c0 int, c1 int, primary key(c0, c1))",
+				"insert into u values (1, 1),(2,2),(2,3)",
+			},
 		},
 		tests: []JoinOpTests{
 			{
 				Query:    `select * from xy_hasnull x where not exists(select 1 from ab_hasnull a where a.b = x.y)`,
 				Expected: []sql.Row{{1, 0}, {3, nil}},
 			},
+			{
+				Query:    "select x from xy where exists (select 1 from ab where ab.b = -1)",
+				Expected: []sql.Row{},
+			},
+			{
+				Query:    "select x from xy where exists (select 1 from ab where ab.b = xy.y)",
+				Expected: []sql.Row{{0}, {2}},
+			},
+			{
+				Query:    "select x from xy where not exists (select 1 from ab where ab.b = xy.y)",
+				Expected: []sql.Row{{1}, {3}},
+			},
+			{
+				Query:    "select x from xy_hasnull where not exists(select 1 from ab_hasnull where ab_hasnull.b <> xy_hasnull.y)",
+				Expected: []sql.Row{{3}},
+			},
+			{
+				Query:    "select x from xy_hasnull_idx where exists(select 1 from rs where rs.s = xy_hasnull_idx.y)",
+				Expected: []sql.Row{{1}},
+			},
+			{
+				Query:    "select x from xy_hasnull_idx where not exists(select 1 from rs where rs.s = xy_hasnull_idx.y)",
+				Expected: []sql.Row{{2}, {0}, {3}},
+			},
+			{
+				// https://github.com/dolthub/dolt/issues/9828
+				Query:    "with v as (select 'a' as c where false) select null from t where not exists (select 1 from v where v.c <> t.c);",
+				Expected: []sql.Row{{nil}, {nil}},
+			},
+			{
+				// https://github.com/dolthub/dolt/issues/9797
+				Query:    "select * from u where exists (select 1 from u as x where x.c0 = u.c0)",
+				Expected: []sql.Row{{1, 1}, {2, 2}, {2, 3}},
+			},
 		},
 	},
 	{

enginetest/join_planning_tests.go

@@ -1788,6 +1788,34 @@ join uv d on d.u = c.x`,
 			},
 		},
 	},
+	{
+		name: "single look up plan does not drop complex equality filters",
+		setup: []string{
+			"create table t1 (i int primary key);",
+			"create table t2 (j int);",
+			"create table t3 (k int);",
+			"insert into t1 values (1), (2);",
+			"insert into t2 values (1), (2);",
+			"insert into t3 values (3);",
+		},
+		tests: []JoinPlanTest{
+			{
+				q:     "select * from t1 cross join t2 join (select * from t3) v3 on v3.k = t2.j;",
+				types: []plan.JoinType{plan.JoinTypeHash, plan.JoinTypeCross},
+				exp:   []sql.Row{},
+			},
+			{
+				q:     "select * from t1 cross join t2 join (select * from t3) v3 on v3.k >= t2.j order by i, j, k;",
+				types: []plan.JoinType{plan.JoinTypeInner, plan.JoinTypeCross},
+				exp: []sql.Row{
+					{1, 1, 3},
+					{1, 2, 3},
+					{2, 1, 3},
+					{2, 2, 3},
+				},
+			},
+		},
+	},
 }
 
 func TestJoinPlanning(t *testing.T, harness Harness) {
@@ -1915,24 +1943,28 @@ func evalIndexTest(t *testing.T, harness Harness, e QueryEngine, q string, index
 	})
 }
 
-func evalJoinCorrectness(t *testing.T, harness Harness, e QueryEngine, name, q string, exp []sql.Row, skipOld bool) {
-	t.Run(name, func(t *testing.T) {
-		ctx := NewContext(harness)
-		ctx = ctx.WithQuery(q)
+func evalJoinCorrectness(t *testing.T, harness Harness, e QueryEngine, name, q string, exp []sql.Row, skip bool) {
+	if skip {
+		t.Skip()
+	} else {
+		t.Run(name, func(t *testing.T) {
+			ctx := NewContext(harness)
+			ctx = ctx.WithQuery(q)
 
-		sch, iter, _, err := e.QueryWithBindings(ctx, q, nil, nil, nil)
-		require.NoError(t, err, "Unexpected error for query %s: %s", q, err)
+			sch, iter, _, err := e.QueryWithBindings(ctx, q, nil, nil, nil)
+			require.NoError(t, err, "Unexpected error for query %s: %s", q, err)
 
-		rows, err := sql.RowIterToRows(ctx, iter)
-		require.NoError(t, err, "Unexpected error for query %s: %s", q, err)
+			rows, err := sql.RowIterToRows(ctx, iter)
+			require.NoError(t, err, "Unexpected error for query %s: %s", q, err)
 
-		if exp != nil {
-			CheckResults(ctx, t, harness, exp, nil, sch, rows, q, e)
-		}
+			if exp != nil {
+				CheckResults(ctx, t, harness, exp, nil, sch, rows, q, e)
+			}
 
-		require.Equal(t, 0, ctx.Memory.NumCaches())
-		validateEngine(t, ctx, harness, e)
-	})
+			require.Equal(t, 0, ctx.Memory.NumCaches())
+			validateEngine(t, ctx, harness, e)
+		})
+	}
 }
 
 func collectJoinTypes(n sql.Node) []plan.JoinType {

enginetest/queries/alter_table_queries.go

@@ -2107,6 +2107,28 @@ var AddColumnScripts = []ScriptTest{
 			},
 		},
 	},
+	{
+		Name: "add column with check constraint",
+		SetUpScript: []string{
+			"create table t (i int primary key, j int)",
+			"insert into t values (1, 2)",
+		},
+		Assertions: []ScriptTestAssertion{
+			{
+				Query: "alter table t add column k int check (k > 0)",
+				// TODO: this should be 1 rowsAffected https://github.com/dolthub/dolt/issues/9606
+				Expected: []sql.Row{{types.NewOkResult(0)}},
+			},
+			{
+				Query:       "alter table t add column l int check (l is not null)",
+				ExpectedErr: sql.ErrCheckConstraintViolated,
+			},
+			{
+				Query:       "alter table t add column m int default 0 check (m != 0)",
+				ExpectedErr: sql.ErrCheckConstraintViolated,
+			},
+		},
+	},
 	{
 		Name: "error cases",
 		Assertions: []ScriptTestAssertion{

enginetest/queries/function_queries.go

@@ -569,9 +569,26 @@ var FunctionQueryTests = []QueryTest{
 	{
 		Query: "SELECT BIT_LENGTH(i) from mytable order by i limit 1",
 		Expected: []sql.Row{
-			{64},
+			{8},
 		},
 	},
+	{
+		// https://github.com/dolthub/dolt/issues/9818
+		Query:    "select bit_length(10)",
+		Expected: []sql.Row{{16}},
+	},
+	{
+		Query:    "select bit_length(now())",
+		Expected: []sql.Row{{152}},
+	},
+	{
+		Query:    "select bit_length(-10)",
+		Expected: []sql.Row{{24}},
+	},
+	{
+		Query:    "select bit_length(true)",
+		Expected: []sql.Row{{8}},
+	},
 	{
 		Query: "select date_format(datetime_col, '%D') from datetime_table order by 1",
 		Expected: []sql.Row{