Add cycle detection for foreign keys (#14339)

Signed-off-by: Manan Gupta <manan@planetscale.com>

go/test/endtoend/utils/utils.go

@@ -253,6 +253,33 @@ func WaitForAuthoritative(t *testing.T, ks, tbl string, readVSchema func() (*int
  }
 }
 
+// WaitForKsError waits for the ks error field to be populated and returns it.
+func WaitForKsError(t *testing.T, vtgateProcess cluster.VtgateProcess, ks string) string {
+ timeout := time.After(60 * time.Second)
+ for {
+ select {
+ case <-timeout:
+ t.Fatalf("schema tracking did not find error in '%s'", ks)
+ return ""
+ default:
+ time.Sleep(1 * time.Second)
+ res, err := vtgateProcess.ReadVSchema()
+ require.NoError(t, err, res)
+ kss := convertToMap(*res)["keyspaces"]
+ ksMap := convertToMap(convertToMap(kss)[ks])
+ ksErr, fieldPresent := ksMap["error"]
+ if !fieldPresent {
+ break
+ }
+ errString, isErr := ksErr.(string)
+ if !isErr {
+ break
+ }
+ return errString
+ }
+ }
+}
+
 // WaitForColumn waits for a table's column to be present
 func WaitForColumn(t *testing.T, vtgateProcess cluster.VtgateProcess, ks, tbl, col string) error {
  timeout := time.After(60 * time.Second)

go/test/endtoend/vtgate/foreignkey/fk_test.go

@@ -774,3 +774,26 @@ func TestFkScenarios(t *testing.T) {
  })
  }
 }
+
+func TestCyclicFks(t *testing.T) {
+ mcmp, closer := start(t)
+ defer closer()
+ _ = utils.Exec(t, mcmp.VtConn, "use `uks`")
+
+ // Create a cyclic foreign key constraint.
+ utils.Exec(t, mcmp.VtConn, "alter table fk_t10 add constraint test_cyclic_fks foreign key (col) references fk_t12 (col) on delete cascade on update cascade")
+ defer func() {
+ utils.Exec(t, mcmp.VtConn, "alter table fk_t10 drop foreign key test_cyclic_fks")
+ }()
+
+ // Wait for schema-tracking to be complete.
+ ksErr := utils.WaitForKsError(t, clusterInstance.VtgateProcess, unshardedKs)
+ // Make sure Vschema has the error for cyclic foreign keys.
+ assert.Contains(t, ksErr, "VT09019: uks has cyclic foreign keys")
+
+ // Ensure that the Vitess database is originally empty
+ ensureDatabaseState(t, mcmp.VtConn, true)
+
+ _, err := utils.ExecAllowError(t, mcmp.VtConn, "insert into fk_t10(id, col) values (1, 1)")
+ require.ErrorContains(t, err, "VT09019: uks has cyclic foreign keys")
+}

go/test/vschemawrapper/vschema_wrapper.go

@@ -136,6 +136,10 @@ func (vw *VSchemaWrapper) ForeignKeyMode(keyspace string) (vschemapb.Keyspace_Fo
  return defaultFkMode, nil
 }
 
