Merge pull request #940 from jzelinskie/delete-ns-list

datastore: DeleteNamespace => DeleteNamespaces

internal/datastore/crdb/readwrite.go

@@ -250,18 +250,27 @@ func (rwt *crdbReadWriteTXN) WriteNamespaces(ctx context.Context, newConfigs ...
 	return nil
 }
 
-func (rwt *crdbReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) error {
-	_, timestamp, err := loadNamespace(ctx, rwt.tx, nsName)
-	if err != nil {
-		if errors.As(err, &datastore.ErrNamespaceNotFound{}) {
-			return err
+func (rwt *crdbReadWriteTXN) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
+	// For each namespace, check they exist and collect predicates for the
+	// "WHERE" clause to delete the namespaces and associated tuples.
+	nsClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	tplClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	for _, nsName := range nsNames {
+		_, timestamp, err := loadNamespace(ctx, rwt.tx, nsName)
+		if err != nil {
+			if errors.As(err, &datastore.ErrNamespaceNotFound{}) {
+				return err
+			}
+			return fmt.Errorf(errUnableToDeleteConfig, err)
+		}
+
+		for _, nsName := range nsNames {
+			nsClauses = append(nsClauses, sq.Eq{colNamespace: nsName, colTimestamp: timestamp})
+			tplClauses = append(tplClauses, sq.Eq{colNamespace: nsName})
 		}
-		return fmt.Errorf(errUnableToDeleteConfig, err)
 	}
 
-	delSQL, delArgs, err := queryDeleteNamespace.
-		Where(sq.Eq{colNamespace: nsName, colTimestamp: timestamp}).
-		ToSql()
+	delSQL, delArgs, err := queryDeleteNamespace.Where(sq.Or(nsClauses)).ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)
 	}
@@ -271,9 +280,7 @@ func (rwt *crdbReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string)
 		return fmt.Errorf(errUnableToDeleteConfig, err)
 	}
 
-	deleteTupleSQL, deleteTupleArgs, err := queryDeleteTuples.
-		Where(sq.Eq{colNamespace: nsName}).
-		ToSql()
+	deleteTupleSQL, deleteTupleArgs, err := queryDeleteTuples.Where(sq.Or(tplClauses)).ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)
 	}

internal/datastore/memdb/readwrite.go

@@ -164,7 +164,7 @@ func (rwt *memdbReadWriteTx) WriteNamespaces(ctx context.Context, newConfigs ...
 	return nil
 }
 
-func (rwt *memdbReadWriteTx) DeleteNamespace(ctx context.Context, nsName string) error {
+func (rwt *memdbReadWriteTx) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
 	rwt.lockOrPanic()
 	defer rwt.Unlock()
 
@@ -173,24 +173,26 @@ func (rwt *memdbReadWriteTx) DeleteNamespace(ctx context.Context, nsName string)
 		return err
 	}
 
