Merge pull request #863 from dolthub/daylon/user-db

Added GRANT, REVOKE, Privilege Checking, Ownership, and persisting changes

Author: Hydrocharged

server/analyzer/drop_table.go

@@ -0,0 +1,33 @@
+// Copyright 2024 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 analyzer
+
+import (
+	"github.com/dolthub/go-mysql-server/sql"
+	"github.com/dolthub/go-mysql-server/sql/analyzer"
+	"github.com/dolthub/go-mysql-server/sql/plan"
+	"github.com/dolthub/go-mysql-server/sql/transform"
+
+	pgnodes "github.com/dolthub/doltgresql/server/node"
+)
+
+// ReplaceDropTable wraps a DropTable node so that it can handle ownership information.
+func ReplaceDropTable(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope *plan.Scope, selector analyzer.RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
+	dropTable, ok := node.(*plan.DropTable)
+	if !ok {
+		return node, transform.SameTree, nil
+	}
+	return pgnodes.NewDropTable(dropTable), transform.NewTree, nil
+}

server/analyzer/handle_disjointed_nodes.go

@@ -20,21 +20,22 @@ import (
 	"github.com/dolthub/go-mysql-server/sql/analyzer"
 )
 
+// IDs are basically arbitrary, we just need to ensure that they do not conflict with existing IDs
 const (
 	ruleId_TypeSanitizer analyzer.RuleId = iota + 1000
 	ruleId_AddDomainConstraints
 	ruleId_AssignInsertCasts
 	ruleId_AssignUpdateCasts
 	ruleId_ReplaceIndexedTables
 	ruleId_ReplaceSerial
+	ruleId_ReplaceDropTable
 	ruleId_AddImplicitPrefixLengths
 	ruleId_InsertContextRootFinalizer
 	ruleId_ResolveType
 )
 
 // Init adds additional rules to the analyzer to handle Doltgres-specific functionality.
 func Init() {
-	// IDs are basically arbitrary, we just need to ensure that they do not conflict with existing IDs
 	analyzer.AlwaysBeforeDefault = append(analyzer.AlwaysBeforeDefault,
 		analyzer.Rule{Id: ruleId_ResolveType, Apply: ResolveType},
 		analyzer.Rule{Id: ruleId_TypeSanitizer, Apply: TypeSanitizer},
@@ -57,6 +58,7 @@ func Init() {
 
 	analyzer.OnceAfterDefault = append(analyzer.OnceAfterDefault,
 		analyzer.Rule{Id: ruleId_ReplaceSerial, Apply: ReplaceSerial},
+		analyzer.Rule{Id: ruleId_ReplaceDropTable, Apply: ReplaceDropTable},
 	)
 
 	// The auto-commit rule writes the contents of the context, so we need to insert our finalizer before that

server/analyzer/init.go

@@ -121,8 +121,5 @@ func ReplaceSerial(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope
 			}
 		}
 	}
-	if len(ctSequences) == 0 {
-		return node, transform.SameTree, nil
-	}
 	return pgnodes.NewCreateTable(createTable, ctSequences), transform.NewTree, nil
 }

server/analyzer/serial.go

