remove unused node

Author: James Cor

sql/plan/revoke.go

@@ -426,76 +426,6 @@ func (n *Revoke) HandleRoutinePrivileges(user *mysql_db.User, dbName string, rou
 	return nil
 }
 
-// RevokeAll represents the statement REVOKE ALL PRIVILEGES.
-type RevokeAll struct {
-	Users []UserName
-}
-
-var _ sql.Node = (*RevokeAll)(nil)
-var _ sql.CollationCoercible = (*RevokeAll)(nil)
-var _ sql.AuthorizationCheckerNode = (*RevokeAll)(nil)
-
-// NewRevokeAll returns a new RevokeAll node.
-func NewRevokeAll(users []UserName) *RevokeAll {
-	return &RevokeAll{
-		Users: users,
-	}
-}
-
-// Schema implements the interface sql.Node.
-func (n *RevokeAll) Schema() sql.Schema {
-	return types.OkResultSchema
-}
-
-func (n *RevokeAll) IsReadOnly() bool {
-	return false
-}
-
-// String implements the interface sql.Node.
-func (n *RevokeAll) String() string {
-	users := make([]string, len(n.Users))
-	for i, user := range n.Users {
-		users[i] = user.String("")
-	}
-	return fmt.Sprintf("RevokeAll(From: %s)", strings.Join(users, ", "))
-}
-
-// Resolved implements the interface sql.Node.
-func (n *RevokeAll) Resolved() bool {
-	return true
-}
-
-// Children implements the interface sql.Node.
-func (n *RevokeAll) Children() []sql.Node {
-	return nil
-}
-
-// WithChildren implements the interface sql.Node.
-func (n *RevokeAll) WithChildren(children ...sql.Node) (sql.Node, error) {
-	if len(children) != 0 {
-		return nil, sql.ErrInvalidChildrenNumber.New(n, len(children), 0)
-	}
-	return n, nil
-}
-
-// CheckAuth implements the interface sql.AuthorizationCheckerNode.
-func (n *RevokeAll) CheckAuth(ctx *sql.Context, opChecker sql.PrivilegedOperationChecker) bool {
-	createUser := sql.NewPrivilegedOperation(sql.PrivilegeCheckSubject{}, sql.PrivilegeType_CreateUser)
-	superUser := sql.NewPrivilegedOperation(sql.PrivilegeCheckSubject{}, sql.PrivilegeType_Super)
-
-	subject := sql.PrivilegeCheckSubject{Database: "mysql"}
-	mysqlUpdate := sql.NewPrivilegedOperation(subject, sql.PrivilegeType_Update)
-
-	return opChecker.UserHasPrivileges(ctx, createUser) ||
-		opChecker.UserHasPrivileges(ctx, superUser) ||
-		opChecker.UserHasPrivileges(ctx, mysqlUpdate)
-}
-
-// CollationCoercibility implements the interface sql.CollationCoercible.
-func (*RevokeAll) CollationCoercibility(ctx *sql.Context) (collation sql.CollationID, coercibility byte) {
-	return sql.Collation_binary, 7
-}
-
 // RevokeRole represents the statement REVOKE [role...] FROM [user...].
 type RevokeRole struct {
 	Roles             []UserName

sql/planbuilder/builder.go

@@ -375,8 +375,6 @@ func (b *Builder) buildSubquery(inScope *scope, stmt ast.Statement, subQuery str
 		return b.buildGrantProxy(inScope, n)
 	case *ast.RevokePrivilege:
 		return b.buildRevokePrivilege(inScope, n)
-	case *ast.RevokeAllPrivileges:
-		return b.buildRevokeAllPrivileges(inScope, n)
 	case *ast.RevokeRole:
 		return b.buildRevokeRole(inScope, n)
 	case *ast.RevokeProxy:

sql/planbuilder/priv.go

@@ -530,16 +530,6 @@ func (b *Builder) buildRevokePrivilege(inScope *scope, n *ast.RevokePrivilege) (
 	return
 }
 
-func (b *Builder) buildRevokeAllPrivileges(inScope *scope, n *ast.RevokeAllPrivileges) (outScope *scope) {
-	outScope = inScope.push()
-	outScope.node = plan.NewRevokeAll(convertAccountName(n.From...))
-	n.Auth.Extra = outScope.node
-	if err := b.cat.AuthorizationHandler().HandleAuth(b.ctx, b.authQueryState, n.Auth); err != nil && b.authEnabled {
-		b.handleErr(err)
-	}
-	return
-}
-
 func (b *Builder) buildRevokeRole(inScope *scope, n *ast.RevokeRole) (outScope *scope) {
 	outScope = inScope.push()
 	outScope.node = &plan.RevokeRole{

sql/rowexec/builder_gen_test.go

@@ -135,7 +135,6 @@ func TestGenBuilder(t *testing.T) {
 		"ResetReplica":              "*plan.ResetReplica",
 		"TableNode":                 "*plan.TableNode",
 		"Revoke":                    "*plan.Revoke",
-		"RevokeAll":                 "*plan.RevokeAll",
 		"RevokeRole":                "*plan.RevokeRole",
 		"RevokeProxy":               "*plan.RevokeProxy",
 		"RowUpdateAccumulator":      "plan.RowUpdateAccumulator",

sql/rowexec/node_builder.gen.go

@@ -198,8 +198,6 @@ func (b *BaseBuilder) buildNodeExecNoAnalyze(ctx *sql.Context, n sql.Node, row s
 		return b.buildAlterPK(ctx, n, row)
 	case plan.Nothing:
 		return b.buildNothing(ctx, n, row)
-	case *plan.RevokeAll:
-		return b.buildRevokeAll(ctx, n, row)
 	case *plan.DeferredAsOfTable:
 		return b.buildDeferredAsOfTable(ctx, n, row)
 	case *plan.CreateUser:

sql/rowexec/priv.go

@@ -291,10 +291,6 @@ func (b *BaseBuilder) buildRevoke(ctx *sql.Context, n *plan.Revoke, row sql.Row)
 	return rowIterWithOkResultWithZeroRowsAffected(), nil
 }
 
-func (b *BaseBuilder) buildRevokeAll(ctx *sql.Context, n *plan.RevokeAll, row sql.Row) (sql.RowIter, error) {
-	return nil, fmt.Errorf("not yet implemented")
-}
-
 func (b *BaseBuilder) buildGrant(ctx *sql.Context, n *plan.Grant, row sql.Row) (sql.RowIter, error) {
 	mysqlDb, ok := n.MySQLDb.(*mysql_db.MySQLDb)
 	if !ok {