Merge branch 'planetscale-fk-verify-update-planning'

Signed-off-by: Harshit Gangal <harshit@planetscale.com>

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

@@ -136,10 +136,11 @@ func TestUpdateWithFK(t *testing.T) {
  utils.Exec(t, conn, `insert into u_t2(id, col2) values (342, 123), (19, 1234)`)
  utils.Exec(t, conn, `insert into u_t3(id, col3) values (32, 123), (1, 12)`)
 
- t.Run("Cascade update with a new value", func(t *testing.T) {
- t.Skip("This doesn't work right now. We are able to only cascade updates for which the data already exists in the parent table")
- _ = utils.Exec(t, conn, `update u_t1 set col1 = 2 where id = 100`)
- })
+ // Cascade update with a new value
+ _ = utils.Exec(t, conn, `update u_t1 set col1 = 2 where id = 100`)
+ // Verify the result in u_t2 and u_t3 as well.
+ utils.AssertMatches(t, conn, `select * from u_t2 order by id`, `[[INT64(19) INT64(1234)] [INT64(342) NULL]]`)
+ utils.AssertMatches(t, conn, `select * from u_t3 order by id`, `[[INT64(1) INT64(12)] [INT64(32) INT64(2)]]`)
 
  // Update u_t1 which has a foreign key constraint to u_t2 with SET NULL type, and to u_t3 with CASCADE type.
  qr = utils.Exec(t, conn, `update u_t1 set col1 = 13 where id = 100`)

go/vt/sqlparser/ast_funcs.go

@@ -2532,3 +2532,14 @@ func (v *visitor) visitAllSelects(in SelectStatement, f func(p *Select, idx int)
  }
  panic("switch should be exhaustive")
 }
+
+func IsNonLiteral(updExprs UpdateExprs) bool {
+ for _, updateExpr := range updExprs {
+ switch updateExpr.Expr.(type) {
+ case *Argument, *NullVal, BoolVal, *Literal:
+ default:
+ return true
+ }
+ }
+ return false
+}

go/vt/vterrors/code.go

