234 lines
4.9 KiB
Go
234 lines
4.9 KiB
Go
// Copyright © 2016 Abcum Ltd
|
|
//
|
|
// 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,
|
|
// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
|
|
// See the License for the specific language governing permissions and
|
|
// limitations under the License.
|
|
|
|
package sql
|
|
|
|
import (
|
|
"bytes"
|
|
"io"
|
|
"strings"
|
|
|
|
"github.com/abcum/fibre"
|
|
)
|
|
|
|
// Parser represents a parser.
|
|
type Parser struct {
|
|
s *Scanner
|
|
c *fibre.Context
|
|
v map[string]interface{}
|
|
buf struct {
|
|
n int // buffer size
|
|
tok Token // last read token
|
|
lit string // last read literal
|
|
val interface{} // Last read value
|
|
}
|
|
}
|
|
|
|
// Parse parses sql from a []byte, string, or io.Reader.
|
|
func Parse(ctx *fibre.Context, i interface{}) (*Query, error) {
|
|
switch v := i.(type) {
|
|
default:
|
|
return nil, &EmptyError{}
|
|
case []byte:
|
|
return ParseBytes(ctx, v)
|
|
case string:
|
|
return ParseString(ctx, v)
|
|
case io.Reader:
|
|
return ParseBuffer(ctx, v)
|
|
}
|
|
}
|
|
|
|
// ParseBytes parses a byte array.
|
|
func ParseBytes(ctx *fibre.Context, i []byte) (*Query, error) {
|
|
r := bytes.NewReader(i)
|
|
p := &Parser{c: ctx}
|
|
p.s = NewScanner(p, r)
|
|
return p.Parse()
|
|
}
|
|
|
|
// ParseString parses a string.
|
|
func ParseString(ctx *fibre.Context, i string) (*Query, error) {
|
|
r := strings.NewReader(i)
|
|
p := &Parser{c: ctx}
|
|
p.s = NewScanner(p, r)
|
|
return p.Parse()
|
|
}
|
|
|
|
// ParseBuffer parses a buffer.
|
|
func ParseBuffer(ctx *fibre.Context, r io.Reader) (*Query, error) {
|
|
p := &Parser{c: ctx}
|
|
p.s = NewScanner(p, r)
|
|
return p.Parse()
|
|
}
|
|
|
|
// Parse parses single or multiple SQL queries.
|
|
func (p *Parser) Parse() (*Query, error) {
|
|
return p.ParseMulti()
|
|
}
|
|
|
|
// ParseMulti parses multiple SQL SELECT statements.
|
|
func (p *Parser) ParseMulti() (*Query, error) {
|
|
|
|
var statements Statements
|
|
|
|
var semi bool
|
|
var text bool
|
|
|
|
for {
|
|
if tok, _, _ := p.scan(); tok == EOF {
|
|
if !text {
|
|
return nil, &EmptyError{}
|
|
}
|
|
return &Query{Statements: statements}, nil
|
|
} else if !semi && tok == SEMICOLON {
|
|
semi = true
|
|
} else {
|
|
text = true
|
|
p.unscan()
|
|
s, err := p.ParseSingle()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
statements = append(statements, s)
|
|
semi = false
|
|
}
|
|
}
|
|
|
|
}
|
|
|
|
// ParseSingle parses a single SQL SELECT statement.
|
|
func (p *Parser) ParseSingle() (Statement, error) {
|
|
|
|
var explain bool
|
|
|
|
if _, _, exi := p.mightBe(EXPLAIN); exi {
|
|
explain = true
|
|
}
|
|
|
|
tok, _, err := p.shouldBe(USE, LET, BEGIN, CANCEL, COMMIT, ROLLBACK, SELECT, CREATE, UPDATE, INSERT, UPSERT, MODIFY, DELETE, RELATE, RECORD, DEFINE, RESYNC, REMOVE)
|
|
|
|
switch tok {
|
|
|
|
case USE:
|
|
return p.parseUseStatement(explain)
|
|
|
|
case BEGIN:
|
|
return p.parseBeginStatement(explain)
|
|
case CANCEL, ROLLBACK:
|
|
return p.parseCancelStatement(explain)
|
|
case COMMIT:
|
|
return p.parseCommitStatement(explain)
|
|
|
|
case SELECT:
|
|
return p.parseSelectStatement(explain)
|
|
case CREATE, INSERT:
|
|
return p.parseCreateStatement(explain)
|
|
case UPDATE, UPSERT:
|
|
return p.parseUpdateStatement(explain)
|
|
case MODIFY:
|
|
return p.parseModifyStatement(explain)
|
|
case DELETE:
|
|
return p.parseDeleteStatement(explain)
|
|
case RELATE:
|
|
return p.parseRelateStatement(explain)
|
|
case RECORD:
|
|
return p.parseRecordStatement(explain)
|
|
|
|
case DEFINE:
|
|
return p.parseDefineStatement(explain)
|
|
case RESYNC:
|
|
return p.parseResyncStatement(explain)
|
|
case REMOVE:
|
|
return p.parseRemoveStatement(explain)
|
|
|
|
default:
|
|
return nil, err
|
|
|
|
}
|
|
|
|
}
|
|
|
|
func (p *Parser) mightBe(expected ...Token) (tok Token, lit string, found bool) {
|
|
|
|
tok, lit, _ = p.scan()
|
|
|
|
if found = p.in(tok, expected); !found {
|
|
p.unscan()
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
func (p *Parser) shouldBe(expected ...Token) (tok Token, lit string, err error) {
|
|
|
|
tok, lit, _ = p.scan()
|
|
|
|
if found := p.in(tok, expected); !found {
|
|
p.unscan()
|
|
err = &ParseError{Found: lit, Expected: lookup(expected)}
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// scan scans the next non-whitespace token.
|
|
func (p *Parser) scan() (tok Token, lit string, val interface{}) {
|
|
|
|
tok, lit, val = p.seek()
|
|
|
|
for {
|
|
if tok == WS {
|
|
tok, lit, val = p.seek()
|
|
} else {
|
|
break
|
|
}
|
|
}
|
|
|
|
return
|
|
|
|
}
|
|
|
|
func (p *Parser) hold(tok Token) (val interface{}) {
|
|
if tok == p.buf.tok {
|
|
return p.buf.val
|
|
}
|
|
return nil
|
|
}
|
|
|
|
// seek returns the next token from the underlying scanner.
|
|
// If a token has been unscanned then read that instead.
|
|
func (p *Parser) seek() (tok Token, lit string, val interface{}) {
|
|
|
|
// If we have a token on the buffer, then return it.
|
|
if p.buf.n != 0 {
|
|
p.buf.n = 0
|
|
return p.buf.tok, p.buf.lit, p.buf.val
|
|
}
|
|
|
|
// Otherwise read the next token from the scanner.
|
|
tok, lit, val = p.s.Scan()
|
|
|
|
// Save it to the buffer in case we unscan later.
|
|
p.buf.tok, p.buf.lit, p.buf.val = tok, lit, val
|
|
|
|
return
|
|
|
|
}
|
|
|
|
// unscan pushes the previously read token back onto the buffer.
|
|
func (p *Parser) unscan() {
|
|
p.buf.n = 1
|
|
}
|