func (b FunctionBuilder) Functions(functions ...FunctionBuilder) FunctionBuilder {
for _, function := range functions {
f := function.build()
b = builder.Append(b, "Functions", f).(FunctionBuilder)
}
return b
}
//############################################################################
func (p beamerBuilder) Sequence(ctxs ...common.TaskCtx) beamerBuilder {
b := p
for _, c := range ctxs {
b = builder.Append(b, "Tasks", c).(beamerBuilder)
}
return b
}
// Where adds WHERE expressions to the query.
//
// See SelectBuilder.Where for more information.
func (b UpdateBuilder) Where(pred interface{}, args ...interface{}) UpdateBuilder {
return builder.Append(b, "WhereParts", newWherePart(pred, args...)).(UpdateBuilder)
}
// Set adds SET clauses to the query.
func (b UpdateBuilder) Set(column string, value interface{}) UpdateBuilder {
return builder.Append(b, "SetClauses", setClause{column: column, value: value}).(UpdateBuilder)
}
func (b unregBuilder) Add(i int) unregBuilder {
return builder.Append(b, "X", i).(unregBuilder)
}
// Values adds a single row's values to the query.
func (b InsertBuilder) Values(values ...interface{}) InsertBuilder {
return builder.Append(b, "Values", values).(InsertBuilder)
}
func (b simpleExprBuilder) Add(i int) simpleExprBuilder {
return builder.Append(b, "Adds", i).(simpleExprBuilder)
}
func (b answersReqBuilder) AddAnswerID(v int) answersReqBuilder {
return builder.Append(b, "AnswerIDS", v).(answersReqBuilder)
}
// Where adds an expression to the WHERE clause of the query.
//
// Expressions are ANDed together in the generated SQL.
//
// Where accepts several types for its pred argument:
//
// nil OR "" - ignored.
//
// string - SQL expression.
// If the expression has SQL placeholders then a set of arguments must be passed
// as well, one for each placeholder.
//
// map[string]interface{} OR Eq - map of SQL expressions to values. Each key is
// transformed into an expression like "<key> = ?", with the corresponding value
// bound to the placeholder. If the value is nil, the expression will be "<key>
// IS NULL". If the value is an array or slice, the expression will be "<key> IN
// (?,?,...)", with one placeholder for each item in the value. These expressions
// are ANDed together.
//
// Where will panic if pred isn't any of the above types.
func (b SelectBuilder) Where(pred interface{}, args ...interface{}) SelectBuilder {
return builder.Append(b, "WhereParts", newWherePart(pred, args...)).(SelectBuilder)
}
// JoinClause adds a join clause to the query.
func (b SelectBuilder) JoinClause(join string) SelectBuilder {
return builder.Append(b, "Joins", join).(SelectBuilder)
}
// Column adds a result column to the query.
// Unlike Columns, Column accepts args which will be bound to placeholders in
// the columns string, for example:
// Column("IF(col IN ("+squirrel.Placeholders(3)+"), 1, 0) as col", 1, 2, 3)
func (b SelectBuilder) Column(column interface{}, args ...interface{}) SelectBuilder {
return builder.Append(b, "Columns", newPart(column, args...)).(SelectBuilder)
}
// JoinClause adds a join clause to the query.
func (b SelectBuilder) JoinClause(pred interface{}, args ...interface{}) SelectBuilder {
return builder.Append(b, "Joins", newPart(pred, args...)).(SelectBuilder)
}
func (rb ruleBuilder) Prepare(cb PrepareCallback) ruleBuilder {
return builder.Append(rb, "Prepares", cb).(ruleBuilder)
}
func (rb ruleBuilder) Alter(cb AlterCallback) ruleBuilder {
return builder.Append(rb, "Alters", cb).(ruleBuilder)
}
// callback
func (rb ruleBuilder) Custom(cb CustomCallback) ruleBuilder {
return builder.Append(rb, "Customs", cb).(ruleBuilder)
}
// Suffix adds an expression to the end of the query
func (b UpdateBuilder) Suffix(sql string, args ...interface{}) UpdateBuilder {
return builder.Append(b, "Suffixes", Expr(sql, args...)).(UpdateBuilder)
}
func (b searchReqBuilder) AddTag(v string) searchReqBuilder {
return builder.Append(b, "Tags", v).(searchReqBuilder)
}
// Having adds an expression to the HAVING clause of the query.
//
// See Where.
func (b SelectBuilder) Having(pred interface{}, rest ...interface{}) SelectBuilder {
return builder.Append(b, "HavingParts", newWherePart(pred, rest...)).(SelectBuilder)
}
// Suffix adds an expression to the end of the query
func (b SelectBuilder) Suffix(sql string, args ...interface{}) SelectBuilder {
return builder.Append(b, "Suffixes", Expr(sql, args...)).(SelectBuilder)
}
// Prefix adds an expression to the beginning of the query
func (b DeleteBuilder) Prefix(sql string, args ...interface{}) DeleteBuilder {
return builder.Append(b, "Prefixes", Expr(sql, args...)).(DeleteBuilder)
}
func (b simpleExprBuilder) Subtract(i int) simpleExprBuilder {
return builder.Append(b, "Subtracts", i).(simpleExprBuilder)
}
func (b fooBuilder) Add(i int) fooBuilder {
return builder.Append(b, "Add", i).(fooBuilder)
}
// Suffix adds an expression to the end of the query
func (b InsertBuilder) Suffix(sql string, args ...interface{}) InsertBuilder {
return builder.Append(b, "Suffixes", Expr(sql, args...)).(InsertBuilder)
}
// When adds "WHEN ... THEN ..." part to CASE construct
func (b CaseBuilder) When(when interface{}, then interface{}) CaseBuilder {
// TODO: performance hint: replace slice of WhenPart with just slice of parts
// where even indices of the slice belong to "when"s and odd indices belong to "then"s
return builder.Append(b, "WhenParts", newWhenPart(when, then)).(CaseBuilder)
}