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.
195 lines
5.1 KiB
195 lines
5.1 KiB
// Copyright 2016 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 expression
|
|
|
|
import (
|
|
"strings"
|
|
)
|
|
|
|
// KeyInfo stores the columns of one unique key or primary key.
|
|
type KeyInfo []*Column
|
|
|
|
// Clone copies the entire UniqueKey.
|
|
func (ki KeyInfo) Clone() KeyInfo {
|
|
result := make([]*Column, 0, len(ki))
|
|
for _, col := range ki {
|
|
result = append(result, col.Clone().(*Column))
|
|
}
|
|
return result
|
|
}
|
|
|
|
// Schema stands for the row schema and unique key information get from input.
|
|
type Schema struct {
|
|
Columns []*Column
|
|
Keys []KeyInfo
|
|
}
|
|
|
|
// String implements fmt.Stringer interface.
|
|
func (s *Schema) String() string {
|
|
colStrs := make([]string, 0, len(s.Columns))
|
|
for _, col := range s.Columns {
|
|
colStrs = append(colStrs, col.String())
|
|
}
|
|
ukStrs := make([]string, 0, len(s.Keys))
|
|
for _, key := range s.Keys {
|
|
ukColStrs := make([]string, 0, len(key))
|
|
for _, col := range key {
|
|
ukColStrs = append(ukColStrs, col.String())
|
|
}
|
|
ukStrs = append(ukStrs, "["+strings.Join(ukColStrs, ",")+"]")
|
|
}
|
|
return "Column: [" + strings.Join(colStrs, ",") + "] Unique key: [" + strings.Join(ukStrs, ",") + "]"
|
|
}
|
|
|
|
// Clone copies the total schema.
|
|
func (s *Schema) Clone() *Schema {
|
|
cols := make([]*Column, 0, s.Len())
|
|
keys := make([]KeyInfo, 0, len(s.Keys))
|
|
for _, col := range s.Columns {
|
|
cols = append(cols, col.Clone().(*Column))
|
|
}
|
|
for _, key := range s.Keys {
|
|
keys = append(keys, key.Clone())
|
|
}
|
|
schema := NewSchema(cols...)
|
|
schema.SetUniqueKeys(keys)
|
|
return schema
|
|
}
|
|
|
|
// ExprFromSchema checks if all columns of this expression are from the same schema.
|
|
func ExprFromSchema(expr Expression, schema *Schema) bool {
|
|
switch v := expr.(type) {
|
|
case *Column:
|
|
return schema.Contains(v)
|
|
case *ScalarFunction:
|
|
for _, arg := range v.GetArgs() {
|
|
if !ExprFromSchema(arg, schema) {
|
|
return false
|
|
}
|
|
}
|
|
return true
|
|
case *CorrelatedColumn, *Constant:
|
|
return true
|
|
}
|
|
return false
|
|
}
|
|
|
|
// RetrieveColumn retrieves column in expression from the columns in schema.
|
|
func (s *Schema) RetrieveColumn(col *Column) *Column {
|
|
index := s.ColumnIndex(col)
|
|
if index != -1 {
|
|
return s.Columns[index]
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// IsUniqueKey checks if this column is a unique key.
|
|
func (s *Schema) IsUniqueKey(col *Column) bool {
|
|
for _, key := range s.Keys {
|
|
if len(key) == 1 && key[0].Equal(nil, col) {
|
|
return true
|
|
}
|
|
}
|
|
return false
|
|
}
|
|
|
|
// ColumnIndex finds the index for a column.
|
|
func (s *Schema) ColumnIndex(col *Column) int {
|
|
for i, c := range s.Columns {
|
|
if c.UniqueID == col.UniqueID {
|
|
return i
|
|
}
|
|
}
|
|
return -1
|
|
}
|
|
|
|
// Contains checks if the schema contains the column.
|
|
func (s *Schema) Contains(col *Column) bool {
|
|
return s.ColumnIndex(col) != -1
|
|
}
|
|
|
|
// Len returns the number of columns in schema.
|
|
func (s *Schema) Len() int {
|
|
return len(s.Columns)
|
|
}
|
|
|
|
// Append append new column to the columns stored in schema.
|
|
func (s *Schema) Append(col ...*Column) {
|
|
s.Columns = append(s.Columns, col...)
|
|
}
|
|
|
|
// SetUniqueKeys will set the value of Schema.Keys.
|
|
func (s *Schema) SetUniqueKeys(keys []KeyInfo) {
|
|
s.Keys = keys
|
|
}
|
|
|
|
// ColumnsIndices will return a slice which contains the position of each column in schema.
|
|
// If there is one column that doesn't match, nil will be returned.
|
|
func (s *Schema) ColumnsIndices(cols []*Column) (ret []int) {
|
|
ret = make([]int, 0, len(cols))
|
|
for _, col := range cols {
|
|
pos := s.ColumnIndex(col)
|
|
if pos != -1 {
|
|
ret = append(ret, pos)
|
|
} else {
|
|
return nil
|
|
}
|
|
}
|
|
return
|
|
}
|
|
|
|
// ColumnsByIndices returns columns by multiple offsets.
|
|
// Callers should guarantee that all the offsets provided should be valid, which means offset should:
|
|
// 1. not smaller than 0, and
|
|
// 2. not exceed len(s.Columns)
|
|
func (s *Schema) ColumnsByIndices(offsets []int) []*Column {
|
|
cols := make([]*Column, 0, len(offsets))
|
|
for _, offset := range offsets {
|
|
cols = append(cols, s.Columns[offset])
|
|
}
|
|
return cols
|
|
}
|
|
|
|
// MergeSchema will merge two schema into one schema. We shouldn't need to consider unique keys.
|
|
// That will be processed in build_key_info.go.
|
|
func MergeSchema(lSchema, rSchema *Schema) *Schema {
|
|
if lSchema == nil && rSchema == nil {
|
|
return nil
|
|
}
|
|
if lSchema == nil {
|
|
return rSchema.Clone()
|
|
}
|
|
if rSchema == nil {
|
|
return lSchema.Clone()
|
|
}
|
|
tmpL := lSchema.Clone()
|
|
tmpR := rSchema.Clone()
|
|
ret := NewSchema(append(tmpL.Columns, tmpR.Columns...)...)
|
|
return ret
|
|
}
|
|
|
|
// GetUsedList shows whether each column in schema is contained in usedCols.
|
|
func GetUsedList(usedCols []*Column, schema *Schema) []bool {
|
|
tmpSchema := NewSchema(usedCols...)
|
|
used := make([]bool, schema.Len())
|
|
for i, col := range schema.Columns {
|
|
used[i] = tmpSchema.Contains(col)
|
|
}
|
|
return used
|
|
}
|
|
|
|
// NewSchema returns a schema made by its parameter.
|
|
func NewSchema(cols ...*Column) *Schema {
|
|
return &Schema{Columns: cols}
|
|
}
|
|
|