From 857d6e4d7556c055ef9416803bd431a9d1f7b8a0 Mon Sep 17 00:00:00 2001 From: minodisk Date: Mon, 6 Mar 2017 12:21:22 +0900 Subject: [PATCH] Make every types pointer --- stmt/assign.go | 11 +- stmt/case_searched.go | 46 +++---- stmt/case_simple.go | 48 ++++---- stmt/column.go | 84 ++++++------- stmt/column_alias.go | 10 +- stmt/column_alias_test.go | 8 +- stmt/column_test.go | 2 +- stmt/create_table.go | 14 +-- stmt/definition.go | 16 +-- stmt/delete.go | 12 +- stmt/from.go | 18 +-- stmt/func.go | 54 ++++----- stmt/func_date.go | 240 ++++++++++++++++++------------------- stmt/func_date_interval.go | 90 +++++++------- stmt/func_string.go | 4 +- stmt/group_by.go | 20 ++-- stmt/having.go | 14 +-- stmt/insert.go | 18 +-- stmt/interfaces.go | 8 +- stmt/join.go | 34 +++--- stmt/join_test.go | 2 +- stmt/limit.go | 12 +- stmt/offset.go | 10 +- stmt/on.go | 40 +++++-- stmt/op.go | 90 +++++++------- stmt/op_nonscalar.go | 68 +++++------ stmt/order.go | 18 +-- stmt/order_by.go | 14 +-- stmt/order_test.go | 10 +- stmt/select.go | 16 +-- stmt/set.go | 14 +-- stmt/set_operation.go | 34 +++--- stmt/subquery.go | 46 +++---- stmt/subquery_alias.go | 12 +- stmt/table.go | 30 ++--- stmt/table_alias.go | 24 ++-- stmt/table_alias_test.go | 2 +- stmt/table_test.go | 8 +- stmt/update.go | 14 +-- stmt/using.go | 32 +++-- stmt/val.go | 12 +- stmt/values.go | 20 ++-- stmt/where.go | 16 +-- 43 files changed, 660 insertions(+), 635 deletions(-) diff --git a/stmt/assign.go b/stmt/assign.go index d276596..1efb8d6 100644 --- a/stmt/assign.go +++ b/stmt/assign.go @@ -7,18 +7,17 @@ import ( ) type Assign struct { - column Column + column *Column param ValOrFuncOrSub } -func NewAssign(column Column, param ValOrFuncOrSub) Assign { - return Assign{ - column: column, - param: param, +func NewAssign(param ValOrFuncOrSub) *Assign { + return &Assign{ + param: param, } } -func (a Assign) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (a *Assign) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := a.column.nodeize() t2, v2 := a.param.nodeize() return tokenizer.ConcatTokenizers( diff --git a/stmt/case_searched.go b/stmt/case_searched.go index 53a9046..eb10b2a 100644 --- a/stmt/case_searched.go +++ b/stmt/case_searched.go @@ -10,13 +10,13 @@ type SearchedCase struct { thenOrElse SearchedThenOrElse } -func NewSearchedCase(thenOrElse SearchedThenOrElse) SearchedCase { - return SearchedCase{ +func NewSearchedCase(thenOrElse SearchedThenOrElse) *SearchedCase { + return &SearchedCase{ thenOrElse: thenOrElse, } } -func (c SearchedCase) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (c *SearchedCase) nodeize() (tokenizer.Tokenizer, []interface{}) { t, v := c.thenOrElse.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Case)), @@ -32,23 +32,23 @@ type SearchedWhen struct { prev Prever } -func NewSearchedWhen(condition ComparisonOrLogicalOperation) SearchedWhen { - return SearchedWhen{ +func NewSearchedWhen(condition ComparisonOrLogicalOperation) *SearchedWhen { + return &SearchedWhen{ condition: condition, } } -func (w SearchedWhen) Then(param ValOrColOrFuncOrSub) SearchedThen { +func (w *SearchedWhen) Then(param ValOrColOrFuncOrSub) *SearchedThen { t := NewSearchedThen(param) t.prev = w return t } -func (w SearchedWhen) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (w *SearchedWhen) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(w) } -func (w SearchedWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (w *SearchedWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t, vals := w.condition.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.When)), @@ -57,7 +57,7 @@ func (w SearchedWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (w SearchedWhen) previous() Prever { +func (w *SearchedWhen) previous() Prever { return w.prev } @@ -66,29 +66,29 @@ type SearchedThen struct { prev Prever } -func NewSearchedThen(param ValOrColOrFuncOrSub) SearchedThen { - return SearchedThen{ +func NewSearchedThen(param ValOrColOrFuncOrSub) *SearchedThen { + return &SearchedThen{ param: param, } } -func (t SearchedThen) When(condition ComparisonOrLogicalOperation) SearchedWhen { +func (t *SearchedThen) When(condition ComparisonOrLogicalOperation) *SearchedWhen { w := NewSearchedWhen(condition) w.prev = t return w } -func (t SearchedThen) Else(param ValOrColOrFuncOrSub) SearchedElse { +func (t *SearchedThen) Else(param ValOrColOrFuncOrSub) *SearchedElse { e := NewSearchedElse(param) e.prev = t return e } -func (t SearchedThen) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (t *SearchedThen) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(t) } -func (t SearchedThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (t *SearchedThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tk, vals := t.param.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Then)), @@ -97,11 +97,11 @@ func (t SearchedThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (t SearchedThen) previous() Prever { +func (t *SearchedThen) previous() Prever { return t.prev } -func (t SearchedThen) isSearchedThenOrElse() bool { +func (t *SearchedThen) isSearchedThenOrElse() bool { return true } @@ -110,17 +110,17 @@ type SearchedElse struct { prev Prever } -func NewSearchedElse(param ValOrColOrFuncOrSub) SearchedElse { - return SearchedElse{ +func NewSearchedElse(param ValOrColOrFuncOrSub) *SearchedElse { + return &SearchedElse{ param: param, } } -func (e SearchedElse) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (e *SearchedElse) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(e) } -func (e SearchedElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (e *SearchedElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t, vals := e.param.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Else)), @@ -129,10 +129,10 @@ func (e SearchedElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (e SearchedElse) previous() Prever { +func (e *SearchedElse) previous() Prever { return e.prev } -func (e SearchedElse) isSearchedThenOrElse() bool { +func (e *SearchedElse) isSearchedThenOrElse() bool { return true } diff --git a/stmt/case_simple.go b/stmt/case_simple.go index 99884fe..bdc0d1a 100644 --- a/stmt/case_simple.go +++ b/stmt/case_simple.go @@ -11,14 +11,14 @@ type SimpleCase struct { thenOrElse SimpleThenOrElse } -func NewSimpleCase(param ValOrColOrFuncOrSub, thenOrElse SimpleThenOrElse) SimpleCase { - return SimpleCase{ +func NewSimpleCase(param ValOrColOrFuncOrSub, thenOrElse SimpleThenOrElse) *SimpleCase { + return &SimpleCase{ param: param, thenOrElse: thenOrElse, } } -func (c SimpleCase) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (c *SimpleCase) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := c.param.nodeize() t2, v2 := c.thenOrElse.nodeize() return tokenizer.NewContainer( @@ -31,27 +31,27 @@ func (c SimpleCase) nodeize() (tokenizer.Tokenizer, []interface{}) { } type SimpleWhen struct { - param Val + param *Val prev Prever } -func NewSimpleWhen(param Val) SimpleWhen { - return SimpleWhen{ +func NewSimpleWhen(param *Val) *SimpleWhen { + return &SimpleWhen{ param: param, } } -func (w SimpleWhen) Then(param ValOrColOrFuncOrSub) SimpleThen { +func (w *SimpleWhen) Then(param ValOrColOrFuncOrSub) *SimpleThen { t := NewSimpleThen(param) t.prev = w return t } -func (w SimpleWhen) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (w *SimpleWhen) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(w) } -func (w SimpleWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (w *SimpleWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t, vals := w.param.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.When)), @@ -60,7 +60,7 @@ func (w SimpleWhen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (w SimpleWhen) previous() Prever { +func (w *SimpleWhen) previous() Prever { return w.prev } @@ -69,29 +69,29 @@ type SimpleThen struct { prev Prever } -func NewSimpleThen(param ValOrColOrFuncOrSub) SimpleThen { - return SimpleThen{ +func NewSimpleThen(param ValOrColOrFuncOrSub) *SimpleThen { + return &SimpleThen{ param: param, } } -func (t SimpleThen) When(param Val) SimpleWhen { +func (t *SimpleThen) When(param *Val) *SimpleWhen { w := NewSimpleWhen(param) w.prev = t return w } -func (t SimpleThen) Else(param ValOrColOrFuncOrSub) SimpleElse { +func (t *SimpleThen) Else(param ValOrColOrFuncOrSub) *SimpleElse { e := NewSimpleElse(param) e.prev = t return e } -func (t SimpleThen) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (t *SimpleThen) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(t) } -func (t SimpleThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (t *SimpleThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tk, vals := t.param.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Then)), @@ -100,11 +100,11 @@ func (t SimpleThen) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (t SimpleThen) previous() Prever { +func (t *SimpleThen) previous() Prever { return t.prev } -func (t SimpleThen) isSimpleThenOrElse() bool { +func (t *SimpleThen) isSimpleThenOrElse() bool { return true } @@ -113,17 +113,17 @@ type SimpleElse struct { prev Prever } -func NewSimpleElse(param ValOrColOrFuncOrSub) SimpleElse { - return SimpleElse{ +func NewSimpleElse(param ValOrColOrFuncOrSub) *SimpleElse { + return &SimpleElse{ param: param, } } -func (e SimpleElse) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (e *SimpleElse) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(e) } -func (e SimpleElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (e *SimpleElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t, vals := e.param.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Else)), @@ -132,10 +132,10 @@ func (e SimpleElse) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), vals } -func (e SimpleElse) previous() Prever { +func (e *SimpleElse) previous() Prever { return e.prev } -func (e SimpleElse) isSimpleThenOrElse() bool { +func (e *SimpleElse) isSimpleThenOrElse() bool { return true } diff --git a/stmt/column.go b/stmt/column.go index 17aedc3..8b887b8 100644 --- a/stmt/column.go +++ b/stmt/column.go @@ -8,19 +8,19 @@ import ( // Column is a stmt to indicate a column in a table. type Column struct { Name string - table Table + table *Table } // NewColumn returns a new Column. -func NewColumn(name string) Column { - return Column{ +func NewColumn(name string) *Column { + return &Column{ Name: name, } } // As is used to give an alias name to the column. // Returns a new ColumnAs. -func (c Column) As(alias string) ColumnAlias { +func (c *Column) As(alias string) *ColumnAlias { a := NewColumnAlias(alias) a.column = c return a @@ -29,7 +29,7 @@ func (c Column) As(alias string) ColumnAlias { // Define is used to specify a definition for the column. // This constitutes a part of the table creation. // Returns a new Definition. -func (c Column) Define(definition string) Definition { +func (c *Column) Define(definition string) *Definition { d := NewDefinition(definition) d.column = c return d @@ -38,178 +38,180 @@ func (c Column) Define(definition string) Definition { // Assign is used to assign a params to the column. // This constitutes a part of the record update stmt. // Returns a new Assign. -func (c Column) Assign(param ValOrFuncOrSub) Assign { - return NewAssign(c, param) +func (c *Column) Assign(param ValOrFuncOrSub) *Assign { + a := NewAssign(param) + a.column = c + return a } -func (c Column) Eq(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Eq(val ValOrColOrFuncOrSub) *ComparisonOperation { e := NewEq(val) e.column = c return e } -func (c Column) NotEq(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) NotEq(val ValOrColOrFuncOrSub) *ComparisonOperation { n := NewNotEq(val) n.column = c return n } -func (c Column) Gt(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Gt(val ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGt(val) g.column = c return g } -func (c Column) Gte(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Gte(val ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGte(val) g.column = c return g } -func (c Column) Lt(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Lt(val ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLt(val) l.column = c return l } -func (c Column) Lte(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Lte(val ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLte(val) l.column = c return l } -func (c Column) Like(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) Like(val ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLike(val) l.column = c return l } -func (c Column) RegExp(val ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Column) RegExp(val ValOrColOrFuncOrSub) *ComparisonOperation { r := NewRegExp(val) r.column = c return r } -func (c Column) Between(from, to ValOrColOrFuncOrSub) Between { +func (c *Column) Between(from, to ValOrColOrFuncOrSub) *Between { b := NewBetween(from, to) b.column = c return b } -func (c Column) In(params ValsOrSub) ContainingOperation { +func (c *Column) In(params ValsOrSub) *ContainingOperation { i := NewIn(params) i.column = c return i } -func (c Column) NotIn(params ValsOrSub) ContainingOperation { +func (c *Column) NotIn(params ValsOrSub) *ContainingOperation { n := NewNotIn(params) n.column = c return n } -func (c Column) IsNull() NullOperation { +func (c *Column) IsNull() *NullOperation { i := NewIsNull() i.column = c return i } -func (c Column) IsNotNull() NullOperation { +func (c *Column) IsNotNull() *NullOperation { i := NewIsNotNull() i.column = c return i } -func (c Column) EqAll(params Subquery) NonScalarOperation { +func (c *Column) EqAll(params *Subquery) *NonScalarOperation { n := NewEqAll(params) n.column = c return n } -func (c Column) NotEqAll(params Subquery) NonScalarOperation { +func (c *Column) NotEqAll(params *Subquery) *NonScalarOperation { n := NewNotEqAll(params) n.column = c return n } -func (c Column) GtAll(params Subquery) NonScalarOperation { +func (c *Column) GtAll(params *Subquery) *NonScalarOperation { n := NewGtAll(params) n.column = c return n } -func (c Column) GteAll(params Subquery) NonScalarOperation { +func (c *Column) GteAll(params *Subquery) *NonScalarOperation { n := NewGteAll(params) n.column = c return n } -func (c Column) LtAll(params Subquery) NonScalarOperation { +func (c *Column) LtAll(params *Subquery) *NonScalarOperation { n := NewLtAll(params) n.column = c return n } -func (c Column) LteAll(params Subquery) NonScalarOperation { +func (c *Column) LteAll(params *Subquery) *NonScalarOperation { n := NewLteAll(params) n.column = c return n } -func (c Column) EqAny(params Subquery) NonScalarOperation { +func (c *Column) EqAny(params *Subquery) *NonScalarOperation { n := NewEqAny(params) n.column = c return n } -func (c Column) NotEqAny(params Subquery) NonScalarOperation { +func (c *Column) NotEqAny(params *Subquery) *NonScalarOperation { n := NewNotEqAny(params) n.column = c return n } -func (c Column) GtAny(params Subquery) NonScalarOperation { +func (c *Column) GtAny(params *Subquery) *NonScalarOperation { n := NewGtAny(params) n.column = c return n } -func (c Column) GteAny(params Subquery) NonScalarOperation { +func (c *Column) GteAny(params *Subquery) *NonScalarOperation { n := NewGteAny(params) n.column = c return n } -func (c Column) LtAny(params Subquery) NonScalarOperation { +func (c *Column) LtAny(params *Subquery) *NonScalarOperation { n := NewLtAny(params) n.column = c return n } -func (c Column) LteAny(params Subquery) NonScalarOperation { +func (c *Column) LteAny(params *Subquery) *NonScalarOperation { n := NewLteAny(params) n.column = c return n } -func (c Column) Asc() Order { +func (c *Column) Asc() *Order { o := NewAsc() o.column = c return o } -func (c Column) Desc() Order { +func (c *Column) Desc() *Order { o := NewDesc() o.column = c return o } -func (c Column) nodeize() (tokenizer.Tokenizer, []interface{}) { - t1, v1 := c.table.nodeizeSelf() - if t1 == nil { +func (c *Column) nodeize() (tokenizer.Tokenizer, []interface{}) { + if c.table == nil { return tokenizer.NewLine(token.Word(c.Name)), nil } + t1, v1 := c.table.nodeizeSelf() return t1.Append( token.Period, token.Word(c.Name), @@ -219,27 +221,27 @@ func (c Column) nodeize() (tokenizer.Tokenizer, []interface{}) { // isColOrSub always returns true. // This method exists only to implement the interface ColOrSub. // This is a shit of duck typing, but anyway it works. -func (c Column) isColOrSub() bool { +func (c *Column) isColOrSub() bool { return true } // isColOrAliasOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrSub. // This is a shit of duck typing, but anyway it works. -func (c Column) isColOrAliasOrSub() bool { +func (c *Column) isColOrAliasOrSub() bool { return true } // isColOrAliasOrFuncOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (c Column) isColOrAliasOrFuncOrSub() bool { +func (c *Column) isColOrAliasOrFuncOrSub() bool { return true } // isValOrColOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrColOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (c Column) isValOrColOrFuncOrSub() bool { +func (c *Column) isValOrColOrFuncOrSub() bool { return true } diff --git a/stmt/column_alias.go b/stmt/column_alias.go index 693ec46..a265c61 100644 --- a/stmt/column_alias.go +++ b/stmt/column_alias.go @@ -11,13 +11,13 @@ type ColumnAlias struct { Alias string } -func NewColumnAlias(alias string) ColumnAlias { - return ColumnAlias{ +func NewColumnAlias(alias string) *ColumnAlias { + return &ColumnAlias{ Alias: alias, } } -func (c ColumnAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (c *ColumnAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { if c.column == nil { return tokenizer.NewLine( token.Word(keyword.As), @@ -45,13 +45,13 @@ func (c ColumnAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { // isColumnOrColumnAsOrSubquery always returns true. // This method exists only to implement the interface ColumnOrColumnAsOrSubquery. // This is a shit of duck typing, but anyway it works. -func (c ColumnAlias) isColOrAliasOrSub() bool { +func (c *ColumnAlias) isColOrAliasOrSub() bool { return true } // isColOrAliasOrFuncOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (c ColumnAlias) isColOrAliasOrFuncOrSub() bool { +func (c *ColumnAlias) isColOrAliasOrFuncOrSub() bool { return true } diff --git a/stmt/column_alias_test.go b/stmt/column_alias_test.go index cc691e3..b9b2fd3 100644 --- a/stmt/column_alias_test.go +++ b/stmt/column_alias_test.go @@ -9,22 +9,22 @@ import ( "github.com/minodisk/sqlabble/stmt" ) -func TestColumnAsType(t *testing.T) { +func TestColumnAliasType(t *testing.T) { t.Parallel() for _, c := range []interface{}{ - stmt.ColumnAlias{}, + &stmt.ColumnAlias{}, } { c := c t.Run(fmt.Sprintf("%T", c), func(t *testing.T) { t.Parallel() if _, ok := c.(stmt.ColOrAliasOrSub); !ok { - t.Errorf("%T should implement stmt.ColumnOrColumnAs", c) + t.Errorf("%T should implement stmt.ColumnOrColumnAlias", c) } }) } } -func TestColumnAsSQL(t *testing.T) { +func TestColumnAliasSQL(t *testing.T) { t.Parallel() for i, c := range []struct { stmt stmt.Statement diff --git a/stmt/column_test.go b/stmt/column_test.go index c72146f..2551a3d 100644 --- a/stmt/column_test.go +++ b/stmt/column_test.go @@ -12,7 +12,7 @@ import ( func TestColumnType(t *testing.T) { t.Parallel() for _, c := range []interface{}{ - stmt.Column{}, + &stmt.Column{}, } { c := c t.Run(fmt.Sprintf("%T", c), func(t *testing.T) { diff --git a/stmt/create_table.go b/stmt/create_table.go index a66d89c..5654ad6 100644 --- a/stmt/create_table.go +++ b/stmt/create_table.go @@ -11,31 +11,31 @@ type CreateTable struct { joiner Joiner } -func NewCreateTable(joiner Joiner) CreateTable { - return CreateTable{ +func NewCreateTable(joiner Joiner) *CreateTable { + return &CreateTable{ ifNotExists: false, joiner: joiner, } } -func NewCreateTableIfNotExists(joiner Joiner) CreateTable { - return CreateTable{ +func NewCreateTableIfNotExists(joiner Joiner) *CreateTable { + return &CreateTable{ ifNotExists: true, joiner: joiner, } } -func (c CreateTable) Definitions(defs ...Definition) Definitions { +func (c *CreateTable) Definitions(defs ...*Definition) *Definitions { ds := NewDefinitions(defs...) ds.createTable = c return ds } -func (c CreateTable) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (c *CreateTable) nodeize() (tokenizer.Tokenizer, []interface{}) { return c.container() } -func (c CreateTable) container() (tokenizer.Container, []interface{}) { +func (c *CreateTable) container() (tokenizer.Container, []interface{}) { line := tokenizer.NewLine(token.Word(keyword.CreateTable)) if c.ifNotExists { line = line.A( diff --git a/stmt/definition.go b/stmt/definition.go index f5dc6af..2b70f7e 100644 --- a/stmt/definition.go +++ b/stmt/definition.go @@ -6,17 +6,17 @@ import ( ) type Definition struct { - column Column + column *Column definition string } -func NewDefinition(definition string) Definition { - return Definition{ +func NewDefinition(definition string) *Definition { + return &Definition{ definition: definition, } } -func (d Definition) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (d *Definition) nodeize() (tokenizer.Tokenizer, []interface{}) { t, values := d.column.nodeize() return t. Append( @@ -25,12 +25,12 @@ func (d Definition) nodeize() (tokenizer.Tokenizer, []interface{}) { } type Definitions struct { - createTable CreateTable - definitions []Definition + createTable *CreateTable + definitions []*Definition } -func NewDefinitions(definitions ...Definition) Definitions { - return Definitions{ +func NewDefinitions(definitions ...*Definition) *Definitions { + return &Definitions{ definitions: definitions, } } diff --git a/stmt/delete.go b/stmt/delete.go index 942591b..1e24979 100644 --- a/stmt/delete.go +++ b/stmt/delete.go @@ -8,26 +8,26 @@ import ( type Delete struct{} -func NewDelete() Delete { - return Delete{} +func NewDelete() *Delete { + return &Delete{} } -func (d Delete) From(t Table) From { +func (d *Delete) From(t *Table) *From { f := NewFrom(t) f.prev = d return f } -func (d Delete) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (d *Delete) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(d) } -func (d Delete) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (d *Delete) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Delete)), ), nil } -func (d Delete) previous() Prever { +func (d *Delete) previous() Prever { return nil } diff --git a/stmt/from.go b/stmt/from.go index c1eaac5..c8959ad 100644 --- a/stmt/from.go +++ b/stmt/from.go @@ -11,41 +11,41 @@ type From struct { table TableOrAliasOrJoiner } -func NewFrom(table TableOrAliasOrJoiner) From { - return From{ +func NewFrom(table TableOrAliasOrJoiner) *From { + return &From{ table: table, } } -func (f From) Where(op ComparisonOrLogicalOperation) Where { +func (f *From) Where(op ComparisonOrLogicalOperation) *Where { w := NewWhere(op) w.prev = f return w } -func (f From) GroupBy(col Column, columns ...Column) GroupBy { +func (f *From) GroupBy(col *Column, columns ...*Column) *GroupBy { g := NewGroupBy(col, columns...) g.prev = f return g } -func (f From) OrderBy(orders ...Order) OrderBy { +func (f *From) OrderBy(orders ...*Order) *OrderBy { o := NewOrderBy(orders...) o.prev = f return o } -func (f From) Limit(count int) Limit { +func (f *From) Limit(count int) *Limit { l := NewLimit(count) l.prev = f return l } -func (f From) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (f *From) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(f) } -func (f From) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (f *From) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { middle, values := f.table.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.From)), @@ -54,6 +54,6 @@ func (f From) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (f From) previous() Prever { +func (f *From) previous() Prever { return f.prev } diff --git a/stmt/func.go b/stmt/func.go index c9561e1..152c2f5 100644 --- a/stmt/func.go +++ b/stmt/func.go @@ -47,145 +47,145 @@ type Func struct { args Args } -func (c Func) Eq(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Eq(value ValOrColOrFuncOrSub) *ComparisonOperation { e := NewEq(value) e.column = c return e } -func (c Func) NotEq(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) NotEq(value ValOrColOrFuncOrSub) *ComparisonOperation { n := NewNotEq(value) n.column = c return n } -func (c Func) Gt(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Gt(value ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGt(value) g.column = c return g } -func (c Func) Gte(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Gte(value ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGte(value) g.column = c return g } -func (c Func) Lt(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Lt(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLt(value) l.column = c return l } -func (c Func) Lte(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Lte(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLte(value) l.column = c return l } -func (c Func) Like(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) Like(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLike(value) l.column = c return l } -func (c Func) RegExp(value ValOrColOrFuncOrSub) ComparisonOperation { +func (c *Func) RegExp(value ValOrColOrFuncOrSub) *ComparisonOperation { r := NewRegExp(value) r.column = c return r } -func (c Func) Between(from, to ValOrColOrFuncOrSub) Between { +func (c *Func) Between(from, to ValOrColOrFuncOrSub) *Between { b := NewBetween(from, to) b.column = c return b } -func (c Func) In(arg ValsOrSub) ContainingOperation { +func (c *Func) In(arg ValsOrSub) *ContainingOperation { i := NewIn(arg) i.column = c return i } -func (c Func) NotIn(arg ValsOrSub) ContainingOperation { +func (c *Func) NotIn(arg ValsOrSub) *ContainingOperation { n := NewNotIn(arg) n.column = c return n } -func (c Func) EqAll(arg Subquery) NonScalarOperation { +func (c *Func) EqAll(arg *Subquery) *NonScalarOperation { n := NewEqAll(arg) n.column = c return n } -func (c Func) NotEqAll(arg Subquery) NonScalarOperation { +func (c *Func) NotEqAll(arg *Subquery) *NonScalarOperation { n := NewNotEqAll(arg) n.column = c return n } -func (c Func) GtAll(arg Subquery) NonScalarOperation { +func (c *Func) GtAll(arg *Subquery) *NonScalarOperation { n := NewGtAll(arg) n.column = c return n } -func (c Func) GteAll(arg Subquery) NonScalarOperation { +func (c *Func) GteAll(arg *Subquery) *NonScalarOperation { n := NewGteAll(arg) n.column = c return n } -func (c Func) LtAll(arg Subquery) NonScalarOperation { +func (c *Func) LtAll(arg *Subquery) *NonScalarOperation { n := NewLtAll(arg) n.column = c return n } -func (c Func) LteAll(arg Subquery) NonScalarOperation { +func (c *Func) LteAll(arg *Subquery) *NonScalarOperation { n := NewLteAll(arg) n.column = c return n } -func (c Func) EqAny(arg Subquery) NonScalarOperation { +func (c *Func) EqAny(arg *Subquery) *NonScalarOperation { n := NewEqAny(arg) n.column = c return n } -func (c Func) NotEqAny(arg Subquery) NonScalarOperation { +func (c *Func) NotEqAny(arg *Subquery) *NonScalarOperation { n := NewNotEqAny(arg) n.column = c return n } -func (c Func) GtAny(arg Subquery) NonScalarOperation { +func (c *Func) GtAny(arg *Subquery) *NonScalarOperation { n := NewGtAny(arg) n.column = c return n } -func (c Func) GteAny(arg Subquery) NonScalarOperation { +func (c *Func) GteAny(arg *Subquery) *NonScalarOperation { n := NewGteAny(arg) n.column = c return n } -func (c Func) LtAny(arg Subquery) NonScalarOperation { +func (c *Func) LtAny(arg *Subquery) *NonScalarOperation { n := NewLtAny(arg) n.column = c return n } -func (c Func) LteAny(arg Subquery) NonScalarOperation { +func (c *Func) LteAny(arg *Subquery) *NonScalarOperation { n := NewLteAny(arg) n.column = c return n } -func (f Func) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (f *Func) nodeize() (tokenizer.Tokenizer, []interface{}) { t, v := f.args.nodeize() return t.Prepend(token.Word(f.name)), v } @@ -193,20 +193,20 @@ func (f Func) nodeize() (tokenizer.Tokenizer, []interface{}) { // isValOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (f Func) isValOrFuncOrSub() bool { +func (f *Func) isValOrFuncOrSub() bool { return true } // isValOrColOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrColOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (f Func) isValOrColOrFuncOrSub() bool { +func (f *Func) isValOrColOrFuncOrSub() bool { return true } // isColOrAliasOrFuncOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (f Func) isColOrAliasOrFuncOrSub() bool { +func (f *Func) isColOrAliasOrFuncOrSub() bool { return true } diff --git a/stmt/func_date.go b/stmt/func_date.go index 4390c4a..5d5a646 100644 --- a/stmt/func_date.go +++ b/stmt/func_date.go @@ -54,419 +54,419 @@ var ( UnitYearMonth = NewVal(YearMonth) ) -func NewAdddate(date ValOrColOrFuncOrSub, interval IntervalUnit) Func { - return Func{ +func NewAdddate(date ValOrColOrFuncOrSub, interval *IntervalUnit) *Func { + return &Func{ name: keyword.Adddate, args: Args{date, interval}, } } -func NewAddtime(date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewAddtime(date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Addtime, args: Args{date1, date2}, } } -func NewConvertTz(date, from, to ValOrColOrFuncOrSub) Func { - return Func{ +func NewConvertTz(date, from, to ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.ConvertTz, args: Args{date, from, to}, } } -func NewCurDate() Func { - return Func{ +func NewCurDate() *Func { + return &Func{ name: keyword.CurDate, } } -func NewCurrentDate() Func { - return Func{ +func NewCurrentDate() *Func { + return &Func{ name: keyword.CurrentDate, } } -func NewCurrentTime(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewCurrentTime(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.CurrentTime, args: Args{fsp}, } } -func NewCurrentTimestamp(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewCurrentTimestamp(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.CurrentTimestamp, args: Args{fsp}, } } -func NewCurtime(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewCurtime(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Curtime, args: Args{fsp}, } } -func NewDate(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDate(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Date, args: Args{date}, } } -func NewDateAdd(date ValOrColOrFuncOrSub, interval IntervalUnit) Func { - return Func{ +func NewDateAdd(date ValOrColOrFuncOrSub, interval *IntervalUnit) *Func { + return &Func{ name: keyword.DateAdd, args: Args{date, interval}, } } -func NewDateFormat(date, format ValOrColOrFuncOrSub) Func { - return Func{ +func NewDateFormat(date, format ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.DateFormat, args: Args{date, format}, } } -func NewDateSub(date ValOrColOrFuncOrSub, interval IntervalUnit) Func { - return Func{ +func NewDateSub(date ValOrColOrFuncOrSub, interval *IntervalUnit) *Func { + return &Func{ name: keyword.DateSub, args: Args{date, interval}, } } -func NewDatediff(date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewDatediff(date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Datediff, args: Args{date1, date2}, } } -func NewDay(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDay(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Day, args: Args{date}, } } -func NewDayname(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDayname(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Dayname, args: Args{date}, } } -func NewDayofmonth(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDayofmonth(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Dayofmonth, args: Args{date}, } } -func NewDayofweek(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDayofweek(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Dayofweek, args: Args{date}, } } -func NewDayofyear(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewDayofyear(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Dayofyear, args: Args{date}, } } -func NewExtract(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewExtract(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Extract, args: Args{date}, } } -func NewFromDays(days ValOrColOrFuncOrSub) Func { - return Func{ +func NewFromDays(days ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.FromDays, args: Args{days}, } } -func NewFromUnixtime(utime, format ValOrColOrFuncOrSub) Func { - return Func{ +func NewFromUnixtime(utime, format ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.FromUnixtime, args: Args{utime, format}, } } -func NewGetFormat(typ, name ValOrColOrFuncOrSub) Func { - return Func{ +func NewGetFormat(typ, name ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.GetFormat, args: Args{typ, name}, } } -func NewHour(time ValOrColOrFuncOrSub) Func { - return Func{ +func NewHour(time ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Hour, args: Args{time}, } } -func NewLastDay(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewLastDay(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.LastDay, args: Args{date}, } } -func NewLocaltime(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewLocaltime(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Localtime, args: Args{fsp}, } } -func NewLocaltimestamp(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewLocaltimestamp(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Localtimestamp, args: Args{fsp}, } } -func NewMakedate(year, days ValOrColOrFuncOrSub) Func { - return Func{ +func NewMakedate(year, days ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Makedate, args: Args{year, days}, } } -func NewMaketime(hours, minutes, seconds ValOrColOrFuncOrSub) Func { - return Func{ +func NewMaketime(hours, minutes, seconds ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Maketime, args: Args{hours, minutes, seconds}, } } -func NewMicrosecond(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewMicrosecond(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Microsecond, args: Args{date}, } } -func NewMinute(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewMinute(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Minute, args: Args{date}, } } -func NewMonth(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewMonth(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Month, args: Args{date}, } } -func NewMonthname(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewMonthname(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Monthname, args: Args{date}, } } -func NewNow(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewNow(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Now, args: Args{fsp}, } } -func NewPeriodAdd(period, value ValOrColOrFuncOrSub) Func { - return Func{ +func NewPeriodAdd(period, value ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.PeriodAdd, args: Args{period, value}, } } -func NewPeriodDiff(period1, period2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewPeriodDiff(period1, period2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.PeriodDiff, args: Args{period1, period2}, } } -func NewQuarter(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewQuarter(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Quarter, args: Args{date}, } } -func NewSecToTime(seconds ValOrColOrFuncOrSub) Func { - return Func{ +func NewSecToTime(seconds ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.SecToTime, args: Args{seconds}, } } -func NewSecond(time ValOrColOrFuncOrSub) Func { - return Func{ +func NewSecond(time ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Second, args: Args{time}, } } -func NewStrToDate(str, format ValOrColOrFuncOrSub) Func { - return Func{ +func NewStrToDate(str, format ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.StrToDate, args: Args{str, format}, } } -func NewSubdate(date ValOrColOrFuncOrSub, interval IntervalUnit) Func { - return Func{ +func NewSubdate(date ValOrColOrFuncOrSub, interval *IntervalUnit) *Func { + return &Func{ name: keyword.Subdate, args: Args{date, interval}, } } -func NewSubtime(date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewSubtime(date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Subtime, args: Args{date1, date2}, } } -func NewSysdate(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewSysdate(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Sysdate, args: Args{fsp}, } } -func NewTime(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewTime(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Time, args: Args{date}, } } -func NewTimeFormat(time, format ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimeFormat(time, format ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.TimeFormat, args: Args{time, format}, } } -func NewTimeToSec(time ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimeToSec(time ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.TimeToSec, args: Args{time}, } } -func NewTimediff(date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimediff(date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Timediff, args: Args{date1, date2}, } } -func NewTimestamp(date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimestamp(date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Timestamp, args: Args{date1, date2}, } } -func NewTimestampadd(unit, interval, date ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimestampadd(unit, interval, date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Timestampadd, args: Args{unit, interval, date}, } } -func NewTimestampdiff(unit, date1, date2 ValOrColOrFuncOrSub) Func { - return Func{ +func NewTimestampdiff(unit, date1, date2 ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Timestampdiff, args: Args{unit, date1, date2}, } } -func NewToDays(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewToDays(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.ToDays, args: Args{date}, } } -func NewToSeconds(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewToSeconds(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.ToSeconds, args: Args{date}, } } -func NewUnixTimestamp(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewUnixTimestamp(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.UnixTimestamp, args: Args{date}, } } -func NewUtcDate() Func { - return Func{ +func NewUtcDate() *Func { + return &Func{ name: keyword.UtcDate, args: Args{}, } } -func NewUtcTime(fsp ValOrColOrFuncOrSub) Func { - return Func{ +func NewUtcTime(fsp ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.UtcTime, args: Args{fsp}, } } -func NewUtcTimestamp(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewUtcTimestamp(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.UtcTimestamp, args: Args{date}, } } -func NewWeek(date, mode ValOrColOrFuncOrSub) Func { - return Func{ +func NewWeek(date, mode ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Week, args: Args{date, mode}, } } -func NewWeekday(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewWeekday(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Weekday, args: Args{date}, } } -func NewWeekofyear(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewWeekofyear(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Weekofyear, args: Args{date}, } } -func NewYear(date ValOrColOrFuncOrSub) Func { - return Func{ +func NewYear(date ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Year, args: Args{date}, } } -func NewYearweek(date, mode ValOrColOrFuncOrSub) Func { - return Func{ +func NewYearweek(date, mode ValOrColOrFuncOrSub) *Func { + return &Func{ name: keyword.Yearweek, args: Args{date, mode}, } diff --git a/stmt/func_date_interval.go b/stmt/func_date_interval.go index 652898c..063736d 100644 --- a/stmt/func_date_interval.go +++ b/stmt/func_date_interval.go @@ -32,153 +32,153 @@ type Interval struct { duration ValOrColOrFuncOrSub } -func NewInterval(duration ValOrColOrFuncOrSub) Interval { - return Interval{ +func NewInterval(duration ValOrColOrFuncOrSub) *Interval { + return &Interval{ duration: duration, } } -func (i Interval) Microsecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Microsecond() *IntervalUnit { + return &IntervalUnit{ unit: Microsecond, interval: i, } } -func (i Interval) Second() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Second() *IntervalUnit { + return &IntervalUnit{ unit: Second, interval: i, } } -func (i Interval) Minute() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Minute() *IntervalUnit { + return &IntervalUnit{ unit: Minute, interval: i, } } -func (i Interval) Hour() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Hour() *IntervalUnit { + return &IntervalUnit{ unit: Hour, interval: i, } } -func (i Interval) Day() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Day() *IntervalUnit { + return &IntervalUnit{ unit: Day, interval: i, } } -func (i Interval) Week() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Week() *IntervalUnit { + return &IntervalUnit{ unit: Week, interval: i, } } -func (i Interval) Month() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Month() *IntervalUnit { + return &IntervalUnit{ unit: Month, interval: i, } } -func (i Interval) Quarter() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Quarter() *IntervalUnit { + return &IntervalUnit{ unit: Quarter, interval: i, } } -func (i Interval) Year() IntervalUnit { - return IntervalUnit{ +func (i *Interval) Year() *IntervalUnit { + return &IntervalUnit{ unit: Year, interval: i, } } -func (i Interval) SecondMicrosecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) SecondMicrosecond() *IntervalUnit { + return &IntervalUnit{ unit: SecondMicrosecond, interval: i, } } -func (i Interval) MinuteMicrosecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) MinuteMicrosecond() *IntervalUnit { + return &IntervalUnit{ unit: MinuteMicrosecond, interval: i, } } -func (i Interval) MinuteSecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) MinuteSecond() *IntervalUnit { + return &IntervalUnit{ unit: MinuteSecond, interval: i, } } -func (i Interval) HourMicrosecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) HourMicrosecond() *IntervalUnit { + return &IntervalUnit{ unit: HourMicrosecond, interval: i, } } -func (i Interval) HourSecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) HourSecond() *IntervalUnit { + return &IntervalUnit{ unit: HourSecond, interval: i, } } -func (i Interval) HourMinute() IntervalUnit { - return IntervalUnit{ +func (i *Interval) HourMinute() *IntervalUnit { + return &IntervalUnit{ unit: HourMinute, interval: i, } } -func (i Interval) DayMicrosecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) DayMicrosecond() *IntervalUnit { + return &IntervalUnit{ unit: DayMicrosecond, interval: i, } } -func (i Interval) DaySecond() IntervalUnit { - return IntervalUnit{ +func (i *Interval) DaySecond() *IntervalUnit { + return &IntervalUnit{ unit: DaySecond, interval: i, } } -func (i Interval) DayMinute() IntervalUnit { - return IntervalUnit{ +func (i *Interval) DayMinute() *IntervalUnit { + return &IntervalUnit{ unit: DayMinute, interval: i, } } -func (i Interval) DayHour() IntervalUnit { - return IntervalUnit{ +func (i *Interval) DayHour() *IntervalUnit { + return &IntervalUnit{ unit: DayHour, interval: i, } } -func (i Interval) YearMonth() IntervalUnit { - return IntervalUnit{ +func (i *Interval) YearMonth() *IntervalUnit { + return &IntervalUnit{ unit: YearMonth, interval: i, } } -func (i Interval) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (i *Interval) nodeize() (tokenizer.Tokenizer, []interface{}) { t, values := i.duration.nodeize() return t.Prepend( token.Word("INTERVAL"), @@ -187,10 +187,10 @@ func (i Interval) nodeize() (tokenizer.Tokenizer, []interface{}) { type IntervalUnit struct { unit string - interval Interval + interval *Interval } -func (i IntervalUnit) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (i *IntervalUnit) nodeize() (tokenizer.Tokenizer, []interface{}) { t, values := i.interval.nodeize() return t.Append( token.Word(i.unit), diff --git a/stmt/func_string.go b/stmt/func_string.go index e12bf53..efe3d36 100644 --- a/stmt/func_string.go +++ b/stmt/func_string.go @@ -1,7 +1,7 @@ package stmt -func NewConcat(strs ...ValOrColOrFuncOrSub) Func { - return Func{ +func NewConcat(strs ...ValOrColOrFuncOrSub) *Func { + return &Func{ name: "CONCAT", args: ValOrColOrFuncOrSubs(strs).ToArgs(), } diff --git a/stmt/group_by.go b/stmt/group_by.go index c16f227..67a79c3 100644 --- a/stmt/group_by.go +++ b/stmt/group_by.go @@ -8,38 +8,38 @@ import ( type GroupBy struct { prev Prever - columns []Column + columns []*Column } -func NewGroupBy(column Column, columns ...Column) GroupBy { - return GroupBy{ - columns: append([]Column{column}, columns...), +func NewGroupBy(column *Column, columns ...*Column) *GroupBy { + return &GroupBy{ + columns: append([]*Column{column}, columns...), } } -func (g GroupBy) Having(operation ComparisonOrLogicalOperation) Having { +func (g *GroupBy) Having(operation ComparisonOrLogicalOperation) *Having { l := NewHaving(operation) l.prev = g return l } -func (g GroupBy) OrderBy(orders ...Order) OrderBy { +func (g *GroupBy) OrderBy(orders ...*Order) *OrderBy { o := NewOrderBy(orders...) o.prev = g return o } -func (g GroupBy) Limit(count int) Limit { +func (g *GroupBy) Limit(count int) *Limit { l := NewLimit(count) l.prev = g return l } -func (g GroupBy) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (g *GroupBy) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(g) } -func (g GroupBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (g *GroupBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ts := make(tokenizer.Tokenizers, len(g.columns)) values := []interface{}{} for i, c := range g.columns { @@ -56,6 +56,6 @@ func (g GroupBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (g GroupBy) previous() Prever { +func (g *GroupBy) previous() Prever { return g.prev } diff --git a/stmt/having.go b/stmt/having.go index d73bd1e..7ede5a1 100644 --- a/stmt/having.go +++ b/stmt/having.go @@ -11,29 +11,29 @@ type Having struct { operation ComparisonOrLogicalOperation } -func NewHaving(operation ComparisonOrLogicalOperation) Having { - return Having{ +func NewHaving(operation ComparisonOrLogicalOperation) *Having { + return &Having{ operation: operation, } } -func (h Having) OrderBy(orders ...Order) OrderBy { +func (h *Having) OrderBy(orders ...*Order) *OrderBy { o := NewOrderBy(orders...) o.prev = h return o } -func (h Having) Limit(count int) Limit { +func (h *Having) Limit(count int) *Limit { l := NewLimit(count) l.prev = h return l } -func (h Having) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (h *Having) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(h) } -func (h Having) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (h *Having) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { middle, values := h.operation.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Having)), @@ -42,6 +42,6 @@ func (h Having) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (h Having) previous() Prever { +func (h *Having) previous() Prever { return h.prev } diff --git a/stmt/insert.go b/stmt/insert.go index 00b7a5a..1c57d5f 100644 --- a/stmt/insert.go +++ b/stmt/insert.go @@ -7,28 +7,28 @@ import ( ) type InsertInto struct { - table Table - columns []Column + table *Table + columns []*Column } -func NewInsertInto(table Table, columns ...Column) InsertInto { - return InsertInto{ +func NewInsertInto(table *Table, columns ...*Column) *InsertInto { + return &InsertInto{ table: table, columns: columns, } } -func (i InsertInto) DefaultValues() DefaultValues { +func (i *InsertInto) DefaultValues() *DefaultValues { v := NewDefaultValues() v.prev = i return v } -func (i InsertInto) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (i *InsertInto) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(i) } -func (i InsertInto) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (i *InsertInto) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tableTokenizer, values := i.table.nodeize() ts := make(tokenizer.Tokenizers, len(i.columns)) for j, c := range i.columns { @@ -51,11 +51,11 @@ func (i InsertInto) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (i InsertInto) previous() Prever { +func (i *InsertInto) previous() Prever { return nil } -func (i InsertInto) Values(paramses ...Vals) Values { +func (i *InsertInto) Values(paramses ...Vals) *Values { v := NewValues(paramses...) v.prev = i return v diff --git a/stmt/interfaces.go b/stmt/interfaces.go index d18e20e..faeef82 100644 --- a/stmt/interfaces.go +++ b/stmt/interfaces.go @@ -20,10 +20,10 @@ type Prever interface { type Joiner interface { Statement - Join(TableOrAlias) Join - InnerJoin(TableOrAlias) Join - LeftJoin(TableOrAlias) Join - RightJoin(TableOrAlias) Join + Join(TableOrAlias) *Join + InnerJoin(TableOrAlias) *Join + LeftJoin(TableOrAlias) *Join + RightJoin(TableOrAlias) *Join } type ValOrFuncOrSub interface { diff --git a/stmt/join.go b/stmt/join.go index 34459f0..5caa38f 100644 --- a/stmt/join.go +++ b/stmt/join.go @@ -12,75 +12,75 @@ type Join struct { table TableOrAlias } -func NewJoin(table TableOrAlias) Join { - return Join{ +func NewJoin(table TableOrAlias) *Join { + return &Join{ joinType: keyword.Join, table: table, } } -func NewInnerJoin(table TableOrAlias) Join { - return Join{ +func NewInnerJoin(table TableOrAlias) *Join { + return &Join{ joinType: keyword.InnerJoin, table: table, } } -func NewLeftJoin(table TableOrAlias) Join { - return Join{ +func NewLeftJoin(table TableOrAlias) *Join { + return &Join{ joinType: keyword.LeftJoin, table: table, } } -func NewRightJoin(table TableOrAlias) Join { - return Join{ +func NewRightJoin(table TableOrAlias) *Join { + return &Join{ joinType: keyword.RightJoin, table: table, } } -func (j Join) Join(table TableOrAlias) Join { +func (j *Join) Join(table TableOrAlias) *Join { j1 := NewJoin(table) j1.prev = j return j1 } -func (j Join) InnerJoin(table TableOrAlias) Join { +func (j *Join) InnerJoin(table TableOrAlias) *Join { j1 := NewInnerJoin(table) j1.prev = j return j1 } -func (j Join) LeftJoin(table TableOrAlias) Join { +func (j *Join) LeftJoin(table TableOrAlias) *Join { j1 := NewLeftJoin(table) j1.prev = j return j1 } -func (j Join) RightJoin(table TableOrAlias) Join { +func (j *Join) RightJoin(table TableOrAlias) *Join { j1 := NewRightJoin(table) j1.prev = j return j1 } -func (j Join) On(column1, column2 Column) On { +func (j *Join) On(column1, column2 *Column) *On { o := NewOn(column1, column2) o.join = j return o } -func (j Join) Using(col Column) Using { +func (j *Join) Using(col *Column) *Using { o := NewUsing(col) o.join = j return o } -func (j Join) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (j *Join) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(j) } -func (j Join) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (j *Join) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { if j.table == nil { return nil, nil } @@ -90,7 +90,7 @@ func (j Join) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), v } -func (j Join) previous() Prever { +func (j *Join) previous() Prever { if j.prev == nil { return nil } diff --git a/stmt/join_test.go b/stmt/join_test.go index 903c134..19aae76 100644 --- a/stmt/join_test.go +++ b/stmt/join_test.go @@ -12,7 +12,7 @@ import ( func TestJoinType(t *testing.T) { t.Parallel() for _, c := range []interface{}{ - stmt.Join{}, + &stmt.Join{}, } { c := c t.Run(fmt.Sprintf("%T", c), func(t *testing.T) { diff --git a/stmt/limit.go b/stmt/limit.go index d2dcb3a..47ebdd0 100644 --- a/stmt/limit.go +++ b/stmt/limit.go @@ -11,23 +11,23 @@ type Limit struct { count int } -func NewLimit(count int) Limit { - return Limit{ +func NewLimit(count int) *Limit { + return &Limit{ count: count, } } -func (l Limit) Offset(count int) Offset { +func (l *Limit) Offset(count int) *Offset { o := NewOffset(count) o.prev = l return o } -func (l Limit) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (l *Limit) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(l) } -func (l Limit) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (l *Limit) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { line, values := tokenizer.ParamsToLine(l.count) return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Limit)), @@ -36,6 +36,6 @@ func (l Limit) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (l Limit) previous() Prever { +func (l *Limit) previous() Prever { return l.prev } diff --git a/stmt/offset.go b/stmt/offset.go index e2541e3..4d67a04 100644 --- a/stmt/offset.go +++ b/stmt/offset.go @@ -13,17 +13,17 @@ type Offset struct { } // NewOffset return a new Offset. -func NewOffset(count int) Offset { - return Offset{ +func NewOffset(count int) *Offset { + return &Offset{ count: count, } } -func (o Offset) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *Offset) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(o) } -func (o Offset) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (o *Offset) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { line, values := tokenizer.ParamsToLine(o.count) return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Offset)), @@ -32,6 +32,6 @@ func (o Offset) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (o Offset) previous() Prever { +func (o *Offset) previous() Prever { return o.prev } diff --git a/stmt/on.go b/stmt/on.go index b290cbf..435a50c 100644 --- a/stmt/on.go +++ b/stmt/on.go @@ -7,49 +7,60 @@ import ( ) type On struct { - join Join - column1, column2 Column + join *Join + column1, column2 *Column } -func NewOn(column1, column2 Column) On { - return On{ +func NewOn(column1, column2 *Column) *On { + return &On{ column1: column1, column2: column2, } } -func (o On) Join(table TableOrAlias) Join { +func (o *On) Join(table TableOrAlias) *Join { j := NewJoin(table) j.prev = o return j } -func (o On) InnerJoin(table TableOrAlias) Join { +func (o *On) InnerJoin(table TableOrAlias) *Join { j := NewInnerJoin(table) j.prev = o return j } -func (o On) LeftJoin(table TableOrAlias) Join { +func (o *On) LeftJoin(table TableOrAlias) *Join { j := NewLeftJoin(table) j.prev = o return j } -func (o On) RightJoin(table TableOrAlias) Join { +func (o *On) RightJoin(table TableOrAlias) *Join { j := NewRightJoin(table) j.prev = o return j } -func (o On) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *On) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(o) } -func (o On) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { - t0, v0 := o.join.nodeizeSelf() +func (o *On) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t1, v1 := o.column1.nodeize() t2, v2 := o.column2.nodeize() + if o.join == nil { + return tokenizer.ConcatTokenizers( + t1, + t2, + tokenizer.NewLine( + token.Word(keyword.Eq), + ), + ).Prepend( + token.Word(keyword.On), + ), append(v1, v2...) + } + t0, v0 := o.join.nodeizeSelf() return tokenizer.ConcatTokenizers( t0, tokenizer.ConcatTokenizers( @@ -65,13 +76,16 @@ func (o On) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), append(append(v0, v1...), v2...) } -func (o On) previous() Prever { +func (o *On) previous() Prever { + if o.join == nil { + return nil + } return o.join.previous() } // isTableOrAliasOrJoiner always returns true. // This method exists only to implement the interface TableOrAliasOrJoiner. // This is a shit of duck typing, but anyway it works. -func (o On) isTableOrAliasOrJoiner() bool { +func (o *On) isTableOrAliasOrJoiner() bool { return true } diff --git a/stmt/op.go b/stmt/op.go index 8054f1c..5a46cff 100644 --- a/stmt/op.go +++ b/stmt/op.go @@ -11,26 +11,26 @@ type JoinOperation struct { ops []ComparisonOrLogicalOperation } -func NewAnd(ops ...ComparisonOrLogicalOperation) JoinOperation { - return JoinOperation{ +func NewAnd(ops ...ComparisonOrLogicalOperation) *JoinOperation { + return &JoinOperation{ op: keyword.And, ops: ops, } } -func NewOr(ops ...ComparisonOrLogicalOperation) JoinOperation { - return JoinOperation{ +func NewOr(ops ...ComparisonOrLogicalOperation) *JoinOperation { + return &JoinOperation{ op: keyword.Or, ops: ops, } } -func (o JoinOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *JoinOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ts := make(tokenizer.Tokenizers, len(o.ops)) values := []interface{}{} for i, op := range o.ops { t, vals := op.nodeize() - if _, ok := op.(JoinOperation); ok { + if _, ok := op.(*JoinOperation); ok { t = tokenizer.NewParentheses(t) } ts[i] = t @@ -41,7 +41,7 @@ func (o JoinOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ), values } -func (o JoinOperation) keyword() keyword.Operator { +func (o *JoinOperation) keyword() keyword.Operator { return o.op } @@ -49,11 +49,11 @@ type Not struct { operation ComparisonOrLogicalOperation } -func NewNot(operation ComparisonOrLogicalOperation) Not { - return Not{operation: operation} +func NewNot(operation ComparisonOrLogicalOperation) *Not { + return &Not{operation: operation} } -func (o Not) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *Not) nodeize() (tokenizer.Tokenizer, []interface{}) { middle, values := o.operation.nodeize() return tokenizer.NewParentheses( middle, @@ -62,7 +62,7 @@ func (o Not) nodeize() (tokenizer.Tokenizer, []interface{}) { ), values } -func (o Not) keyword() keyword.Operator { +func (o *Not) keyword() keyword.Operator { return keyword.Not } @@ -72,63 +72,63 @@ type ComparisonOperation struct { val ValOrColOrFuncOrSub } -func NewEq(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewEq(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Eq, val: val, } } -func NewNotEq(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewNotEq(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.NotEq, val: val, } } -func NewGt(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewGt(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Gt, val: val, } } -func NewGte(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewGte(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Gte, val: val, } } -func NewLt(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewLt(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Lt, val: val, } } -func NewLte(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewLte(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Lte, val: val, } } -func NewLike(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewLike(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.Like, val: val, } } -func NewRegExp(val ValOrColOrFuncOrSub) ComparisonOperation { - return ComparisonOperation{ +func NewRegExp(val ValOrColOrFuncOrSub) *ComparisonOperation { + return &ComparisonOperation{ op: keyword.RegExp, val: val, } } -func (o ComparisonOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *ComparisonOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := o.column.nodeize() t2, v2 := o.val.nodeize() return tokenizer.ConcatTokenizers( @@ -140,7 +140,7 @@ func (o ComparisonOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ), append(v1, v2...) } -func (o ComparisonOperation) keyword() keyword.Operator { +func (o *ComparisonOperation) keyword() keyword.Operator { return o.op } @@ -149,14 +149,14 @@ type Between struct { from, to ValOrColOrFuncOrSub } -func NewBetween(from, to ValOrColOrFuncOrSub) Between { - return Between{ +func NewBetween(from, to ValOrColOrFuncOrSub) *Between { + return &Between{ from: from, to: to, } } -func (o Between) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *Between) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := o.column.nodeize() t2, v2 := o.from.nodeize() t3, v3 := o.to.nodeize() @@ -175,7 +175,7 @@ func (o Between) nodeize() (tokenizer.Tokenizer, []interface{}) { ), append(append(v1, v2...), v3...) } -func (o Between) keyword() keyword.Operator { +func (o *Between) keyword() keyword.Operator { return keyword.Between } @@ -185,21 +185,21 @@ type ContainingOperation struct { vals ValsOrSub } -func NewIn(vals ValsOrSub) ContainingOperation { - return ContainingOperation{ +func NewIn(vals ValsOrSub) *ContainingOperation { + return &ContainingOperation{ op: keyword.In, vals: vals, } } -func NewNotIn(vals ValsOrSub) ContainingOperation { - return ContainingOperation{ +func NewNotIn(vals ValsOrSub) *ContainingOperation { + return &ContainingOperation{ op: keyword.NotIn, vals: vals, } } -func (o ContainingOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *ContainingOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := o.column.nodeize() t2, v2 := o.vals.nodeize() return tokenizer.ConcatTokenizers( @@ -211,7 +211,7 @@ func (o ContainingOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ), append(v1, v2...) } -func (o ContainingOperation) keyword() keyword.Operator { +func (o *ContainingOperation) keyword() keyword.Operator { return o.op } @@ -220,19 +220,19 @@ type NullOperation struct { column ColOrSub } -func NewIsNull() NullOperation { - return NullOperation{ +func NewIsNull() *NullOperation { + return &NullOperation{ op: keyword.Is, } } -func NewIsNotNull() NullOperation { - return NullOperation{ +func NewIsNotNull() *NullOperation { + return &NullOperation{ op: keyword.IsNot, } } -func (o NullOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *NullOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := o.column.nodeize() return tokenizer.ConcatTokenizers( t1, @@ -243,6 +243,6 @@ func (o NullOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ), v1 } -func (o NullOperation) keyword() keyword.Operator { +func (o *NullOperation) keyword() keyword.Operator { return o.op } diff --git a/stmt/op_nonscalar.go b/stmt/op_nonscalar.go index 62286ce..59fd458 100644 --- a/stmt/op_nonscalar.go +++ b/stmt/op_nonscalar.go @@ -9,94 +9,94 @@ import ( type NonScalarOperation struct { op keyword.Operator column ValOrColOrFuncOrSub - sub Subquery + sub *Subquery } -func NewEqAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewEqAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.EqAll, sub: sub, } } -func NewNotEqAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewNotEqAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.NotEqAll, sub: sub, } } -func NewGtAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewGtAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.GtAll, sub: sub, } } -func NewGteAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewGteAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.GteAll, sub: sub, } } -func NewLtAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewLtAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.LtAll, sub: sub, } } -func NewLteAll(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewLteAll(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.LteAll, sub: sub, } } -func NewEqAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewEqAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.EqAny, sub: sub, } } -func NewNotEqAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewNotEqAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.NotEqAny, sub: sub, } } -func NewGtAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewGtAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.GtAny, sub: sub, } } -func NewGteAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewGteAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.GteAny, sub: sub, } } -func NewLtAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewLtAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.LtAny, sub: sub, } } -func NewLteAny(sub Subquery) NonScalarOperation { - return NonScalarOperation{ +func NewLteAny(sub *Subquery) *NonScalarOperation { + return &NonScalarOperation{ op: keyword.LteAny, sub: sub, } } -func (n NonScalarOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (n *NonScalarOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { t2, v2 := n.sub.nodeize() if n.column == nil { return t2.Prepend( @@ -114,36 +114,36 @@ func (n NonScalarOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { ), append(v1, v2...) } -func (n NonScalarOperation) keyword() keyword.Operator { +func (n *NonScalarOperation) keyword() keyword.Operator { return n.op } type ExistanceOperation struct { op keyword.Operator - sub Subquery + sub *Subquery } -func NewExists(sub Subquery) ExistanceOperation { - return ExistanceOperation{ +func NewExists(sub *Subquery) *ExistanceOperation { + return &ExistanceOperation{ op: keyword.Exists, sub: sub, } } -func NewNotExists(sub Subquery) ExistanceOperation { - return ExistanceOperation{ +func NewNotExists(sub *Subquery) *ExistanceOperation { + return &ExistanceOperation{ op: keyword.NotExists, sub: sub, } } -func (e ExistanceOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (e *ExistanceOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { t2, v2 := e.sub.nodeize() return t2.Prepend( token.Word(e.keyword()), ), v2 } -func (e ExistanceOperation) keyword() keyword.Operator { +func (e *ExistanceOperation) keyword() keyword.Operator { return e.op } diff --git a/stmt/order.go b/stmt/order.go index 1b98bcb..1b039bf 100644 --- a/stmt/order.go +++ b/stmt/order.go @@ -7,29 +7,33 @@ import ( ) type Order struct { - column Column + column *Column dir keyword.Direction } -func NewAsc() Order { - return Order{ +func NewAsc() *Order { + return &Order{ dir: keyword.ASC, } } -func NewDesc() Order { - return Order{ +func NewDesc() *Order { + return &Order{ dir: keyword.DESC, } } -func (o Order) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *Order) nodeize() (tokenizer.Tokenizer, []interface{}) { + if o.column == nil { + return tokenizer.NewLine(token.Word(o.keyword())), nil + } + t1, v1 := o.column.nodeize() return t1.Append( token.Word(o.keyword()), ), v1 } -func (o Order) keyword() keyword.Direction { +func (o *Order) keyword() keyword.Direction { return o.dir } diff --git a/stmt/order_by.go b/stmt/order_by.go index e839905..58a500d 100644 --- a/stmt/order_by.go +++ b/stmt/order_by.go @@ -8,24 +8,24 @@ import ( type OrderBy struct { prev Prever - orders []Order + orders []*Order } -func NewOrderBy(os ...Order) OrderBy { - return OrderBy{orders: os} +func NewOrderBy(os ...*Order) *OrderBy { + return &OrderBy{orders: os} } -func (o OrderBy) Limit(count int) Limit { +func (o *OrderBy) Limit(count int) *Limit { l := NewLimit(count) l.prev = o return l } -func (o OrderBy) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (o *OrderBy) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(o) } -func (o OrderBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (o *OrderBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tokenizers := make(tokenizer.Tokenizers, len(o.orders)) values := []interface{}{} for i, o := range o.orders { @@ -40,6 +40,6 @@ func (o OrderBy) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (o OrderBy) previous() Prever { +func (o *OrderBy) previous() Prever { return o.prev } diff --git a/stmt/order_test.go b/stmt/order_test.go index f5d53ca..a587623 100644 --- a/stmt/order_test.go +++ b/stmt/order_test.go @@ -11,7 +11,7 @@ import ( func TestOrderType(t *testing.T) { t.Parallel() - o := stmt.Order{} + o := &stmt.Order{} if _, ok := interface{}(o).(stmt.Statement); !ok { t.Errorf("%T should implement stmt.Statement", o) } @@ -27,15 +27,15 @@ func TestOrderSQL(t *testing.T) { }{ { stmt.NewAsc(), - " ASC", - `> ASC + "ASC", + `> ASC `, nil, }, { stmt.NewDesc(), - " DESC", - `> DESC + "DESC", + `> DESC `, nil, }, diff --git a/stmt/select.go b/stmt/select.go index 212260e..e2ac381 100644 --- a/stmt/select.go +++ b/stmt/select.go @@ -11,31 +11,31 @@ type Select struct { columns []ColOrAliasOrFuncOrSub } -func NewSelect(columns ...ColOrAliasOrFuncOrSub) Select { - return Select{ +func NewSelect(columns ...ColOrAliasOrFuncOrSub) *Select { + return &Select{ distinct: false, columns: columns, } } -func NewSelectDistinct(columns ...ColOrAliasOrFuncOrSub) Select { - return Select{ +func NewSelectDistinct(columns ...ColOrAliasOrFuncOrSub) *Select { + return &Select{ distinct: true, columns: columns, } } -func (s Select) From(t TableOrAliasOrJoiner) From { +func (s *Select) From(t TableOrAliasOrJoiner) *From { f := NewFrom(t) f.prev = s return f } -func (s Select) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (s *Select) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(s) } -func (s Select) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (s *Select) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tokenizers := make(tokenizer.Tokenizers, len(s.columns)) values := []interface{}{} for i, c := range s.columns { @@ -56,6 +56,6 @@ func (s Select) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (s Select) previous() Prever { +func (s *Select) previous() Prever { return nil } diff --git a/stmt/set.go b/stmt/set.go index 4656cb7..be74072 100644 --- a/stmt/set.go +++ b/stmt/set.go @@ -8,26 +8,26 @@ import ( type Set struct { prev Prever - assigns []Assign + assigns []*Assign } -func NewSet(assigns ...Assign) Set { - return Set{ +func NewSet(assigns ...*Assign) *Set { + return &Set{ assigns: assigns, } } -func (s Set) Where(operation ComparisonOrLogicalOperation) Where { +func (s *Set) Where(operation ComparisonOrLogicalOperation) *Where { w := NewWhere(operation) w.prev = s return w } -func (s Set) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (s *Set) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(s) } -func (s Set) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (s *Set) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tokenizers := make(tokenizer.Tokenizers, len(s.assigns)) values := []interface{}{} for i, a := range s.assigns { @@ -44,6 +44,6 @@ func (s Set) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (s Set) previous() Prever { +func (s *Set) previous() Prever { return s.prev } diff --git a/stmt/set_operation.go b/stmt/set_operation.go index d7408cf..363bb1f 100644 --- a/stmt/set_operation.go +++ b/stmt/set_operation.go @@ -11,59 +11,59 @@ type SetOperation struct { stmts []Statement } -func NewUnion(stmts ...Statement) SetOperation { - return SetOperation{ +func NewUnion(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.Union, stmts: stmts, } } -func NewUnionAll(stmts ...Statement) SetOperation { - return SetOperation{ +func NewUnionAll(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.UnionAll, stmts: stmts, } } -func NewIntersect(stmts ...Statement) SetOperation { - return SetOperation{ +func NewIntersect(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.Intersect, stmts: stmts, } } -func NewIntersectAll(stmts ...Statement) SetOperation { - return SetOperation{ +func NewIntersectAll(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.IntersectAll, stmts: stmts, } } -func NewExcept(stmts ...Statement) SetOperation { - return SetOperation{ +func NewExcept(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.Except, stmts: stmts, } } -func NewExceptAll(stmts ...Statement) SetOperation { - return SetOperation{ +func NewExceptAll(stmts ...Statement) *SetOperation { + return &SetOperation{ op: keyword.ExceptAll, stmts: stmts, } } -func (u SetOperation) OrderBy(os ...Order) OrderBy { +func (u *SetOperation) OrderBy(os ...*Order) *OrderBy { o := NewOrderBy(os...) o.prev = u return o } -func (u SetOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (u *SetOperation) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(u) } -func (u SetOperation) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (u *SetOperation) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tokenizers := make(tokenizer.Tokenizers, len(u.stmts)) values := []interface{}{} for i, s := range u.stmts { @@ -80,10 +80,10 @@ func (u SetOperation) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { return tokenizers, values } -func (u SetOperation) previous() Prever { +func (u *SetOperation) previous() Prever { return nil } -func (u SetOperation) keyword() keyword.Operator { +func (u *SetOperation) keyword() keyword.Operator { return u.op } diff --git a/stmt/subquery.go b/stmt/subquery.go index c4f0902..e590a5d 100644 --- a/stmt/subquery.go +++ b/stmt/subquery.go @@ -6,97 +6,97 @@ type Subquery struct { stmt Statement } -func NewSubquery(stmt Statement) Subquery { - return Subquery{ +func NewSubquery(stmt Statement) *Subquery { + return &Subquery{ stmt: stmt, } } -func (s Subquery) As(alias string) SubqueryAlias { +func (s *Subquery) As(alias string) *SubqueryAlias { a := NewSubqueryAlias(alias) a.subquery = s return a } -func (s Subquery) Eq(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Eq(value ValOrColOrFuncOrSub) *ComparisonOperation { e := NewEq(value) e.column = s return e } -func (s Subquery) NotEq(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) NotEq(value ValOrColOrFuncOrSub) *ComparisonOperation { n := NewNotEq(value) n.column = s return n } -func (s Subquery) Gt(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Gt(value ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGt(value) g.column = s return g } -func (s Subquery) Gte(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Gte(value ValOrColOrFuncOrSub) *ComparisonOperation { g := NewGte(value) g.column = s return g } -func (s Subquery) Lt(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Lt(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLt(value) l.column = s return l } -func (s Subquery) Lte(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Lte(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLte(value) l.column = s return l } -func (s Subquery) Like(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) Like(value ValOrColOrFuncOrSub) *ComparisonOperation { l := NewLike(value) l.column = s return l } -func (s Subquery) RegExp(value ValOrColOrFuncOrSub) ComparisonOperation { +func (s *Subquery) RegExp(value ValOrColOrFuncOrSub) *ComparisonOperation { r := NewRegExp(value) r.column = s return r } -func (s Subquery) Between(from, to ValOrColOrFuncOrSub) Between { +func (s *Subquery) Between(from, to ValOrColOrFuncOrSub) *Between { b := NewBetween(from, to) b.column = s return b } -func (s Subquery) In(params ValsOrSub) ContainingOperation { +func (s *Subquery) In(params ValsOrSub) *ContainingOperation { i := NewIn(params) i.column = s return i } -func (s Subquery) NotIn(params ValsOrSub) ContainingOperation { +func (s *Subquery) NotIn(params ValsOrSub) *ContainingOperation { n := NewNotIn(params) n.column = s return n } -func (s Subquery) IsNull() NullOperation { +func (s *Subquery) IsNull() *NullOperation { i := NewIsNull() i.column = s return i } -func (s Subquery) IsNotNull() NullOperation { +func (s *Subquery) IsNotNull() *NullOperation { i := NewIsNotNull() i.column = s return i } -func (s Subquery) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (s *Subquery) nodeize() (tokenizer.Tokenizer, []interface{}) { t, values := s.stmt.nodeize() return tokenizer.NewParentheses(t), values } @@ -104,41 +104,41 @@ func (s Subquery) nodeize() (tokenizer.Tokenizer, []interface{}) { // isValsOrSub always returns true. // This method exists only to implement the interface isValsOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isValsOrSub() bool { +func (s *Subquery) isValsOrSub() bool { return true } // isValOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isValOrFuncOrSub() bool { +func (s *Subquery) isValOrFuncOrSub() bool { return true } // isValOrColOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrColOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isValOrColOrFuncOrSub() bool { +func (s *Subquery) isValOrColOrFuncOrSub() bool { return true } // isColOrSub always returns true. // This method exists only to implement the interface ColOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isColOrSub() bool { +func (s *Subquery) isColOrSub() bool { return true } // isColOrAliasOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isColOrAliasOrSub() bool { +func (s *Subquery) isColOrAliasOrSub() bool { return true } // isColOrAliasOrFuncOrSub always returns true. // This method exists only to implement the interface ColOrAliasOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (s Subquery) isColOrAliasOrFuncOrSub() bool { +func (s *Subquery) isColOrAliasOrFuncOrSub() bool { return true } diff --git a/stmt/subquery_alias.go b/stmt/subquery_alias.go index c9debac..50dafdb 100644 --- a/stmt/subquery_alias.go +++ b/stmt/subquery_alias.go @@ -7,17 +7,17 @@ import ( ) type SubqueryAlias struct { - subquery Subquery + subquery *Subquery Alias string } -func NewSubqueryAlias(alias string) SubqueryAlias { - return SubqueryAlias{ +func NewSubqueryAlias(alias string) *SubqueryAlias { + return &SubqueryAlias{ Alias: alias, } } -func (a SubqueryAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (a *SubqueryAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { t1, v1 := a.subquery.nodeize() t2 := tokenizer.NewLine(token.Word(a.Alias)) return tokenizer.ConcatTokenizers( @@ -32,13 +32,13 @@ func (a SubqueryAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { // isTableOrAlias always returns true. // This method exists only to implement the interface TableOrAlias. // This is a shit of duck typing, but anyway it works. -func (a SubqueryAlias) isTableOrAlias() bool { +func (a *SubqueryAlias) isTableOrAlias() bool { return true } // isTableOrAliasOrJoiner always returns true. // This method exists only to implement the interface TableOrAliasOrJoiner. // This is a shit of duck typing, but anyway it works. -func (a SubqueryAlias) isTableOrAliasOrJoiner() bool { +func (a *SubqueryAlias) isTableOrAliasOrJoiner() bool { return true } diff --git a/stmt/table.go b/stmt/table.go index 0f12b09..48521a5 100644 --- a/stmt/table.go +++ b/stmt/table.go @@ -9,74 +9,74 @@ type Table struct { Name string } -func NewTable(name string) Table { - return Table{ +func NewTable(name string) *Table { + return &Table{ Name: name, } } -func (t Table) As(alias string) TableAlias { - return TableAlias{ +func (t *Table) As(alias string) *TableAlias { + return &TableAlias{ table: t, Alias: alias, } } -func (t Table) Column(name string) Column { +func (t *Table) Column(name string) *Column { c := NewColumn(name) c.table = t return c } -func (t Table) Join(table TableOrAlias) Join { +func (t *Table) Join(table TableOrAlias) *Join { nj := NewJoin(table) nj.prev = t return nj } -func (t Table) InnerJoin(table TableOrAlias) Join { +func (t *Table) InnerJoin(table TableOrAlias) *Join { ij := NewInnerJoin(table) ij.prev = t return ij } -func (t Table) LeftJoin(table TableOrAlias) Join { +func (t *Table) LeftJoin(table TableOrAlias) *Join { lj := NewLeftJoin(table) lj.prev = t return lj } -func (t Table) RightJoin(table TableOrAlias) Join { +func (t *Table) RightJoin(table TableOrAlias) *Join { rj := NewRightJoin(table) rj.prev = t return rj } -func (t Table) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (t *Table) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(t) } -func (t Table) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { - if t.Name == "" { +func (t *Table) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { + if t == nil { return nil, nil } return tokenizer.NewLine(token.Word(t.Name)), nil } -func (t Table) previous() Prever { +func (t *Table) previous() Prever { return nil } // isTableOrAlias always returns true. // This method exists only to implement the interface TableOrAlias. // This is a shit of duck typing, but anyway it works. -func (t Table) isTableOrAlias() bool { +func (t *Table) isTableOrAlias() bool { return true } // isTableOrAliasOrJoiner always returns true. // This method exists only to implement the interface TableOrAliasOrJoiner. // This is a shit of duck typing, but anyway it works. -func (t Table) isTableOrAliasOrJoiner() bool { +func (t *Table) isTableOrAliasOrJoiner() bool { return true } diff --git a/stmt/table_alias.go b/stmt/table_alias.go index bd4a5af..1928c39 100644 --- a/stmt/table_alias.go +++ b/stmt/table_alias.go @@ -7,45 +7,45 @@ import ( ) type TableAlias struct { - table Table + table *Table Alias string } -func NewTableAlias(alias string) TableAlias { - return TableAlias{ +func NewTableAlias(alias string) *TableAlias { + return &TableAlias{ Alias: alias, } } -func (t TableAlias) Join(table TableOrAlias) Join { +func (t *TableAlias) Join(table TableOrAlias) *Join { nj := NewJoin(table) nj.prev = t return nj } -func (t TableAlias) InnerJoin(table TableOrAlias) Join { +func (t *TableAlias) InnerJoin(table TableOrAlias) *Join { ij := NewInnerJoin(table) ij.prev = t return ij } -func (t TableAlias) LeftJoin(table TableOrAlias) Join { +func (t *TableAlias) LeftJoin(table TableOrAlias) *Join { lj := NewLeftJoin(table) lj.prev = t return lj } -func (t TableAlias) RightJoin(table TableOrAlias) Join { +func (t *TableAlias) RightJoin(table TableOrAlias) *Join { rj := NewRightJoin(table) rj.prev = t return rj } -func (t TableAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (t *TableAlias) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(t) } -func (t TableAlias) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (t *TableAlias) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t1, v1 := t.table.nodeize() t2 := tokenizer.NewLine( token.LQuote, @@ -62,20 +62,20 @@ func (t TableAlias) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), v1 } -func (t TableAlias) previous() Prever { +func (t *TableAlias) previous() Prever { return nil } // isTableOrAlias always returns true. // This method exists only to implement the interface TableOrAlias. // This is a shit of duck typing, but anyway it works. -func (t TableAlias) isTableOrAlias() bool { +func (t *TableAlias) isTableOrAlias() bool { return true } // isTableOrAliasOrJoiner always returns true. // This method exists only to implement the interface TableOrAliasOrJoiner. // This is a shit of duck typing, but anyway it works. -func (t TableAlias) isTableOrAliasOrJoiner() bool { +func (t *TableAlias) isTableOrAliasOrJoiner() bool { return true } diff --git a/stmt/table_alias_test.go b/stmt/table_alias_test.go index 59cd881..0a85d3b 100644 --- a/stmt/table_alias_test.go +++ b/stmt/table_alias_test.go @@ -12,7 +12,7 @@ import ( func TestTableAliasType(t *testing.T) { t.Parallel() for _, c := range []interface{}{ - stmt.TableAlias{}, + &stmt.TableAlias{}, } { c := c t.Run(fmt.Sprintf("%T", c), func(t *testing.T) { diff --git a/stmt/table_test.go b/stmt/table_test.go index 00186eb..933a8d8 100644 --- a/stmt/table_test.go +++ b/stmt/table_test.go @@ -12,7 +12,7 @@ import ( func TestTableType(t *testing.T) { t.Parallel() for _, c := range []interface{}{ - stmt.Table{}, + &stmt.Table{}, } { c := c t.Run(fmt.Sprintf("%T", c), func(t *testing.T) { @@ -35,7 +35,7 @@ func TestTable(t *testing.T) { { stmt.NewTable(""), ``, - ``, + "> \n", nil, }, { @@ -98,7 +98,7 @@ func TestTable(t *testing.T) { } { c := c t.Run(fmt.Sprintf("%d Build", i), func(t *testing.T) { - t.Parallel() + // t.Parallel() sql, values := b.Build(c.stmt) if sql != c.sql { t.Error(diff.SQL(sql, c.sql)) @@ -108,7 +108,7 @@ func TestTable(t *testing.T) { } }) t.Run(fmt.Sprintf("%d BuildIndent", i), func(t *testing.T) { - t.Parallel() + // t.Parallel() sql, values := bi.Build(c.stmt) if sql != c.sqlIndent { t.Error(diff.SQL(sql, c.sqlIndent)) diff --git a/stmt/update.go b/stmt/update.go index 01ef00f..2c6957f 100644 --- a/stmt/update.go +++ b/stmt/update.go @@ -8,26 +8,26 @@ import ( type Update struct { prev Prever - table Table + table *Table } -func NewUpdate(table Table) Update { - return Update{ +func NewUpdate(table *Table) *Update { + return &Update{ table: table, } } -func (u Update) Set(assigns ...Assign) Set { +func (u *Update) Set(assigns ...*Assign) *Set { s := NewSet(assigns...) s.prev = u return s } -func (u Update) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (u *Update) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(u) } -func (u Update) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (u *Update) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { middle, values := u.table.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Update)), @@ -36,6 +36,6 @@ func (u Update) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (u Update) previous() Prever { +func (u *Update) previous() Prever { return u.prev } diff --git a/stmt/using.go b/stmt/using.go index a5267b3..85cc7b6 100644 --- a/stmt/using.go +++ b/stmt/using.go @@ -7,47 +7,50 @@ import ( ) type Using struct { - join Join - column Column + join *Join + column *Column } -func NewUsing(column Column) Using { - return Using{ +func NewUsing(column *Column) *Using { + return &Using{ column: column, } } -func (u Using) Join(table TableOrAlias) Join { +func (u *Using) Join(table TableOrAlias) *Join { j := NewJoin(table) j.prev = u return j } -func (u Using) InnerJoin(table TableOrAlias) Join { +func (u *Using) InnerJoin(table TableOrAlias) *Join { j := NewInnerJoin(table) j.prev = u return j } -func (u Using) LeftJoin(table TableOrAlias) Join { +func (u *Using) LeftJoin(table TableOrAlias) *Join { j := NewLeftJoin(table) j.prev = u return j } -func (u Using) RightJoin(table TableOrAlias) Join { +func (u *Using) RightJoin(table TableOrAlias) *Join { j := NewRightJoin(table) j.prev = u return j } -func (u Using) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (u *Using) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(u) } -func (u Using) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { - t1, v1 := u.join.nodeizeSelf() +func (u *Using) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { t2, v2 := u.column.nodeize() + if u.join == nil { + return t2.Prepend(token.Word(keyword.Using)), v2 + } + t1, v1 := u.join.nodeizeSelf() return tokenizer.ConcatTokenizers( t1, t2, @@ -57,13 +60,16 @@ func (u Using) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), append(v1, v2...) } -func (u Using) previous() Prever { +func (u *Using) previous() Prever { + if u.join == nil { + return nil + } return u.join.previous() } // isTableOrAliasOrJoiner always returns true. // This method exists only to implement the interface TableOrAliasOrJoiner. // This is a shit of duck typing, but anyway it works. -func (u Using) isTableOrAliasOrJoiner() bool { +func (u *Using) isTableOrAliasOrJoiner() bool { return true } diff --git a/stmt/val.go b/stmt/val.go index 0183ee6..eed16e1 100644 --- a/stmt/val.go +++ b/stmt/val.go @@ -9,31 +9,31 @@ type Val struct { value interface{} } -func NewVal(value interface{}) Val { - return Val{ +func NewVal(value interface{}) *Val { + return &Val{ value: value, } } -func (p Val) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (p *Val) nodeize() (tokenizer.Tokenizer, []interface{}) { return tokenizer.ParamsToLine(p.value) } // isValOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (p Val) isValOrFuncOrSub() bool { +func (p *Val) isValOrFuncOrSub() bool { return true } // isValOrColOrFuncOrSub always returns true. // This method exists only to implement the interface ValOrColOrFuncOrSub. // This is a shit of duck typing, but anyway it works. -func (p Val) isValOrColOrFuncOrSub() bool { +func (p *Val) isValOrColOrFuncOrSub() bool { return true } -type Vals []Val +type Vals []*Val func NewVals(values ...interface{}) Vals { ps := make(Vals, len(values)) diff --git a/stmt/values.go b/stmt/values.go index f66a4d7..36a0f10 100644 --- a/stmt/values.go +++ b/stmt/values.go @@ -11,17 +11,17 @@ type Values struct { valses []Vals } -func NewValues(valses ...Vals) Values { - return Values{ +func NewValues(valses ...Vals) *Values { + return &Values{ valses: valses, } } -func (v Values) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (v *Values) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(v) } -func (v Values) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (v *Values) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { tokenizers := make(tokenizer.Tokenizers, len(v.valses)) values := []interface{}{} for i, p := range v.valses { @@ -39,7 +39,7 @@ func (v Values) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (v Values) previous() Prever { +func (v *Values) previous() Prever { return v.prev } @@ -47,20 +47,20 @@ type DefaultValues struct { prev Prever } -func NewDefaultValues() DefaultValues { - return DefaultValues{} +func NewDefaultValues() *DefaultValues { + return &DefaultValues{} } -func (v DefaultValues) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (v *DefaultValues) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(v) } -func (v DefaultValues) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (v *DefaultValues) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.DefaultValues)), ), nil } -func (v DefaultValues) previous() Prever { +func (v *DefaultValues) previous() Prever { return v.prev } diff --git a/stmt/where.go b/stmt/where.go index 9ad3222..4f9db21 100644 --- a/stmt/where.go +++ b/stmt/where.go @@ -11,35 +11,35 @@ type Where struct { operation ComparisonOrLogicalOperation } -func NewWhere(operation ComparisonOrLogicalOperation) Where { - return Where{ +func NewWhere(operation ComparisonOrLogicalOperation) *Where { + return &Where{ operation: operation, } } -func (w Where) GroupBy(column Column, columns ...Column) GroupBy { +func (w *Where) GroupBy(column *Column, columns ...*Column) *GroupBy { g := NewGroupBy(column, columns...) g.prev = w return g } -func (w Where) OrderBy(orders ...Order) OrderBy { +func (w *Where) OrderBy(orders ...*Order) *OrderBy { o := NewOrderBy(orders...) o.prev = w return o } -func (w Where) Limit(count int) Limit { +func (w *Where) Limit(count int) *Limit { l := NewLimit(count) l.prev = w return l } -func (w Where) nodeize() (tokenizer.Tokenizer, []interface{}) { +func (w *Where) nodeize() (tokenizer.Tokenizer, []interface{}) { return nodeizePrevs(w) } -func (w Where) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { +func (w *Where) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { middle, values := w.operation.nodeize() return tokenizer.NewContainer( tokenizer.NewLine(token.Word(keyword.Where)), @@ -48,6 +48,6 @@ func (w Where) nodeizeSelf() (tokenizer.Tokenizer, []interface{}) { ), values } -func (w Where) previous() Prever { +func (w *Where) previous() Prever { return w.prev }