wehub-resource-sync
122 lines
4.1 KiB
Go
122 lines
4.1 KiB
Go
// Copyright 2026 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 hook
|
|
|
|
import (
|
|
"fmt"
|
|
|
|
"github.com/cockroachdb/errors"
|
|
"github.com/dolthub/dolt/go/libraries/doltcore/doltdb"
|
|
"github.com/dolthub/go-mysql-server/sql"
|
|
"github.com/dolthub/go-mysql-server/sql/plan"
|
|
|
|
"github.com/dolthub/doltgresql/core"
|
|
"github.com/dolthub/doltgresql/core/id"
|
|
pgtypes "github.com/dolthub/doltgresql/server/types"
|
|
)
|
|
|
|
// AfterTableDropColumn handles updating various table columns, alongside other validation that's unique to Doltgres.
|
|
func AfterTableDropColumn(ctx *sql.Context, runner sql.StatementRunner, nodeInterface sql.Node) error {
|
|
n, ok := nodeInterface.(*plan.DropColumn)
|
|
if !ok {
|
|
return errors.Errorf("DROP COLUMN post-hook expected `*plan.DropColumn` but received `%T`", nodeInterface)
|
|
}
|
|
|
|
// Grab the table being altered
|
|
doltTable := core.SQLNodeToDoltTable(n.Table)
|
|
if doltTable == nil {
|
|
// If this table isn't a Dolt table then we don't have anything to do
|
|
return nil
|
|
}
|
|
_, root, err := core.GetRootFromContext(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
tableName := doltTable.TableName()
|
|
tableAsType := id.NewType(tableName.Schema, tableName.Name)
|
|
allTableNames, err := root.GetAllTableNames(ctx, false)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
sch := n.TargetSchema()
|
|
|
|
for _, otherTableName := range allTableNames {
|
|
if doltdb.IsSystemTable(otherTableName) {
|
|
// System tables don't use any table types
|
|
continue
|
|
}
|
|
otherTable, ok, err := root.GetTable(ctx, otherTableName)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
if !ok {
|
|
return errors.Errorf("root returned table name `%s` but it could not be found?", otherTableName.String())
|
|
}
|
|
otherTableSch, err := otherTable.GetSchema(ctx)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, otherCol := range otherTableSch.GetAllCols().GetColumns() {
|
|
colType := otherCol.TypeInfo.ToSqlType()
|
|
dgtype, ok := colType.(*pgtypes.DoltgresType)
|
|
if !ok {
|
|
// If this isn't a Doltgres type, then it can't be a table type so we can ignore it
|
|
continue
|
|
}
|
|
if dgtype.ID != tableAsType {
|
|
// This column isn't our table type, so we can ignore it
|
|
continue
|
|
}
|
|
// Build the UPDATE statement that we'll run for this table
|
|
trimIdx := -1
|
|
for i, col := range sch {
|
|
if col.Name == n.Column {
|
|
trimIdx = i
|
|
break
|
|
}
|
|
}
|
|
if trimIdx == -1 {
|
|
return errors.New("DROP COLUMN post-hook could not find the index of the column to remove")
|
|
}
|
|
// The UPDATE changes the values in the table
|
|
updateStr := fmt.Sprintf(`UPDATE "%s"."%s" SET "%s" = dolt_recordtrim("%s", %d)::"%s"."%s";`,
|
|
otherTableName.Schema, otherTableName.Name, otherCol.Name, otherCol.Name, trimIdx, tableName.Schema, tableName.Name)
|
|
// The ALTER updates the type on the schema since it still has the old one
|
|
alterStr := fmt.Sprintf(`ALTER TABLE "%s"."%s" ALTER COLUMN "%s" TYPE "%s"."%s";`,
|
|
otherTableName.Schema, otherTableName.Name, otherCol.Name, tableName.Schema, tableName.Name)
|
|
// We run the statements as though they were interpreted since we're running new statements inside the original
|
|
_, err = sql.RunInterpreted(ctx, func(subCtx *sql.Context) ([]sql.Row, error) {
|
|
_, rowIter, _, err := runner.QueryWithBindings(subCtx, updateStr, nil, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, err = sql.RowIterToRows(subCtx, rowIter)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
_, rowIter, _, err = runner.QueryWithBindings(subCtx, alterStr, nil, nil, nil)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return sql.RowIterToRows(subCtx, rowIter)
|
|
})
|
|
if err != nil {
|
|
return err
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|