1f262daf6f
This is to ensure that there are no projects that try to import `minio/minio/pkg` into their own repo. Any such common packages should go to `https://github.com/minio/pkg`
325 lines
8 KiB
Go
325 lines
8 KiB
Go
// Copyright (c) 2015-2021 MinIO, Inc.
|
|
//
|
|
// This file is part of MinIO Object Storage stack
|
|
//
|
|
// This program is free software: you can redistribute it and/or modify
|
|
// it under the terms of the GNU Affero General Public License as published by
|
|
// the Free Software Foundation, either version 3 of the License, or
|
|
// (at your option) any later version.
|
|
//
|
|
// This program is distributed in the hope that it will be useful
|
|
// but WITHOUT ANY WARRANTY; without even the implied warranty of
|
|
// MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
|
// GNU Affero General Public License for more details.
|
|
//
|
|
// You should have received a copy of the GNU Affero General Public License
|
|
// along with this program. If not, see <http://www.gnu.org/licenses/>.
|
|
|
|
package sql
|
|
|
|
import (
|
|
"errors"
|
|
"fmt"
|
|
"strings"
|
|
)
|
|
|
|
// Query analysis - The query is analyzed to determine if it involves
|
|
// aggregation.
|
|
//
|
|
// Aggregation functions - An expression that involves aggregation of
|
|
// rows in some manner. Requires all input rows to be processed,
|
|
// before a result is returned.
|
|
//
|
|
// Row function - An expression that depends on a value in the
|
|
// row. They have an output for each input row.
|
|
//
|
|
// Some types of a queries are not valid. For example, an aggregation
|
|
// function combined with a row function is meaningless ("AVG(s.Age) +
|
|
// s.Salary"). Analysis determines if such a scenario exists so an
|
|
// error can be returned.
|
|
|
|
var (
|
|
// Fatal error for query processing.
|
|
errNestedAggregation = errors.New("Cannot nest aggregations")
|
|
errFunctionNotImplemented = errors.New("Function is not yet implemented")
|
|
errUnexpectedInvalidNode = errors.New("Unexpected node value")
|
|
errInvalidKeypath = errors.New("A provided keypath is invalid")
|
|
)
|
|
|
|
// qProp contains analysis info about an SQL term.
|
|
type qProp struct {
|
|
isAggregation, isRowFunc bool
|
|
|
|
err error
|
|
}
|
|
|
|
// `combine` combines a pair of `qProp`s, so that errors are
|
|
// propagated correctly, and checks that an aggregation is not being
|
|
// combined with a row-function term.
|
|
func (p *qProp) combine(q qProp) {
|
|
switch {
|
|
case p.err != nil:
|
|
// Do nothing
|
|
case q.err != nil:
|
|
p.err = q.err
|
|
default:
|
|
p.isAggregation = p.isAggregation || q.isAggregation
|
|
p.isRowFunc = p.isRowFunc || q.isRowFunc
|
|
if p.isAggregation && p.isRowFunc {
|
|
p.err = errNestedAggregation
|
|
}
|
|
}
|
|
}
|
|
|
|
func (e *SelectExpression) analyze(s *Select) (result qProp) {
|
|
if e.All {
|
|
return qProp{isRowFunc: true}
|
|
}
|
|
|
|
for _, ex := range e.Expressions {
|
|
result.combine(ex.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *AliasedExpression) analyze(s *Select) qProp {
|
|
return e.Expression.analyze(s)
|
|
}
|
|
|
|
func (e *Expression) analyze(s *Select) (result qProp) {
|
|
for _, ac := range e.And {
|
|
result.combine(ac.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *AndCondition) analyze(s *Select) (result qProp) {
|
|
for _, ac := range e.Condition {
|
|
result.combine(ac.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *Condition) analyze(s *Select) (result qProp) {
|
|
if e.Operand != nil {
|
|
result = e.Operand.analyze(s)
|
|
} else {
|
|
result = e.Not.analyze(s)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *ListExpr) analyze(s *Select) (result qProp) {
|
|
for _, ac := range e.Elements {
|
|
result.combine(ac.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *ConditionOperand) analyze(s *Select) (result qProp) {
|
|
if e.ConditionRHS == nil {
|
|
result = e.Operand.analyze(s)
|
|
} else {
|
|
result.combine(e.Operand.analyze(s))
|
|
result.combine(e.ConditionRHS.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *ConditionRHS) analyze(s *Select) (result qProp) {
|
|
switch {
|
|
case e.Compare != nil:
|
|
result = e.Compare.Operand.analyze(s)
|
|
case e.Between != nil:
|
|
result.combine(e.Between.Start.analyze(s))
|
|
result.combine(e.Between.End.analyze(s))
|
|
case e.In != nil:
|
|
result.combine(e.In.ListExpression.analyze(s))
|
|
case e.Like != nil:
|
|
result.combine(e.Like.Pattern.analyze(s))
|
|
if e.Like.EscapeChar != nil {
|
|
result.combine(e.Like.EscapeChar.analyze(s))
|
|
}
|
|
default:
|
|
result = qProp{err: errUnexpectedInvalidNode}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *Operand) analyze(s *Select) (result qProp) {
|
|
result.combine(e.Left.analyze(s))
|
|
for _, r := range e.Right {
|
|
result.combine(r.Right.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *MultOp) analyze(s *Select) (result qProp) {
|
|
result.combine(e.Left.analyze(s))
|
|
for _, r := range e.Right {
|
|
result.combine(r.Right.analyze(s))
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *UnaryTerm) analyze(s *Select) (result qProp) {
|
|
if e.Negated != nil {
|
|
result = e.Negated.Term.analyze(s)
|
|
} else {
|
|
result = e.Primary.analyze(s)
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *PrimaryTerm) analyze(s *Select) (result qProp) {
|
|
switch {
|
|
case e.Value != nil:
|
|
result = qProp{}
|
|
|
|
case e.JPathExpr != nil:
|
|
// Check if the path expression is valid
|
|
if len(e.JPathExpr.PathExpr) > 0 {
|
|
if e.JPathExpr.BaseKey.String() != s.From.As && strings.ToLower(e.JPathExpr.BaseKey.String()) != baseTableName {
|
|
result = qProp{err: errInvalidKeypath}
|
|
return
|
|
}
|
|
}
|
|
result = qProp{isRowFunc: true}
|
|
|
|
case e.ListExpr != nil:
|
|
result = e.ListExpr.analyze(s)
|
|
|
|
case e.SubExpression != nil:
|
|
result = e.SubExpression.analyze(s)
|
|
|
|
case e.FuncCall != nil:
|
|
result = e.FuncCall.analyze(s)
|
|
|
|
default:
|
|
result = qProp{err: errUnexpectedInvalidNode}
|
|
}
|
|
return
|
|
}
|
|
|
|
func (e *FuncExpr) analyze(s *Select) (result qProp) {
|
|
funcName := e.getFunctionName()
|
|
|
|
switch funcName {
|
|
case sqlFnCast:
|
|
return e.Cast.Expr.analyze(s)
|
|
|
|
case sqlFnExtract:
|
|
return e.Extract.From.analyze(s)
|
|
|
|
case sqlFnDateAdd:
|
|
result.combine(e.DateAdd.Quantity.analyze(s))
|
|
result.combine(e.DateAdd.Timestamp.analyze(s))
|
|
return result
|
|
|
|
case sqlFnDateDiff:
|
|
result.combine(e.DateDiff.Timestamp1.analyze(s))
|
|
result.combine(e.DateDiff.Timestamp2.analyze(s))
|
|
return result
|
|
|
|
// Handle aggregation function calls
|
|
case aggFnAvg, aggFnMax, aggFnMin, aggFnSum, aggFnCount:
|
|
// Initialize accumulator
|
|
e.aggregate = newAggVal(funcName)
|
|
|
|
var exprA qProp
|
|
if funcName == aggFnCount {
|
|
if e.Count.StarArg {
|
|
return qProp{isAggregation: true}
|
|
}
|
|
|
|
exprA = e.Count.ExprArg.analyze(s)
|
|
} else {
|
|
if len(e.SFunc.ArgsList) != 1 {
|
|
return qProp{err: fmt.Errorf("%s takes exactly one argument", funcName)}
|
|
}
|
|
exprA = e.SFunc.ArgsList[0].analyze(s)
|
|
}
|
|
|
|
if exprA.err != nil {
|
|
return exprA
|
|
}
|
|
if exprA.isAggregation {
|
|
return qProp{err: errNestedAggregation}
|
|
}
|
|
return qProp{isAggregation: true}
|
|
|
|
case sqlFnCoalesce:
|
|
if len(e.SFunc.ArgsList) == 0 {
|
|
return qProp{err: fmt.Errorf("%s needs at least one argument", string(funcName))}
|
|
}
|
|
for _, arg := range e.SFunc.ArgsList {
|
|
result.combine(arg.analyze(s))
|
|
}
|
|
return result
|
|
|
|
case sqlFnNullIf:
|
|
if len(e.SFunc.ArgsList) != 2 {
|
|
return qProp{err: fmt.Errorf("%s needs exactly 2 arguments", string(funcName))}
|
|
}
|
|
for _, arg := range e.SFunc.ArgsList {
|
|
result.combine(arg.analyze(s))
|
|
}
|
|
return result
|
|
|
|
case sqlFnCharLength, sqlFnCharacterLength:
|
|
if len(e.SFunc.ArgsList) != 1 {
|
|
return qProp{err: fmt.Errorf("%s needs exactly 2 arguments", string(funcName))}
|
|
}
|
|
for _, arg := range e.SFunc.ArgsList {
|
|
result.combine(arg.analyze(s))
|
|
}
|
|
return result
|
|
|
|
case sqlFnLower, sqlFnUpper:
|
|
if len(e.SFunc.ArgsList) != 1 {
|
|
return qProp{err: fmt.Errorf("%s needs exactly 2 arguments", string(funcName))}
|
|
}
|
|
for _, arg := range e.SFunc.ArgsList {
|
|
result.combine(arg.analyze(s))
|
|
}
|
|
return result
|
|
|
|
case sqlFnTrim:
|
|
if e.Trim.TrimChars != nil {
|
|
result.combine(e.Trim.TrimChars.analyze(s))
|
|
}
|
|
if e.Trim.TrimFrom != nil {
|
|
result.combine(e.Trim.TrimFrom.analyze(s))
|
|
}
|
|
return result
|
|
|
|
case sqlFnSubstring:
|
|
errVal := fmt.Errorf("Invalid argument(s) to %s", string(funcName))
|
|
result.combine(e.Substring.Expr.analyze(s))
|
|
switch {
|
|
case e.Substring.From != nil:
|
|
result.combine(e.Substring.From.analyze(s))
|
|
if e.Substring.For != nil {
|
|
result.combine(e.Substring.Expr.analyze(s))
|
|
}
|
|
case e.Substring.Arg2 != nil:
|
|
result.combine(e.Substring.Arg2.analyze(s))
|
|
if e.Substring.Arg3 != nil {
|
|
result.combine(e.Substring.Arg3.analyze(s))
|
|
}
|
|
default:
|
|
result.err = errVal
|
|
}
|
|
return result
|
|
|
|
case sqlFnUTCNow:
|
|
if len(e.SFunc.ArgsList) != 0 {
|
|
result.err = fmt.Errorf("%s() takes no arguments", string(funcName))
|
|
}
|
|
return result
|
|
}
|
|
|
|
// TODO: implement other functions
|
|
return qProp{err: errFunctionNotImplemented}
|
|
}
|