qm

Documentation

Index

• func Apply(q *queries.Query, mods ...QueryMod)
• func Rels(r ...string) string
• type QueryMod
  • func And(clause string, args ...interface{}) QueryMod
  • func AndIn(clause string, args ...interface{}) QueryMod
  • func Expr(wheremods ...QueryMod) QueryMod
  • func For(clause string) QueryMod
  • func From(from string) QueryMod
  • func GroupBy(clause string) QueryMod
  • func Having(clause string, args ...interface{}) QueryMod
  • func InnerJoin(clause string, args ...interface{}) QueryMod
  • func Limit(limit int) QueryMod
  • func Load(relationship string, mods ...QueryMod) QueryMod
  • func Offset(offset int) QueryMod
  • func Or(clause string, args ...interface{}) QueryMod
  • func Or2(q QueryMod) QueryMod
  • func OrIn(clause string, args ...interface{}) QueryMod
  • func OrderBy(clause string) QueryMod
  • func SQL(sql string, args ...interface{}) QueryMod
  • func Select(columns ...string) QueryMod
  • func Where(clause string, args ...interface{}) QueryMod
  • func WhereIn(clause string, args ...interface{}) QueryMod
• type QueryModFunc
  • func (f QueryModFunc) Apply(q *queries.Query)

Functions

func Apply

func Apply(q *queries.Query, mods ...QueryMod)

Apply the query mods to the Query object

func Rels

func Rels(r ...string) string

Rels is an alias for strings.Join to make it easier to use relationship name constants in Load.

Types

type QueryMod

type QueryMod interface {
	Apply(q *queries.Query)
}

QueryMod modifies a query object.

func And

func And(clause string, args ...interface{}) QueryMod

And allows you to specify a where clause separated by an AND for your statement And is a duplicate of the Where function, but allows for more natural looking query mod chains, for example: (Where("a=?"), And("b=?"), Or("c=?")))

Because Where statements are by default combined with and, there's no reason to call this method as it behaves the same as "Where"

func AndIn

func AndIn(clause string, args ...interface{}) QueryMod

AndIn allows you to specify a "x IN (set)" clause separated by an AndIn for your where statement. AndIn is a duplicate of the WhereIn function, but allows for more natural looking query mod chains, for example: (WhereIn("column1 in ?"), AndIn("column2 in ?"), OrIn("column3 in ?"))

func Expr

func Expr(wheremods ...QueryMod) QueryMod

Expr groups where query mods. It's detrimental to use this with any other type of Query Mod because the effects will always only affect where clauses.

When Expr is used, the entire query will stop doing automatic paretheses for the where statement and you must use Expr anywhere you would like them.

Do NOT use with anything except where.

func For

func For(clause string) QueryMod

For inserts a concurrency locking clause at the end of your statement

func From

func From(from string) QueryMod

From allows to specify the table for your statement

func GroupBy

func GroupBy(clause string) QueryMod

GroupBy allows you to specify a group by clause for your statement

func Having

func Having(clause string, args ...interface{}) QueryMod

Having allows you to specify a having clause for your statement

func InnerJoin

func InnerJoin(clause string, args ...interface{}) QueryMod

InnerJoin on another table

func Limit

func Limit(limit int) QueryMod

Limit the number of returned rows

func Load

func Load(relationship string, mods ...QueryMod) QueryMod

Load allows you to specify foreign key relationships to eager load for your query. Passed in relationships need to be in the format MyThing or MyThings. Relationship name plurality is important, if your relationship is singular, you need to specify the singular form and vice versa.

In the following example we see how to eager load a users's videos and the video's tags comments, and publisher during a query to find users.

models.Users(qm.Load("Videos.Tags"))

In order to filter better on the query for the relationships you can additionally supply query mods.

models.Users(qm.Load("Videos.Tags", Where("deleted = ?", isDeleted)))

Keep in mind the above only sets the query mods for the query on the last specified relationship. In this case, only Tags will get the query mod. If you want to do intermediate relationships with query mods you must specify them separately:

models.Users(
  qm.Load("Videos", Where("deleted = false"))
  qm.Load("Videos.Tags", Where("deleted = ?", isDeleted))
)

func Offset

func Offset(offset int) QueryMod

Offset into the results

func Or

func Or(clause string, args ...interface{}) QueryMod

Or allows you to specify a where clause separated by an OR for your statement

func Or2

func Or2(q QueryMod) QueryMod

Or2 takes a Where query mod and turns it into an Or. It can be detrimental if used on things that are not Where query mods as it will still modify the last Where statement into an Or.

func OrIn

func OrIn(clause string, args ...interface{}) QueryMod

OrIn allows you to specify an IN clause separated by an OR for your where statement

func OrderBy

func OrderBy(clause string) QueryMod

OrderBy allows you to specify a order by clause for your statement

func SQL

func SQL(sql string, args ...interface{}) QueryMod

SQL allows you to execute a plain SQL statement

func Select

func Select(columns ...string) QueryMod

Select specific columns opposed to all columns

func Where

func Where(clause string, args ...interface{}) QueryMod

Where allows you to specify a where clause for your statement. If multiple Where statements are used they are combined with 'and'

func WhereIn

func WhereIn(clause string, args ...interface{}) QueryMod

WhereIn allows you to specify a "x IN (set)" clause for your where statement Example clauses: "column in ?", "(column1,column2) in ?"

type QueryModFunc

type QueryModFunc func(q *queries.Query)

The QueryModFunc type is an adapter to allow the use of ordinary functions for query modifying. If f is a function with the appropriate signature, QueryModFunc(f) is a QueryMod that calls f.

func (QueryModFunc) Apply

func (f QueryModFunc) Apply(q *queries.Query)

Apply calls f(q).