exclause

Documentation

Index

• type CTE
  • func (cte CTE) Build(builder clause.Builder)
• type Subquery
  • func (subquery Subquery) Build(builder clause.Builder)
• type Union
  • func NewUnion(query interface{}, args ...interface{}) Union
  • func (union Union) Build(builder clause.Builder)
  • func (union Union) MergeClause(mergeClause *clause.Clause)
  • func (union Union) Name() string
• type With
  • func NewWith(name string, subquery interface{}, args ...interface{}) With
  • func (with With) Build(builder clause.Builder)
  • func (with With) MergeClause(clause *clause.Clause)
  • func (with With) Name() string

Types

type CTE

type CTE struct {
	Name     string
	Columns  []string
	Subquery clause.Expression
}

CTE common table expressions

func (CTE) Build

func (cte CTE) Build(builder clause.Builder)

Build build CTE

type Subquery

type Subquery struct {
	DB *gorm.DB
}

Subquery is subquery statement

func (Subquery) Build

func (subquery Subquery) Build(builder clause.Builder)

Build build subquery

type Union

type Union struct {
	Statements []clause.Expression
}

Union is union clause

func NewUnion

func NewUnion(query interface{}, args ...interface{}) Union

NewUnion is easy to create new Union

// examples
// SELECT * FROM `general_users` UNION SELECT * FROM `admin_users`
db.Table("general_users").Clauses(exclause.NewUnion("SELECT * FROM `admin_users`")).Scan(&users)

// SELECT * FROM `general_users` UNION SELECT * FROM `admin_users`
db.Table("general_users").Clauses(exclause.NewUnion(db.Table("admin_users"))).Scan(&users)

// SELECT * FROM `general_users` UNION ALL SELECT * FROM `admin_users`
db.Table("general_users").Clauses(exclause.NewUnion("ALL ?", db.Table("admin_users"))).Scan(&users)

func (Union) Build

func (union Union) Build(builder clause.Builder)

Build build union clause

func (Union) MergeClause

func (union Union) MergeClause(mergeClause *clause.Clause)

MergeClause merge Union clauses

func (Union) Name

func (union Union) Name() string

Name union clause name

type With

type With struct {
	Recursive bool
	CTEs      []CTE
}

With with clause

// examples
// WITH `cte` AS (SELECT * FROM `users`) SELECT * FROM `cte`
db.Clauses(exclause.With{CTEs: []exclause.CTE{{Name: "cte", Subquery: clause.Expr{SQL: "SELECT * FROM `users`"}}}}).Table("cte").Scan(&users)

// WITH `cte` AS (SELECT * FROM `users`) SELECT * FROM `cte`
db.Clauses(exclause.With{CTEs: []exclause.CTE{{Name: "cte", Subquery: exclause.Subquery{DB: db.Table("users")}}}}).Table("cte").Scan(&users)

// WITH `cte` (`id`,`name`) AS (SELECT * FROM `users`) SELECT * FROM `cte`
db.Clauses(exclause.With{CTEs: []exclause.CTE{{Name: "cte", Columns: []string{"id", "name"}, Subquery: exclause.Subquery{DB: db.Table("users")}}}}).Table("cte").Scan(&users)

// WITH RECURSIVE `cte` AS (SELECT * FROM `users`) SELECT * FROM `cte`
db.Clauses(exclause.With{Recursive: true, CTEs: []exclause.CTE{{Name: "cte", Subquery: exclause.Subquery{DB: db.Table("users")}}}}).Table("cte").Scan(&users)

func NewWith

func NewWith(name string, subquery interface{}, args ...interface{}) With

NewWith is easy to create new With

// examples
// WITH `cte` AS (SELECT * FROM `users`) SELECT * FROM `cte`
db.Clauses(exclause.NewWith("cte", "SELECT * FROM `users`")).Table("cte").Scan(&users)

// WITH `cte` AS (SELECT * FROM `users` WHERE `name` = 'WinterYukky') SELECT * FROM `cte`
db.Clauses(exclause.NewWith("cte", "SELECT * FROM `users` WHERE `name` = ?", "WinterYukky")).Table("cte").Scan(&users)

// WITH `cte` AS (SELECT * FROM `users` WHERE `name` = 'WinterYukky') SELECT * FROM `cte`
db.Clauses(exclause.NewWith("cte", db.Table("users").Where("`name` = ?", "WinterYukky"))).Table("cte").Scan(&users)

If you need more advanced WITH clause, you can see With struct.

func (With) Build

func (with With) Build(builder clause.Builder)

Build build with clause

func (With) MergeClause

func (with With) MergeClause(clause *clause.Clause)

MergeClause merge With clauses

func (With) Name

func (with With) Name() string

Name with clause name