query

func (*Connection) EXPECT ¶

func (_m *Connection) EXPECT() *Connection_Expecter

func (*Connection) Insert ¶

func (_m *Connection) Insert(statement string, values []interface{}, sequence string) error

Insert provides a mock function with given fields: statement, values, sequence

func (*Connection) LastInsertID ¶

func (_m *Connection) LastInsertID(sequence string) (interface{}, error)

LastInsertID provides a mock function with given fields: sequence

func (*Connection) SelectFromWriteConnection ¶

func (_m *Connection) SelectFromWriteConnection(statement string, values []interface{}, sequence string) (interface{}, error)

SelectFromWriteConnection provides a mock function with given fields: statement, values, sequence

func (*Connection_Expecter) Insert ¶

func (_e *Connection_Expecter) Insert(statement interface{}, values interface{}, sequence interface{}) *Connection_Insert_Call

Insert is a helper method to define mock.On call

• statement string
• values []interface{}
• sequence string

func (*Connection_Expecter) LastInsertID ¶

func (_e *Connection_Expecter) LastInsertID(sequence interface{}) *Connection_LastInsertID_Call

LastInsertID is a helper method to define mock.On call

• sequence string

func (*Connection_Expecter) SelectFromWriteConnection ¶

func (_e *Connection_Expecter) SelectFromWriteConnection(statement interface{}, values interface{}, sequence interface{}) *Connection_SelectFromWriteConnection_Call

SelectFromWriteConnection is a helper method to define mock.On call

• statement string
• values []interface{}
• sequence string

func (*Connection_Insert_Call) Return ¶

func (_c *Connection_Insert_Call) Return(_a0 error) *Connection_Insert_Call

func (*Connection_Insert_Call) Run ¶

func (_c *Connection_Insert_Call) Run(run func(statement string, values []interface{}, sequence string)) *Connection_Insert_Call

func (*Connection_Insert_Call) RunAndReturn ¶

func (_c *Connection_Insert_Call) RunAndReturn(run func(string, []interface{}, string) error) *Connection_Insert_Call

func (*Connection_LastInsertID_Call) Return ¶

func (_c *Connection_LastInsertID_Call) Return(_a0 interface{}, _a1 error) *Connection_LastInsertID_Call

func (*Connection_LastInsertID_Call) Run ¶

func (_c *Connection_LastInsertID_Call) Run(run func(sequence string)) *Connection_LastInsertID_Call

func (*Connection_LastInsertID_Call) RunAndReturn ¶

func (_c *Connection_LastInsertID_Call) RunAndReturn(run func(string) (interface{}, error)) *Connection_LastInsertID_Call

func (*Connection_SelectFromWriteConnection_Call) Return ¶

func (_c *Connection_SelectFromWriteConnection_Call) Return(_a0 interface{}, _a1 error) *Connection_SelectFromWriteConnection_Call

func (*Connection_SelectFromWriteConnection_Call) Run ¶

func (_c *Connection_SelectFromWriteConnection_Call) Run(run func(statement string, values []interface{}, sequence string)) *Connection_SelectFromWriteConnection_Call

func (*Connection_SelectFromWriteConnection_Call) RunAndReturn ¶

func (_c *Connection_SelectFromWriteConnection_Call) RunAndReturn(run func(string, []interface{}, string) (interface{}, error)) *Connection_SelectFromWriteConnection_Call

func (*Grammar) Columnize ¶

func (_m *Grammar) Columnize(columns []interface{}) string

Columnize provides a mock function with given fields: columns

func (*Grammar) CompileAggregate ¶

func (_m *Grammar) CompileAggregate(b core.Query, aggregate core.Aggregate) string

CompileAggregate provides a mock function with given fields: b, aggregate

func (*Grammar) CompileColumns ¶

func (_m *Grammar) CompileColumns(b core.Query, columns []interface{}) string

CompileColumns provides a mock function with given fields: b, columns

func (*Grammar) CompileComponents ¶

func (_m *Grammar) CompileComponents(b core.Query) []string

CompileComponents provides a mock function with given fields: b

func (*Grammar) CompileDelete ¶

func (_m *Grammar) CompileDelete(b core.Query) string

CompileDelete provides a mock function with given fields: b

func (*Grammar) CompileDeleteWithJoins ¶

func (_m *Grammar) CompileDeleteWithJoins(b core.Query, table string, where string) string

CompileDeleteWithJoins provides a mock function with given fields: b, table, where

func (*Grammar) CompileDeleteWithoutJoins ¶

func (_m *Grammar) CompileDeleteWithoutJoins(b core.Query, table string, where string) string

CompileDeleteWithoutJoins provides a mock function with given fields: b, table, where

func (*Grammar) CompileExists ¶

func (_m *Grammar) CompileExists(b core.Query) string

CompileExists provides a mock function with given fields: b

func (*Grammar) CompileFrom ¶

func (_m *Grammar) CompileFrom(b core.Query, table interface{}) string

CompileFrom provides a mock function with given fields: b, table

func (*Grammar) CompileGroupLimit ¶

func (_m *Grammar) CompileGroupLimit(b core.Query) string

CompileGroupLimit provides a mock function with given fields: b

func (*Grammar) CompileGroups ¶

func (_m *Grammar) CompileGroups(b core.Query, groups []interface{}) string

CompileGroups provides a mock function with given fields: b, groups

func (*Grammar) CompileHaving ¶

func (_m *Grammar) CompileHaving(b core.Query, having core.Having) string

CompileHaving provides a mock function with given fields: b, having

func (*Grammar) CompileHavings ¶

func (_m *Grammar) CompileHavings(b core.Query) string

CompileHavings provides a mock function with given fields: b

func (*Grammar) CompileIndexHint ¶

func (_m *Grammar) CompileIndexHint(b core.Query, hint *core.IndexHint) string

CompileIndexHint provides a mock function with given fields: b, hint

func (*Grammar) CompileInsert ¶

func (_m *Grammar) CompileInsert(b core.Query, values []map[string]interface{}) string

CompileInsert provides a mock function with given fields: b, values

func (*Grammar) CompileInsertGetId ¶

func (_m *Grammar) CompileInsertGetId(b core.Query, values []map[string]interface{}, sequence string) string

CompileInsertGetId provides a mock function with given fields: b, values, sequence

func (*Grammar) CompileInsertOrIgnore ¶

func (_m *Grammar) CompileInsertOrIgnore(b core.Query, values []map[string]interface{}) string

CompileInsertOrIgnore provides a mock function with given fields: b, values

func (*Grammar) CompileInsertOrIgnoreUsing ¶

func (_m *Grammar) CompileInsertOrIgnoreUsing(b core.Query, columns []interface{}, sql string) string

CompileInsertOrIgnoreUsing provides a mock function with given fields: b, columns, sql

func (*Grammar) CompileInsertUsing ¶

func (_m *Grammar) CompileInsertUsing(b core.Query, columns []interface{}, sql string) string

CompileInsertUsing provides a mock function with given fields: b, columns, sql

func (*Grammar) CompileJoinLateral ¶

func (_m *Grammar) CompileJoinLateral(join core.Join, expression string) string

CompileJoinLateral provides a mock function with given fields: join, expression

func (*Grammar) CompileJoins ¶

func (_m *Grammar) CompileJoins(b core.Query, joins []core.Join) string

CompileJoins provides a mock function with given fields: b, joins

func (*Grammar) CompileJsonContains ¶

func (_m *Grammar) CompileJsonContains(column string, value string) string

CompileJsonContains provides a mock function with given fields: column, value

func (*Grammar) CompileJsonContainsKey ¶

func (_m *Grammar) CompileJsonContainsKey(column string) string

CompileJsonContainsKey provides a mock function with given fields: column

func (*Grammar) CompileJsonLength ¶

func (_m *Grammar) CompileJsonLength(column string, operator string, value string) string

CompileJsonLength provides a mock function with given fields: column, operator, value

func (*Grammar) CompileJsonOverlaps ¶

func (_m *Grammar) CompileJsonOverlaps(column string, value string) string

CompileJsonOverlaps provides a mock function with given fields: column, value

func (*Grammar) CompileJsonUpdateColumn ¶

func (_m *Grammar) CompileJsonUpdateColumn(key string, value interface{}) string

CompileJsonUpdateColumn provides a mock function with given fields: key, value

func (*Grammar) CompileJsonValueCast ¶

func (_m *Grammar) CompileJsonValueCast(value string) string

CompileJsonValueCast provides a mock function with given fields: value

func (*Grammar) CompileLegacyGroupLimit ¶

func (_m *Grammar) CompileLegacyGroupLimit(b core.Query) string

CompileLegacyGroupLimit provides a mock function with given fields: b

func (*Grammar) CompileLimit ¶

func (_m *Grammar) CompileLimit(b core.Query, limit *int) string

CompileLimit provides a mock function with given fields: b, limit

func (*Grammar) CompileLock ¶

func (_m *Grammar) CompileLock(b core.Query, value interface{}) string

CompileLock provides a mock function with given fields: b, value

func (*Grammar) CompileOffset ¶

func (_m *Grammar) CompileOffset(b core.Query, offset *int) string

CompileOffset provides a mock function with given fields: b, offset

func (*Grammar) CompileOrders ¶

func (_m *Grammar) CompileOrders(b core.Query, orders []core.Order) string

CompileOrders provides a mock function with given fields: b, orders

func (*Grammar) CompileRandom ¶

func (_m *Grammar) CompileRandom(seed interface{}) string

CompileRandom provides a mock function with given fields: seed

func (*Grammar) CompileRowNumber ¶

func (_m *Grammar) CompileRowNumber(partition string, orders string) string

CompileRowNumber provides a mock function with given fields: partition, orders

func (*Grammar) CompileSelect ¶

func (_m *Grammar) CompileSelect(b core.Query) string

CompileSelect provides a mock function with given fields: b

func (*Grammar) CompileTruncate ¶

func (_m *Grammar) CompileTruncate(b core.Query) []core.Statement

CompileTruncate provides a mock function with given fields: b

func (*Grammar) CompileUnionAggregate ¶

func (_m *Grammar) CompileUnionAggregate(b core.Query) string

CompileUnionAggregate provides a mock function with given fields: b

func (*Grammar) CompileUnions ¶

func (_m *Grammar) CompileUnions(b core.Query) string

CompileUnions provides a mock function with given fields: b

func (*Grammar) CompileUpdate ¶

func (_m *Grammar) CompileUpdate(b core.Query, values core.UpdateValues) string

CompileUpdate provides a mock function with given fields: b, values

func (*Grammar) CompileUpdateColumns ¶

