func (b *planBuilder) buildShow(show *ast.ShowStmt) Plan {
var p Plan
p = &Show{
Tp: show.Tp,
DBName: show.DBName,
Table: show.Table,
Column: show.Column,
Flag: show.Flag,
Full: show.Full,
User: show.User,
}
switch show.Tp {
case ast.ShowProcedureStatus:
p.SetFields(buildShowProcedureFields())
case ast.ShowTriggers:
p.SetFields(buildShowTriggerFields())
default:
p.SetFields(show.GetResultFields())
}
var conditions []ast.ExprNode
if show.Pattern != nil {
conditions = append(conditions, show.Pattern)
}
if show.Where != nil {
conditions = append(conditions, show.Where)
}
if len(conditions) != 0 {
filter := &Filter{Conditions: conditions}
addChild(filter, p)
p = filter
}
return p
}
func (b *planBuilder) buildShow(show *ast.ShowStmt) Plan {
var resultPlan Plan
p := &Show{
Tp: show.Tp,
DBName: show.DBName,
Table: show.Table,
Column: show.Column,
Flag: show.Flag,
Full: show.Full,
User: show.User,
baseLogicalPlan: newBaseLogicalPlan("Show", b.allocator),
}
resultPlan = p
p.initIDAndContext(b.ctx)
p.self = p
switch show.Tp {
case ast.ShowProcedureStatus:
p.SetSchema(buildShowProcedureSchema())
case ast.ShowTriggers:
p.SetSchema(buildShowTriggerSchema())
case ast.ShowEvents:
p.SetSchema(buildShowEventsSchema())
default:
p.SetSchema(expression.ResultFieldsToSchema(show.GetResultFields()))
}
for i, col := range p.schema {
col.Position = i
}
var conditions []expression.Expression
if show.Pattern != nil {
expr, _, err := b.rewrite(show.Pattern, p, nil, false)
if err != nil {
b.err = errors.Trace(err)
return nil
}
conditions = append(conditions, expr)
}
if show.Where != nil {
conds := splitWhere(show.Where)
for _, cond := range conds {
expr, _, err := b.rewrite(cond, p, nil, false)
if err != nil {
b.err = errors.Trace(err)
return nil
}
conditions = append(conditions, expr)
}
}
if len(conditions) != 0 {
sel := &Selection{
baseLogicalPlan: newBaseLogicalPlan(Sel, b.allocator),
Conditions: conditions,
}
sel.initIDAndContext(b.ctx)
sel.self = sel
addChild(sel, p)
resultPlan = sel
}
return resultPlan
}
func (b *planBuilder) buildShow(show *ast.ShowStmt) Plan {
var p Plan
p = &Show{
Tp: show.Tp,
DBName: show.DBName,
Table: show.Table,
Column: show.Column,
Flag: show.Flag,
Full: show.Full,
User: show.User,
}
p.SetFields(show.GetResultFields())
var conditions []ast.ExprNode
if show.Pattern != nil {
conditions = append(conditions, show.Pattern)
}
if show.Where != nil {
conditions = append(conditions, show.Where)
}
if len(conditions) != 0 {
filter := &Filter{Conditions: conditions}
filter.SetSrc(p)
p = filter
}
return p
}
func convertShow(converter *expressionConverter, v *ast.ShowStmt) (*stmts.ShowStmt, error) {
oldShow := &stmts.ShowStmt{
DBName: v.DBName,
Flag: v.Flag,
Full: v.Full,
GlobalScope: v.GlobalScope,
Text: v.Text(),
}
if v.Table != nil {
oldShow.TableIdent = table.Ident{
Schema: v.Table.Schema,
Name: v.Table.Name,
}
}
if v.Column != nil {
oldShow.ColumnName = joinColumnName(v.Column)
}
if v.Where != nil {
oldWhere, err := convertExpr(converter, v.Where)
if err != nil {
return nil, errors.Trace(err)
}
oldShow.Where = oldWhere
}
if v.Pattern != nil {
oldPattern, err := convertExpr(converter, v.Pattern)
if err != nil {
return nil, errors.Trace(err)
}
oldShow.Pattern = oldPattern.(*expression.PatternLike)
}
switch v.Tp {
case ast.ShowCharset:
oldShow.Target = stmt.ShowCharset
case ast.ShowCollation:
oldShow.Target = stmt.ShowCollation
case ast.ShowColumns:
oldShow.Target = stmt.ShowColumns
case ast.ShowCreateTable:
oldShow.Target = stmt.ShowCreateTable
case ast.ShowDatabases:
oldShow.Target = stmt.ShowDatabases
case ast.ShowTables:
oldShow.Target = stmt.ShowTables
case ast.ShowEngines:
oldShow.Target = stmt.ShowEngines
case ast.ShowVariables:
oldShow.Target = stmt.ShowVariables
case ast.ShowStatus:
oldShow.Target = stmt.ShowStatus
case ast.ShowWarnings:
oldShow.Target = stmt.ShowWarnings
case ast.ShowNone:
oldShow.Target = stmt.ShowNone
}
return oldShow, nil
}
func (nr *nameResolver) fillShowFields(s *ast.ShowStmt) {
if s.DBName == "" {
if s.Table != nil && s.Table.Schema.L != "" {
s.DBName = s.Table.Schema.O
} else {
s.DBName = nr.DefaultSchema.O
}
} else if s.Table != nil && s.Table.Schema.L == "" {
s.Table.Schema = model.NewCIStr(s.DBName)
}
var fields []*ast.ResultField
var (
names []string
ftypes []byte
)
switch s.Tp {
case ast.ShowEngines:
names = []string{"Engine", "Support", "Comment", "Transactions", "XA", "Savepoints"}
case ast.ShowDatabases:
names = []string{"Database"}
case ast.ShowTables:
names = []string{fmt.Sprintf("Tables_in_%s", s.DBName)}
if s.Full {
names = append(names, "Table_type")
}
case ast.ShowTableStatus:
names = []string{"Name", "Engine", "Version", "Row_format", "Rows", "Avg_row_length",
"Data_length", "Max_data_length", "Index_length", "Data_free", "Auto_increment",
"Create_time", "Update_time", "Check_time", "Collation", "Checksum",
"Create_options", "Comment"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeLonglong, mysql.TypeVarchar, mysql.TypeLonglong, mysql.TypeLonglong,
mysql.TypeLonglong, mysql.TypeLonglong, mysql.TypeLonglong, mysql.TypeLonglong, mysql.TypeLonglong,
mysql.TypeDatetime, mysql.TypeDatetime, mysql.TypeDatetime, mysql.TypeVarchar, mysql.TypeVarchar,
mysql.TypeVarchar, mysql.TypeVarchar}
case ast.ShowColumns:
names = table.ColDescFieldNames(s.Full)
case ast.ShowWarnings:
names = []string{"Level", "Code", "Message"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeLong, mysql.TypeVarchar}
case ast.ShowCharset:
names = []string{"Charset", "Description", "Default collation", "Maxlen"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeLonglong}
case ast.ShowVariables:
names = []string{"Variable_name", "Value"}
case ast.ShowStatus:
names = []string{"Variable_name", "Value"}
case ast.ShowCollation:
names = []string{"Collation", "Charset", "Id", "Default", "Compiled", "Sortlen"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeLonglong,
mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeLonglong}
case ast.ShowCreateTable:
names = []string{"Table", "Create Table"}
case ast.ShowGrants:
names = []string{fmt.Sprintf("Grants for %s", s.User)}
case ast.ShowTriggers:
names = []string{"Trigger", "Event", "Table", "Statement", "Timing", "Created",
"sql_mode", "Definer", "character_set_client", "collation_connection", "Database Collation"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar,
mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar}
case ast.ShowProcedureStatus:
names = []string{}
ftypes = []byte{}
case ast.ShowIndex:
names = []string{"Table", "Non_unique", "Key_name", "Seq_in_index",
"Column_name", "Collation", "Cardinality", "Sub_part", "Packed",
"Null", "Index_type", "Comment", "Index_comment"}
ftypes = []byte{mysql.TypeVarchar, mysql.TypeLonglong, mysql.TypeVarchar, mysql.TypeLonglong,
mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeLonglong, mysql.TypeLonglong,
mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar, mysql.TypeVarchar}
}
for i, name := range names {
f := &ast.ResultField{
ColumnAsName: model.NewCIStr(name),
Column: &model.ColumnInfo{}, // Empty column info.
Table: &model.TableInfo{}, // Empty table info.
}
if ftypes == nil || ftypes[i] == 0 {
// use varchar as the default return column type
f.Column.Tp = mysql.TypeVarchar
} else {
f.Column.Tp = ftypes[i]
}
f.Column.Charset, f.Column.Collate = types.DefaultCharsetForType(f.Column.Tp)
f.Expr = &ast.ValueExpr{}
f.Expr.SetType(&f.Column.FieldType)
fields = append(fields, f)
}
if s.Pattern != nil && s.Pattern.Expr == nil {
rf := fields[0]
s.Pattern.Expr = &ast.ColumnNameExpr{
Name: &ast.ColumnName{Name: rf.ColumnAsName},
}
ast.SetFlag(s.Pattern)
}
s.SetResultFields(fields)
nr.currentContext().fieldList = fields
}
