noth/surrealpatch
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions
surrealpatch/sql/ast.go
Tobie Morgan Hitchcock a569ad78d6 Improve statement read/write status detection 
Only store read-write statement status in the database for statements which can be either read or write. For those statements which are always write statements (Live, Kill, Create, Update, Delete, Relate, Insert, Upsert, Define, Remove….), then hardcode this on the statement itself.
2017-11-24 12:56:53 +00:00

783 lines
21 KiB
Go
Raw Blame History

// 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 (
"strconv"
"strings"
"time"
"golang.org/x/text/language"
)
// --------------------------------------------------
// Queries
// --------------------------------------------------
// Query represents a multi statement SQL query
type Query struct {
Statements Statements
}
// Statement represents a single SQL AST
type Statement interface{}
// Statements represents multiple SQL ASTs
type Statements []Statement
// --------------------------------------------------
// Other
// --------------------------------------------------
type AuthableStatement interface {
Auth() (string, string)
}
type KillableStatement interface {
Duration() time.Duration
}
type WriteableStatement interface {
Writeable() bool
}
// --------------------------------------------------
// Trans
// --------------------------------------------------
// UseStatement represents a SQL BEGIN TRANSACTION statement.
type BeginStatement struct{}
// UseStatement represents a SQL CANCEL TRANSACTION statement.
type CancelStatement struct{}
// UseStatement represents a SQL COMMIT TRANSACTION statement.
type CommitStatement struct{}
// --------------------------------------------------
// Use
// --------------------------------------------------
// UseStatement represents a SQL USE statement.
type UseStatement struct {
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Info
// --------------------------------------------------
// InfoStatement represents an SQL INFO statement.
type InfoStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Kind Token `cork:"-" codec:"-"`
What *Table `cork:"-" codec:"-"`
}
// --------------------------------------------------
// If
// --------------------------------------------------
// IfStatement represents an if else clause.
type IfStatement struct {
RW bool `cork:"-" codec:"-"`
Cond Exprs `cork:"cond" codec:"cond"`
Then Exprs `cork:"then" codec:"then"`
Else Expr `cork:"else" codec:"else"`
}
// --------------------------------------------------
// LET
// --------------------------------------------------
// LetStatement represents a SQL LET statement.
type LetStatement struct {
RW bool `cork:"-" codec:"-"`
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"-" codec:"-"`
What Expr `cork:"-" codec:"-"`
}
// ReturnStatement represents a SQL RETURN statement.
type ReturnStatement struct {
RW bool `cork:"-" codec:"-"`
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
What Exprs `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Normal
// --------------------------------------------------
// LiveStatement represents a SQL LIVE statement.
type LiveStatement struct {
ID string `cork:"ID" codec:"ID"`
FB string `cork:"FB" codec:"FB"`
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Diff bool `cork:"diff" codec:"diff"`
Expr Fields `cork:"expr" codec:"expr"`
What *Table `cork:"what" codec:"what"`
Cond Expr `cork:"cond" codec:"cond"`
}
// KillStatement represents a SQL KILL statement.
type KillStatement struct {
FB string `cork:"FB" codec:"FB"`
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Name *Value `cork:"name" codec:"name"`
}
// SelectStatement represents a SQL SELECT statement.
type SelectStatement struct {
RW bool `cork:"-" codec:"-"`
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Expr Fields `cork:"expr" codec:"expr"`
What Exprs `cork:"what" codec:"what"`
Cond Expr `cork:"cond" codec:"cond"`
Group Groups `cork:"group" codec:"group"`
Order Orders `cork:"order" codec:"order"`
Limit Expr `cork:"limit" codec:"limit"`
Start Expr `cork:"start" codec:"start"`
Version Expr `cork:"version" codec:"version"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// CreateStatement represents a SQL CREATE statement.
type CreateStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
What Exprs `cork:"what" codec:"what"`
Data Expr `cork:"data" codec:"data"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// UpdateStatement represents a SQL UPDATE statement.
type UpdateStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
What Exprs `cork:"what" codec:"what"`
Data Expr `cork:"data" codec:"data"`
Cond Expr `cork:"cond" codec:"cond"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// DeleteStatement represents a SQL DELETE statement.
type DeleteStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Hard bool `cork:"hard" codec:"hard"`
What Exprs `cork:"what" codec:"what"`
Cond Expr `cork:"cond" codec:"cond"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// RelateStatement represents a SQL RELATE statement.
type RelateStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Type Expr `cork:"type" codec:"type"`
From Exprs `cork:"from" codec:"from"`
With Exprs `cork:"with" codec:"with"`
Data Expr `cork:"data" codec:"data"`
Uniq bool `cork:"uniq" codec:"uniq"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// InsertStatement represents a SQL INSERT statement.
type InsertStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Data Expr `cork:"data" codec:"data"`
Into *Table `cork:"into" codec:"into"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// UpsertStatement represents a SQL UPSERT statement.
type UpsertStatement struct {
KV string `cork:"KV" codec:"KV"`
NS string `cork:"NS" codec:"NS"`
DB string `cork:"DB" codec:"DB"`
Data Expr `cork:"data" codec:"data"`
Into *Table `cork:"into" codec:"into"`
Echo Token `cork:"echo" codec:"echo"`
Timeout time.Duration `cork:"timeout" codec:"timeout"`
Parallel int `cork:"parallel" codec:"parallel"`
}
// --------------------------------------------------
// Namespace
// --------------------------------------------------
type DefineNamespaceStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
}
type RemoveNamespaceStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
}
// --------------------------------------------------
// Database
// --------------------------------------------------
type DefineDatabaseStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
}
type RemoveDatabaseStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
}
// --------------------------------------------------
// Login
// --------------------------------------------------
// DefineLoginStatement represents an SQL DEFINE LOGIN statement.
type DefineLoginStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Kind Token `cork:"kind" codec:"kind"`
User *Ident `cork:"user" codec:"user"`
Pass []byte `cork:"pass" codec:"pass"`
Code []byte `cork:"code" codec:"code"`
}
// RemoveLoginStatement represents an SQL REMOVE LOGIN statement.
type RemoveLoginStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Kind Token `cork:"kind" codec:"kind"`
User *Ident `cork:"user" codec:"user"`
}
// --------------------------------------------------
// Token
// --------------------------------------------------
// DefineTokenStatement represents an SQL DEFINE TOKEN statement.
type DefineTokenStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Kind Token `cork:"kind" codec:"kind"`
Name *Ident `cork:"name" codec:"name"`
Type string `cork:"type" codec:"type"`
Code []byte `cork:"code" codec:"code"`
}
// RemoveTokenStatement represents an SQL REMOVE TOKEN statement.
type RemoveTokenStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Kind Token `cork:"kind" codec:"kind"`
Name *Ident `cork:"name" codec:"name"`
}
// --------------------------------------------------
// Scope
// --------------------------------------------------
// DefineScopeStatement represents an SQL DEFINE SCOPE statement.
type DefineScopeStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
Time time.Duration `cork:"time" codec:"time"`
Code []byte `cork:"code" codec:"code"`
Signup Expr `cork:"signup" codec:"signup"`
Signin Expr `cork:"signin" codec:"signin"`
Connect Expr `cork:"connect" codec:"connect"`
}
// RemoveScopeStatement represents an SQL REMOVE SCOPE statement.
type RemoveScopeStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
}
// --------------------------------------------------
// Table
// --------------------------------------------------
// DefineTableStatement represents an SQL DEFINE TABLE statement.
type DefineTableStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
What Tables `cork:"-" codec:"-"`
Full bool `cork:"full" codec:"full"`
Drop bool `cork:"drop" codec:"drop"`
Lock bool `cork:"lock" codec:"lock"`
Expr Fields `cork:"expr" codec:"expr"`
From Tables `cork:"from" codec:"from"`
Cond Expr `cork:"cond" codec:"cond"`
Group Groups `cork:"group" codec:"group"`
Perms Expr `cork:"perms" codec:"perms"`
}
// RemoveTableStatement represents an SQL REMOVE TABLE statement.
type RemoveTableStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
What Tables `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Event
// --------------------------------------------------
// DefineEventStatement represents an SQL DEFINE EVENT statement.
type DefineEventStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
What Tables `cork:"-" codec:"-"`
When Expr `cork:"when" codec:"when"`
Then Expr `cork:"then" codec:"then"`
}
// RemoveEventStatement represents an SQL REMOVE EVENT statement.
type RemoveEventStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"-" codec:"-"`
What Tables `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Field
// --------------------------------------------------
// DefineFieldStatement represents an SQL DEFINE FIELD statement.
type DefineFieldStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
What Tables `cork:"-" codec:"-"`
Perms Expr `cork:"perms" codec:"perms"`
Type string `cork:"type" codec:"type"`
Kind string `cork:"kind" codec:"kind"`
Value Expr `cork:"value" codec:"value"`
Assert Expr `cork:"assert" codec:"assert"`
}
// RemoveFieldStatement represents an SQL REMOVE FIELD statement.
type RemoveFieldStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"-" codec:"-"`
What Tables `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Index
// --------------------------------------------------
// DefineIndexStatement represents an SQL DEFINE INDEX statement.
type DefineIndexStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"name" codec:"name"`
What Tables `cork:"-" codec:"-"`
Cols Idents `cork:"cols" codec:"cols"`
Uniq bool `cork:"uniq" codec:"uniq"`
}
// RemoveIndexStatement represents an SQL REMOVE INDEX statement.
type RemoveIndexStatement struct {
KV string `cork:"-" codec:"-"`
NS string `cork:"-" codec:"-"`
DB string `cork:"-" codec:"-"`
Name *Ident `cork:"-" codec:"-"`
What Tables `cork:"-" codec:"-"`
}
// --------------------------------------------------
// Literals
// --------------------------------------------------
// Expr represents a sql expression.
type Expr interface{}
// Exprs represents multiple sql expressions.
type Exprs []Expr
// All represents a * expression.
type All struct{}
// Any represents a ? expression.
type Any struct{}
// Void represents an expression which is not set.
type Void struct{}
// Empty represents an expression which is null or "".
type Empty struct{}
// Field represents a SELECT AS clause.
type Field struct {
Expr Expr
Field string
Alias string
}
// Fields represents multiple SELECT AS clauses.
type Fields []*Field
// Group represents a GROUP BY clause.
type Group struct {
Expr Expr
}
// Groups represents multiple GROUP BY clauses.
type Groups []*Group
// Order represents a ORDER BY clause.
type Order struct {
Expr Expr
Dir bool
Tag language.Tag
}
// Orders represents multiple ORDER BY clauses.
type Orders []*Order
// --------------------------------------------------
// Expressions
// --------------------------------------------------
// SubExpression represents a subquery.
type SubExpression struct {
Expr Expr
}
// IfelExpression represents an if else clause.
type IfelExpression struct {
Cond Exprs
Then Exprs
Else Expr
}
// FuncExpression represents a function call.
type FuncExpression struct {
Name string
Args Exprs
Aggr bool
}
// ItemExpression represents a part of a SET expression.
type ItemExpression struct {
LHS Expr
Op Token
RHS Expr
}
// BinaryExpression represents a WHERE expression.
type BinaryExpression struct {
LHS Expr
Op Token
RHS Expr
}
// PathExpression represents a path expression.
type PathExpression struct {
Expr Exprs
}
// PartExpression represents a path part expression.
type PartExpression struct {
Part Expr
}
// JoinExpression represents a path join expression.
type JoinExpression struct {
Join Token
}
// SubpExpression represents a sub path expression.
type SubpExpression struct {
What Exprs
Name *Ident
Cond Expr
}
// PermExpression represents a permissions expression.
type PermExpression struct {
Select Expr
Create Expr
Update Expr
Delete Expr
}
// DataExpression represents a SET expression.
type DataExpression struct {
Data []*ItemExpression
}
// DiffExpression represents a JSON to DIFF
type DiffExpression struct {
Data Expr
}
// MergeExpression represents JSON to MERGE
type MergeExpression struct {
Data Expr
}
// ContentExpression represents JSON to REPLACE
type ContentExpression struct {
Data Expr
}
// --------------------------------------------------
// Model
// --------------------------------------------------
// Model comment
type Model struct {
TB string
MIN float64
INC float64
MAX float64
}
func NewModel(TB string, MIN, INC, MAX float64) *Model {
return &Model{TB: TB, MIN: MIN, INC: INC, MAX: MAX}
}
// --------------------------------------------------
// Param
// --------------------------------------------------
// Params represents multiple Param clauses.
type Params []*Param
// Param comment
type Param struct {
ID string
}
func NewParam(ID string) *Param {
return &Param{ID}
}
// --------------------------------------------------
// Value
// --------------------------------------------------
// Values represents multiple Value clauses.
type Values []*Value
// Value comment
type Value struct {
ID string
}
func NewValue(ID string) *Value {
return &Value{ID}
}
// --------------------------------------------------
// Ident
// --------------------------------------------------
// Idents represents multiple Ident clauses.
type Idents []*Ident
// Ident comment
type Ident struct {
ID string
}
func NewIdent(ID string) *Ident {
return &Ident{ID}
}
// --------------------------------------------------
// Table
// --------------------------------------------------
// Tables represents multiple Table clauses.
type Tables []*Table
// Table comment
type Table struct {
TB string
}
func NewTable(TB string) *Table {
return &Table{TB}
}
// --------------------------------------------------
// Batch
// --------------------------------------------------
// Batchs represents multiple Batch clauses.
type Batchs []*Batch
// Batch comment
type Batch struct {
TB string
BA []*Thing
}
func NewBatch(TB string, BA []interface{}) *Batch {
var b = &Batch{TB: TB}
for _, ID := range BA {
b.BA = append(b.BA, NewThing(TB, ID))
}
return b
}
// --------------------------------------------------
// Thing
// --------------------------------------------------
// Things represents multiple Thing clauses.
type Things []*Thing
// Thing comment
type Thing struct {
TB string
ID interface{}
}
func NewThing(TB string, ID interface{}) *Thing {
switch val := ID.(type) {
default:
return &Thing{TB: TB, ID: ID}
case int:
return &Thing{TB: TB, ID: float64(val)}
case int64:
return &Thing{TB: TB, ID: float64(val)}
case string:
val = strings.Replace(val, TB+":", "", -1)
if cnv, err := strconv.ParseFloat(val, 64); err == nil {
return &Thing{TB: TB, ID: cnv}
} else if cnv, err := strconv.ParseBool(val); err == nil {
return &Thing{TB: TB, ID: cnv}
} else if cnv, err := time.Parse(RFCDate, val); err == nil {
return &Thing{TB: TB, ID: cnv.UTC()}
} else if cnv, err := time.Parse(RFCTime, val); err == nil {
return &Thing{TB: TB, ID: cnv.UTC()}
}
return &Thing{TB: TB, ID: val}
}
}
// --------------------------------------------------
// Point
// --------------------------------------------------
// Points represents multiple Point clauses.
type Points []*Point
// Point comment
type Point struct {
LA float64
LO float64
}
func NewPoint(LA, LO float64) *Point {
return &Point{LA: LA, LO: LO}
}
// --------------------------------------------------
// Circle
// --------------------------------------------------
// Circles represents multiple Circle clauses.
type Circles []*Circle
// Circle comment
type Circle struct {
CE *Point
RA float64
}
func NewCircle(CE *Point, RA float64) *Circle {
return &Circle{CE: CE, RA: RA}
}
// --------------------------------------------------
// Polygon
// --------------------------------------------------
// Polygons represents multiple Polygon clauses.
type Polygons []*Polygon
// Polygon comment
type Polygon struct {
PS Points
}
func NewPolygon(PS ...*Point) *Polygon {
return &Polygon{PS: PS}
}
Reference in a new issue View git blame Copy permalink