func (_m *Grammar) CompileUpdateColumns(b core.Query, values core.UpdateValues) string

CompileUpdateColumns provides a mock function with given fields: b, values

func (*Grammar) CompileUpdateWithJoins ¶

func (_m *Grammar) CompileUpdateWithJoins(b core.Query, table string, columns string, where string) string

CompileUpdateWithJoins provides a mock function with given fields: b, table, columns, where

func (*Grammar) CompileUpdateWithoutJoins ¶

func (_m *Grammar) CompileUpdateWithoutJoins(b core.Query, table string, columns string, where string) string

CompileUpdateWithoutJoins provides a mock function with given fields: b, table, columns, where

func (*Grammar) CompileUpsert ¶

func (_m *Grammar) CompileUpsert(b core.Query, values []map[string]interface{}, uniqueBy []string, update []core.UpsertUpdate) string

CompileUpsert provides a mock function with given fields: b, values, uniqueBy, update

func (*Grammar) CompileWhere ¶

func (_m *Grammar) CompileWhere(b core.Query, where core.Where) string

CompileWhere provides a mock function with given fields: b, where

func (*Grammar) CompileWheres ¶

func (_m *Grammar) CompileWheres(b core.Query) string

CompileWheres provides a mock function with given fields: b

func (*Grammar) EXPECT ¶

func (_m *Grammar) EXPECT() *Grammar_Expecter

func (*Grammar) GetBitwiseOperators ¶

func (_m *Grammar) GetBitwiseOperators() []string

GetBitwiseOperators provides a mock function with no fields

func (*Grammar) GetDateFormat ¶

func (_m *Grammar) GetDateFormat() string

GetDateFormat provides a mock function with no fields

func (*Grammar) GetOperators ¶

func (_m *Grammar) GetOperators() []string

GetOperators provides a mock function with no fields

func (*Grammar) GetValue ¶

func (_m *Grammar) GetValue(expression core.Expression) string

GetValue provides a mock function with given fields: expression

func (*Grammar) IsJsonSelector ¶

func (_m *Grammar) IsJsonSelector(value string) bool

IsJsonSelector provides a mock function with given fields: value

func (*Grammar) Parameter ¶

func (_m *Grammar) Parameter(value interface{}) string

Parameter provides a mock function with given fields: value

func (*Grammar) Parameterize ¶

func (_m *Grammar) Parameterize(values []interface{}) string

Parameterize provides a mock function with given fields: values

func (*Grammar) PrepareBindingForJsonContains ¶

func (_m *Grammar) PrepareBindingForJsonContains(value interface{}) interface{}

PrepareBindingForJsonContains provides a mock function with given fields: value

func (*Grammar) PrepareBindingsForDelete ¶

func (_m *Grammar) PrepareBindingsForDelete(bindings map[string][]interface{}) []interface{}

PrepareBindingsForDelete provides a mock function with given fields: bindings

func (*Grammar) PrepareBindingsForUpdate ¶

func (_m *Grammar) PrepareBindingsForUpdate(bindings map[string][]interface{}, values core.UpdateValues) []interface{}

PrepareBindingsForUpdate provides a mock function with given fields: bindings, values

func (*Grammar) PrepareWhereLikeBinding ¶

func (_m *Grammar) PrepareWhereLikeBinding(value string, caseSensitive bool) string

PrepareWhereLikeBinding provides a mock function with given fields: value, caseSensitive

func (*Grammar) SelectComponents ¶

func (_m *Grammar) SelectComponents() []string

SelectComponents provides a mock function with no fields

func (*Grammar) SetEscaper ¶

func (_m *Grammar) SetEscaper(escape func(interface{}, bool) string)

SetEscaper provides a mock function with given fields: escape

func (*Grammar) SubstituteBindingsIntoRawSQL ¶

func (_m *Grammar) SubstituteBindingsIntoRawSQL(sql string, bindings []interface{}) string

SubstituteBindingsIntoRawSQL provides a mock function with given fields: sql, bindings

func (*Grammar) UseLegacyGroupLimit ¶

func (_m *Grammar) UseLegacyGroupLimit(b core.Query) bool

UseLegacyGroupLimit provides a mock function with given fields: b

func (*Grammar) WhereBasic ¶

func (_m *Grammar) WhereBasic(b core.Query, where core.Where) string

WhereBasic provides a mock function with given fields: b, where

func (*Grammar) WhereBetween ¶

func (_m *Grammar) WhereBetween(b core.Query, where core.Where) string

WhereBetween provides a mock function with given fields: b, where

func (*Grammar) WhereBetweenColumns ¶

func (_m *Grammar) WhereBetweenColumns(b core.Query, where core.Where) string

WhereBetweenColumns provides a mock function with given fields: b, where

func (*Grammar) WhereBitwise ¶

func (_m *Grammar) WhereBitwise(b core.Query, where core.Where) string

WhereBitwise provides a mock function with given fields: b, where

func (*Grammar) WhereColumn ¶

func (_m *Grammar) WhereColumn(b core.Query, where core.Where) string

WhereColumn provides a mock function with given fields: b, where

func (*Grammar) WhereDate ¶

func (_m *Grammar) WhereDate(b core.Query, where core.Where) string

WhereDate provides a mock function with given fields: b, where

func (*Grammar) WhereDay ¶

func (_m *Grammar) WhereDay(b core.Query, where core.Where) string

WhereDay provides a mock function with given fields: b, where

func (*Grammar) WhereExists ¶

func (_m *Grammar) WhereExists(b core.Query, where core.Where) string

WhereExists provides a mock function with given fields: b, where

func (*Grammar) WhereExpression ¶

func (_m *Grammar) WhereExpression(b core.Query, where core.Where) string

WhereExpression provides a mock function with given fields: b, where

func (*Grammar) WhereFullText ¶

func (_m *Grammar) WhereFullText(b core.Query, where core.Where) string

WhereFullText provides a mock function with given fields: b, where

func (*Grammar) WhereIn ¶

func (_m *Grammar) WhereIn(b core.Query, where core.Where) string

WhereIn provides a mock function with given fields: b, where

func (*Grammar) WhereInRaw ¶

func (_m *Grammar) WhereInRaw(b core.Query, where core.Where) string

WhereInRaw provides a mock function with given fields: b, where

func (*Grammar) WhereJsonBoolean ¶

func (_m *Grammar) WhereJsonBoolean(b core.Query, where core.Where) string

WhereJsonBoolean provides a mock function with given fields: b, where

func (*Grammar) WhereJsonContains ¶

func (_m *Grammar) WhereJsonContains(b core.Query, where core.Where) string

WhereJsonContains provides a mock function with given fields: b, where

func (*Grammar) WhereJsonContainsKey ¶

func (_m *Grammar) WhereJsonContainsKey(b core.Query, where core.Where) string

WhereJsonContainsKey provides a mock function with given fields: b, where

func (*Grammar) WhereJsonLength ¶

func (_m *Grammar) WhereJsonLength(b core.Query, where core.Where) string

WhereJsonLength provides a mock function with given fields: b, where

func (*Grammar) WhereJsonOverlaps ¶

func (_m *Grammar) WhereJsonOverlaps(b core.Query, where core.Where) string

WhereJsonOverlaps provides a mock function with given fields: b, where

func (*Grammar) WhereLike ¶

func (_m *Grammar) WhereLike(b core.Query, where core.Where) string

WhereLike provides a mock function with given fields: b, where

func (*Grammar) WhereMonth ¶

func (_m *Grammar) WhereMonth(b core.Query, where core.Where) string

WhereMonth provides a mock function with given fields: b, where

func (*Grammar) WhereNested ¶

func (_m *Grammar) WhereNested(b core.Query, where core.Where) string

WhereNested provides a mock function with given fields: b, where

func (*Grammar) WhereNotExists ¶

func (_m *Grammar) WhereNotExists(b core.Query, where core.Where) string

WhereNotExists provides a mock function with given fields: b, where

func (*Grammar) WhereNotIn ¶

func (_m *Grammar) WhereNotIn(b core.Query, where core.Where) string

WhereNotIn provides a mock function with given fields: b, where

func (*Grammar) WhereNotInRaw ¶

func (_m *Grammar) WhereNotInRaw(b core.Query, where core.Where) string

WhereNotInRaw provides a mock function with given fields: b, where

func (*Grammar) WhereNotNull ¶

func (_m *Grammar) WhereNotNull(b core.Query, where core.Where) string

WhereNotNull provides a mock function with given fields: b, where

func (*Grammar) WhereNull ¶

func (_m *Grammar) WhereNull(b core.Query, where core.Where) string

WhereNull provides a mock function with given fields: b, where

func (*Grammar) WhereRaw ¶

func (_m *Grammar) WhereRaw(b core.Query, where core.Where) string

WhereRaw provides a mock function with given fields: b, where

func (*Grammar) WhereRowValues ¶

func (_m *Grammar) WhereRowValues(b core.Query, where core.Where) string

WhereRowValues provides a mock function with given fields: b, where

func (*Grammar) WhereSub ¶

func (_m *Grammar) WhereSub(b core.Query, where core.Where) string

WhereSub provides a mock function with given fields: b, where

func (*Grammar) WhereTime ¶

func (_m *Grammar) WhereTime(b core.Query, where core.Where) string

WhereTime provides a mock function with given fields: b, where

func (*Grammar) WhereValueBetween ¶

func (_m *Grammar) WhereValueBetween(b core.Query, where core.Where) string

WhereValueBetween provides a mock function with given fields: b, where

func (*Grammar) WhereYear ¶

func (_m *Grammar) WhereYear(b core.Query, where core.Where) string

WhereYear provides a mock function with given fields: b, where

func (*Grammar) Wrap ¶

func (_m *Grammar) Wrap(value interface{}) string

Wrap provides a mock function with given fields: value

func (*Grammar) WrapJsonBooleanSelector ¶

func (_m *Grammar) WrapJsonBooleanSelector(value string) string

WrapJsonBooleanSelector provides a mock function with given fields: value

func (*Grammar) WrapJsonBooleanValue ¶

func (_m *Grammar) WrapJsonBooleanValue(value string) string

WrapJsonBooleanValue provides a mock function with given fields: value

func (*Grammar) WrapJsonSelector ¶

func (_m *Grammar) WrapJsonSelector(value string) string

WrapJsonSelector provides a mock function with given fields: value

func (*Grammar) WrapTable ¶

func (_m *Grammar) WrapTable(table interface{}) string

WrapTable provides a mock function with given fields: table

func (*Grammar) WrapUnion ¶

func (_m *Grammar) WrapUnion(sql string) string

