You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
329 lines
10 KiB
329 lines
10 KiB
// Copyright 2017 PingCAP, 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,
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package ddl
|
|
|
|
import (
|
|
"github.com/pingcap/errors"
|
|
"github.com/pingcap/parser/ast"
|
|
"github.com/pingcap/parser/model"
|
|
"github.com/pingcap/tidb/expression"
|
|
"github.com/pingcap/tidb/infoschema"
|
|
"github.com/pingcap/tidb/table"
|
|
)
|
|
|
|
// columnGenerationInDDL is a struct for validating generated columns in DDL.
|
|
type columnGenerationInDDL struct {
|
|
position int
|
|
generated bool
|
|
dependences map[string]struct{}
|
|
}
|
|
|
|
// verifyColumnGeneration is for CREATE TABLE, because we need verify all columns in the table.
|
|
func verifyColumnGeneration(colName2Generation map[string]columnGenerationInDDL, colName string) error {
|
|
attribute := colName2Generation[colName]
|
|
if attribute.generated {
|
|
for depCol := range attribute.dependences {
|
|
if attr, ok := colName2Generation[depCol]; ok {
|
|
if attr.generated && attribute.position <= attr.position {
|
|
// A generated column definition can refer to other
|
|
// generated columns occurring earlier in the table.
|
|
err := errGeneratedColumnNonPrior.GenWithStackByArgs()
|
|
return errors.Trace(err)
|
|
}
|
|
} else {
|
|
err := ErrBadField.GenWithStackByArgs(depCol, "generated column function")
|
|
return errors.Trace(err)
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// verifyColumnGenerationSingle is for ADD GENERATED COLUMN, we just need verify one column itself.
|
|
func verifyColumnGenerationSingle(dependColNames map[string]struct{}, cols []*table.Column, position *ast.ColumnPosition) error {
|
|
// Since the added column does not exist yet, we should derive it's offset from ColumnPosition.
|
|
pos, err := findPositionRelativeColumn(cols, position)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
// should check unknown column first, then the prior ones.
|
|
for _, col := range cols {
|
|
if _, ok := dependColNames[col.Name.L]; ok {
|
|
if col.IsGenerated() && col.Offset >= pos {
|
|
// Generated column can refer only to generated columns defined prior to it.
|
|
return errGeneratedColumnNonPrior.GenWithStackByArgs()
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// checkDependedColExist ensure all depended columns exist and not hidden.
|
|
// NOTE: this will MODIFY parameter `dependCols`.
|
|
func checkDependedColExist(dependCols map[string]struct{}, cols []*table.Column) error {
|
|
for _, col := range cols {
|
|
if !col.Hidden {
|
|
delete(dependCols, col.Name.L)
|
|
}
|
|
}
|
|
if len(dependCols) != 0 {
|
|
for arbitraryCol := range dependCols {
|
|
return ErrBadField.GenWithStackByArgs(arbitraryCol, "generated column function")
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// findPositionRelativeColumn returns a pos relative to added generated column position.
|
|
func findPositionRelativeColumn(cols []*table.Column, pos *ast.ColumnPosition) (int, error) {
|
|
position := len(cols)
|
|
// Get the column position, default is cols's length means appending.
|
|
// For "alter table ... add column(...)", the position will be nil.
|
|
// For "alter table ... add column ... ", the position will be default one.
|
|
if pos == nil {
|
|
return position, nil
|
|
}
|
|
if pos.Tp == ast.ColumnPositionFirst {
|
|
position = 0
|
|
} else if pos.Tp == ast.ColumnPositionAfter {
|
|
var col *table.Column
|
|
for _, c := range cols {
|
|
if c.Name.L == pos.RelativeColumn.Name.L {
|
|
col = c
|
|
break
|
|
}
|
|
}
|
|
if col == nil {
|
|
return -1, ErrBadField.GenWithStackByArgs(pos.RelativeColumn, "generated column function")
|
|
}
|
|
// Inserted position is after the mentioned column.
|
|
position = col.Offset + 1
|
|
}
|
|
return position, nil
|
|
}
|
|
|
|
// findDependedColumnNames returns a set of string, which indicates
|
|
// the names of the columns that are depended by colDef.
|
|
func findDependedColumnNames(colDef *ast.ColumnDef) (generated bool, colsMap map[string]struct{}) {
|
|
colsMap = make(map[string]struct{})
|
|
for _, option := range colDef.Options {
|
|
if option.Tp == ast.ColumnOptionGenerated {
|
|
generated = true
|
|
colNames := findColumnNamesInExpr(option.Expr)
|
|
for _, depCol := range colNames {
|
|
colsMap[depCol.Name.L] = struct{}{}
|
|
}
|
|
break
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// findColumnNamesInExpr returns a slice of ast.ColumnName which is referred in expr.
|
|
func findColumnNamesInExpr(expr ast.ExprNode) []*ast.ColumnName {
|
|
var c generatedColumnChecker
|
|
expr.Accept(&c)
|
|
return c.cols
|
|
}
|
|
|
|
type generatedColumnChecker struct {
|
|
cols []*ast.ColumnName
|
|
}
|
|
|
|
func (c *generatedColumnChecker) Enter(inNode ast.Node) (outNode ast.Node, skipChildren bool) {
|
|
return inNode, false
|
|
}
|
|
|
|
func (c *generatedColumnChecker) Leave(inNode ast.Node) (node ast.Node, ok bool) {
|
|
switch x := inNode.(type) {
|
|
case *ast.ColumnName:
|
|
c.cols = append(c.cols, x)
|
|
}
|
|
return inNode, true
|
|
}
|
|
|
|
// checkModifyGeneratedColumn checks the modification between
|
|
// old and new is valid or not by such rules:
|
|
// 1. the modification can't change stored status;
|
|
// 2. if the new is generated, check its refer rules.
|
|
// 3. check if the modified expr contains non-deterministic functions
|
|
// 4. check whether new column refers to any auto-increment columns.
|
|
// 5. check if the new column is indexed or stored
|
|
func checkModifyGeneratedColumn(tbl table.Table, oldCol, newCol *table.Column, newColDef *ast.ColumnDef) error {
|
|
// rule 1.
|
|
oldColIsStored := !oldCol.IsGenerated() || oldCol.GeneratedStored
|
|
newColIsStored := !newCol.IsGenerated() || newCol.GeneratedStored
|
|
if oldColIsStored != newColIsStored {
|
|
return errUnsupportedOnGeneratedColumn.GenWithStackByArgs("Changing the STORED status")
|
|
}
|
|
|
|
// rule 2.
|
|
originCols := tbl.Cols()
|
|
var colName2Generation = make(map[string]columnGenerationInDDL, len(originCols))
|
|
for i, column := range originCols {
|
|
// We can compare the pointers simply.
|
|
if column == oldCol {
|
|
colName2Generation[newCol.Name.L] = columnGenerationInDDL{
|
|
position: i,
|
|
generated: newCol.IsGenerated(),
|
|
dependences: newCol.Dependences,
|
|
}
|
|
} else if !column.IsGenerated() {
|
|
colName2Generation[column.Name.L] = columnGenerationInDDL{
|
|
position: i,
|
|
generated: false,
|
|
}
|
|
} else {
|
|
colName2Generation[column.Name.L] = columnGenerationInDDL{
|
|
position: i,
|
|
generated: true,
|
|
dependences: column.Dependences,
|
|
}
|
|
}
|
|
}
|
|
// We always need test all columns, even if it's not changed
|
|
// because other can depend on it so its name can't be changed.
|
|
for _, column := range originCols {
|
|
var colName string
|
|
if column == oldCol {
|
|
colName = newCol.Name.L
|
|
} else {
|
|
colName = column.Name.L
|
|
}
|
|
if err := verifyColumnGeneration(colName2Generation, colName); err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
}
|
|
|
|
if newCol.IsGenerated() {
|
|
// rule 3.
|
|
if err := checkIllegalFn4GeneratedColumn(newCol.Name.L, newCol.GeneratedExpr); err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
// rule 4.
|
|
if err := checkGeneratedWithAutoInc(tbl.Meta(), newColDef); err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
|
|
// rule 5.
|
|
if err := checkIndexOrStored(tbl, oldCol, newCol); err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
type illegalFunctionChecker struct {
|
|
hasIllegalFunc bool
|
|
hasAggFunc bool
|
|
hasWindowFunc bool
|
|
}
|
|
|
|
func (c *illegalFunctionChecker) Enter(inNode ast.Node) (outNode ast.Node, skipChildren bool) {
|
|
switch node := inNode.(type) {
|
|
case *ast.FuncCallExpr:
|
|
// Blocked functions & non-builtin functions is not allowed
|
|
_, IsFunctionBlocked := expression.IllegalFunctions4GeneratedColumns[node.FnName.L]
|
|
if IsFunctionBlocked || !expression.IsFunctionSupported(node.FnName.L) {
|
|
c.hasIllegalFunc = true
|
|
return inNode, true
|
|
}
|
|
case *ast.SubqueryExpr, *ast.ValuesExpr, *ast.VariableExpr:
|
|
// Subquery & `values(x)` & variable is not allowed
|
|
c.hasIllegalFunc = true
|
|
return inNode, true
|
|
case *ast.AggregateFuncExpr:
|
|
// Aggregate function is not allowed
|
|
c.hasAggFunc = true
|
|
return inNode, true
|
|
case *ast.WindowFuncExpr:
|
|
c.hasWindowFunc = true
|
|
return inNode, true
|
|
}
|
|
return inNode, false
|
|
}
|
|
|
|
func (c *illegalFunctionChecker) Leave(inNode ast.Node) (node ast.Node, ok bool) {
|
|
return inNode, true
|
|
}
|
|
|
|
func checkIllegalFn4GeneratedColumn(colName string, expr ast.ExprNode) error {
|
|
if expr == nil {
|
|
return nil
|
|
}
|
|
var c illegalFunctionChecker
|
|
expr.Accept(&c)
|
|
if c.hasIllegalFunc {
|
|
return ErrGeneratedColumnFunctionIsNotAllowed.GenWithStackByArgs(colName)
|
|
}
|
|
if c.hasAggFunc {
|
|
return ErrInvalidGroupFuncUse
|
|
}
|
|
if c.hasWindowFunc {
|
|
return errWindowInvalidWindowFuncUse
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Check whether newColumnDef refers to any auto-increment columns.
|
|
func checkGeneratedWithAutoInc(tableInfo *model.TableInfo, newColumnDef *ast.ColumnDef) error {
|
|
_, dependColNames := findDependedColumnNames(newColumnDef)
|
|
if err := checkAutoIncrementRef(newColumnDef.Name.Name.L, dependColNames, tableInfo); err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
return nil
|
|
}
|
|
|
|
func checkIndexOrStored(tbl table.Table, oldCol, newCol *table.Column) error {
|
|
if oldCol.GeneratedExprString == newCol.GeneratedExprString {
|
|
return nil
|
|
}
|
|
|
|
if newCol.GeneratedStored {
|
|
return errUnsupportedOnGeneratedColumn.GenWithStackByArgs("modifying a stored column")
|
|
}
|
|
|
|
for _, idx := range tbl.Indices() {
|
|
for _, col := range idx.Meta().Columns {
|
|
if col.Name.L == newCol.Name.L {
|
|
return errUnsupportedOnGeneratedColumn.GenWithStackByArgs("modifying an indexed column")
|
|
}
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// checkAutoIncrementRef checks if an generated column depends on an auto-increment column and raises an error if so.
|
|
// See https://dev.mysql.com/doc/refman/5.7/en/create-table-generated-columns.html for details.
|
|
func checkAutoIncrementRef(name string, dependencies map[string]struct{}, tbInfo *model.TableInfo) error {
|
|
exists, autoIncrementColumn := infoschema.HasAutoIncrementColumn(tbInfo)
|
|
if exists {
|
|
if _, found := dependencies[autoIncrementColumn]; found {
|
|
return ErrGeneratedColumnRefAutoInc.GenWithStackByArgs(name)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// checkExpressionIndexAutoIncrement checks if an generated column depends on an auto-increment column and raises an error if so.
|
|
func checkExpressionIndexAutoIncrement(name string, dependencies map[string]struct{}, tbInfo *model.TableInfo) error {
|
|
exists, autoIncrementColumn := infoschema.HasAutoIncrementColumn(tbInfo)
|
|
if exists {
|
|
if _, found := dependencies[autoIncrementColumn]; found {
|
|
return ErrExpressionIndexCanNotRefer.GenWithStackByArgs(name)
|
|
}
|
|
}
|
|
return nil
|
|
}
|
|
|