-	foundRaw, err := tx.First(tableNamespace, indexID, nsName)
-	if err != nil {
-		return err
-	}
+	for _, nsName := range nsNames {
+		foundRaw, err := tx.First(tableNamespace, indexID, nsName)
+		if err != nil {
+			return err
+		}
 
-	if foundRaw == nil {
-		return fmt.Errorf("unable to find namespace to delete")
-	}
+		if foundRaw == nil {
+			return fmt.Errorf("unable to find namespace to delete")
+		}
 
-	if err := tx.Delete(tableNamespace, foundRaw); err != nil {
-		return err
-	}
+		if err := tx.Delete(tableNamespace, foundRaw); err != nil {
+			return err
+		}
 
-	// Delete the relationships from the namespace
-	if err := rwt.deleteWithLock(tx, &v1.RelationshipFilter{
-		ResourceType: nsName,
-	}); err != nil {
-		return fmt.Errorf("unable to delete relationships from deleted namespace: %w", err)
+		// Delete the relationships from the namespace
+		if err := rwt.deleteWithLock(tx, &v1.RelationshipFilter{
+			ResourceType: nsName,
+		}); err != nil {
+			return fmt.Errorf("unable to delete relationships from deleted namespace: %w", err)
+		}
 	}
 
 	return nil

internal/datastore/mysql/readwrite.go

@@ -234,23 +234,34 @@ func (rwt *mysqlReadWriteTXN) WriteNamespaces(ctx context.Context, newNamespaces
 	return nil
 }
 
-func (rwt *mysqlReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) error {
+func (rwt *mysqlReadWriteTXN) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
 	// TODO (@vroldanbet) dupe from postgres datastore - need to refactor
 
-	baseQuery := rwt.ReadNamespaceQuery.Where(sq.Eq{colDeletedTxn: liveDeletedTxnID})
-	_, createdAt, err := loadNamespace(ctx, nsName, rwt.tx, baseQuery)
-	switch {
-	case errors.As(err, &datastore.ErrNamespaceNotFound{}):
-		return err
-	case err == nil:
-		break
-	default:
-		return fmt.Errorf(errUnableToDeleteConfig, err)
+	// For each namespace, check they exist and collect predicates for the
+	// "WHERE" clause to delete the namespaces and associated tuples.
+	nsClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	tplClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	for _, nsName := range nsNames {
+		// TODO(jzelinskie): check these in one query
+		baseQuery := rwt.ReadNamespaceQuery.Where(sq.Eq{colDeletedTxn: liveDeletedTxnID})
+		_, createdAt, err := loadNamespace(ctx, nsName, rwt.tx, baseQuery)
+		switch {
+		case errors.As(err, &datastore.ErrNamespaceNotFound{}):
+			// TODO(jzelinskie): return the name of the missing namespace
+			return err
+		case err == nil:
+			break
+		default:
+			return fmt.Errorf(errUnableToDeleteConfig, err)
+		}
+
+		nsClauses = append(nsClauses, sq.Eq{colNamespace: nsName, colCreatedTxn: createdAt})
+		tplClauses = append(tplClauses, sq.Eq{colNamespace: nsName})
 	}
 
 	delSQL, delArgs, err := rwt.DeleteNamespaceQuery.
 		Set(colDeletedTxn, rwt.newTxnID).
-		Where(sq.Eq{colNamespace: nsName, colCreatedTxn: createdAt}).
+		Where(sq.Or(nsClauses)).
 		ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)
@@ -263,7 +274,7 @@ func (rwt *mysqlReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string
 
 	deleteTupleSQL, deleteTupleArgs, err := rwt.DeleteNamespaceTuplesQuery.
 		Set(colDeletedTxn, rwt.newTxnID).
-		Where(sq.Eq{colNamespace: nsName}).
+		Where(sq.Or(tplClauses)).
 		ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)

internal/datastore/postgres/postgres_test.go

@@ -887,7 +887,7 @@ func XIDMigrationAssumptionsTest(t *testing.T, b testdatastore.RunningEngineForT
 			ResourceType: "one_namespace",
 		}))
 
-		require.NoError(rwt.DeleteNamespace(ctx, "one_namespace"))
+		require.NoError(rwt.DeleteNamespaces(ctx, "one_namespace"))
 
 		require.NoError(rwt.WriteNamespaces(ctx, namespace.Namespace(
 			"three_namespace", namespace.Relation("parent", nil, nil))))
@@ -955,7 +955,7 @@ func XIDMigrationAssumptionsTest(t *testing.T, b testdatastore.RunningEngineForT
 			ResourceType: "two_namespace",
 		}))
 
-		require.NoError(rwt.DeleteNamespace(ctx, "two_namespace"))
+		require.NoError(rwt.DeleteNamespaces(ctx, "two_namespace"))
 
 		require.NoError(rwt.WriteNamespaces(ctx, namespace.Namespace(
 			"four_namespace", namespace.Relation("parent", nil, nil))))
@@ -1022,7 +1022,7 @@ func XIDMigrationAssumptionsTest(t *testing.T, b testdatastore.RunningEngineForT
 			ResourceType: "three_namespace",
 		}))
 
-		require.NoError(rwt.DeleteNamespace(ctx, "three_namespace"))
+		require.NoError(rwt.DeleteNamespaces(ctx, "three_namespace"))
 
 		require.NoError(rwt.WriteNamespaces(ctx, namespace.Namespace(
 			"five_namespace", namespace.Relation("parent", nil, nil))))

internal/datastore/postgres/readwrite.go

@@ -292,7 +292,7 @@ func (rwt *pgReadWriteTXN) WriteNamespaces(ctx context.Context, newConfigs ...*c
 	return nil
 }
 
-func (rwt *pgReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) error {
+func (rwt *pgReadWriteTXN) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
 	filterer := func(original sq.SelectBuilder) sq.SelectBuilder {
 		return original.Where(sq.Eq{colDeletedXid: liveDeletedTxnID})
 	}
@@ -304,35 +304,46 @@ func (rwt *pgReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) e
 		}
 	}
 