WrapUnion provides a mock function with given fields: sql

func (*Grammar) WrapValue ¶

func (_m *Grammar) WrapValue(value string) string

WrapValue provides a mock function with given fields: value

func (*Grammar_Columnize_Call) Return ¶

func (_c *Grammar_Columnize_Call) Return(_a0 string) *Grammar_Columnize_Call

func (*Grammar_Columnize_Call) Run ¶

func (_c *Grammar_Columnize_Call) Run(run func(columns []interface{})) *Grammar_Columnize_Call

func (*Grammar_Columnize_Call) RunAndReturn ¶

func (_c *Grammar_Columnize_Call) RunAndReturn(run func([]interface{}) string) *Grammar_Columnize_Call

func (*Grammar_CompileAggregate_Call) Return ¶

func (_c *Grammar_CompileAggregate_Call) Return(_a0 string) *Grammar_CompileAggregate_Call

func (*Grammar_CompileAggregate_Call) Run ¶

func (_c *Grammar_CompileAggregate_Call) Run(run func(b core.Query, aggregate core.Aggregate)) *Grammar_CompileAggregate_Call

func (*Grammar_CompileAggregate_Call) RunAndReturn ¶

func (_c *Grammar_CompileAggregate_Call) RunAndReturn(run func(core.Query, core.Aggregate) string) *Grammar_CompileAggregate_Call

func (*Grammar_CompileColumns_Call) Return ¶

func (_c *Grammar_CompileColumns_Call) Return(_a0 string) *Grammar_CompileColumns_Call

func (*Grammar_CompileColumns_Call) Run ¶

func (_c *Grammar_CompileColumns_Call) Run(run func(b core.Query, columns []interface{})) *Grammar_CompileColumns_Call

func (*Grammar_CompileColumns_Call) RunAndReturn ¶

func (_c *Grammar_CompileColumns_Call) RunAndReturn(run func(core.Query, []interface{}) string) *Grammar_CompileColumns_Call

func (*Grammar_CompileComponents_Call) Return ¶

func (_c *Grammar_CompileComponents_Call) Return(_a0 []string) *Grammar_CompileComponents_Call

func (*Grammar_CompileComponents_Call) Run ¶

func (_c *Grammar_CompileComponents_Call) Run(run func(b core.Query)) *Grammar_CompileComponents_Call

func (*Grammar_CompileComponents_Call) RunAndReturn ¶

func (_c *Grammar_CompileComponents_Call) RunAndReturn(run func(core.Query) []string) *Grammar_CompileComponents_Call

func (*Grammar_CompileDeleteWithJoins_Call) Return ¶

func (_c *Grammar_CompileDeleteWithJoins_Call) Return(_a0 string) *Grammar_CompileDeleteWithJoins_Call

func (*Grammar_CompileDeleteWithJoins_Call) Run ¶

func (_c *Grammar_CompileDeleteWithJoins_Call) Run(run func(b core.Query, table string, where string)) *Grammar_CompileDeleteWithJoins_Call

func (*Grammar_CompileDeleteWithJoins_Call) RunAndReturn ¶

func (_c *Grammar_CompileDeleteWithJoins_Call) RunAndReturn(run func(core.Query, string, string) string) *Grammar_CompileDeleteWithJoins_Call

func (*Grammar_CompileDeleteWithoutJoins_Call) Return ¶

func (_c *Grammar_CompileDeleteWithoutJoins_Call) Return(_a0 string) *Grammar_CompileDeleteWithoutJoins_Call

func (*Grammar_CompileDeleteWithoutJoins_Call) Run ¶

func (_c *Grammar_CompileDeleteWithoutJoins_Call) Run(run func(b core.Query, table string, where string)) *Grammar_CompileDeleteWithoutJoins_Call

func (*Grammar_CompileDeleteWithoutJoins_Call) RunAndReturn ¶

func (_c *Grammar_CompileDeleteWithoutJoins_Call) RunAndReturn(run func(core.Query, string, string) string) *Grammar_CompileDeleteWithoutJoins_Call

func (*Grammar_CompileDelete_Call) Return ¶

func (_c *Grammar_CompileDelete_Call) Return(_a0 string) *Grammar_CompileDelete_Call

func (*Grammar_CompileDelete_Call) Run ¶

func (_c *Grammar_CompileDelete_Call) Run(run func(b core.Query)) *Grammar_CompileDelete_Call

func (*Grammar_CompileDelete_Call) RunAndReturn ¶

