changefeedccl: block db-level changefeed creation for non-empty tableset

On startup, the changefeed should not be started until there exist
tables in the database to watch. If no tables exist at the time of
startup, then a tableset watcher is created and polled; the changefeed
will be started from where there is first a target table.

Fixes: #147371
Epic: CRDB-1421

Release note: none

Author: log-head

pkg/ccl/changefeedccl/BUILD.bazel

@@ -64,6 +64,7 @@ go_library(
         "//pkg/ccl/changefeedccl/kvfeed",
         "//pkg/ccl/changefeedccl/resolvedspan",
         "//pkg/ccl/changefeedccl/schemafeed",
+        "//pkg/ccl/changefeedccl/tableset",
         "//pkg/ccl/changefeedccl/timers",
         "//pkg/ccl/kvccl/kvfollowerreadsccl",
         "//pkg/ccl/utilccl",

pkg/ccl/changefeedccl/changefeed_dist.go

@@ -252,6 +252,7 @@ func startDistChangefeed(
 	onTracingEvent func(ctx context.Context, meta *execinfrapb.TracingAggregatorEvents),
 	targets changefeedbase.Targets,
 ) error {
+	fmt.Println("startDistChangefeed: schemaTS: ", schemaTS)
 	execCfg := execCtx.ExecCfg()
 	tableDescs, err := fetchTableDescriptors(ctx, execCfg, targets, schemaTS)
 	if err != nil {

pkg/ccl/changefeedccl/changefeed_stmt.go

@@ -18,6 +18,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/ccl/changefeedccl/changefeedbase"
 	"github.com/cockroachdb/cockroach/pkg/ccl/changefeedccl/changefeedvalidators"
 	"github.com/cockroachdb/cockroach/pkg/ccl/changefeedccl/checkpoint"
+	"github.com/cockroachdb/cockroach/pkg/ccl/changefeedccl/tableset"
 	"github.com/cockroachdb/cockroach/pkg/ccl/utilccl"
 	"github.com/cockroachdb/cockroach/pkg/cloud"
 	"github.com/cockroachdb/cockroach/pkg/cloud/externalconn"
@@ -40,6 +41,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/colinfo"
 	"github.com/cockroachdb/cockroach/pkg/sql/catalog/descpb"
+	"github.com/cockroachdb/cockroach/pkg/sql/execinfra"
 	"github.com/cockroachdb/cockroach/pkg/sql/execinfrapb"
 	"github.com/cockroachdb/cockroach/pkg/sql/exprutil"
 	"github.com/cockroachdb/cockroach/pkg/sql/isql"
@@ -59,6 +61,7 @@ import (
 	"github.com/cockroachdb/cockroach/pkg/util/log/channel"
 	"github.com/cockroachdb/cockroach/pkg/util/log/eventpb"
 	"github.com/cockroachdb/cockroach/pkg/util/log/severity"
+	"github.com/cockroachdb/cockroach/pkg/util/mon"
 	"github.com/cockroachdb/cockroach/pkg/util/randutil"
 	"github.com/cockroachdb/cockroach/pkg/util/span"
 	"github.com/cockroachdb/cockroach/pkg/util/syncutil"
@@ -1724,6 +1727,12 @@ func (b *changefeedResumer) resumeWithRetries(
 
 	maxBackoff := changefeedbase.MaxRetryBackoff.Get(&execCfg.Settings.SV)
 	backoffReset := changefeedbase.RetryBackoffReset.Get(&execCfg.Settings.SV)
+
+	// Create memory monitor for tableset watcher. Similar to how processors create
+	// their monitors at function start, we create this unconditionally.
+	watcherMemMonitor := execinfra.NewMonitor(ctx, execCfg.DistSQLSrv.ChangefeedMonitor, mon.MakeName("changefeed-tableset-watcher-mem"))
+	defer watcherMemMonitor.Stop(ctx)
+
 	for r := getRetry(ctx, maxBackoff, backoffReset); r.Next(); {
 		flowErr := maybeUpgradePreProductionReadyExpression(ctx, jobID, details, jobExec)
 
@@ -1737,7 +1746,7 @@ func (b *changefeedResumer) resumeWithRetries(
 				knobs.BeforeDistChangefeed()
 			}
 
-			confPoller := make(chan struct{})
+			runningChangefeedChan := make(chan struct{})
 			g := ctxgroup.WithContext(ctx)
 			initialHighWater, schemaTS, err := computeDistChangefeedTimestamps(ctx, jobExec, details, localState)
 			if err != nil {
@@ -1751,28 +1760,94 @@ func (b *changefeedResumer) resumeWithRetries(
 			if haveKnobs && maybeCfKnobs.TablesetChangingCallback != nil {
 				maybeCfKnobs.TablesetChangingCallback()
 			}
+
+			// Watcher is only used for db-level changefeeds with no watched tables.
+			var watcher *tableset.Watcher
+			watcherChan := make(chan []tableset.TableDiff, 1)
+			var watcherCancel context.CancelFunc
+			if len(details.TargetSpecifications) == 1 &&
+				details.TargetSpecifications[0].Type == jobspb.ChangefeedTargetSpecification_DATABASE &&
+				targets.NumUniqueTables() == 0 {
+
+				// Create watcher dependencies.
+				dbID := details.TargetSpecifications[0].DescID
+				filter := tableset.Filter{
+					DatabaseID: dbID,
+				}
+
+				var watcherCtx context.Context
+				// Create a separate cancellable context for the watcher so that
+				// it can be stopped when the changefeed is stopped.
+				watcherCtx, watcherCancel = context.WithCancel(ctx)
+
+				// Create a watcher for the database.
+				watcher = tableset.NewWatcher(filter, execCfg, watcherMemMonitor, int64(jobID))
+				g.GoCtx(func(ctx context.Context) error {
+					err := watcher.Start(watcherCtx, schemaTS)
+					if err != nil && errors.Is(err, context.Canceled) {
+						// Check if watcherCtx was canceled (expected) vs parent ctx (error)
+						if errors.Is(watcherCtx.Err(), context.Canceled) && ctx.Err() == nil {
+							// Watcher was intentionally canceled, not an error
+							return nil
+						}
+					}
+					return err
+				})
+			}
+
+			// Start the changefeed.
 			g.GoCtx(func(ctx context.Context) error {
-				defer close(confPoller)
+				defer close(runningChangefeedChan)
+				if watcher != nil {
+					select {
+					case <-ctx.Done():
+						return ctx.Err()
+					case diffs := <-watcherChan:
+						schemaTS = diffs[0].AsOf
+						initialHighWater = diffs[0].AsOf
+						targets, err = AllTargets(ctx, details, execCfg, schemaTS)
+						if err != nil {
+							return err
+						}
+						watcherCancel()
+					}
+				}
 				return startDistChangefeed(ctx, jobExec, jobID, schemaTS, details, description, initialHighWater, localState, startedCh, onTracingEvent, targets)
-
 			})
+
+			// Poll for updated configuration or new database tables if hibernating.
 			g.GoCtx(func(ctx context.Context) error {
 				t := time.NewTicker(15 * time.Second)
 				defer t.Stop()
+				diffSent := false
 				for {
 					select {
 					case <-ctx.Done():
 						return ctx.Err()
-					case <-confPoller:
+					case <-runningChangefeedChan:
 						return nil
-					case <-t.C:
+					case tick := <-t.C:
 						newDest, err := reloadDest(ctx, jobID, execCfg)
 						if err != nil {
 							log.Changefeed.Warningf(ctx, "failed to check for updated configuration: %v", err)
 						} else if newDest != resolvedDest {
 							resolvedDest = newDest
 							return replanErr
 						}
+						if watcher != nil && !diffSent {
+							unchanged, diffs, err := watcher.PopUnchangedUpTo(ctx, hlc.Timestamp{WallTime: tick.UnixNano()})
+							if err != nil {
+								return err
+							}
+							if !unchanged && len(diffs) > 0 {
+								select {
+								case watcherChan <- diffs:
+									diffSent = true
+								case <-ctx.Done():
+									return ctx.Err()
+								}
+							}
+						}
 					}
 				}
 			})

pkg/ccl/changefeedccl/changefeed_test.go

@@ -12933,3 +12933,44 @@ func TestDatabaseLevelChangefeedChangingTableset(t *testing.T) {
 	}
 	cdcTest(t, testFnAddEnriched, withKnobsFn(knobsFn), feedTestForceSink("kafka"))
 }
+
+func TestDatabaseLevelChangefeedEmptyTableset(t *testing.T) {
+	defer leaktest.AfterTest(t)()
+	defer log.Scope(t).Close(t)
+
+	testFnNoWait := func(t *testing.T, s TestServer, f cdctest.TestFeedFactory) {
+		sqlDB := sqlutils.MakeSQLRunner(s.DB)
+		sqlDB.Exec(t, `CREATE DATABASE db`)
+		sqlDB.Exec(t, `GRANT CHANGEFEED ON DATABASE db TO enterprisefeeduser`)
+		dbcf := feed(t, f, `CREATE CHANGEFEED FOR DATABASE db`)
+		defer closeFeed(t, dbcf)
+
+		// create a table
+		sqlDB.Exec(t, `CREATE TABLE db.foo (a INT PRIMARY KEY, b STRING)`)
+		sqlDB.Exec(t, `INSERT INTO db.foo VALUES (0, 'initial')`)
+
+		assertPayloads(t, dbcf, []string{
+			`foo: [0]->{"after": {"a": 0, "b": "initial"}}`,
+		})
+	}
+	cdcTest(t, testFnNoWait, feedTestEnterpriseSinks)
+
+	testFnWait := func(t *testing.T, s TestServer, f cdctest.TestFeedFactory) {
+		sqlDB := sqlutils.MakeSQLRunner(s.DB)
+		sqlDB.Exec(t, `CREATE DATABASE db`)
+		sqlDB.Exec(t, `GRANT CHANGEFEED ON DATABASE db TO enterprisefeeduser`)
+		dbcf := feed(t, f, `CREATE CHANGEFEED FOR DATABASE db`)
+		defer closeFeed(t, dbcf)
+
+		time.Sleep(5 * time.Second)
+
+		// create a table
+		sqlDB.Exec(t, `CREATE TABLE db.foo (a INT PRIMARY KEY, b STRING)`)
+		sqlDB.Exec(t, `INSERT INTO db.foo VALUES (0, 'initial')`)
+
+		assertPayloads(t, dbcf, []string{
+			`foo: [0]->{"after": {"a": 0, "b": "initial"}}`,
+		})
+	}
+	cdcTest(t, testFnWait, feedTestEnterpriseSinks)
+}