avoid running queries on the WriteOnly state table

Signed-off-by: Yang Keao <[email protected]>

Author: YangKeao

pkg/ddl/create_table.go

@@ -200,13 +200,20 @@ func createTableWithForeignKeys(jobCtx *jobContext, t *meta.Meta, job *model.Job
 		if err != nil {
 			return ver, errors.Trace(err)
 		}
-		tbInfo.State = model.StateWriteOnly
+		tbInfo.State = model.StateDeleteOnly
 		ver, err = updateVersionAndTableInfo(jobCtx, t, job, tbInfo, true)
 		if err != nil {
 			return ver, errors.Trace(err)
 		}
-		job.SchemaState = model.StateWriteOnly
-	case model.StateWriteOnly:
+		job.SchemaState = model.StateDeleteOnly
+	// The `tblInfo.State` should be transformed from `None/Public` to `DeleteOnly`. In the `DeleteOnly` state, the table cannot be used explicitly
+	// in any SQL statement, but if this table has a `ON DELETE CASCADE` or `ON UPDATE CASCADE`, it'll still be deleted/updated automatically to keep
+	// consistency.
+	//
+	// This branch handles both `StateDeleteOnly` and `StateWriteOnly` to avoid compatibility issues. If the TiDB is upgraded from an old version,
+	// there may be a DDL job in the `StateWriteOnly` state. Now, we handle it in the same way as the `StateDeleteOnly` state. When we believe it's
+	// impossible to upgrade from a too old version to the current version, we can remove the `StateWriteOnly` branch.
+	case model.StateDeleteOnly, model.StateWriteOnly:
 		tbInfo.State = model.StatePublic
 		ver, err = updateVersionAndTableInfo(jobCtx, t, job, tbInfo, true)
 		if err != nil {

pkg/ddl/foreign_key_test.go

@@ -402,3 +402,41 @@ func TestAddForeignKey3(t *testing.T) {
 	tk.MustQuery("select * from t1 order by id").Check(testkit.Rows("1 1", "2 2", "3 3"))
 	tk.MustQuery("select * from t2 order by id").Check(testkit.Rows("1 1", "2 2", "3 3"))
 }
+
+func TestForeignKeyInWriteOnlyMode(t *testing.T) {
+	store := testkit.CreateMockStore(t)
+	tk := testkit.NewTestKit(t, store)
+	tk.MustExec("use test")
+
+	tkDDL := testkit.NewTestKit(t, store)
+	tkDDL.MustExec("use test")
+	tkDDL.MustExec("create table parent (id int key)")
+	tkDDL.MustExec("insert into parent values(1)")
+
+	var notExistErrs []error
+	testfailpoint.EnableCall(t, "github.com/pingcap/tidb/pkg/ddl/onJobRunBefore", func(job *model.Job) {
+		if job.Type == model.ActionCreateTable && job.TableName == "child" {
+			if job.SchemaState == model.StateDeleteOnly {
+				// tk with the latest schema will insert data into child
+				_, err := tk.Exec("insert into child values (1, 1)")
+				notExistErrs = append(notExistErrs, err)
+				_, err = tk.Exec("update child set id = 2 where id = 1")
+				notExistErrs = append(notExistErrs, err)
+				_, err = tk.Exec("delete from child where id = 1")
+				notExistErrs = append(notExistErrs, err)
+				_, err = tk.Exec("delete child from child inner join parent where child.pid = parent.id")
+				notExistErrs = append(notExistErrs, err)
+				_, err = tk.Exec("delete parent from child inner join parent where child.pid = parent.id")
+				notExistErrs = append(notExistErrs, err)
+			}
+		}
+	})
+	tkDDL.MustExec("create table child (id int, pid int, index idx_pid(pid), foreign key (pid) references parent(id) on delete cascade);")
+
+	testfailpoint.Disable(t, "github.com/pingcap/tidb/pkg/ddl/onJobRunBefore")
+
+	for _, err := range notExistErrs {
+		require.Error(t, err)
+		require.Contains(t, err.Error(), "Table 'test.child' doesn't exist")
+	}
+}

pkg/infoschema/perfschema/init.go

@@ -62,6 +62,7 @@ func Init() {
 				c.ID = int64(i) + 1
 			}
 			meta.DBID = dbID
+			meta.State = model.StatePublic
 		}
 		dbInfo := &model.DBInfo{
 			ID:      dbID,

pkg/planner/core/preprocess.go

@@ -1634,6 +1634,10 @@ func (p *preprocessor) handleTableName(tn *ast.TableName) {
 			return
 		}
 	}
+	if err := p.checkTableVisible(tableInfo); err != nil {
+		p.err = err
+		return
+	}
 	p.resolveCtx.AddTableName(&resolve.TableNameW{
 		TableName: tn,
 		DBInfo:    dbInfo,
@@ -1975,3 +1979,20 @@ func (p *preprocessor) skipLockMDL() bool {
 	// skip lock mdl for ANALYZE statement.
 	return p.flag&inImportInto > 0 || p.flag&inAnalyze > 0
 }
+
+// checkTableVisible returns an `ErrTableNotExists` error if the table is not visible (in non-Public state).
+func (p *preprocessor) checkTableVisible(tblInfo *model.TableInfo) error {
+	is := p.ensureInfoSchema()
+
+	if tblInfo.State != model.StatePublic {
+		schemaName := "unknown"
+		schema, ok := infoschema.SchemaByTable(is, tblInfo)
+		if ok {
+			// theoretically, this should always happen
+			schemaName = schema.Name.O
+		}
+		return infoschema.ErrTableNotExists.FastGenByArgs(schemaName, tblInfo.Name.O)
+	}
+
+	return nil
+}