+func (vw *VSchemaWrapper) KeyspaceError(keyspace string) error {
+ return nil
+}
+
 func (vw *VSchemaWrapper) AllKeyspace() ([]*vindexes.Keyspace, error) {
  if vw.Keyspace == nil {
  return nil, vterrors.VT13001("keyspace not available")

go/vt/graph/graph.go

@@ -0,0 +1,119 @@
+/*
+Copyright 2023 The Vitess Authors.
+
+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 graph
+
+import (
+ "fmt"
+ "slices"
+ "strings"
+)
+
+// Graph is a generic graph implementation.
+type Graph[C comparable] struct {
+ edges map[C][]C
+}
+
+// NewGraph creates a new graph for the given comparable type.
+func NewGraph[C comparable]() *Graph[C] {
+ return &Graph[C]{
+ edges: map[C][]C{},
+ }
+}
+
+// AddVertex adds a vertex to the given Graph.
+func (gr *Graph[C]) AddVertex(vertex C) {
+ _, alreadyExists := gr.edges[vertex]
+ if alreadyExists {
+ return
+ }
+ gr.edges[vertex] = []C{}
+}
+
+// AddEdge adds an edge to the given Graph.
+// It also makes sure that the vertices are added to the graph if not already present.
+func (gr *Graph[C]) AddEdge(start C, end C) {
+ gr.AddVertex(start)
+ gr.AddVertex(end)
+ gr.edges[start] = append(gr.edges[start], end)
+}
+
+// PrintGraph is used to print the graph. This is only used for testing.
+func (gr *Graph[C]) PrintGraph() string {
+ adjacencyLists := []string{}
+ for vertex, edges := range gr.edges {
+ adjacencyList := fmt.Sprintf("%v -", vertex)
+ for _, end := range edges {
+ adjacencyList += fmt.Sprintf(" %v", end)
+ }
+ adjacencyLists = append(adjacencyLists, adjacencyList)
+ }
+ slices.Sort(adjacencyLists)
+ return strings.Join(adjacencyLists, "\n")
+}
+
+// Empty checks whether the graph is empty or not.
+func (gr *Graph[C]) Empty() bool {
+ return len(gr.edges) == 0
+}
+
+// HasCycles checks whether the given graph has a cycle or not.
+// We are using a well-known DFS based colouring algorithm to check for cycles.
+// Look at https://cp-algorithms.com/graph/finding-cycle.html for more details on the algorithm.
+func (gr *Graph[C]) HasCycles() bool {
+ // If the graph is empty, then we don't need to check anything.
+ if gr.Empty() {
+ return false
+ }
+ // Initialize the coloring map.
+ // 0 represents white.
+ // 1 represents grey.
+ // 2 represents black.
+ color := map[C]int{}
+ for vertex := range gr.edges {
+ // If any vertex is still white, we initiate a new DFS.
+ if color[vertex] == 0 {
+ if gr.hasCyclesDfs(color, vertex) {
+ return true
+ }
+ }
+ }
+ return false
+}
+
+// hasCyclesDfs is a utility function for checking for cycles in a graph.
+// It runs a dfs from the given vertex marking each vertex as grey. During the dfs,
+// if we encounter a grey vertex, we know we have a cycle. We mark the visited vertices black
+// on finishing the dfs.
+func (gr *Graph[C]) hasCyclesDfs(color map[C]int, vertex C) bool {
+ // Mark the vertex grey.
+ color[vertex] = 1
+ // Go over all the edges.
+ for _, end := range gr.edges[vertex] {
+ // If we encounter a white vertex, we continue the dfs.
+ if color[end] == 0 {
+ if gr.hasCyclesDfs(color, end) {
+ return true
+ }
+ } else if color[end] == 1 {
+ // We encountered a grey vertex, we have a cycle.
+ return true
+ }
+ }
+ // Mark the vertex black before finishing
+ color[vertex] = 2
+ return false
+}

go/vt/graph/graph_test.go

@@ -0,0 +1,153 @@
+/*
+Copyright 2023 The Vitess Authors.
+
+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 graph
+
+import (
+ "testing"
+
+ "github.com/stretchr/testify/require"
+)
+
+// TestIntegerGraph tests that a graph with Integers can be created and all graph functions work as intended.
+func TestIntegerGraph(t *testing.T) {
+ testcases := []struct {
+ name string
+ edges [][2]int
+ wantedGraph string
+ wantEmpty bool
+ wantHasCycles bool
+ }{
+ {
+ name: "empty graph",
+ edges: nil,
+ wantedGraph: "",
+ wantEmpty: true,
+ wantHasCycles: false,
+ }, {
+ name: "non-cyclic graph",
+ edges: [][2]int{
+ {1, 2},
+ {2, 3},
+ {1, 4},
+ {2, 5},
+ {4, 5},
+ },
+ wantedGraph: `1 - 2 4
+2 - 3 5
+3 -
+4 - 5
+5 -`,
+ wantEmpty: false,
+ wantHasCycles: false,
+ }, {
+ name: "cyclic graph",
+ edges: [][2]int{
+ {1, 2},
+ {2, 3},
+ {1, 4},
+ {2, 5},
+ {4, 5},
+ {5, 6},
+ {6, 1},
+ },
+ wantedGraph: `1 - 2 4
+2 - 3 5
+3 -
+4 - 5
+5 - 6
+6 - 1`,
+ wantEmpty: false,
+ wantHasCycles: true,
+ },
+ }
+ for _, tt := range testcases {
+ t.Run(tt.name, func(t *testing.T) {
+ graph := NewGraph[int]()
+ for _, edge := range tt.edges {
+ graph.AddEdge(edge[0], edge[1])
+ }
+ require.Equal(t, tt.wantedGraph, graph.PrintGraph())
+ require.Equal(t, tt.wantEmpty, graph.Empty())
+ require.Equal(t, tt.wantHasCycles, graph.HasCycles())
+ })
+ }
+}
+
+// TestStringGraph tests that a graph with strings can be created and all graph functions work as intended.
+func TestStringGraph(t *testing.T) {
+ testcases := []struct {
+ name string
+ edges [][2]string
+ wantedGraph string
+ wantEmpty bool
+ wantHasCycles bool
+ }{
+ {
+ name: "empty graph",
+ edges: nil,
+ wantedGraph: "",
+ wantEmpty: true,
+ wantHasCycles: false,
+ }, {
+ name: "non-cyclic graph",
+ edges: [][2]string{
+ {"A", "B"},
+ {"B", "C"},
+ {"A", "D"},
+ {"B", "E"},
+ {"D", "E"},
+ },
+ wantedGraph: `A - B D
+B - C E
+C -
+D - E
+E -`,
+ wantEmpty: false,
+ wantHasCycles: false,
+ }, {
+ name: "cyclic graph",
+ edges: [][2]string{
+ {"A", "B"},
+ {"B", "C"},
+ {"A", "D"},
+ {"B", "E"},
+ {"D", "E"},
+ {"E", "F"},
+ {"F", "A"},
+ },
+ wantedGraph: `A - B D
+B - C E
+C -
+D - E
+E - F
+F - A`,
+ wantEmpty: false,
+ wantHasCycles: true,
+ },
+ }
+ for _, tt := range testcases {
+ t.Run(tt.name, func(t *testing.T) {
+ graph := NewGraph[string]()
+ for _, edge := range tt.edges {
+ graph.AddEdge(edge[0], edge[1])
+ }
+ require.Equal(t, tt.wantedGraph, graph.PrintGraph())
+ require.Equal(t, tt.wantEmpty, graph.Empty())
+ require.Equal(t, tt.wantHasCycles, graph.HasCycles())
+ })
+ }
+}

go/vt/schemadiff/semantics.go

@@ -60,6 +60,10 @@ func (si *declarativeSchemaInformation) ForeignKeyMode(keyspace string) (vschema
  return vschemapb.Keyspace_unmanaged, nil
 }
 
+func (si *declarativeSchemaInformation) KeyspaceError(keyspace string) error {
+ return nil
+}
+
 // addTable adds a fake table with an empty column list
 func (si *declarativeSchemaInformation) addTable(tableName string) {
  tbl := &vindexes.Table{

go/vt/vterrors/code.go

@@ -79,7 +79,8 @@ var (
  VT09015 = errorWithoutState("VT09015", vtrpcpb.Code_FAILED_PRECONDITION, "schema tracking required", "This query cannot be planned without more information on the SQL schema. Please turn on schema tracking or add authoritative columns information to your VSchema.")
  VT09016 = errorWithState("VT09016", vtrpcpb.Code_FAILED_PRECONDITION, RowIsReferenced2, "Cannot delete or update a parent row: a foreign key constraint fails", "SET DEFAULT is not supported by InnoDB")
  VT09017 = errorWithoutState("VT09017", vtrpcpb.Code_FAILED_PRECONDITION, "%s", "Invalid syntax for the statement type.")
- VT09018 = errorWithoutState("VT09017", vtrpcpb.Code_FAILED_PRECONDITION, "%s", "Invalid syntax for the vindex function statement.")
+ VT09018 = errorWithoutState("VT09018", vtrpcpb.Code_FAILED_PRECONDITION, "%s", "Invalid syntax for the vindex function statement.")
+ VT09019 = errorWithoutState("VT09019", vtrpcpb.Code_FAILED_PRECONDITION, "%s has cyclic foreign keys", "Vitess doesn't support cyclic foreign keys.")
 
  VT10001 = errorWithoutState("VT10001", vtrpcpb.Code_ABORTED, "foreign key constraints are not allowed", "Foreign key constraints are not allowed, see https://vitess.io/blog/2021-06-15-online-ddl-why-no-fk/.")
 

go/vt/vtgate/planbuilder/plancontext/vschema.go

@@ -57,6 +57,9 @@ type VSchema interface {
  // ForeignKeyMode returns the foreign_key flag value
  ForeignKeyMode(keyspace string) (vschemapb.Keyspace_ForeignKeyMode, error)
 
+ // KeyspaceError returns any error in the keyspace vschema.
+ KeyspaceError(keyspace string) error
+
  // GetVSchema returns the latest cached vindexes.VSchema
  GetVSchema() *vindexes.VSchema