125 lines
3.5 KiB
Go
125 lines
3.5 KiB
Go
// Copyright 2014 The ql Authors. All rights reserved.
|
|
// Use of this source code is governed by a BSD-style
|
|
// license that can be found in the LICENSES/QL-LICENSE file.
|
|
|
|
// Copyright 2015 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 rsets
|
|
|
|
import (
|
|
"strings"
|
|
|
|
"github.com/juju/errors"
|
|
"github.com/pingcap/tidb/context"
|
|
"github.com/pingcap/tidb/expression"
|
|
"github.com/pingcap/tidb/field"
|
|
"github.com/pingcap/tidb/plan"
|
|
"github.com/pingcap/tidb/plan/plans"
|
|
)
|
|
|
|
var (
|
|
_ plan.Planner = (*SelectFieldsRset)(nil)
|
|
_ plan.Planner = (*SelectFromDualRset)(nil)
|
|
)
|
|
|
|
// SelectFieldsRset is record set to select fields.
|
|
type SelectFieldsRset struct {
|
|
Src plan.Plan
|
|
SelectList *plans.SelectList
|
|
}
|
|
|
|
func updateSelectFieldsRefer(selectList *plans.SelectList) error {
|
|
visitor := NewFromIdentVisitor(selectList.FromFields, FieldListClause)
|
|
|
|
// we only fix un-hidden fields here, for hidden fields, it should be
|
|
// handled in their own clause, in order by or having.
|
|
for i, f := range selectList.Fields[0:selectList.HiddenFieldOffset] {
|
|
e, err := f.Expr.Accept(visitor)
|
|
if err != nil {
|
|
return errors.Trace(err)
|
|
}
|
|
selectList.Fields[i].Expr = e
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// Plan gets SrcPlan/SelectFieldsDefaultPlan.
|
|
// If all fields are equal to src plan fields, then gets SrcPlan.
|
|
// Default gets SelectFieldsDefaultPlan.
|
|
func (r *SelectFieldsRset) Plan(ctx context.Context) (plan.Plan, error) {
|
|
if err := updateSelectFieldsRefer(r.SelectList); err != nil {
|
|
return nil, errors.Trace(err)
|
|
}
|
|
|
|
fields := r.SelectList.Fields
|
|
srcFields := r.Src.GetFields()
|
|
if len(fields) == len(srcFields) {
|
|
match := true
|
|
for i, v := range fields {
|
|
// TODO: is it this check enough? e.g, the ident field is t.c.
|
|
if x, ok := v.Expr.(*expression.Ident); ok && strings.EqualFold(x.L, srcFields[i].Name) {
|
|
if len(v.AsName) > 0 && !strings.EqualFold(v.AsName, srcFields[i].Name) {
|
|
// have alias name, but alias name is not the same with result field name.
|
|
// e.g, select c as a from t;
|
|
match = false
|
|
break
|
|
}
|
|
continue
|
|
}
|
|
|
|
match = false
|
|
break
|
|
}
|
|
|
|
if match {
|
|
return r.Src, nil
|
|
}
|
|
}
|
|
|
|
src := r.Src
|
|
if x, ok := src.(*plans.TableDefaultPlan); ok {
|
|
// check whether src plan will be set TableNilPlan, like `select 1, 2 from t`.
|
|
isConst := true
|
|
for _, v := range fields {
|
|
if expression.FastEval(v.Expr) == nil {
|
|
isConst = false
|
|
break
|
|
}
|
|
}
|
|
if isConst {
|
|
src = &plans.TableNilPlan{T: x.T}
|
|
}
|
|
}
|
|
|
|
p := &plans.SelectFieldsDefaultPlan{Src: src, SelectList: r.SelectList}
|
|
return p, nil
|
|
}
|
|
|
|
// SelectFromDualRset is Recordset for select from dual, like `select 1, 1+1` or `select 1 from dual`.
|
|
type SelectFromDualRset struct {
|
|
Fields []*field.Field
|
|
}
|
|
|
|
// Plan gets SelectExprPlan.
|
|
func (r *SelectFromDualRset) Plan(ctx context.Context) (plan.Plan, error) {
|
|
// field cannot contain identifier
|
|
for _, f := range r.Fields {
|
|
if cs := expression.MentionedColumns(f.Expr); len(cs) > 0 {
|
|
// TODO: check in outer query, like select * from t where t.c = (select c limit 1);
|
|
return nil, errors.Errorf("Unknown column '%s' in 'field list'", cs[0])
|
|
}
|
|
}
|
|
return &plans.SelectFromDualPlan{Fields: r.Fields}, nil
|
|
}
|