chore: import upstream snapshot with attribution

server/ast/revoke.go

@@ -0,0 +1,162 @@
+// Copyright 2023 Dolthub, Inc.
+//
+// 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 ast
+
+import (
+	"github.com/cockroachdb/errors"
+
+	"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
+	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
+
+	"github.com/dolthub/doltgresql/postgres/parser/privilege"
+	"github.com/dolthub/doltgresql/postgres/parser/sem/tree"
+	"github.com/dolthub/doltgresql/server/auth"
+	pgnodes "github.com/dolthub/doltgresql/server/node"
+)
+
+// nodeRevoke handles *tree.Revoke nodes.
+func nodeRevoke(ctx *Context, node *tree.Revoke) (vitess.Statement, error) {
+	if node == nil {
+		return nil, nil
+	}
+	var revokeTable *pgnodes.RevokeTable
+	var revokeSchema *pgnodes.RevokeSchema
+	var revokeDatabase *pgnodes.RevokeDatabase
+	var revokeSequence *pgnodes.RevokeSequence
+	var revokeRoutine *pgnodes.RevokeRoutine
+	switch node.Targets.TargetType {
+	case privilege.Table:
+		tables := make([]doltdb.TableName, len(node.Targets.Tables)+len(node.Targets.InSchema))
+		for i, table := range node.Targets.Tables {
+			normalizedTable, err := table.NormalizeTablePattern()
+			if err != nil {
+				return nil, err
+			}
+			switch normalizedTable := normalizedTable.(type) {
+			case *tree.TableName:
+				if normalizedTable.ExplicitCatalog {
+					return nil, errors.Errorf("revoking privileges from other databases is not yet supported")
+				}
+				tables[i] = doltdb.TableName{
+					Name:   string(normalizedTable.ObjectName),
+					Schema: string(normalizedTable.SchemaName),
+				}
+			case *tree.AllTablesSelector:
+				tables[i] = doltdb.TableName{
+					Name:   "",
+					Schema: string(normalizedTable.SchemaName),
+				}
+			default:
+				return nil, errors.Errorf(`unexpected table type in REVOKE: %T`, normalizedTable)
+			}
+		}
+		for _, schema := range node.Targets.InSchema {
+			tables = append(tables, doltdb.TableName{
+				Name:   "",
+				Schema: schema,
+			})
+		}
+		privileges, err := convertPrivilegeKinds(auth.PrivilegeObject_TABLE, node.Privileges)
+		if err != nil {
+			return nil, err
+		}
+		revokeTable = &pgnodes.RevokeTable{
+			Privileges: privileges,
+			Tables:     tables,
+		}
+	case privilege.Schema:
+		privileges, err := convertPrivilegeKinds(auth.PrivilegeObject_SCHEMA, node.Privileges)
+		if err != nil {
+			return nil, err
+		}
+		revokeSchema = &pgnodes.RevokeSchema{
+			Privileges: privileges,
+			Schemas:    node.Targets.Names,
+		}
+	case privilege.Database:
+		privileges, err := convertPrivilegeKinds(auth.PrivilegeObject_DATABASE, node.Privileges)
+		if err != nil {
+			return nil, err
+		}
+		revokeDatabase = &pgnodes.RevokeDatabase{
+			Privileges: privileges,
+			Databases:  node.Targets.Databases.ToStrings(),
+		}
+	case privilege.Sequence:
+		sequences := make([]auth.SequencePrivilegeKey, 0, len(node.Targets.Sequences)+len(node.Targets.InSchema))
+		for _, seq := range node.Targets.Sequences {
+			sequences = append(sequences, auth.SequencePrivilegeKey{
+				Schema: sequenceSchema(seq),
+				Name:   seq.Parts[0],
+			})
+		}
+		for _, schema := range node.Targets.InSchema {
+			sequences = append(sequences, auth.SequencePrivilegeKey{
+				Schema: schema,
+				Name:   "",
+			})
+		}
+		privileges, err := convertPrivilegeKinds(auth.PrivilegeObject_SEQUENCE, node.Privileges)
+		if err != nil {
+			return nil, err
+		}
+		revokeSequence = &pgnodes.RevokeSequence{
+			Privileges: privileges,
+			Sequences:  sequences,
+		}
+	case privilege.Function, privilege.Procedure, privilege.Routine:
+		routines := make([]auth.RoutinePrivilegeKey, 0, len(node.Targets.Routines)+len(node.Targets.InSchema))
+		for _, r := range node.Targets.Routines {
+			routines = append(routines, auth.RoutinePrivilegeKey{
+				Schema: routineSchema(r.Name),
+				Name:   r.Name.Parts[0],
+				// TODO: there can be 2 routines with the same name but different argument types
+				//  need a fix for getting argument types from parsing CALL statement
+				//ArgTypes: routineArgTypesKey(r.Args),
+			})
+		}
+		for _, schema := range node.Targets.InSchema {
+			routines = append(routines, auth.RoutinePrivilegeKey{
+				Schema: schema,
+				Name:   "",
+			})
+		}
+		privileges, err := convertPrivilegeKinds(auth.PrivilegeObject_FUNCTION, node.Privileges)
+		if err != nil {
+			return nil, err
+		}
+		revokeRoutine = &pgnodes.RevokeRoutine{
+			Privileges: privileges,
+			Routines:   routines,
+		}
+	default:
+		return nil, errors.Errorf("this form of REVOKE is not yet supported")
+	}
+	return vitess.InjectedStatement{
+		Statement: &pgnodes.Revoke{
+			RevokeTable:    revokeTable,
+			RevokeSchema:   revokeSchema,
+			RevokeDatabase: revokeDatabase,
+			RevokeSequence: revokeSequence,
+			RevokeRoutine:  revokeRoutine,
+			RevokeRole:     nil,
+			FromRoles:      node.Grantees,
+			GrantedBy:      node.GrantedBy,
+			GrantOptionFor: node.GrantOptionFor,
+			Cascade:        node.DropBehavior == tree.DropCascade,
+		},
+		Children: nil,
+	}, nil
+}