@@ -82,7 +82,6 @@ var (
 
  VT12001 = errorWithoutState("VT12001", vtrpcpb.Code_UNIMPLEMENTED, "unsupported: %s", "This statement is unsupported by Vitess. Please rewrite your query to use supported syntax.")
  VT12002 = errorWithoutState("VT12002", vtrpcpb.Code_UNIMPLEMENTED, "unsupported: cross-shard foreign keys", "Vitess does not support cross shard foreign keys.")
- VT12003 = errorWithoutState("VT12002", vtrpcpb.Code_UNIMPLEMENTED, "unsupported: foreign keys management at vitess", "Vitess does not support managing foreign keys tables.")
 
  // VT13001 General Error
  VT13001 = errorWithoutState("VT13001", vtrpcpb.Code_INTERNAL, "[BUG] %s", "This error should not happen and is a bug. Please file an issue on GitHub: https://github.com/vitessio/vitess/issues/new/choose.")
@@ -148,7 +147,6 @@ var (
  VT10001,
  VT12001,
  VT12002,
- VT12003,
  VT13001,
  VT13002,
  VT14001,

go/vt/vtgate/engine/fk_verify.go

@@ -23,28 +23,30 @@ import (
  "vitess.io/vitess/go/sqltypes"
  querypb "vitess.io/vitess/go/vt/proto/query"
  vtrpcpb "vitess.io/vitess/go/vt/proto/vtrpc"
- "vitess.io/vitess/go/vt/sqlparser"
  "vitess.io/vitess/go/vt/vterrors"
 )
 
-// FkParent is a primitive that represents a parent table foreign key constraint to verify against.
-type FkParent struct {
- Values []sqlparser.Exprs
- Cols []CheckCol
- BvName string
-
+// Verify contains the verification primitve and its type i.e. parent or child
+type Verify struct {
  Exec Primitive
+ Typ string
 }
 
 // FkVerify is a primitive that verifies that the foreign key constraints in parent tables are satisfied.
 // It does this by executing a select distinct query on the parent table with the values that are being inserted/updated.
 type FkVerify struct {
- Verify []*FkParent
+ Verify []*Verify
  Exec Primitive
 
  txNeeded
 }
 
+// constants for verification type.
+const (
+ ParentVerify = "VerifyParent"
+ ChildVerify = "VerifyChild"
+)
+
 // RouteType implements the Primitive interface
 func (f *FkVerify) RouteType() string {
  return "FKVerify"
@@ -67,78 +69,30 @@ func (f *FkVerify) GetFields(ctx context.Context, vcursor VCursor, bindVars map[
 
 // TryExecute implements the Primitive interface
 func (f *FkVerify) TryExecute(ctx context.Context, vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool) (*sqltypes.Result, error) {
- for _, fk := range f.Verify {
- pt := newProbeTable(fk.Cols)
- newBv := &querypb.BindVariable{
- Type: querypb.Type_TUPLE,
- }
- for _, exprs := range fk.Values {
- var row sqltypes.Row
- var values []*querypb.Value
- for _, expr := range exprs {
- val, err := getValue(expr, bindVars)
- if err != nil {
- return nil, vterrors.Wrapf(err, "unable to get value for the expression %v", expr)
- }
- row = append(row, val)
- values = append(values, sqltypes.ValueToProto(val))
- }
- if exists, err := pt.exists(row); err != nil {
- return nil, err
- } else if !exists {
- newBv.Values = append(newBv.Values, &querypb.Value{Type: querypb.Type_TUPLE, Values: values})
- }
- }
- distinctValues := len(newBv.Values)
- qr, err := vcursor.ExecutePrimitive(ctx, fk.Exec, map[string]*querypb.BindVariable{fk.BvName: newBv}, wantfields)
+ for _, v := range f.Verify {
+ qr, err := vcursor.ExecutePrimitive(ctx, v.Exec, bindVars, wantfields)
  if err != nil {
  return nil, err
  }
- if distinctValues != len(qr.Rows) {
- return nil, vterrors.NewErrorf(vtrpcpb.Code_FAILED_PRECONDITION, vterrors.NoReferencedRow2, "Cannot add or update a child row: a foreign key constraint fails")
+ if len(qr.Rows) > 0 {
+ return nil, getError(v.Typ)
  }
  }
  return vcursor.ExecutePrimitive(ctx, f.Exec, bindVars, wantfields)
 }
 
 // TryStreamExecute implements the Primitive interface
 func (f *FkVerify) TryStreamExecute(ctx context.Context, vcursor VCursor, bindVars map[string]*querypb.BindVariable, wantfields bool, callback func(*sqltypes.Result) error) error {
- for _, fk := range f.Verify {
- pt := newProbeTable(fk.Cols)
- newBv := &querypb.BindVariable{
- Type: querypb.Type_TUPLE,
- }
- for _, exprs := range fk.Values {
- var row sqltypes.Row
- var values []*querypb.Value
- for _, expr := range exprs {
- val, err := getValue(expr, bindVars)
- if err != nil {
- return vterrors.Wrapf(err, "unable to get value for the expression %v", expr)
- }
- row = append(row, val)
- values = append(values, sqltypes.ValueToProto(val))
+ for _, v := range f.Verify {
+ err := vcursor.StreamExecutePrimitive(ctx, v.Exec, bindVars, wantfields, func(qr *sqltypes.Result) error {
+ if len(qr.Rows) > 0 {
+ return getError(v.Typ)
  }
- if exists, err := pt.exists(row); err != nil {
- return err
- } else if !exists {
- newBv.Values = append(newBv.Values, &querypb.Value{Type: querypb.Type_TUPLE, Values: values})
- }
- }
- distinctValues := len(newBv.Values)
-
- seenRows := 0
- err := vcursor.StreamExecutePrimitive(ctx, fk.Exec, map[string]*querypb.BindVariable{fk.BvName: newBv}, wantfields, func(qr *sqltypes.Result) error {
- seenRows += len(qr.Rows)
  return nil
  })
  if err != nil {
  return err
  }
-
- if distinctValues != seenRows {
- return vterrors.NewErrorf(vtrpcpb.Code_FAILED_PRECONDITION, vterrors.NoReferencedRow2, "Cannot add or update a child row: a foreign key constraint fails")
- }
  }
  return vcursor.StreamExecutePrimitive(ctx, f.Exec, bindVars, wantfields, callback)
 }
@@ -147,17 +101,15 @@ func (f *FkVerify) TryStreamExecute(ctx context.Context, vcursor VCursor, bindVa
 func (f *FkVerify) Inputs() ([]Primitive, []map[string]any) {
  var inputs []Primitive
  var inputsMap []map[string]any
- for idx, parent := range f.Verify {
+ for idx, v := range f.Verify {
  inputsMap = append(inputsMap, map[string]any{
- inputName: fmt.Sprintf("VerifyParent-%d", idx+1),
- "BvName": parent.BvName,
- "Cols": parent.Cols,
+ inputName: fmt.Sprintf("%s-%d", v.Typ, idx+1),
  })
- inputs = append(inputs, parent.Exec)
+ inputs = append(inputs, v.Exec)
  }
  inputs = append(inputs, f.Exec)
  inputsMap = append(inputsMap, map[string]any{
- inputName: "Child",
+ inputName: "PostVerify",
  })
  return inputs, inputsMap
 
@@ -169,24 +121,9 @@ func (f *FkVerify) description() PrimitiveDescription {
 
 var _ Primitive = (*FkVerify)(nil)
 
-func getValue(expr sqlparser.Expr, bindVars map[string]*querypb.BindVariable) (sqltypes.Value, error) {
- switch e := expr.(type) {
- case *sqlparser.Literal:
- return sqlparser.LiteralToValue(e)
- case sqlparser.BoolVal:
- b := int32(0)
- if e {
- b = 1
- }
- return sqltypes.NewInt32(b), nil
- case *sqlparser.NullVal:
- return sqltypes.NULL, nil
- case *sqlparser.Argument:
- bv, exists := bindVars[e.Name]
- if !exists {
- return sqltypes.Value{}, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "[BUG] bind variable %s missing", e.Name)
- }
- return sqltypes.BindVariableToValue(bv)
+func getError(typ string) error {
+ if typ == ParentVerify {
+ return vterrors.NewErrorf(vtrpcpb.Code_FAILED_PRECONDITION, vterrors.NoReferencedRow2, "Cannot add or update a child row: a foreign key constraint fails")
  }
- return sqltypes.Value{}, vterrors.Errorf(vtrpcpb.Code_INTERNAL, "[BUG] unexpected expression type: %T", expr)
+ return vterrors.NewErrorf(vtrpcpb.Code_FAILED_PRECONDITION, vterrors.RowIsReferenced2, "Cannot delete or update a parent row: a foreign key constraint fails")
 }