@@ -30,23 +30,15 @@ import (
 
 	pgexprs "github.com/dolthub/doltgresql/server/expression"
 	"github.com/dolthub/doltgresql/server/functions/framework"
+	pgtransform "github.com/dolthub/doltgresql/server/transform"
 	pgtypes "github.com/dolthub/doltgresql/server/types"
 )
 
 // TypeSanitizer converts all GMS types into Doltgres types. Some places, such as parameter binding, will always default
 // to GMS types, so by taking care of all conversions here, we can ensure that Doltgres only needs to worry about its
 // own types.
 func TypeSanitizer(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope *plan.Scope, selector analyzer.RuleSelector, qFlags *sql.QueryFlags) (sql.Node, transform.TreeIdentity, error) {
-	node, nodeSame, err := transform.NodeWithOpaque(node, func(node sql.Node) (sql.Node, transform.TreeIdentity, error) {
-		if disjointedNode, ok := node.(plan.DisjointedChildrenNode); ok {
-			return handleDisjointedNodes(ctx, a, disjointedNode, scope, selector, TypeSanitizer, qFlags)
-		}
-		return node, transform.SameTree, nil
-	})
-	if err != nil {
-		return nil, transform.NewTree, err
-	}
-	node, exprsSame, err := transform.NodeExprsWithOpaque(node, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
+	return pgtransform.NodeExprsWithOpaque(node, func(expr sql.Expression) (sql.Expression, transform.TreeIdentity, error) {
 		// This can be updated if we find more expressions that return GMS types.
 		// These should eventually be replaced with Doltgres-equivalents over time, rendering this function unnecessary.
 		switch expr := expr.(type) {
@@ -88,10 +80,6 @@ func TypeSanitizer(ctx *sql.Context, a *analyzer.Analyzer, node sql.Node, scope
 		}
 		return expr, transform.SameTree, nil
 	})
-	if err != nil {
-		return nil, transform.NewTree, err
-	}
-	return node, nodeSame && exprsSame, nil
 }
 
 // typeSanitizerLiterals handles literal expressions for TypeSanitizer.

server/analyzer/type_sanitizer.go

@@ -20,27 +20,34 @@ import (
 	vitess "github.com/dolthub/vitess/go/vt/sqlparser"
 
 	"github.com/dolthub/doltgresql/postgres/parser/sem/tree"
+	"github.com/dolthub/doltgresql/server/auth"
 )
 
 // nodeAliasedTableExpr handles *tree.AliasedTableExpr nodes.
-func nodeAliasedTableExpr(node *tree.AliasedTableExpr) (*vitess.AliasedTableExpr, error) {
+func nodeAliasedTableExpr(ctx *Context, node *tree.AliasedTableExpr) (*vitess.AliasedTableExpr, error) {
 	if node.Ordinality {
 		return nil, fmt.Errorf("ordinality is not yet supported")
 	}
 	if node.IndexFlags != nil {
 		return nil, fmt.Errorf("index flags are not yet supported")
 	}
 	var aliasExpr vitess.SimpleTableExpr
+	var authInfo vitess.AuthInformation
 
 	switch expr := node.Expr.(type) {
 	case *tree.TableName:
-		var err error
-		aliasExpr, err = nodeTableName(expr)
+		tableName, err := nodeTableName(ctx, expr)
 		if err != nil {
 			return nil, err
 		}
+		aliasExpr = tableName
+		authInfo = vitess.AuthInformation{
+			AuthType:    ctx.Auth().PeekAuthType(),
+			TargetType:  auth.AuthTargetType_SingleTableIdentifier,
+			TargetNames: []string{tableName.SchemaQualifier.String(), tableName.Name.String()},
+		}
 	case *tree.Subquery:
-		tableExpr, err := nodeTableExpr(expr)
+		tableExpr, err := nodeTableExpr(ctx, expr)
 		if err != nil {
 			return nil, err
 		}
@@ -92,7 +99,7 @@ func nodeAliasedTableExpr(node *tree.AliasedTableExpr) (*vitess.AliasedTableExpr
 		}
 		aliasExpr = subquery
 	case *tree.RowsFromExpr:
-		tableExpr, err := nodeTableExpr(expr)
+		tableExpr, err := nodeTableExpr(ctx, expr)
 		if err != nil {
 			return nil, err
 		}
@@ -119,7 +126,7 @@ func nodeAliasedTableExpr(node *tree.AliasedTableExpr) (*vitess.AliasedTableExpr
 
 	var asOf *vitess.AsOf
 	if node.AsOf != nil {
-		asOfExpr, err := nodeExpr(node.AsOf.Expr)
+		asOfExpr, err := nodeExpr(ctx, node.AsOf.Expr)
 		if err != nil {
 			return nil, err
 		}
@@ -134,5 +141,6 @@ func nodeAliasedTableExpr(node *tree.AliasedTableExpr) (*vitess.AliasedTableExpr
 		As:      vitess.NewTableIdent(alias),
 		AsOf:    asOf,
 		Lateral: node.Lateral,
+		Auth:    authInfo,
 	}, nil
 }

server/ast/aliased_table_expr.go

@@ -23,11 +23,11 @@ import (
 )
 
 // nodeAlterAggregate handles *tree.AlterAggregate nodes.
-func nodeAlterAggregate(node *tree.AlterAggregate) (vitess.Statement, error) {
+func nodeAlterAggregate(ctx *Context, node *tree.AlterAggregate) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}
-	if err := validateAggArgMode(node.AggSig.Args, node.AggSig.OrderByArgs); err != nil {
+	if err := validateAggArgMode(ctx, node.AggSig.Args, node.AggSig.OrderByArgs); err != nil {
 		return nil, err
 	}
 	return nil, fmt.Errorf("ALTER AGGREGATE is not yet supported")

server/ast/alter_aggregate.go

@@ -23,7 +23,7 @@ import (
 )
 
 // nodeAlterDatabase handles *tree.AlterDatabase nodes.
-func nodeAlterDatabase(node *tree.AlterDatabase) (vitess.Statement, error) {
+func nodeAlterDatabase(ctx *Context, node *tree.AlterDatabase) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}

server/ast/alter_database.go

@@ -23,8 +23,8 @@ import (
 )
 
 // nodeAlterFunction handles *tree.AlterFunction nodes.
-func nodeAlterFunction(node *tree.AlterFunction) (vitess.Statement, error) {
-	err := verifyRedundantRoutineOption(node.Options)
+func nodeAlterFunction(ctx *Context, node *tree.AlterFunction) (vitess.Statement, error) {
+	err := verifyRedundantRoutineOption(ctx, node.Options)
 	if err != nil {
 		return nil, err
 	}

server/ast/alter_function.go

@@ -23,7 +23,7 @@ import (
 )
 
 // nodeAlterIndex handles *tree.AlterIndex nodes.
-func nodeAlterIndex(node *tree.AlterIndex) (vitess.Statement, error) {
+func nodeAlterIndex(ctx *Context, node *tree.AlterIndex) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}

server/ast/alter_index.go

@@ -23,8 +23,8 @@ import (
 )
 
 // nodeAlterProcedure handles *tree.AlterProcedure nodes.
-func nodeAlterProcedure(node *tree.AlterProcedure) (vitess.Statement, error) {
-	err := verifyRedundantRoutineOption(node.Options)
+func nodeAlterProcedure(ctx *Context, node *tree.AlterProcedure) (vitess.Statement, error) {
+	err := verifyRedundantRoutineOption(ctx, node.Options)
 	if err != nil {
 		return nil, err
 	}

server/ast/alter_procedure.go

@@ -26,7 +26,7 @@ import (
 )
 
 // nodeAlterRole handles *tree.AlterRole nodes.
-func nodeAlterRole(node *tree.AlterRole) (vitess.Statement, error) {
+func nodeAlterRole(ctx *Context, node *tree.AlterRole) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}

server/ast/alter_role.go

@@ -23,7 +23,7 @@ import (
 )
 
 // nodeAlterSchema handles *tree.AlterSchema nodes.
-func nodeAlterSchema(node *tree.AlterSchema) (vitess.Statement, error) {
+func nodeAlterSchema(ctx *Context, node *tree.AlterSchema) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}

server/ast/alter_schema.go

@@ -23,7 +23,7 @@ import (
 )
 
 // nodeAlterSequence handles *tree.AlterSequence nodes.
-func nodeAlterSequence(node *tree.AlterSequence) (vitess.Statement, error) {
+func nodeAlterSequence(ctx *Context, node *tree.AlterSequence) (vitess.Statement, error) {
 	if node == nil {
 		return nil, nil
 	}