-	_, createdAt, err := rwt.loadNamespace(ctx, nsName, rwt.tx, filterer)
-	switch {
-	case errors.As(err, &datastore.ErrNamespaceNotFound{}):
-		return err
-	case err == nil:
-		break
-	default:
-		return fmt.Errorf(errUnableToDeleteConfig, err)
+	nsClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	tplClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	migrationClauses := make([]sq.Sqlizer, 0, len(nsNames))
+	for _, nsName := range nsNames {
+		_, createdAt, err := rwt.loadNamespace(ctx, nsName, rwt.tx, filterer)
+		switch {
+		case errors.As(err, &datastore.ErrNamespaceNotFound{}):
+			return err
+		case err == nil:
+			break
+		default:
+			return fmt.Errorf(errUnableToDeleteConfig, err)
+		}
+
+		nsClauses = append(nsClauses, sq.Eq{colNamespace: nsName, colCreatedXid: createdAt.tx})
+		tplClauses = append(tplClauses, sq.Eq{colNamespace: nsName})
+
+		// TODO remove once the ID->XID migrations are all complete
+		switch rwt.migrationPhase {
+		case writeBothReadOld:
+			migrationClauses = append(migrationClauses, sq.Eq{colNamespace: nsName, colCreatedTxnDeprecated: createdAt.tx.Uint})
+		case writeBothReadNew:
+			migrationClauses = nsClauses
+		}
 	}
 
 	delSQL, delArgs, err := deleteNamespace.
 		Set(colDeletedXid, rwt.newXID).
-		Where(sq.Eq{colNamespace: nsName, colCreatedXid: createdAt.tx}).
+		Where(sq.Or(nsClauses)).
 		ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)
 	}
 
 	// TODO remove once the ID->XID migrations are all complete
 	if rwt.migrationPhase == writeBothReadNew || rwt.migrationPhase == writeBothReadOld {
-		whereClause := sq.Eq{colNamespace: nsName, colCreatedXid: createdAt.tx}
-		if rwt.migrationPhase == writeBothReadOld {
-			whereClause = sq.Eq{colNamespace: nsName, colCreatedTxnDeprecated: createdAt.tx.Uint}
-		}
-
 		delSQL, delArgs, err = deleteNamespace.
 			Set(colDeletedTxnDeprecated, rwt.newXID.Uint).
 			Set(colDeletedXid, rwt.newXID).
-			Where(whereClause).
+			Where(sq.Or(migrationClauses)).
 			ToSql()
 		if err != nil {
 			return fmt.Errorf(errUnableToDeleteConfig, err)
@@ -346,7 +357,7 @@ func (rwt *pgReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) e
 
 	deleteTupleSQL, deleteTupleArgs, err := deleteNamespaceTuples.
 		Set(colDeletedXid, rwt.newXID).
-		Where(sq.Eq{colNamespace: nsName}).
+		Where(sq.Or(tplClauses)).
 		ToSql()
 	if err != nil {
 		return fmt.Errorf(errUnableToDeleteConfig, err)
@@ -357,7 +368,7 @@ func (rwt *pgReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) e
 		deleteTupleSQL, deleteTupleArgs, err = deleteNamespaceTuples.
 			Set(colDeletedTxnDeprecated, rwt.newXID.Uint).
 			Set(colDeletedXid, rwt.newXID).
-			Where(sq.Eq{colNamespace: nsName}).
+			Where(sq.Or(tplClauses)).
 			ToSql()
 		if err != nil {
 			return fmt.Errorf(errUnableToDeleteConfig, err)

internal/datastore/proxy/observable.go

@@ -251,14 +251,14 @@ func (rwt *observableRWT) WriteNamespaces(ctx context.Context, newConfigs ...*co
 	return rwt.delegate.WriteNamespaces(ctx, newConfigs...)
 }
 
-func (rwt *observableRWT) DeleteNamespace(ctx context.Context, nsName string) error {
+func (rwt *observableRWT) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
 	var span trace.Span
 	ctx, span = tracer.Start(ctx, "DeleteNamespace", trace.WithAttributes(
-		attribute.String("name", nsName),
+		attribute.StringSlice("names", nsNames),
 	))
 	defer span.End()
 
-	return rwt.delegate.DeleteNamespace(ctx, nsName)
+	return rwt.delegate.DeleteNamespaces(ctx, nsNames...)
 }
 
 func (rwt *observableRWT) DeleteRelationships(ctx context.Context, filter *v1.RelationshipFilter) error {

internal/datastore/proxy/proxy_test/mock.go

@@ -240,8 +240,13 @@ func (dm *MockReadWriteTransaction) WriteNamespaces(ctx context.Context, newConf
 	return args.Error(0)
 }
 
-func (dm *MockReadWriteTransaction) DeleteNamespace(ctx context.Context, nsName string) error {
-	args := dm.Called(nsName)
+func (dm *MockReadWriteTransaction) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
+	xs := make([]any, 0, len(nsNames))
+	for _, nsName := range nsNames {
+		xs = append(xs, nsName)
+	}
+
+	args := dm.Called(xs...)
 	return args.Error(0)
 }
 

internal/datastore/proxy/readonly_test.go

@@ -35,7 +35,7 @@ func TestRWOperationErrors(t *testing.T) {
 	ctx := context.Background()
 
 	rev, err := ds.ReadWriteTx(ctx, func(rwt datastore.ReadWriteTransaction) error {
-		return rwt.DeleteNamespace(ctx, "fake")
+		return rwt.DeleteNamespaces(ctx, "fake")
 	})
 	require.ErrorAs(err, &datastore.ErrReadOnly{})
 	require.Equal(datastore.NoRevision, rev)

internal/datastore/spanner/readwrite.go

@@ -238,21 +238,23 @@ func (rwt spannerReadWriteTXN) WriteNamespaces(ctx context.Context, newConfigs .
 	return rwt.spannerRWT.BufferWrite(mutations)
 }
 
-func (rwt spannerReadWriteTXN) DeleteNamespace(ctx context.Context, nsName string) error {
-	if err := deleteWithFilter(ctx, rwt.spannerRWT, &v1.RelationshipFilter{
-		ResourceType: nsName,
-	}); err != nil {
-		return fmt.Errorf(errUnableToDeleteConfig, err)
-	}
+func (rwt spannerReadWriteTXN) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
+	for _, nsName := range nsNames {
+		if err := deleteWithFilter(ctx, rwt.spannerRWT, &v1.RelationshipFilter{
+			ResourceType: nsName,
+		}); err != nil {
+			return fmt.Errorf(errUnableToDeleteConfig, err)
+		}
 
-	err := rwt.spannerRWT.BufferWrite([]*spanner.Mutation{
-		spanner.Delete(tableNamespace, spanner.KeySetFromKeys(spanner.Key{nsName})),
-	})
-	if err != nil {
-		return fmt.Errorf(errUnableToDeleteConfig, err)
+		err := rwt.spannerRWT.BufferWrite([]*spanner.Mutation{
+			spanner.Delete(tableNamespace, spanner.KeySetFromKeys(spanner.Key{nsName})),
+		})
+		if err != nil {
+			return fmt.Errorf(errUnableToDeleteConfig, err)
+		}
 	}
 
-	return err
+	return nil
 }
 
 var _ datastore.ReadWriteTransaction = spannerReadWriteTXN{}

internal/services/v1/schema.go

@@ -214,10 +214,10 @@ func (ss *schemaServer) WriteSchema(ctx context.Context, in *v1.WriteSchemaReque
 		})
 
 		// Delete the removed namespaces.
-		if err := removedObjectDefNames.ForEach(func(value string) error {
-			return rwt.DeleteNamespace(ctx, value)
-		}); err != nil {
-			return err
+		if removedObjectDefNames.Len() > 0 {
+			if err := rwt.DeleteNamespaces(ctx, removedObjectDefNames.AsSlice()...); err != nil {
+				return err
+			}
 		}
 
 		// Delete the removed caveats.

internal/services/v1alpha1/schema_test.go

@@ -263,7 +263,7 @@ func TestSchemaReadDeleteAndFailWrite(t *testing.T) {
 	// Issue a delete out of band for the namespace.
 	_, err = ds.ReadWriteTx(ctx, func(rwt datastore.ReadWriteTransaction) error {
 		for _, nsName := range requestedObjectDefNames {
-			derr := rwt.DeleteNamespace(ctx, nsName)
+			derr := rwt.DeleteNamespaces(ctx, nsName)
 			if derr != nil {
 				return derr
 			}

internal/testfixtures/validating.go

@@ -167,8 +167,8 @@ func (vrwt validatingReadWriteTransaction) WriteNamespaces(ctx context.Context,
 	return vrwt.delegate.WriteNamespaces(ctx, newConfigs...)
 }
 
-func (vrwt validatingReadWriteTransaction) DeleteNamespace(ctx context.Context, nsName string) error {
-	return vrwt.delegate.DeleteNamespace(ctx, nsName)
+func (vrwt validatingReadWriteTransaction) DeleteNamespaces(ctx context.Context, nsNames ...string) error {
+	return vrwt.delegate.DeleteNamespaces(ctx, nsNames...)
 }
 
 func (vrwt validatingReadWriteTransaction) WriteRelationships(ctx context.Context, mutations []*core.RelationTupleUpdate) error {

pkg/datastore/datastore.go

@@ -188,8 +188,8 @@ type ReadWriteTransaction interface {
 	// WriteNamespaces takes proto namespace definitions and persists them.
 	WriteNamespaces(ctx context.Context, newConfigs ...*core.NamespaceDefinition) error
 
-	// DeleteNamespace deletes a namespace and any associated tuples.
-	DeleteNamespace(ctx context.Context, nsName string) error
+	// DeleteNamespaces deletes namespaces including associated relationships.
+	DeleteNamespaces(ctx context.Context, nsNames ...string) error
 }
 
 // TxUserFunc is a type for the function that users supply when they invoke a read-write transaction.