func (_c *Grammar_CompileDelete_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileDelete_Call

func (*Grammar_CompileExists_Call) Return ¶

func (_c *Grammar_CompileExists_Call) Return(_a0 string) *Grammar_CompileExists_Call

func (*Grammar_CompileExists_Call) Run ¶

func (_c *Grammar_CompileExists_Call) Run(run func(b core.Query)) *Grammar_CompileExists_Call

func (*Grammar_CompileExists_Call) RunAndReturn ¶

func (_c *Grammar_CompileExists_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileExists_Call

func (*Grammar_CompileFrom_Call) Return ¶

func (_c *Grammar_CompileFrom_Call) Return(_a0 string) *Grammar_CompileFrom_Call

func (*Grammar_CompileFrom_Call) Run ¶

func (_c *Grammar_CompileFrom_Call) Run(run func(b core.Query, table interface{})) *Grammar_CompileFrom_Call

func (*Grammar_CompileFrom_Call) RunAndReturn ¶

func (_c *Grammar_CompileFrom_Call) RunAndReturn(run func(core.Query, interface{}) string) *Grammar_CompileFrom_Call

func (*Grammar_CompileGroupLimit_Call) Return ¶

func (_c *Grammar_CompileGroupLimit_Call) Return(_a0 string) *Grammar_CompileGroupLimit_Call

func (*Grammar_CompileGroupLimit_Call) Run ¶

func (_c *Grammar_CompileGroupLimit_Call) Run(run func(b core.Query)) *Grammar_CompileGroupLimit_Call

func (*Grammar_CompileGroupLimit_Call) RunAndReturn ¶

func (_c *Grammar_CompileGroupLimit_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileGroupLimit_Call

func (*Grammar_CompileGroups_Call) Return ¶

func (_c *Grammar_CompileGroups_Call) Return(_a0 string) *Grammar_CompileGroups_Call

func (*Grammar_CompileGroups_Call) Run ¶

func (_c *Grammar_CompileGroups_Call) Run(run func(b core.Query, groups []interface{})) *Grammar_CompileGroups_Call

func (*Grammar_CompileGroups_Call) RunAndReturn ¶

func (_c *Grammar_CompileGroups_Call) RunAndReturn(run func(core.Query, []interface{}) string) *Grammar_CompileGroups_Call

func (*Grammar_CompileHaving_Call) Return ¶

func (_c *Grammar_CompileHaving_Call) Return(_a0 string) *Grammar_CompileHaving_Call

func (*Grammar_CompileHaving_Call) Run ¶

func (_c *Grammar_CompileHaving_Call) Run(run func(b core.Query, having core.Having)) *Grammar_CompileHaving_Call

func (*Grammar_CompileHaving_Call) RunAndReturn ¶

func (_c *Grammar_CompileHaving_Call) RunAndReturn(run func(core.Query, core.Having) string) *Grammar_CompileHaving_Call

func (*Grammar_CompileHavings_Call) Return ¶

func (_c *Grammar_CompileHavings_Call) Return(_a0 string) *Grammar_CompileHavings_Call

func (*Grammar_CompileHavings_Call) Run ¶

func (_c *Grammar_CompileHavings_Call) Run(run func(b core.Query)) *Grammar_CompileHavings_Call

func (*Grammar_CompileHavings_Call) RunAndReturn ¶

func (_c *Grammar_CompileHavings_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileHavings_Call

func (*Grammar_CompileIndexHint_Call) Return ¶

func (_c *Grammar_CompileIndexHint_Call) Return(_a0 string) *Grammar_CompileIndexHint_Call

func (*Grammar_CompileIndexHint_Call) Run ¶

func (_c *Grammar_CompileIndexHint_Call) Run(run func(b core.Query, hint *core.IndexHint)) *Grammar_CompileIndexHint_Call

func (*Grammar_CompileIndexHint_Call) RunAndReturn ¶

func (_c *Grammar_CompileIndexHint_Call) RunAndReturn(run func(core.Query, *core.IndexHint) string) *Grammar_CompileIndexHint_Call

func (*Grammar_CompileInsertGetId_Call) Return ¶

func (_c *Grammar_CompileInsertGetId_Call) Return(_a0 string) *Grammar_CompileInsertGetId_Call

func (*Grammar_CompileInsertGetId_Call) Run ¶

func (_c *Grammar_CompileInsertGetId_Call) Run(run func(b core.Query, values []map[string]interface{}, sequence string)) *Grammar_CompileInsertGetId_Call

func (*Grammar_CompileInsertGetId_Call) RunAndReturn ¶

func (_c *Grammar_CompileInsertGetId_Call) RunAndReturn(run func(core.Query, []map[string]interface{}, string) string) *Grammar_CompileInsertGetId_Call

func (*Grammar_CompileInsertOrIgnoreUsing_Call) Return ¶

func (_c *Grammar_CompileInsertOrIgnoreUsing_Call) Return(_a0 string) *Grammar_CompileInsertOrIgnoreUsing_Call

func (*Grammar_CompileInsertOrIgnoreUsing_Call) Run ¶

func (_c *Grammar_CompileInsertOrIgnoreUsing_Call) Run(run func(b core.Query, columns []interface{}, sql string)) *Grammar_CompileInsertOrIgnoreUsing_Call

func (*Grammar_CompileInsertOrIgnoreUsing_Call) RunAndReturn ¶

func (_c *Grammar_CompileInsertOrIgnoreUsing_Call) RunAndReturn(run func(core.Query, []interface{}, string) string) *Grammar_CompileInsertOrIgnoreUsing_Call

func (*Grammar_CompileInsertOrIgnore_Call) Return ¶

func (_c *Grammar_CompileInsertOrIgnore_Call) Return(_a0 string) *Grammar_CompileInsertOrIgnore_Call

func (*Grammar_CompileInsertOrIgnore_Call) Run ¶

func (_c *Grammar_CompileInsertOrIgnore_Call) Run(run func(b core.Query, values []map[string]interface{})) *Grammar_CompileInsertOrIgnore_Call

func (*Grammar_CompileInsertOrIgnore_Call) RunAndReturn ¶

func (_c *Grammar_CompileInsertOrIgnore_Call) RunAndReturn(run func(core.Query, []map[string]interface{}) string) *Grammar_CompileInsertOrIgnore_Call

func (*Grammar_CompileInsertUsing_Call) Return ¶

func (_c *Grammar_CompileInsertUsing_Call) Return(_a0 string) *Grammar_CompileInsertUsing_Call

func (*Grammar_CompileInsertUsing_Call) Run ¶

func (_c *Grammar_CompileInsertUsing_Call) Run(run func(b core.Query, columns []interface{}, sql string)) *Grammar_CompileInsertUsing_Call

func (*Grammar_CompileInsertUsing_Call) RunAndReturn ¶

func (_c *Grammar_CompileInsertUsing_Call) RunAndReturn(run func(core.Query, []interface{}, string) string) *Grammar_CompileInsertUsing_Call

func (*Grammar_CompileInsert_Call) Return ¶

func (_c *Grammar_CompileInsert_Call) Return(_a0 string) *Grammar_CompileInsert_Call

func (*Grammar_CompileInsert_Call) Run ¶

func (_c *Grammar_CompileInsert_Call) Run(run func(b core.Query, values []map[string]interface{})) *Grammar_CompileInsert_Call

func (*Grammar_CompileInsert_Call) RunAndReturn ¶

func (_c *Grammar_CompileInsert_Call) RunAndReturn(run func(core.Query, []map[string]interface{}) string) *Grammar_CompileInsert_Call

func (*Grammar_CompileJoinLateral_Call) Return ¶

func (_c *Grammar_CompileJoinLateral_Call) Return(_a0 string) *Grammar_CompileJoinLateral_Call

func (*Grammar_CompileJoinLateral_Call) Run ¶

func (_c *Grammar_CompileJoinLateral_Call) Run(run func(join core.Join, expression string)) *Grammar_CompileJoinLateral_Call

func (*Grammar_CompileJoinLateral_Call) RunAndReturn ¶

func (_c *Grammar_CompileJoinLateral_Call) RunAndReturn(run func(core.Join, string) string) *Grammar_CompileJoinLateral_Call

func (*Grammar_CompileJoins_Call) Return ¶

func (_c *Grammar_CompileJoins_Call) Return(_a0 string) *Grammar_CompileJoins_Call

func (*Grammar_CompileJoins_Call) Run ¶

func (_c *Grammar_CompileJoins_Call) Run(run func(b core.Query, joins []core.Join)) *Grammar_CompileJoins_Call

func (*Grammar_CompileJoins_Call) RunAndReturn ¶

func (_c *Grammar_CompileJoins_Call) RunAndReturn(run func(core.Query, []core.Join) string) *Grammar_CompileJoins_Call

func (*Grammar_CompileJsonContainsKey_Call) Return ¶

func (_c *Grammar_CompileJsonContainsKey_Call) Return(_a0 string) *Grammar_CompileJsonContainsKey_Call

func (*Grammar_CompileJsonContainsKey_Call) Run ¶

func (_c *Grammar_CompileJsonContainsKey_Call) Run(run func(column string)) *Grammar_CompileJsonContainsKey_Call

func (*Grammar_CompileJsonContainsKey_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonContainsKey_Call) RunAndReturn(run func(string) string) *Grammar_CompileJsonContainsKey_Call

func (*Grammar_CompileJsonContains_Call) Return ¶

func (_c *Grammar_CompileJsonContains_Call) Return(_a0 string) *Grammar_CompileJsonContains_Call

func (*Grammar_CompileJsonContains_Call) Run ¶

func (_c *Grammar_CompileJsonContains_Call) Run(run func(column string, value string)) *Grammar_CompileJsonContains_Call

func (*Grammar_CompileJsonContains_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonContains_Call) RunAndReturn(run func(string, string) string) *Grammar_CompileJsonContains_Call

func (*Grammar_CompileJsonLength_Call) Return ¶

func (_c *Grammar_CompileJsonLength_Call) Return(_a0 string) *Grammar_CompileJsonLength_Call

func (*Grammar_CompileJsonLength_Call) Run ¶

func (_c *Grammar_CompileJsonLength_Call) Run(run func(column string, operator string, value string)) *Grammar_CompileJsonLength_Call

func (*Grammar_CompileJsonLength_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonLength_Call) RunAndReturn(run func(string, string, string) string) *Grammar_CompileJsonLength_Call

func (*Grammar_CompileJsonOverlaps_Call) Return ¶

func (_c *Grammar_CompileJsonOverlaps_Call) Return(_a0 string) *Grammar_CompileJsonOverlaps_Call

func (*Grammar_CompileJsonOverlaps_Call) Run ¶

func (_c *Grammar_CompileJsonOverlaps_Call) Run(run func(column string, value string)) *Grammar_CompileJsonOverlaps_Call

func (*Grammar_CompileJsonOverlaps_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonOverlaps_Call) RunAndReturn(run func(string, string) string) *Grammar_CompileJsonOverlaps_Call

func (*Grammar_CompileJsonUpdateColumn_Call) Return ¶

func (_c *Grammar_CompileJsonUpdateColumn_Call) Return(_a0 string) *Grammar_CompileJsonUpdateColumn_Call

func (*Grammar_CompileJsonUpdateColumn_Call) Run ¶

func (_c *Grammar_CompileJsonUpdateColumn_Call) Run(run func(key string, value interface{})) *Grammar_CompileJsonUpdateColumn_Call

func (*Grammar_CompileJsonUpdateColumn_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonUpdateColumn_Call) RunAndReturn(run func(string, interface{}) string) *Grammar_CompileJsonUpdateColumn_Call

func (*Grammar_CompileJsonValueCast_Call) Return ¶

func (_c *Grammar_CompileJsonValueCast_Call) Return(_a0 string) *Grammar_CompileJsonValueCast_Call

func (*Grammar_CompileJsonValueCast_Call) Run ¶

func (_c *Grammar_CompileJsonValueCast_Call) Run(run func(value string)) *Grammar_CompileJsonValueCast_Call

func (*Grammar_CompileJsonValueCast_Call) RunAndReturn ¶

func (_c *Grammar_CompileJsonValueCast_Call) RunAndReturn(run func(string) string) *Grammar_CompileJsonValueCast_Call

func (*Grammar_CompileLegacyGroupLimit_Call) Return ¶

func (_c *Grammar_CompileLegacyGroupLimit_Call) Return(_a0 string) *Grammar_CompileLegacyGroupLimit_Call

func (*Grammar_CompileLegacyGroupLimit_Call) Run ¶

func (_c *Grammar_CompileLegacyGroupLimit_Call) Run(run func(b core.Query)) *Grammar_CompileLegacyGroupLimit_Call

func (*Grammar_CompileLegacyGroupLimit_Call) RunAndReturn ¶

func (_c *Grammar_CompileLegacyGroupLimit_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileLegacyGroupLimit_Call

func (*Grammar_CompileLimit_Call) Return ¶

func (_c *Grammar_CompileLimit_Call) Return(_a0 string) *Grammar_CompileLimit_Call

func (*Grammar_CompileLimit_Call) Run ¶

func (_c *Grammar_CompileLimit_Call) Run(run func(b core.Query, limit *int)) *Grammar_CompileLimit_Call

func (*Grammar_CompileLimit_Call) RunAndReturn ¶

func (_c *Grammar_CompileLimit_Call) RunAndReturn(run func(core.Query, *int) string) *Grammar_CompileLimit_Call

func (*Grammar_CompileLock_Call) Return ¶

func (_c *Grammar_CompileLock_Call) Return(_a0 string) *Grammar_CompileLock_Call

func (*Grammar_CompileLock_Call) Run ¶

func (_c *Grammar_CompileLock_Call) Run(run func(b core.Query, value interface{})) *Grammar_CompileLock_Call

func (*Grammar_CompileLock_Call) RunAndReturn ¶

func (_c *Grammar_CompileLock_Call) RunAndReturn(run func(core.Query, interface{}) string) *Grammar_CompileLock_Call

func (*Grammar_CompileOffset_Call) Return ¶

func (_c *Grammar_CompileOffset_Call) Return(_a0 string) *Grammar_CompileOffset_Call

func (*Grammar_CompileOffset_Call) Run ¶

func (_c *Grammar_CompileOffset_Call) Run(run func(b core.Query, offset *int)) *Grammar_CompileOffset_Call

func (*Grammar_CompileOffset_Call) RunAndReturn ¶

func (_c *Grammar_CompileOffset_Call) RunAndReturn(run func(core.Query, *int) string) *Grammar_CompileOffset_Call

func (*Grammar_CompileOrders_Call) Return ¶

func (_c *Grammar_CompileOrders_Call) Return(_a0 string) *Grammar_CompileOrders_Call

func (*Grammar_CompileOrders_Call) Run ¶

func (_c *Grammar_CompileOrders_Call) Run(run func(b core.Query, orders []core.Order)) *Grammar_CompileOrders_Call

func (*Grammar_CompileOrders_Call) RunAndReturn ¶

func (_c *Grammar_CompileOrders_Call) RunAndReturn(run func(core.Query, []core.Order) string) *Grammar_CompileOrders_Call

func (*Grammar_CompileRandom_Call) Return ¶

func (_c *Grammar_CompileRandom_Call) Return(_a0 string) *Grammar_CompileRandom_Call

func (*Grammar_CompileRandom_Call) Run ¶

func (_c *Grammar_CompileRandom_Call) Run(run func(seed interface{})) *Grammar_CompileRandom_Call

func (*Grammar_CompileRandom_Call) RunAndReturn ¶

func (_c *Grammar_CompileRandom_Call) RunAndReturn(run func(interface{}) string) *Grammar_CompileRandom_Call

func (*Grammar_CompileRowNumber_Call) Return ¶

func (_c *Grammar_CompileRowNumber_Call) Return(_a0 string) *Grammar_CompileRowNumber_Call

func (*Grammar_CompileRowNumber_Call) Run ¶

func (_c *Grammar_CompileRowNumber_Call) Run(run func(partition string, orders string)) *Grammar_CompileRowNumber_Call

func (*Grammar_CompileRowNumber_Call) RunAndReturn ¶

func (_c *Grammar_CompileRowNumber_Call) RunAndReturn(run func(string, string) string) *Grammar_CompileRowNumber_Call

func (*Grammar_CompileSelect_Call) Return ¶

func (_c *Grammar_CompileSelect_Call) Return(_a0 string) *Grammar_CompileSelect_Call

func (*Grammar_CompileSelect_Call) Run ¶

func (_c *Grammar_CompileSelect_Call) Run(run func(b core.Query)) *Grammar_CompileSelect_Call

func (*Grammar_CompileSelect_Call) RunAndReturn ¶

func (_c *Grammar_CompileSelect_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileSelect_Call

func (*Grammar_CompileTruncate_Call) Return ¶

func (_c *Grammar_CompileTruncate_Call) Return(_a0 []core.Statement) *Grammar_CompileTruncate_Call

func (*Grammar_CompileTruncate_Call) Run ¶

func (_c *Grammar_CompileTruncate_Call) Run(run func(b core.Query)) *Grammar_CompileTruncate_Call

func (*Grammar_CompileTruncate_Call) RunAndReturn ¶

func (_c *Grammar_CompileTruncate_Call) RunAndReturn(run func(core.Query) []core.Statement) *Grammar_CompileTruncate_Call

func (*Grammar_CompileUnionAggregate_Call) Return ¶

func (_c *Grammar_CompileUnionAggregate_Call) Return(_a0 string) *Grammar_CompileUnionAggregate_Call

func (*Grammar_CompileUnionAggregate_Call) Run ¶

func (_c *Grammar_CompileUnionAggregate_Call) Run(run func(b core.Query)) *Grammar_CompileUnionAggregate_Call

func (*Grammar_CompileUnionAggregate_Call) RunAndReturn ¶

func (_c *Grammar_CompileUnionAggregate_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileUnionAggregate_Call

func (*Grammar_CompileUnions_Call) Return ¶

func (_c *Grammar_CompileUnions_Call) Return(_a0 string) *Grammar_CompileUnions_Call

func (*Grammar_CompileUnions_Call) Run ¶

func (_c *Grammar_CompileUnions_Call) Run(run func(b core.Query)) *Grammar_CompileUnions_Call

func (*Grammar_CompileUnions_Call) RunAndReturn ¶

func (_c *Grammar_CompileUnions_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileUnions_Call

func (*Grammar_CompileUpdateColumns_Call) Return ¶

func (_c *Grammar_CompileUpdateColumns_Call) Return(_a0 string) *Grammar_CompileUpdateColumns_Call

func (*Grammar_CompileUpdateColumns_Call) Run ¶

func (_c *Grammar_CompileUpdateColumns_Call) Run(run func(b core.Query, values core.UpdateValues)) *Grammar_CompileUpdateColumns_Call

func (*Grammar_CompileUpdateColumns_Call) RunAndReturn ¶

func (_c *Grammar_CompileUpdateColumns_Call) RunAndReturn(run func(core.Query, core.UpdateValues) string) *Grammar_CompileUpdateColumns_Call

func (*Grammar_CompileUpdateWithJoins_Call) Return ¶

func (_c *Grammar_CompileUpdateWithJoins_Call) Return(_a0 string) *Grammar_CompileUpdateWithJoins_Call

func (*Grammar_CompileUpdateWithJoins_Call) Run ¶

func (_c *Grammar_CompileUpdateWithJoins_Call) Run(run func(b core.Query, table string, columns string, where string)) *Grammar_CompileUpdateWithJoins_Call

func (*Grammar_CompileUpdateWithJoins_Call) RunAndReturn ¶

func (_c *Grammar_CompileUpdateWithJoins_Call) RunAndReturn(run func(core.Query, string, string, string) string) *Grammar_CompileUpdateWithJoins_Call

func (*Grammar_CompileUpdateWithoutJoins_Call) Return ¶

func (_c *Grammar_CompileUpdateWithoutJoins_Call) Return(_a0 string) *Grammar_CompileUpdateWithoutJoins_Call

func (*Grammar_CompileUpdateWithoutJoins_Call) Run ¶

func (_c *Grammar_CompileUpdateWithoutJoins_Call) Run(run func(b core.Query, table string, columns string, where string)) *Grammar_CompileUpdateWithoutJoins_Call

func (*Grammar_CompileUpdateWithoutJoins_Call) RunAndReturn ¶

func (_c *Grammar_CompileUpdateWithoutJoins_Call) RunAndReturn(run func(core.Query, string, string, string) string) *Grammar_CompileUpdateWithoutJoins_Call

func (*Grammar_CompileUpdate_Call) Return ¶

func (_c *Grammar_CompileUpdate_Call) Return(_a0 string) *Grammar_CompileUpdate_Call

func (*Grammar_CompileUpdate_Call) Run ¶

func (_c *Grammar_CompileUpdate_Call) Run(run func(b core.Query, values core.UpdateValues)) *Grammar_CompileUpdate_Call

func (*Grammar_CompileUpdate_Call) RunAndReturn ¶

func (_c *Grammar_CompileUpdate_Call) RunAndReturn(run func(core.Query, core.UpdateValues) string) *Grammar_CompileUpdate_Call

func (*Grammar_CompileUpsert_Call) Return ¶

func (_c *Grammar_CompileUpsert_Call) Return(_a0 string) *Grammar_CompileUpsert_Call

func (*Grammar_CompileUpsert_Call) Run ¶

func (_c *Grammar_CompileUpsert_Call) Run(run func(b core.Query, values []map[string]interface{}, uniqueBy []string, update []core.UpsertUpdate)) *Grammar_CompileUpsert_Call

func (*Grammar_CompileUpsert_Call) RunAndReturn ¶

func (_c *Grammar_CompileUpsert_Call) RunAndReturn(run func(core.Query, []map[string]interface{}, []string, []core.UpsertUpdate) string) *Grammar_CompileUpsert_Call

func (*Grammar_CompileWhere_Call) Return ¶

func (_c *Grammar_CompileWhere_Call) Return(_a0 string) *Grammar_CompileWhere_Call

func (*Grammar_CompileWhere_Call) Run ¶

func (_c *Grammar_CompileWhere_Call) Run(run func(b core.Query, where core.Where)) *Grammar_CompileWhere_Call

func (*Grammar_CompileWhere_Call) RunAndReturn ¶

func (_c *Grammar_CompileWhere_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_CompileWhere_Call

func (*Grammar_CompileWheres_Call) Return ¶

func (_c *Grammar_CompileWheres_Call) Return(_a0 string) *Grammar_CompileWheres_Call

func (*Grammar_CompileWheres_Call) Run ¶

func (_c *Grammar_CompileWheres_Call) Run(run func(b core.Query)) *Grammar_CompileWheres_Call

func (*Grammar_CompileWheres_Call) RunAndReturn ¶

func (_c *Grammar_CompileWheres_Call) RunAndReturn(run func(core.Query) string) *Grammar_CompileWheres_Call

func (*Grammar_Expecter) Columnize ¶

func (_e *Grammar_Expecter) Columnize(columns interface{}) *Grammar_Columnize_Call

Columnize is a helper method to define mock.On call

• columns []interface{}

func (*Grammar_Expecter) CompileAggregate ¶

func (_e *Grammar_Expecter) CompileAggregate(b interface{}, aggregate interface{}) *Grammar_CompileAggregate_Call

CompileAggregate is a helper method to define mock.On call

• b core.Query
• aggregate core.Aggregate

func (*Grammar_Expecter) CompileColumns ¶

func (_e *Grammar_Expecter) CompileColumns(b interface{}, columns interface{}) *Grammar_CompileColumns_Call

CompileColumns is a helper method to define mock.On call

• b core.Query
• columns []interface{}

func (*Grammar_Expecter) CompileComponents ¶

func (_e *Grammar_Expecter) CompileComponents(b interface{}) *Grammar_CompileComponents_Call

CompileComponents is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileDelete ¶

func (_e *Grammar_Expecter) CompileDelete(b interface{}) *Grammar_CompileDelete_Call

CompileDelete is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileDeleteWithJoins ¶

func (_e *Grammar_Expecter) CompileDeleteWithJoins(b interface{}, table interface{}, where interface{}) *Grammar_CompileDeleteWithJoins_Call

CompileDeleteWithJoins is a helper method to define mock.On call

• b core.Query
• table string
• where string

func (*Grammar_Expecter) CompileDeleteWithoutJoins ¶

func (_e *Grammar_Expecter) CompileDeleteWithoutJoins(b interface{}, table interface{}, where interface{}) *Grammar_CompileDeleteWithoutJoins_Call

CompileDeleteWithoutJoins is a helper method to define mock.On call

• b core.Query
• table string
• where string

func (*Grammar_Expecter) CompileExists ¶

func (_e *Grammar_Expecter) CompileExists(b interface{}) *Grammar_CompileExists_Call

CompileExists is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileFrom ¶

func (_e *Grammar_Expecter) CompileFrom(b interface{}, table interface{}) *Grammar_CompileFrom_Call

CompileFrom is a helper method to define mock.On call

• b core.Query
• table interface{}

func (*Grammar_Expecter) CompileGroupLimit ¶

func (_e *Grammar_Expecter) CompileGroupLimit(b interface{}) *Grammar_CompileGroupLimit_Call

CompileGroupLimit is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileGroups ¶

func (_e *Grammar_Expecter) CompileGroups(b interface{}, groups interface{}) *Grammar_CompileGroups_Call

CompileGroups is a helper method to define mock.On call

• b core.Query
• groups []interface{}

func (*Grammar_Expecter) CompileHaving ¶

func (_e *Grammar_Expecter) CompileHaving(b interface{}, having interface{}) *Grammar_CompileHaving_Call

CompileHaving is a helper method to define mock.On call

• b core.Query
• having core.Having

func (*Grammar_Expecter) CompileHavings ¶

func (_e *Grammar_Expecter) CompileHavings(b interface{}) *Grammar_CompileHavings_Call

CompileHavings is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileIndexHint ¶

func (_e *Grammar_Expecter) CompileIndexHint(b interface{}, hint interface{}) *Grammar_CompileIndexHint_Call

CompileIndexHint is a helper method to define mock.On call

• b core.Query
• hint *core.IndexHint

func (*Grammar_Expecter) CompileInsert ¶

func (_e *Grammar_Expecter) CompileInsert(b interface{}, values interface{}) *Grammar_CompileInsert_Call

CompileInsert is a helper method to define mock.On call

• b core.Query
• values []map[string]interface{}

func (*Grammar_Expecter) CompileInsertGetId ¶

func (_e *Grammar_Expecter) CompileInsertGetId(b interface{}, values interface{}, sequence interface{}) *Grammar_CompileInsertGetId_Call

CompileInsertGetId is a helper method to define mock.On call

• b core.Query
• values []map[string]interface{}
• sequence string

func (*Grammar_Expecter) CompileInsertOrIgnore ¶

func (_e *Grammar_Expecter) CompileInsertOrIgnore(b interface{}, values interface{}) *Grammar_CompileInsertOrIgnore_Call

CompileInsertOrIgnore is a helper method to define mock.On call

• b core.Query
• values []map[string]interface{}

func (*Grammar_Expecter) CompileInsertOrIgnoreUsing ¶

func (_e *Grammar_Expecter) CompileInsertOrIgnoreUsing(b interface{}, columns interface{}, sql interface{}) *Grammar_CompileInsertOrIgnoreUsing_Call

CompileInsertOrIgnoreUsing is a helper method to define mock.On call

• b core.Query
• columns []interface{}
• sql string

func (*Grammar_Expecter) CompileInsertUsing ¶

func (_e *Grammar_Expecter) CompileInsertUsing(b interface{}, columns interface{}, sql interface{}) *Grammar_CompileInsertUsing_Call

CompileInsertUsing is a helper method to define mock.On call

• b core.Query
• columns []interface{}
• sql string

func (*Grammar_Expecter) CompileJoinLateral ¶

func (_e *Grammar_Expecter) CompileJoinLateral(join interface{}, expression interface{}) *Grammar_CompileJoinLateral_Call

CompileJoinLateral is a helper method to define mock.On call

• join core.Join
• expression string

func (*Grammar_Expecter) CompileJoins ¶

func (_e *Grammar_Expecter) CompileJoins(b interface{}, joins interface{}) *Grammar_CompileJoins_Call

CompileJoins is a helper method to define mock.On call

• b core.Query
• joins []core.Join

func (*Grammar_Expecter) CompileJsonContains ¶

func (_e *Grammar_Expecter) CompileJsonContains(column interface{}, value interface{}) *Grammar_CompileJsonContains_Call

CompileJsonContains is a helper method to define mock.On call

• column string
• value string

func (*Grammar_Expecter) CompileJsonContainsKey ¶

func (_e *Grammar_Expecter) CompileJsonContainsKey(column interface{}) *Grammar_CompileJsonContainsKey_Call

CompileJsonContainsKey is a helper method to define mock.On call

• column string

func (*Grammar_Expecter) CompileJsonLength ¶

func (_e *Grammar_Expecter) CompileJsonLength(column interface{}, operator interface{}, value interface{}) *Grammar_CompileJsonLength_Call

CompileJsonLength is a helper method to define mock.On call

• column string
• operator string
• value string

func (*Grammar_Expecter) CompileJsonOverlaps ¶

func (_e *Grammar_Expecter) CompileJsonOverlaps(column interface{}, value interface{}) *Grammar_CompileJsonOverlaps_Call

CompileJsonOverlaps is a helper method to define mock.On call

• column string
• value string

func (*Grammar_Expecter) CompileJsonUpdateColumn ¶

func (_e *Grammar_Expecter) CompileJsonUpdateColumn(key interface{}, value interface{}) *Grammar_CompileJsonUpdateColumn_Call

CompileJsonUpdateColumn is a helper method to define mock.On call

• key string
• value interface{}

func (*Grammar_Expecter) CompileJsonValueCast ¶

func (_e *Grammar_Expecter) CompileJsonValueCast(value interface{}) *Grammar_CompileJsonValueCast_Call

CompileJsonValueCast is a helper method to define mock.On call

• value string

func (*Grammar_Expecter) CompileLegacyGroupLimit ¶

func (_e *Grammar_Expecter) CompileLegacyGroupLimit(b interface{}) *Grammar_CompileLegacyGroupLimit_Call

CompileLegacyGroupLimit is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileLimit ¶

func (_e *Grammar_Expecter) CompileLimit(b interface{}, limit interface{}) *Grammar_CompileLimit_Call

CompileLimit is a helper method to define mock.On call

• b core.Query
• limit *int

func (*Grammar_Expecter) CompileLock ¶

func (_e *Grammar_Expecter) CompileLock(b interface{}, value interface{}) *Grammar_CompileLock_Call

CompileLock is a helper method to define mock.On call

• b core.Query
• value interface{}

func (*Grammar_Expecter) CompileOffset ¶

func (_e *Grammar_Expecter) CompileOffset(b interface{}, offset interface{}) *Grammar_CompileOffset_Call

CompileOffset is a helper method to define mock.On call

• b core.Query
• offset *int

func (*Grammar_Expecter) CompileOrders ¶

func (_e *Grammar_Expecter) CompileOrders(b interface{}, orders interface{}) *Grammar_CompileOrders_Call

CompileOrders is a helper method to define mock.On call

• b core.Query
• orders []core.Order

func (*Grammar_Expecter) CompileRandom ¶

func (_e *Grammar_Expecter) CompileRandom(seed interface{}) *Grammar_CompileRandom_Call

CompileRandom is a helper method to define mock.On call

• seed interface{}

func (*Grammar_Expecter) CompileRowNumber ¶

func (_e *Grammar_Expecter) CompileRowNumber(partition interface{}, orders interface{}) *Grammar_CompileRowNumber_Call

CompileRowNumber is a helper method to define mock.On call

• partition string
• orders string

func (*Grammar_Expecter) CompileSelect ¶

func (_e *Grammar_Expecter) CompileSelect(b interface{}) *Grammar_CompileSelect_Call

CompileSelect is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileTruncate ¶

func (_e *Grammar_Expecter) CompileTruncate(b interface{}) *Grammar_CompileTruncate_Call

CompileTruncate is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileUnionAggregate ¶

func (_e *Grammar_Expecter) CompileUnionAggregate(b interface{}) *Grammar_CompileUnionAggregate_Call

CompileUnionAggregate is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileUnions ¶

func (_e *Grammar_Expecter) CompileUnions(b interface{}) *Grammar_CompileUnions_Call

CompileUnions is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) CompileUpdate ¶

func (_e *Grammar_Expecter) CompileUpdate(b interface{}, values interface{}) *Grammar_CompileUpdate_Call

CompileUpdate is a helper method to define mock.On call

• b core.Query
• values core.UpdateValues

func (*Grammar_Expecter) CompileUpdateColumns ¶

func (_e *Grammar_Expecter) CompileUpdateColumns(b interface{}, values interface{}) *Grammar_CompileUpdateColumns_Call

CompileUpdateColumns is a helper method to define mock.On call

• b core.Query
• values core.UpdateValues

func (*Grammar_Expecter) CompileUpdateWithJoins ¶

func (_e *Grammar_Expecter) CompileUpdateWithJoins(b interface{}, table interface{}, columns interface{}, where interface{}) *Grammar_CompileUpdateWithJoins_Call

CompileUpdateWithJoins is a helper method to define mock.On call

• b core.Query
• table string
• columns string
• where string

func (*Grammar_Expecter) CompileUpdateWithoutJoins ¶

func (_e *Grammar_Expecter) CompileUpdateWithoutJoins(b interface{}, table interface{}, columns interface{}, where interface{}) *Grammar_CompileUpdateWithoutJoins_Call

CompileUpdateWithoutJoins is a helper method to define mock.On call

• b core.Query
• table string
• columns string
• where string

func (*Grammar_Expecter) CompileUpsert ¶

func (_e *Grammar_Expecter) CompileUpsert(b interface{}, values interface{}, uniqueBy interface{}, update interface{}) *Grammar_CompileUpsert_Call

CompileUpsert is a helper method to define mock.On call

• b core.Query
• values []map[string]interface{}
• uniqueBy []string
• update []core.UpsertUpdate

func (*Grammar_Expecter) CompileWhere ¶

func (_e *Grammar_Expecter) CompileWhere(b interface{}, where interface{}) *Grammar_CompileWhere_Call

CompileWhere is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) CompileWheres ¶

func (_e *Grammar_Expecter) CompileWheres(b interface{}) *Grammar_CompileWheres_Call

CompileWheres is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) GetBitwiseOperators ¶

func (_e *Grammar_Expecter) GetBitwiseOperators() *Grammar_GetBitwiseOperators_Call

GetBitwiseOperators is a helper method to define mock.On call

func (*Grammar_Expecter) GetDateFormat ¶

func (_e *Grammar_Expecter) GetDateFormat() *Grammar_GetDateFormat_Call

GetDateFormat is a helper method to define mock.On call

func (*Grammar_Expecter) GetOperators ¶

func (_e *Grammar_Expecter) GetOperators() *Grammar_GetOperators_Call

GetOperators is a helper method to define mock.On call

func (*Grammar_Expecter) GetValue ¶

func (_e *Grammar_Expecter) GetValue(expression interface{}) *Grammar_GetValue_Call

GetValue is a helper method to define mock.On call

• expression core.Expression

func (*Grammar_Expecter) IsJsonSelector ¶

func (_e *Grammar_Expecter) IsJsonSelector(value interface{}) *Grammar_IsJsonSelector_Call

IsJsonSelector is a helper method to define mock.On call

• value string

func (*Grammar_Expecter) Parameter ¶

func (_e *Grammar_Expecter) Parameter(value interface{}) *Grammar_Parameter_Call

Parameter is a helper method to define mock.On call

• value interface{}

func (*Grammar_Expecter) Parameterize ¶

func (_e *Grammar_Expecter) Parameterize(values interface{}) *Grammar_Parameterize_Call

Parameterize is a helper method to define mock.On call

• values []interface{}

func (*Grammar_Expecter) PrepareBindingForJsonContains ¶

func (_e *Grammar_Expecter) PrepareBindingForJsonContains(value interface{}) *Grammar_PrepareBindingForJsonContains_Call

PrepareBindingForJsonContains is a helper method to define mock.On call

• value interface{}

func (*Grammar_Expecter) PrepareBindingsForDelete ¶

func (_e *Grammar_Expecter) PrepareBindingsForDelete(bindings interface{}) *Grammar_PrepareBindingsForDelete_Call

PrepareBindingsForDelete is a helper method to define mock.On call

• bindings map[string][]interface{}

func (*Grammar_Expecter) PrepareBindingsForUpdate ¶

func (_e *Grammar_Expecter) PrepareBindingsForUpdate(bindings interface{}, values interface{}) *Grammar_PrepareBindingsForUpdate_Call

PrepareBindingsForUpdate is a helper method to define mock.On call

• bindings map[string][]interface{}
• values core.UpdateValues

func (*Grammar_Expecter) PrepareWhereLikeBinding ¶

func (_e *Grammar_Expecter) PrepareWhereLikeBinding(value interface{}, caseSensitive interface{}) *Grammar_PrepareWhereLikeBinding_Call

PrepareWhereLikeBinding is a helper method to define mock.On call

• value string
• caseSensitive bool

func (*Grammar_Expecter) SelectComponents ¶

func (_e *Grammar_Expecter) SelectComponents() *Grammar_SelectComponents_Call

SelectComponents is a helper method to define mock.On call

func (*Grammar_Expecter) SetEscaper ¶

func (_e *Grammar_Expecter) SetEscaper(escape interface{}) *Grammar_SetEscaper_Call

SetEscaper is a helper method to define mock.On call

• escape func(interface{} , bool) string

func (*Grammar_Expecter) SubstituteBindingsIntoRawSQL ¶

func (_e *Grammar_Expecter) SubstituteBindingsIntoRawSQL(sql interface{}, bindings interface{}) *Grammar_SubstituteBindingsIntoRawSQL_Call

SubstituteBindingsIntoRawSQL is a helper method to define mock.On call

• sql string
• bindings []interface{}

func (*Grammar_Expecter) UseLegacyGroupLimit ¶

func (_e *Grammar_Expecter) UseLegacyGroupLimit(b interface{}) *Grammar_UseLegacyGroupLimit_Call

UseLegacyGroupLimit is a helper method to define mock.On call

• b core.Query

func (*Grammar_Expecter) WhereBasic ¶

func (_e *Grammar_Expecter) WhereBasic(b interface{}, where interface{}) *Grammar_WhereBasic_Call

WhereBasic is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereBetween ¶

func (_e *Grammar_Expecter) WhereBetween(b interface{}, where interface{}) *Grammar_WhereBetween_Call

WhereBetween is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereBetweenColumns ¶

func (_e *Grammar_Expecter) WhereBetweenColumns(b interface{}, where interface{}) *Grammar_WhereBetweenColumns_Call

WhereBetweenColumns is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereBitwise ¶

func (_e *Grammar_Expecter) WhereBitwise(b interface{}, where interface{}) *Grammar_WhereBitwise_Call

WhereBitwise is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereColumn ¶

func (_e *Grammar_Expecter) WhereColumn(b interface{}, where interface{}) *Grammar_WhereColumn_Call

WhereColumn is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereDate ¶

func (_e *Grammar_Expecter) WhereDate(b interface{}, where interface{}) *Grammar_WhereDate_Call

WhereDate is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereDay ¶

func (_e *Grammar_Expecter) WhereDay(b interface{}, where interface{}) *Grammar_WhereDay_Call

WhereDay is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereExists ¶

func (_e *Grammar_Expecter) WhereExists(b interface{}, where interface{}) *Grammar_WhereExists_Call

WhereExists is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereExpression ¶

func (_e *Grammar_Expecter) WhereExpression(b interface{}, where interface{}) *Grammar_WhereExpression_Call

WhereExpression is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereFullText ¶

func (_e *Grammar_Expecter) WhereFullText(b interface{}, where interface{}) *Grammar_WhereFullText_Call

WhereFullText is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereIn ¶

func (_e *Grammar_Expecter) WhereIn(b interface{}, where interface{}) *Grammar_WhereIn_Call

WhereIn is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereInRaw ¶

func (_e *Grammar_Expecter) WhereInRaw(b interface{}, where interface{}) *Grammar_WhereInRaw_Call

WhereInRaw is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereJsonBoolean ¶

func (_e *Grammar_Expecter) WhereJsonBoolean(b interface{}, where interface{}) *Grammar_WhereJsonBoolean_Call

WhereJsonBoolean is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereJsonContains ¶

func (_e *Grammar_Expecter) WhereJsonContains(b interface{}, where interface{}) *Grammar_WhereJsonContains_Call

WhereJsonContains is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereJsonContainsKey ¶

func (_e *Grammar_Expecter) WhereJsonContainsKey(b interface{}, where interface{}) *Grammar_WhereJsonContainsKey_Call

WhereJsonContainsKey is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereJsonLength ¶

func (_e *Grammar_Expecter) WhereJsonLength(b interface{}, where interface{}) *Grammar_WhereJsonLength_Call

WhereJsonLength is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereJsonOverlaps ¶

func (_e *Grammar_Expecter) WhereJsonOverlaps(b interface{}, where interface{}) *Grammar_WhereJsonOverlaps_Call

WhereJsonOverlaps is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereLike ¶

func (_e *Grammar_Expecter) WhereLike(b interface{}, where interface{}) *Grammar_WhereLike_Call

WhereLike is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereMonth ¶

func (_e *Grammar_Expecter) WhereMonth(b interface{}, where interface{}) *Grammar_WhereMonth_Call

WhereMonth is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNested ¶

func (_e *Grammar_Expecter) WhereNested(b interface{}, where interface{}) *Grammar_WhereNested_Call

WhereNested is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNotExists ¶

func (_e *Grammar_Expecter) WhereNotExists(b interface{}, where interface{}) *Grammar_WhereNotExists_Call

WhereNotExists is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNotIn ¶

func (_e *Grammar_Expecter) WhereNotIn(b interface{}, where interface{}) *Grammar_WhereNotIn_Call

WhereNotIn is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNotInRaw ¶

func (_e *Grammar_Expecter) WhereNotInRaw(b interface{}, where interface{}) *Grammar_WhereNotInRaw_Call

WhereNotInRaw is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNotNull ¶

func (_e *Grammar_Expecter) WhereNotNull(b interface{}, where interface{}) *Grammar_WhereNotNull_Call

WhereNotNull is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereNull ¶

func (_e *Grammar_Expecter) WhereNull(b interface{}, where interface{}) *Grammar_WhereNull_Call

WhereNull is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereRaw ¶

func (_e *Grammar_Expecter) WhereRaw(b interface{}, where interface{}) *Grammar_WhereRaw_Call

WhereRaw is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereRowValues ¶

func (_e *Grammar_Expecter) WhereRowValues(b interface{}, where interface{}) *Grammar_WhereRowValues_Call

WhereRowValues is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereSub ¶

func (_e *Grammar_Expecter) WhereSub(b interface{}, where interface{}) *Grammar_WhereSub_Call

WhereSub is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereTime ¶

func (_e *Grammar_Expecter) WhereTime(b interface{}, where interface{}) *Grammar_WhereTime_Call

WhereTime is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereValueBetween ¶

func (_e *Grammar_Expecter) WhereValueBetween(b interface{}, where interface{}) *Grammar_WhereValueBetween_Call

WhereValueBetween is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) WhereYear ¶

func (_e *Grammar_Expecter) WhereYear(b interface{}, where interface{}) *Grammar_WhereYear_Call

WhereYear is a helper method to define mock.On call

• b core.Query
• where core.Where

func (*Grammar_Expecter) Wrap ¶

func (_e *Grammar_Expecter) Wrap(value interface{}) *Grammar_Wrap_Call

Wrap is a helper method to define mock.On call

• value interface{}

func (*Grammar_Expecter) WrapJsonBooleanSelector ¶

func (_e *Grammar_Expecter) WrapJsonBooleanSelector(value interface{}) *Grammar_WrapJsonBooleanSelector_Call

WrapJsonBooleanSelector is a helper method to define mock.On call

• value string

func (*Grammar_Expecter) WrapJsonBooleanValue ¶

func (_e *Grammar_Expecter) WrapJsonBooleanValue(value interface{}) *Grammar_WrapJsonBooleanValue_Call

WrapJsonBooleanValue is a helper method to define mock.On call

• value string

func (*Grammar_Expecter) WrapJsonSelector ¶

func (_e *Grammar_Expecter) WrapJsonSelector(value interface{}) *Grammar_WrapJsonSelector_Call

WrapJsonSelector is a helper method to define mock.On call

• value string

func (*Grammar_Expecter) WrapTable ¶

func (_e *Grammar_Expecter) WrapTable(table interface{}) *Grammar_WrapTable_Call

WrapTable is a helper method to define mock.On call

• table interface{}

func (*Grammar_Expecter) WrapUnion ¶

func (_e *Grammar_Expecter) WrapUnion(sql interface{}) *Grammar_WrapUnion_Call

WrapUnion is a helper method to define mock.On call

• sql string

func (*Grammar_Expecter) WrapValue ¶

func (_e *Grammar_Expecter) WrapValue(value interface{}) *Grammar_WrapValue_Call

WrapValue is a helper method to define mock.On call

• value string

func (*Grammar_GetBitwiseOperators_Call) Return ¶

func (_c *Grammar_GetBitwiseOperators_Call) Return(_a0 []string) *Grammar_GetBitwiseOperators_Call

func (*Grammar_GetBitwiseOperators_Call) Run ¶

func (_c *Grammar_GetBitwiseOperators_Call) Run(run func()) *Grammar_GetBitwiseOperators_Call

func (*Grammar_GetBitwiseOperators_Call) RunAndReturn ¶

func (_c *Grammar_GetBitwiseOperators_Call) RunAndReturn(run func() []string) *Grammar_GetBitwiseOperators_Call

func (*Grammar_GetDateFormat_Call) Return ¶

func (_c *Grammar_GetDateFormat_Call) Return(_a0 string) *Grammar_GetDateFormat_Call

func (*Grammar_GetDateFormat_Call) Run ¶

func (_c *Grammar_GetDateFormat_Call) Run(run func()) *Grammar_GetDateFormat_Call

func (*Grammar_GetDateFormat_Call) RunAndReturn ¶

func (_c *Grammar_GetDateFormat_Call) RunAndReturn(run func() string) *Grammar_GetDateFormat_Call

func (*Grammar_GetOperators_Call) Return ¶

func (_c *Grammar_GetOperators_Call) Return(_a0 []string) *Grammar_GetOperators_Call

func (*Grammar_GetOperators_Call) Run ¶

func (_c *Grammar_GetOperators_Call) Run(run func()) *Grammar_GetOperators_Call

func (*Grammar_GetOperators_Call) RunAndReturn ¶

func (_c *Grammar_GetOperators_Call) RunAndReturn(run func() []string) *Grammar_GetOperators_Call

func (*Grammar_GetValue_Call) Return ¶

func (_c *Grammar_GetValue_Call) Return(_a0 string) *Grammar_GetValue_Call

func (*Grammar_GetValue_Call) Run ¶

func (_c *Grammar_GetValue_Call) Run(run func(expression core.Expression)) *Grammar_GetValue_Call

func (*Grammar_GetValue_Call) RunAndReturn ¶

func (_c *Grammar_GetValue_Call) RunAndReturn(run func(core.Expression) string) *Grammar_GetValue_Call

func (*Grammar_IsJsonSelector_Call) Return ¶

func (_c *Grammar_IsJsonSelector_Call) Return(_a0 bool) *Grammar_IsJsonSelector_Call

func (*Grammar_IsJsonSelector_Call) Run ¶

func (_c *Grammar_IsJsonSelector_Call) Run(run func(value string)) *Grammar_IsJsonSelector_Call

func (*Grammar_IsJsonSelector_Call) RunAndReturn ¶

func (_c *Grammar_IsJsonSelector_Call) RunAndReturn(run func(string) bool) *Grammar_IsJsonSelector_Call

func (*Grammar_Parameter_Call) Return ¶

func (_c *Grammar_Parameter_Call) Return(_a0 string) *Grammar_Parameter_Call

func (*Grammar_Parameter_Call) Run ¶

func (_c *Grammar_Parameter_Call) Run(run func(value interface{})) *Grammar_Parameter_Call

func (*Grammar_Parameter_Call) RunAndReturn ¶

func (_c *Grammar_Parameter_Call) RunAndReturn(run func(interface{}) string) *Grammar_Parameter_Call

func (*Grammar_Parameterize_Call) Return ¶

func (_c *Grammar_Parameterize_Call) Return(_a0 string) *Grammar_Parameterize_Call

func (*Grammar_Parameterize_Call) Run ¶

func (_c *Grammar_Parameterize_Call) Run(run func(values []interface{})) *Grammar_Parameterize_Call

func (*Grammar_Parameterize_Call) RunAndReturn ¶

func (_c *Grammar_Parameterize_Call) RunAndReturn(run func([]interface{}) string) *Grammar_Parameterize_Call

func (*Grammar_PrepareBindingForJsonContains_Call) Return ¶

func (_c *Grammar_PrepareBindingForJsonContains_Call) Return(_a0 interface{}) *Grammar_PrepareBindingForJsonContains_Call

func (*Grammar_PrepareBindingForJsonContains_Call) Run ¶

func (_c *Grammar_PrepareBindingForJsonContains_Call) Run(run func(value interface{})) *Grammar_PrepareBindingForJsonContains_Call

func (*Grammar_PrepareBindingForJsonContains_Call) RunAndReturn ¶

func (_c *Grammar_PrepareBindingForJsonContains_Call) RunAndReturn(run func(interface{}) interface{}) *Grammar_PrepareBindingForJsonContains_Call

func (*Grammar_PrepareBindingsForDelete_Call) Return ¶

func (_c *Grammar_PrepareBindingsForDelete_Call) Return(_a0 []interface{}) *Grammar_PrepareBindingsForDelete_Call

func (*Grammar_PrepareBindingsForDelete_Call) Run ¶

func (_c *Grammar_PrepareBindingsForDelete_Call) Run(run func(bindings map[string][]interface{})) *Grammar_PrepareBindingsForDelete_Call

func (*Grammar_PrepareBindingsForDelete_Call) RunAndReturn ¶

func (_c *Grammar_PrepareBindingsForDelete_Call) RunAndReturn(run func(map[string][]interface{}) []interface{}) *Grammar_PrepareBindingsForDelete_Call

func (*Grammar_PrepareBindingsForUpdate_Call) Return ¶

func (_c *Grammar_PrepareBindingsForUpdate_Call) Return(_a0 []interface{}) *Grammar_PrepareBindingsForUpdate_Call

func (*Grammar_PrepareBindingsForUpdate_Call) Run ¶

func (_c *Grammar_PrepareBindingsForUpdate_Call) Run(run func(bindings map[string][]interface{}, values core.UpdateValues)) *Grammar_PrepareBindingsForUpdate_Call

func (*Grammar_PrepareBindingsForUpdate_Call) RunAndReturn ¶

func (_c *Grammar_PrepareBindingsForUpdate_Call) RunAndReturn(run func(map[string][]interface{}, core.UpdateValues) []interface{}) *Grammar_PrepareBindingsForUpdate_Call

func (*Grammar_PrepareWhereLikeBinding_Call) Return ¶

func (_c *Grammar_PrepareWhereLikeBinding_Call) Return(_a0 string) *Grammar_PrepareWhereLikeBinding_Call

func (*Grammar_PrepareWhereLikeBinding_Call) Run ¶

func (_c *Grammar_PrepareWhereLikeBinding_Call) Run(run func(value string, caseSensitive bool)) *Grammar_PrepareWhereLikeBinding_Call

func (*Grammar_PrepareWhereLikeBinding_Call) RunAndReturn ¶

func (_c *Grammar_PrepareWhereLikeBinding_Call) RunAndReturn(run func(string, bool) string) *Grammar_PrepareWhereLikeBinding_Call

func (*Grammar_SelectComponents_Call) Return ¶

func (_c *Grammar_SelectComponents_Call) Return(_a0 []string) *Grammar_SelectComponents_Call

func (*Grammar_SelectComponents_Call) Run ¶

func (_c *Grammar_SelectComponents_Call) Run(run func()) *Grammar_SelectComponents_Call

func (*Grammar_SelectComponents_Call) RunAndReturn ¶

func (_c *Grammar_SelectComponents_Call) RunAndReturn(run func() []string) *Grammar_SelectComponents_Call

func (*Grammar_SetEscaper_Call) Return ¶

func (_c *Grammar_SetEscaper_Call) Return() *Grammar_SetEscaper_Call

func (*Grammar_SetEscaper_Call) Run ¶

func (_c *Grammar_SetEscaper_Call) Run(run func(escape func(interface{}, bool) string)) *Grammar_SetEscaper_Call

func (*Grammar_SetEscaper_Call) RunAndReturn ¶

func (_c *Grammar_SetEscaper_Call) RunAndReturn(run func(func(interface{}, bool) string)) *Grammar_SetEscaper_Call

func (*Grammar_SubstituteBindingsIntoRawSQL_Call) Return ¶

func (_c *Grammar_SubstituteBindingsIntoRawSQL_Call) Return(_a0 string) *Grammar_SubstituteBindingsIntoRawSQL_Call

func (*Grammar_SubstituteBindingsIntoRawSQL_Call) Run ¶

func (_c *Grammar_SubstituteBindingsIntoRawSQL_Call) Run(run func(sql string, bindings []interface{})) *Grammar_SubstituteBindingsIntoRawSQL_Call

func (*Grammar_SubstituteBindingsIntoRawSQL_Call) RunAndReturn ¶

func (_c *Grammar_SubstituteBindingsIntoRawSQL_Call) RunAndReturn(run func(string, []interface{}) string) *Grammar_SubstituteBindingsIntoRawSQL_Call

func (*Grammar_UseLegacyGroupLimit_Call) Return ¶

func (_c *Grammar_UseLegacyGroupLimit_Call) Return(_a0 bool) *Grammar_UseLegacyGroupLimit_Call

func (*Grammar_UseLegacyGroupLimit_Call) Run ¶

func (_c *Grammar_UseLegacyGroupLimit_Call) Run(run func(b core.Query)) *Grammar_UseLegacyGroupLimit_Call

func (*Grammar_UseLegacyGroupLimit_Call) RunAndReturn ¶

func (_c *Grammar_UseLegacyGroupLimit_Call) RunAndReturn(run func(core.Query) bool) *Grammar_UseLegacyGroupLimit_Call

func (*Grammar_WhereBasic_Call) Return ¶

func (_c *Grammar_WhereBasic_Call) Return(_a0 string) *Grammar_WhereBasic_Call

func (*Grammar_WhereBasic_Call) Run ¶

func (_c *Grammar_WhereBasic_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereBasic_Call

func (*Grammar_WhereBasic_Call) RunAndReturn ¶

func (_c *Grammar_WhereBasic_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereBasic_Call

func (*Grammar_WhereBetweenColumns_Call) Return ¶

func (_c *Grammar_WhereBetweenColumns_Call) Return(_a0 string) *Grammar_WhereBetweenColumns_Call

func (*Grammar_WhereBetweenColumns_Call) Run ¶

func (_c *Grammar_WhereBetweenColumns_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereBetweenColumns_Call

func (*Grammar_WhereBetweenColumns_Call) RunAndReturn ¶

func (_c *Grammar_WhereBetweenColumns_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereBetweenColumns_Call

func (*Grammar_WhereBetween_Call) Return ¶

func (_c *Grammar_WhereBetween_Call) Return(_a0 string) *Grammar_WhereBetween_Call

func (*Grammar_WhereBetween_Call) Run ¶

func (_c *Grammar_WhereBetween_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereBetween_Call

func (*Grammar_WhereBetween_Call) RunAndReturn ¶

func (_c *Grammar_WhereBetween_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereBetween_Call

func (*Grammar_WhereBitwise_Call) Return ¶

func (_c *Grammar_WhereBitwise_Call) Return(_a0 string) *Grammar_WhereBitwise_Call

func (*Grammar_WhereBitwise_Call) Run ¶

func (_c *Grammar_WhereBitwise_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereBitwise_Call

func (*Grammar_WhereBitwise_Call) RunAndReturn ¶

func (_c *Grammar_WhereBitwise_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereBitwise_Call

func (*Grammar_WhereColumn_Call) Return ¶

func (_c *Grammar_WhereColumn_Call) Return(_a0 string) *Grammar_WhereColumn_Call

func (*Grammar_WhereColumn_Call) Run ¶

func (_c *Grammar_WhereColumn_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereColumn_Call

func (*Grammar_WhereColumn_Call) RunAndReturn ¶

func (_c *Grammar_WhereColumn_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereColumn_Call

func (*Grammar_WhereDate_Call) Return ¶

func (_c *Grammar_WhereDate_Call) Return(_a0 string) *Grammar_WhereDate_Call

func (*Grammar_WhereDate_Call) Run ¶

func (_c *Grammar_WhereDate_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereDate_Call

func (*Grammar_WhereDate_Call) RunAndReturn ¶

func (_c *Grammar_WhereDate_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereDate_Call

func (*Grammar_WhereDay_Call) Return ¶

func (_c *Grammar_WhereDay_Call) Return(_a0 string) *Grammar_WhereDay_Call

func (*Grammar_WhereDay_Call) Run ¶

func (_c *Grammar_WhereDay_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereDay_Call

func (*Grammar_WhereDay_Call) RunAndReturn ¶

func (_c *Grammar_WhereDay_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereDay_Call

func (*Grammar_WhereExists_Call) Return ¶

func (_c *Grammar_WhereExists_Call) Return(_a0 string) *Grammar_WhereExists_Call

func (*Grammar_WhereExists_Call) Run ¶

func (_c *Grammar_WhereExists_Call) Run(run func(b core.Query, where core.Where)) *Grammar_WhereExists_Call

func (*Grammar_WhereExists_Call) RunAndReturn ¶

func (_c *Grammar_WhereExists_Call) RunAndReturn(run func(core.Query, core.Where) string) *Grammar_WhereExists_Call