Documentation

Overview

    Package sql provides wrappers around the standard database/sql package to allow the generated code to interact with a statically-typed API.

    Users that are interacting with this package should be aware that the following builders don't check the given SQL syntax nor validate or escape user-inputs. ~All validations are expected to be happened in the generated ent package.

    Index

    Constants

    This section is empty.

    Variables

    This section is empty.

    Functions

    func As

    func As(ident string, as string) string

      As suffixed the given column with an alias (`a` AS `b`).

      func Asc

      func Asc(column string) string

        Asc adds the ASC suffix for the given column.

        func Avg

        func Avg(ident string) string

          Avg wraps the ident with the AVG aggregation function.

          func Count

          func Count(ident string) string

            Count wraps the ident with the COUNT aggregation function.

            func Desc

            func Desc(column string) string

              Desc adds the DESC suffix for the given column.

              func Distinct

              func Distinct(idents ...string) string

                Distinct prefixed the given columns with the `DISTINCT` keyword (DISTINCT `id`).

                func Lower

                func Lower(ident string) string

                  Lower wraps the given column with the LOWER function.

                  P().EQ(sql.Lower("name"), "a8m")
                  

                  func Max

                  func Max(ident string) string

                    Max wraps the ident with the MAX aggregation function.

                    func Min

                    func Min(ident string) string

                      Min wraps the ident with the MIN aggregation function.

                      func ScanInt

                      func ScanInt(rows ColumnScanner) (int, error)

                        ScanInt scans and returns an int from the rows columns.

                        func ScanInt64

                        func ScanInt64(rows ColumnScanner) (int64, error)

                          ScanInt64 scans and returns an int64 from the rows columns.

                          func ScanOne

                          func ScanOne(rows ColumnScanner, v interface{}) error

                            ScanOne scans one row to the given value. It fails if the rows holds more than 1 row.

                            func ScanSlice

                            func ScanSlice(rows ColumnScanner, v interface{}) error

                              ScanSlice scans the given ColumnScanner (basically, sql.Row or sql.Rows) into the given slice.

                              func ScanString

                              func ScanString(rows ColumnScanner) (string, error)

                                ScanString scans and returns a string from the rows columns.

                                func ScanValue

                                func ScanValue(rows ColumnScanner) (driver.Value, error)

                                  ScanValue scans and returns a driver.Value from the rows columns.

                                  func Sum

                                  func Sum(ident string) string

                                    Sum wraps the ident with the SUM aggregation function.

                                    Types

                                    type Builder

                                    type Builder struct {
                                    	bytes.Buffer // underlying buffer.
                                    	// contains filtered or unexported fields
                                    }

                                      Builder is the base query builder for the sql dsl.

                                      func (*Builder) AddError

                                      func (b *Builder) AddError(err error) *Builder

                                        AddError appends an error to the builder errors.

                                        func (*Builder) Arg

                                        func (b *Builder) Arg(a interface{}) *Builder

                                          Arg appends an input argument to the builder.

                                          func (*Builder) Args

                                          func (b *Builder) Args(a ...interface{}) *Builder

                                            Args appends a list of arguments to the builder.

                                            func (*Builder) Comma

                                            func (b *Builder) Comma() *Builder

                                              Comma adds a comma to the query.

                                              func (Builder) Dialect

                                              func (b Builder) Dialect() string

                                                Dialect returns the dialect of the builder.

                                                func (*Builder) Err

                                                func (b *Builder) Err() error

                                                  Err returns a concatenated error of all errors encountered during the query-building, or were added manually by calling AddError.

                                                  func (*Builder) Ident

                                                  func (b *Builder) Ident(s string) *Builder

                                                    Ident appends the given string as an identifier.

                                                    func (*Builder) IdentComma

                                                    func (b *Builder) IdentComma(s ...string) *Builder

                                                      IdentComma calls Ident on all arguments and adds a comma between them.

                                                      func (*Builder) Join

                                                      func (b *Builder) Join(qs ...Querier) *Builder

                                                        Join joins a list of Queries to the builder.

                                                        func (*Builder) JoinComma

                                                        func (b *Builder) JoinComma(qs ...Querier) *Builder

                                                          JoinComma joins a list of Queries and adds comma between them.

                                                          func (*Builder) Nested

                                                          func (b *Builder) Nested(f func(*Builder)) *Builder

                                                            Nested gets a callback, and wraps its result with parentheses.

                                                            func (*Builder) Pad

                                                            func (b *Builder) Pad() *Builder

                                                              Pad adds a space to the query.

                                                              func (Builder) Query

                                                              func (b Builder) Query() (string, []interface{})

                                                                Query implements the Querier interface.

                                                                func (*Builder) Quote

                                                                func (b *Builder) Quote(ident string) string

                                                                  Quote quotes the given identifier with the characters based on the configured dialect. It defaults to "`".

                                                                  func (*Builder) SetDialect

                                                                  func (b *Builder) SetDialect(dialect string)

                                                                    SetDialect sets the builder dialect. It's used for garnering dialect specific queries.

                                                                    func (*Builder) SetTotal

                                                                    func (b *Builder) SetTotal(total int)

                                                                      SetTotal sets the value of the total arguments. Used to pass this information between sub queries/expressions.

                                                                      func (Builder) Total

                                                                      func (b Builder) Total() int

                                                                        Total returns the total number of arguments so far.

                                                                        func (*Builder) WriteByte

                                                                        func (b *Builder) WriteByte(c byte) *Builder

                                                                          WriteByte wraps the Buffer.WriteByte to make it chainable with other methods.

                                                                          func (*Builder) WriteOp

                                                                          func (b *Builder) WriteOp(op Op) *Builder

                                                                            WriteOp writes an operator to the builder.

                                                                            func (*Builder) WriteString

                                                                            func (b *Builder) WriteString(s string) *Builder

                                                                              WriteString wraps the Buffer.WriteString to make it chainable with other methods.

                                                                              type ColumnBuilder

                                                                              type ColumnBuilder struct {
                                                                              	Builder
                                                                              	// contains filtered or unexported fields
                                                                              }

                                                                                ColumnBuilder is a builder for column definition in table creation.

                                                                                func Column

                                                                                func Column(name string) *ColumnBuilder

                                                                                  Column returns a new ColumnBuilder with the given name.

                                                                                  sql.Column("group_id").Type("int").Attr("UNIQUE")
                                                                                  

                                                                                  func (*ColumnBuilder) Attr

                                                                                  func (c *ColumnBuilder) Attr(attr string) *ColumnBuilder

                                                                                    Attr sets an extra attribute for the column, like UNIQUE or AUTO_INCREMENT.

                                                                                    func (*ColumnBuilder) Check

                                                                                    func (c *ColumnBuilder) Check(check func(*Builder)) *ColumnBuilder

                                                                                      Check adds a CHECK clause to the ADD COLUMN statement.

                                                                                      func (*ColumnBuilder) Constraint

                                                                                      func (c *ColumnBuilder) Constraint(fk *ForeignKeyBuilder) *ColumnBuilder

                                                                                        Constraint adds the CONSTRAINT clause to the ADD COLUMN statement in SQLite.

                                                                                        func (*ColumnBuilder) Query

                                                                                        func (c *ColumnBuilder) Query() (string, []interface{})

                                                                                          Query returns query representation of a Column.

                                                                                          func (*ColumnBuilder) Type

                                                                                          func (c *ColumnBuilder) Type(t string) *ColumnBuilder

                                                                                            Type sets the column type.

                                                                                            type ColumnScanner

                                                                                            type ColumnScanner interface {
                                                                                            	Next() bool
                                                                                            	Scan(...interface{}) error
                                                                                            	Columns() ([]string, error)
                                                                                            	Err() error
                                                                                            }

                                                                                              ColumnScanner is the interface that wraps the four sql.Rows methods used for scanning.

                                                                                              type Conn

                                                                                              type Conn struct {
                                                                                              	ExecQuerier
                                                                                              }

                                                                                                Conn implements dialect.ExecQuerier given ExecQuerier.

                                                                                                func (Conn) Exec

                                                                                                func (c Conn) Exec(ctx context.Context, query string, args, v interface{}) error

                                                                                                  Exec implements the dialect.Exec method.

                                                                                                  func (Conn) Query

                                                                                                  func (c Conn) Query(ctx context.Context, query string, args, v interface{}) error

                                                                                                    Query implements the dialect.Query method.

                                                                                                    type DeleteBuilder

                                                                                                    type DeleteBuilder struct {
                                                                                                    	Builder
                                                                                                    	// contains filtered or unexported fields
                                                                                                    }

                                                                                                      DeleteBuilder is a builder for `DELETE` statement.

                                                                                                      func Delete

                                                                                                      func Delete(table string) *DeleteBuilder

                                                                                                        Delete creates a builder for the `DELETE` statement.

                                                                                                        Delete("users").
                                                                                                        	Where(
                                                                                                        		Or(
                                                                                                        			EQ("name", "foo").And().EQ("age", 10),
                                                                                                        			EQ("name", "bar").And().EQ("age", 20),
                                                                                                        			And(
                                                                                                        				EQ("name", "qux"),
                                                                                                        				EQ("age", 1).Or().EQ("age", 2),
                                                                                                        			),
                                                                                                        		),
                                                                                                        	)
                                                                                                        

                                                                                                        func (*DeleteBuilder) FromSelect

                                                                                                        func (d *DeleteBuilder) FromSelect(s *Selector) *DeleteBuilder

                                                                                                          FromSelect makes it possible to delete a sub query.

                                                                                                          func (*DeleteBuilder) Query

                                                                                                          func (d *DeleteBuilder) Query() (string, []interface{})

                                                                                                            Query returns query representation of a `DELETE` statement.

                                                                                                            func (*DeleteBuilder) Schema

                                                                                                            func (d *DeleteBuilder) Schema(name string) *DeleteBuilder

                                                                                                              Schema sets the database name for the table whose row will be deleted.

                                                                                                              func (*DeleteBuilder) Where

                                                                                                              func (d *DeleteBuilder) Where(p *Predicate) *DeleteBuilder

                                                                                                                Where appends a where predicate to the `DELETE` statement.

                                                                                                                type DescribeBuilder

                                                                                                                type DescribeBuilder struct {
                                                                                                                	Builder
                                                                                                                	// contains filtered or unexported fields
                                                                                                                }

                                                                                                                  DescribeBuilder is a query builder for `DESCRIBE` statement.

                                                                                                                  func Describe

                                                                                                                  func Describe(name string) *DescribeBuilder

                                                                                                                    Describe returns a query builder for the `DESCRIBE` statement.

                                                                                                                    Describe("users")
                                                                                                                    

                                                                                                                    func (*DescribeBuilder) Query

                                                                                                                    func (t *DescribeBuilder) Query() (string, []interface{})

                                                                                                                      Query returns query representation of a `DESCRIBE` statement.

                                                                                                                      type DialectBuilder

                                                                                                                      type DialectBuilder struct {
                                                                                                                      	// contains filtered or unexported fields
                                                                                                                      }

                                                                                                                        DialectBuilder prefixes all root builders with the `Dialect` constructor.

                                                                                                                        func Dialect

                                                                                                                        func Dialect(name string) *DialectBuilder

                                                                                                                          Dialect creates a new DialectBuilder with the given dialect name.

                                                                                                                          func (*DialectBuilder) AlterIndex

                                                                                                                          func (d *DialectBuilder) AlterIndex(name string) *IndexAlter

                                                                                                                            AlterIndex creates an IndexAlter for the configured dialect.

                                                                                                                            Dialect(dialect.Postgres).
                                                                                                                            	AlterIndex("old").
                                                                                                                            	Rename("new")
                                                                                                                            

                                                                                                                            func (*DialectBuilder) AlterTable

                                                                                                                            func (d *DialectBuilder) AlterTable(name string) *TableAlter

                                                                                                                              AlterTable creates a TableAlter for the configured dialect.

                                                                                                                              Dialect(dialect.Postgres).
                                                                                                                              	AlterTable("users").
                                                                                                                              	AddColumn(Column("group_id").Type("int").Attr("UNIQUE")).
                                                                                                                              	AddForeignKey(ForeignKey().Columns("group_id").
                                                                                                                              		Reference(Reference().Table("groups").Columns("id")).
                                                                                                                              		OnDelete("CASCADE"),
                                                                                                                              	)
                                                                                                                              

                                                                                                                              func (*DialectBuilder) Column

                                                                                                                              func (d *DialectBuilder) Column(name string) *ColumnBuilder

                                                                                                                                Column creates a ColumnBuilder for the configured dialect.

                                                                                                                                Dialect(dialect.Postgres)..
                                                                                                                                	Column("group_id").Type("int").Attr("UNIQUE")
                                                                                                                                

                                                                                                                                func (*DialectBuilder) CreateIndex

                                                                                                                                func (d *DialectBuilder) CreateIndex(name string) *IndexBuilder

                                                                                                                                  CreateIndex creates a IndexBuilder for the configured dialect.

                                                                                                                                  Dialect(dialect.Postgres).
                                                                                                                                  	CreateIndex("unique_name").
                                                                                                                                  	Unique().
                                                                                                                                  	Table("users").
                                                                                                                                  	Columns("first", "last")
                                                                                                                                  

                                                                                                                                  func (*DialectBuilder) CreateTable

                                                                                                                                  func (d *DialectBuilder) CreateTable(name string) *TableBuilder

                                                                                                                                    CreateTable creates a TableBuilder for the configured dialect.

                                                                                                                                    Dialect(dialect.Postgres).
                                                                                                                                    	CreateTable("users").
                                                                                                                                    		Columns(
                                                                                                                                    			Column("id").Type("int").Attr("auto_increment"),
                                                                                                                                    			Column("name").Type("varchar(255)"),
                                                                                                                                    		).
                                                                                                                                    		PrimaryKey("id")
                                                                                                                                    

                                                                                                                                    func (*DialectBuilder) Delete

                                                                                                                                    func (d *DialectBuilder) Delete(table string) *DeleteBuilder

                                                                                                                                      Delete creates a DeleteBuilder for the configured dialect.

                                                                                                                                      Dialect(dialect.Postgres).
                                                                                                                                      	Delete().From("users")
                                                                                                                                      

                                                                                                                                      func (*DialectBuilder) Describe

                                                                                                                                      func (d *DialectBuilder) Describe(name string) *DescribeBuilder

                                                                                                                                        Describe creates a DescribeBuilder for the configured dialect.

                                                                                                                                        Dialect(dialect.Postgres).
                                                                                                                                        	Describe("users")
                                                                                                                                        

                                                                                                                                        func (*DialectBuilder) DropIndex

                                                                                                                                        func (d *DialectBuilder) DropIndex(name string) *DropIndexBuilder

                                                                                                                                          DropIndex creates a DropIndexBuilder for the configured dialect.

                                                                                                                                          Dialect(dialect.Postgres).
                                                                                                                                          	DropIndex("name")
                                                                                                                                          

                                                                                                                                          func (*DialectBuilder) Insert

                                                                                                                                          func (d *DialectBuilder) Insert(table string) *InsertBuilder

                                                                                                                                            Insert creates a InsertBuilder for the configured dialect.

                                                                                                                                            Dialect(dialect.Postgres).
                                                                                                                                            	Insert("users").Columns("age").Values(1)
                                                                                                                                            

                                                                                                                                            func (*DialectBuilder) Select

                                                                                                                                            func (d *DialectBuilder) Select(columns ...string) *Selector

                                                                                                                                              Select creates a Selector for the configured dialect.

                                                                                                                                              Dialect(dialect.Postgres).
                                                                                                                                              	Select().From(Table("users"))
                                                                                                                                              

                                                                                                                                              func (*DialectBuilder) Table

                                                                                                                                              func (d *DialectBuilder) Table(name string) *SelectTable

                                                                                                                                                Table creates a SelectTable for the configured dialect.

                                                                                                                                                Dialect(dialect.Postgres).
                                                                                                                                                	Table("users").As("u")
                                                                                                                                                

                                                                                                                                                func (*DialectBuilder) Update

                                                                                                                                                func (d *DialectBuilder) Update(table string) *UpdateBuilder

                                                                                                                                                  Update creates a UpdateBuilder for the configured dialect.

                                                                                                                                                  Dialect(dialect.Postgres).
                                                                                                                                                  	Update("users").Set("name", "foo")
                                                                                                                                                  

                                                                                                                                                  func (*DialectBuilder) With

                                                                                                                                                  func (d *DialectBuilder) With(name string) *WithBuilder

                                                                                                                                                    With creates a WithBuilder for the configured dialect.

                                                                                                                                                    Dialect(dialect.Postgres).
                                                                                                                                                    	With("users_view").
                                                                                                                                                    	As(Select().From(Table("users")))
                                                                                                                                                    

                                                                                                                                                    type Driver

                                                                                                                                                    type Driver struct {
                                                                                                                                                    	Conn
                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                    }

                                                                                                                                                      Driver is a dialect.Driver implementation for SQL based databases.

                                                                                                                                                      func Open

                                                                                                                                                      func Open(driver, source string) (*Driver, error)

                                                                                                                                                        Open wraps the database/sql.Open method and returns a dialect.Driver that implements the an ent/dialect.Driver interface.

                                                                                                                                                        func OpenDB

                                                                                                                                                        func OpenDB(driver string, db *sql.DB) *Driver

                                                                                                                                                          OpenDB wraps the given database/sql.DB method with a Driver.

                                                                                                                                                          func (*Driver) BeginTx

                                                                                                                                                          func (d *Driver) BeginTx(ctx context.Context, opts *TxOptions) (dialect.Tx, error)

                                                                                                                                                            BeginTx starts a transaction with options.

                                                                                                                                                            func (*Driver) Close

                                                                                                                                                            func (d *Driver) Close() error

                                                                                                                                                              Close closes the underlying connection.

                                                                                                                                                              func (Driver) DB

                                                                                                                                                              func (d Driver) DB() *sql.DB

                                                                                                                                                                DB returns the underlying *sql.DB instance.

                                                                                                                                                                func (Driver) Dialect

                                                                                                                                                                func (d Driver) Dialect() string

                                                                                                                                                                  Dialect implements the dialect.Dialect method.

                                                                                                                                                                  func (*Driver) Tx

                                                                                                                                                                  func (d *Driver) Tx(ctx context.Context) (dialect.Tx, error)

                                                                                                                                                                    Tx starts and returns a transaction.

                                                                                                                                                                    type DropIndexBuilder

                                                                                                                                                                    type DropIndexBuilder struct {
                                                                                                                                                                    	Builder
                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                    }

                                                                                                                                                                      DropIndexBuilder is a builder for `DROP INDEX` statement.

                                                                                                                                                                      func DropIndex

                                                                                                                                                                      func DropIndex(name string) *DropIndexBuilder

                                                                                                                                                                        DropIndex creates a builder for the `DROP INDEX` statement.

                                                                                                                                                                        MySQL:
                                                                                                                                                                        
                                                                                                                                                                        	DropIndex("index_name").
                                                                                                                                                                        		Table("users").
                                                                                                                                                                        
                                                                                                                                                                        SQLite/PostgreSQL:
                                                                                                                                                                        
                                                                                                                                                                        	DropIndex("index_name")
                                                                                                                                                                        

                                                                                                                                                                        func (*DropIndexBuilder) Query

                                                                                                                                                                        func (d *DropIndexBuilder) Query() (string, []interface{})

                                                                                                                                                                          Query returns query representation of a reference clause.

                                                                                                                                                                          DROP INDEX index_name [ON table_name]
                                                                                                                                                                          

                                                                                                                                                                          func (*DropIndexBuilder) Table

                                                                                                                                                                          func (d *DropIndexBuilder) Table(table string) *DropIndexBuilder

                                                                                                                                                                            Table defines the table for the index.

                                                                                                                                                                            type ExecQuerier

                                                                                                                                                                            type ExecQuerier interface {
                                                                                                                                                                            	ExecContext(ctx context.Context, query string, args ...interface{}) (sql.Result, error)
                                                                                                                                                                            	QueryContext(ctx context.Context, query string, args ...interface{}) (*sql.Rows, error)
                                                                                                                                                                            }

                                                                                                                                                                              ExecQuerier wraps the standard Exec and Query methods.

                                                                                                                                                                              type ForeignKeyBuilder

                                                                                                                                                                              type ForeignKeyBuilder struct {
                                                                                                                                                                              	Builder
                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                              }

                                                                                                                                                                                ForeignKeyBuilder is the builder for the foreign-key constraint clause.

                                                                                                                                                                                func ForeignKey

                                                                                                                                                                                func ForeignKey(symbol ...string) *ForeignKeyBuilder

                                                                                                                                                                                  ForeignKey returns a builder for the foreign-key constraint clause in create/alter table statements.

                                                                                                                                                                                  ForeignKey().
                                                                                                                                                                                  	Columns("group_id").
                                                                                                                                                                                  	Reference(Reference().Table("groups").Columns("id")).
                                                                                                                                                                                  	OnDelete("CASCADE")
                                                                                                                                                                                  

                                                                                                                                                                                  func (*ForeignKeyBuilder) Columns

                                                                                                                                                                                  func (fk *ForeignKeyBuilder) Columns(s ...string) *ForeignKeyBuilder

                                                                                                                                                                                    Columns sets the columns of the foreign key in the source table.

                                                                                                                                                                                    func (*ForeignKeyBuilder) OnDelete

                                                                                                                                                                                    func (fk *ForeignKeyBuilder) OnDelete(action string) *ForeignKeyBuilder

                                                                                                                                                                                      OnDelete sets the on delete action for this constraint.

                                                                                                                                                                                      func (*ForeignKeyBuilder) OnUpdate

                                                                                                                                                                                      func (fk *ForeignKeyBuilder) OnUpdate(action string) *ForeignKeyBuilder

                                                                                                                                                                                        OnUpdate sets the on delete action for this constraint.

                                                                                                                                                                                        func (*ForeignKeyBuilder) Query

                                                                                                                                                                                        func (fk *ForeignKeyBuilder) Query() (string, []interface{})

                                                                                                                                                                                          Query returns query representation of a foreign key constraint.

                                                                                                                                                                                          func (*ForeignKeyBuilder) Reference

                                                                                                                                                                                            Reference sets the reference clause.

                                                                                                                                                                                            func (*ForeignKeyBuilder) Symbol

                                                                                                                                                                                              Symbol sets the symbol of the foreign key.

                                                                                                                                                                                              type Func

                                                                                                                                                                                              type Func struct {
                                                                                                                                                                                              	Builder
                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                              }

                                                                                                                                                                                                Func represents an SQL function.

                                                                                                                                                                                                func (*Func) Append

                                                                                                                                                                                                func (f *Func) Append(fn func(*Builder)) *Func

                                                                                                                                                                                                  Append appends a new function to the function callbacks. The callback list are executed on call to String.

                                                                                                                                                                                                  func (*Func) Avg

                                                                                                                                                                                                  func (f *Func) Avg(ident string)

                                                                                                                                                                                                    Avg wraps the ident with the AVG aggregation function.

                                                                                                                                                                                                    func (*Func) Count

                                                                                                                                                                                                    func (f *Func) Count(ident string)

                                                                                                                                                                                                      Count wraps the ident with the COUNT aggregation function.

                                                                                                                                                                                                      func (*Func) Lower

                                                                                                                                                                                                      func (f *Func) Lower(ident string)

                                                                                                                                                                                                        Lower wraps the given ident with the LOWER function.

                                                                                                                                                                                                        func (*Func) Max

                                                                                                                                                                                                        func (f *Func) Max(ident string)

                                                                                                                                                                                                          Max wraps the ident with the MAX aggregation function.

                                                                                                                                                                                                          func (*Func) Min

                                                                                                                                                                                                          func (f *Func) Min(ident string)

                                                                                                                                                                                                            Min wraps the ident with the MIN aggregation function.

                                                                                                                                                                                                            func (*Func) String

                                                                                                                                                                                                            func (f *Func) String() string

                                                                                                                                                                                                              String implements the fmt.Stringer.

                                                                                                                                                                                                              func (*Func) Sum

                                                                                                                                                                                                              func (f *Func) Sum(ident string)

                                                                                                                                                                                                                Sum wraps the ident with the SUM aggregation function.

                                                                                                                                                                                                                type IndexAlter

                                                                                                                                                                                                                type IndexAlter struct {
                                                                                                                                                                                                                	Builder
                                                                                                                                                                                                                
                                                                                                                                                                                                                	Queries []Querier // alter options.
                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                }

                                                                                                                                                                                                                  IndexAlter is a query builder for `ALTER INDEX` statement.

                                                                                                                                                                                                                  func AlterIndex

                                                                                                                                                                                                                  func AlterIndex(name string) *IndexAlter

                                                                                                                                                                                                                    AlterIndex returns a query builder for the `ALTER INDEX` statement.

                                                                                                                                                                                                                    AlterIndex("old_key").
                                                                                                                                                                                                                    	Rename("new_key")
                                                                                                                                                                                                                    

                                                                                                                                                                                                                    func (*IndexAlter) Query

                                                                                                                                                                                                                    func (i *IndexAlter) Query() (string, []interface{})

                                                                                                                                                                                                                      Query returns query representation of the `ALTER INDEX` statement.

                                                                                                                                                                                                                      	ALTER INDEX name
                                                                                                                                                                                                                         [alter_specification]
                                                                                                                                                                                                                      

                                                                                                                                                                                                                      func (*IndexAlter) Rename

                                                                                                                                                                                                                      func (i *IndexAlter) Rename(name string) *IndexAlter

                                                                                                                                                                                                                        Rename appends the `RENAME TO` clause to the `ALTER INDEX` statement.

                                                                                                                                                                                                                        type IndexBuilder

                                                                                                                                                                                                                        type IndexBuilder struct {
                                                                                                                                                                                                                        	Builder
                                                                                                                                                                                                                        	// contains filtered or unexported fields
                                                                                                                                                                                                                        }

                                                                                                                                                                                                                          IndexBuilder is a builder for `CREATE INDEX` statement.

                                                                                                                                                                                                                          func CreateIndex

                                                                                                                                                                                                                          func CreateIndex(name string) *IndexBuilder

                                                                                                                                                                                                                            CreateIndex creates a builder for the `CREATE INDEX` statement.

                                                                                                                                                                                                                            CreateIndex("index_name").
                                                                                                                                                                                                                            	Unique().
                                                                                                                                                                                                                            	Table("users").
                                                                                                                                                                                                                            	Column("name")
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            Or:

                                                                                                                                                                                                                            CreateIndex("index_name").
                                                                                                                                                                                                                            	Unique().
                                                                                                                                                                                                                            	Table("users").
                                                                                                                                                                                                                            	Columns("name", "age")
                                                                                                                                                                                                                            

                                                                                                                                                                                                                            func (*IndexBuilder) Column

                                                                                                                                                                                                                            func (i *IndexBuilder) Column(column string) *IndexBuilder

                                                                                                                                                                                                                              Column appends a column to the column list for the index.

                                                                                                                                                                                                                              func (*IndexBuilder) Columns

                                                                                                                                                                                                                              func (i *IndexBuilder) Columns(columns ...string) *IndexBuilder

                                                                                                                                                                                                                                Columns appends the given columns to the column list for the index.

                                                                                                                                                                                                                                func (*IndexBuilder) Query

                                                                                                                                                                                                                                func (i *IndexBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                  Query returns query representation of a reference clause.

                                                                                                                                                                                                                                  func (*IndexBuilder) Table

                                                                                                                                                                                                                                  func (i *IndexBuilder) Table(table string) *IndexBuilder

                                                                                                                                                                                                                                    Table defines the table for the index.

                                                                                                                                                                                                                                    func (*IndexBuilder) Unique

                                                                                                                                                                                                                                    func (i *IndexBuilder) Unique() *IndexBuilder

                                                                                                                                                                                                                                      Unique sets the index to be a unique index.

                                                                                                                                                                                                                                      type InsertBuilder

                                                                                                                                                                                                                                      type InsertBuilder struct {
                                                                                                                                                                                                                                      	Builder
                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                        InsertBuilder is a builder for `INSERT INTO` statement.

                                                                                                                                                                                                                                        func Insert

                                                                                                                                                                                                                                        func Insert(table string) *InsertBuilder

                                                                                                                                                                                                                                          Insert creates a builder for the `INSERT INTO` statement.

                                                                                                                                                                                                                                          Insert("users").
                                                                                                                                                                                                                                          	Columns("name", "age").
                                                                                                                                                                                                                                          	Values("a8m", 10).
                                                                                                                                                                                                                                          	Values("foo", 20)
                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                          Note: Insert inserts all values in one batch.

                                                                                                                                                                                                                                          func (*InsertBuilder) Columns

                                                                                                                                                                                                                                          func (i *InsertBuilder) Columns(columns ...string) *InsertBuilder

                                                                                                                                                                                                                                            Columns sets the columns of the insert statement.

                                                                                                                                                                                                                                            func (*InsertBuilder) Default

                                                                                                                                                                                                                                            func (i *InsertBuilder) Default() *InsertBuilder

                                                                                                                                                                                                                                              Default sets the default values clause based on the dialect type.

                                                                                                                                                                                                                                              func (*InsertBuilder) Query

                                                                                                                                                                                                                                              func (i *InsertBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                                Query returns query representation of an `INSERT INTO` statement.

                                                                                                                                                                                                                                                func (*InsertBuilder) Returning

                                                                                                                                                                                                                                                func (i *InsertBuilder) Returning(columns ...string) *InsertBuilder

                                                                                                                                                                                                                                                  Returning adds the `RETURNING` clause to the insert statement. PostgreSQL only.

                                                                                                                                                                                                                                                  func (*InsertBuilder) Schema

                                                                                                                                                                                                                                                  func (i *InsertBuilder) Schema(name string) *InsertBuilder

                                                                                                                                                                                                                                                    Schema sets the database name for the insert table.

                                                                                                                                                                                                                                                    func (*InsertBuilder) Set

                                                                                                                                                                                                                                                    func (i *InsertBuilder) Set(column string, v interface{}) *InsertBuilder

                                                                                                                                                                                                                                                      Set is a syntactic sugar API for inserting only one row.

                                                                                                                                                                                                                                                      func (*InsertBuilder) Values

                                                                                                                                                                                                                                                      func (i *InsertBuilder) Values(values ...interface{}) *InsertBuilder

                                                                                                                                                                                                                                                        Values append a value tuple for the insert statement.

                                                                                                                                                                                                                                                        type NullBool

                                                                                                                                                                                                                                                        type NullBool = sql.NullBool

                                                                                                                                                                                                                                                          NullBool is an alias to sql.NullBool.

                                                                                                                                                                                                                                                          type NullFloat64

                                                                                                                                                                                                                                                          type NullFloat64 = sql.NullFloat64

                                                                                                                                                                                                                                                            NullFloat64 is an alias to sql.NullFloat64.

                                                                                                                                                                                                                                                            type NullInt64

                                                                                                                                                                                                                                                            type NullInt64 = sql.NullInt64

                                                                                                                                                                                                                                                              NullInt64 is an alias to sql.NullInt64.

                                                                                                                                                                                                                                                              type NullString

                                                                                                                                                                                                                                                              type NullString = sql.NullString

                                                                                                                                                                                                                                                                NullString is an alias to sql.NullString.

                                                                                                                                                                                                                                                                type NullTime

                                                                                                                                                                                                                                                                type NullTime = sql.NullTime

                                                                                                                                                                                                                                                                  NullTime represents a time.Time that may be null.

                                                                                                                                                                                                                                                                  type Op

                                                                                                                                                                                                                                                                  type Op int

                                                                                                                                                                                                                                                                    An Op represents a predicate operator.

                                                                                                                                                                                                                                                                    const (
                                                                                                                                                                                                                                                                    	OpEQ      Op = iota // logical and.
                                                                                                                                                                                                                                                                    	OpNEQ               // <>
                                                                                                                                                                                                                                                                    	OpGT                // >
                                                                                                                                                                                                                                                                    	OpGTE               // >=
                                                                                                                                                                                                                                                                    	OpLT                // <
                                                                                                                                                                                                                                                                    	OpLTE               // <=
                                                                                                                                                                                                                                                                    	OpIn                // IN
                                                                                                                                                                                                                                                                    	OpNotIn             // NOT IN
                                                                                                                                                                                                                                                                    	OpLike              // LIKE
                                                                                                                                                                                                                                                                    	OpIsNull            // IS NULL
                                                                                                                                                                                                                                                                    	OpNotNull           // IS NOT NULL
                                                                                                                                                                                                                                                                    )

                                                                                                                                                                                                                                                                      Predicate operators

                                                                                                                                                                                                                                                                      type Predicate

                                                                                                                                                                                                                                                                      type Predicate struct {
                                                                                                                                                                                                                                                                      	Builder
                                                                                                                                                                                                                                                                      	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                        Predicate is a where predicate.

                                                                                                                                                                                                                                                                        func And

                                                                                                                                                                                                                                                                        func And(preds ...*Predicate) *Predicate

                                                                                                                                                                                                                                                                          And combines all given predicates with AND between them.

                                                                                                                                                                                                                                                                          func CompositeGT

                                                                                                                                                                                                                                                                          func CompositeGT(columns []string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                            CompositeGT returns a comiposite ">" predicate

                                                                                                                                                                                                                                                                            func CompositeLT

                                                                                                                                                                                                                                                                            func CompositeLT(columns []string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                              CompositeLT returns a comiposite "<" predicate

                                                                                                                                                                                                                                                                              func Contains

                                                                                                                                                                                                                                                                              func Contains(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                Contains is a helper predicate that checks substring using the LIKE predicate.

                                                                                                                                                                                                                                                                                func ContainsFold

                                                                                                                                                                                                                                                                                func ContainsFold(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                  ContainsFold is a helper predicate that checks substring using the LIKE predicate.

                                                                                                                                                                                                                                                                                  func EQ

                                                                                                                                                                                                                                                                                  func EQ(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                    EQ returns a "=" predicate.

                                                                                                                                                                                                                                                                                    func EqualFold

                                                                                                                                                                                                                                                                                    func EqualFold(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                      EqualFold is a helper predicate that applies the "=" predicate with case-folding.

                                                                                                                                                                                                                                                                                      func False

                                                                                                                                                                                                                                                                                      func False() *Predicate

                                                                                                                                                                                                                                                                                        False appends the FALSE keyword to the predicate.

                                                                                                                                                                                                                                                                                        Delete().From("users").Where(False())
                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                        func GT

                                                                                                                                                                                                                                                                                        func GT(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                          GT returns a ">" predicate.

                                                                                                                                                                                                                                                                                          func GTE

                                                                                                                                                                                                                                                                                          func GTE(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                            GTE returns a ">=" predicate.

                                                                                                                                                                                                                                                                                            func HasPrefix

                                                                                                                                                                                                                                                                                            func HasPrefix(col, prefix string) *Predicate

                                                                                                                                                                                                                                                                                              HasPrefix is a helper predicate that checks prefix using the LIKE predicate.

                                                                                                                                                                                                                                                                                              func HasSuffix

                                                                                                                                                                                                                                                                                              func HasSuffix(col, suffix string) *Predicate

                                                                                                                                                                                                                                                                                                HasSuffix is a helper predicate that checks suffix using the LIKE predicate.

                                                                                                                                                                                                                                                                                                func In

                                                                                                                                                                                                                                                                                                func In(col string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                  In returns the `IN` predicate.

                                                                                                                                                                                                                                                                                                  func InInts

                                                                                                                                                                                                                                                                                                  func InInts(col string, args ...int) *Predicate

                                                                                                                                                                                                                                                                                                    InInts returns the `IN` predicate for ints.

                                                                                                                                                                                                                                                                                                    func InValues

                                                                                                                                                                                                                                                                                                    func InValues(col string, args ...driver.Value) *Predicate

                                                                                                                                                                                                                                                                                                      InValues adds the `IN` predicate for slice of driver.Value.

                                                                                                                                                                                                                                                                                                      func IsNull

                                                                                                                                                                                                                                                                                                      func IsNull(col string) *Predicate

                                                                                                                                                                                                                                                                                                        IsNull returns the `IS NULL` predicate.

                                                                                                                                                                                                                                                                                                        func LT

                                                                                                                                                                                                                                                                                                        func LT(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                                          LT returns a "<" predicate.

                                                                                                                                                                                                                                                                                                          func LTE

                                                                                                                                                                                                                                                                                                          func LTE(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                                            LTE returns a "<=" predicate.

                                                                                                                                                                                                                                                                                                            func Like

                                                                                                                                                                                                                                                                                                            func Like(col, pattern string) *Predicate

                                                                                                                                                                                                                                                                                                              Like returns the `LIKE` predicate.

                                                                                                                                                                                                                                                                                                              func NEQ

                                                                                                                                                                                                                                                                                                              func NEQ(col string, value interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                NEQ returns a "<>" predicate.

                                                                                                                                                                                                                                                                                                                func Not

                                                                                                                                                                                                                                                                                                                func Not(pred *Predicate) *Predicate

                                                                                                                                                                                                                                                                                                                  Not wraps the given predicate with the not predicate.

                                                                                                                                                                                                                                                                                                                  Not(Or(EQ("name", "foo"), EQ("name", "bar")))
                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                  func NotIn

                                                                                                                                                                                                                                                                                                                  func NotIn(col string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                    NotIn returns the `Not IN` predicate.

                                                                                                                                                                                                                                                                                                                    func NotNull

                                                                                                                                                                                                                                                                                                                    func NotNull(col string) *Predicate

                                                                                                                                                                                                                                                                                                                      NotNull returns the `IS NOT NULL` predicate.

                                                                                                                                                                                                                                                                                                                      func Or

                                                                                                                                                                                                                                                                                                                      func Or(preds ...*Predicate) *Predicate

                                                                                                                                                                                                                                                                                                                        Or combines all given predicates with OR between them.

                                                                                                                                                                                                                                                                                                                        Or(EQ("name", "foo"), EQ("name", "bar"))
                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                        func P

                                                                                                                                                                                                                                                                                                                        func P(fns ...func(*Builder)) *Predicate

                                                                                                                                                                                                                                                                                                                          P creates a new predicate.

                                                                                                                                                                                                                                                                                                                          P().EQ("name", "a8m").And().EQ("age", 30)
                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                          func (*Predicate) Append

                                                                                                                                                                                                                                                                                                                          func (p *Predicate) Append(f func(*Builder)) *Predicate

                                                                                                                                                                                                                                                                                                                            Append appends a new function to the predicate callbacks. The callback list are executed on call to Query.

                                                                                                                                                                                                                                                                                                                            func (*Predicate) CompositeGT

                                                                                                                                                                                                                                                                                                                            func (p *Predicate) CompositeGT(columns []string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                              CompositeGT returns a composite ">" predicate.

                                                                                                                                                                                                                                                                                                                              func (*Predicate) CompositeLT

                                                                                                                                                                                                                                                                                                                              func (p *Predicate) CompositeLT(columns []string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                CompositeLT appends a composite "<" predicate.

                                                                                                                                                                                                                                                                                                                                func (*Predicate) Contains

                                                                                                                                                                                                                                                                                                                                func (p *Predicate) Contains(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                                                                  Contains is a helper predicate that checks substring using the LIKE predicate.

                                                                                                                                                                                                                                                                                                                                  func (*Predicate) ContainsFold

                                                                                                                                                                                                                                                                                                                                  func (p *Predicate) ContainsFold(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                                                                    ContainsFold is a helper predicate that applies the LIKE predicate with case-folding.

                                                                                                                                                                                                                                                                                                                                    func (*Predicate) EQ

                                                                                                                                                                                                                                                                                                                                    func (p *Predicate) EQ(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                      EQ appends a "=" predicate.

                                                                                                                                                                                                                                                                                                                                      func (*Predicate) EqualFold

                                                                                                                                                                                                                                                                                                                                      func (p *Predicate) EqualFold(col, sub string) *Predicate

                                                                                                                                                                                                                                                                                                                                        EqualFold is a helper predicate that applies the "=" predicate with case-folding.

                                                                                                                                                                                                                                                                                                                                        func (*Predicate) False

                                                                                                                                                                                                                                                                                                                                        func (p *Predicate) False() *Predicate

                                                                                                                                                                                                                                                                                                                                          False appends FALSE to the predicate.

                                                                                                                                                                                                                                                                                                                                          func (*Predicate) GT

                                                                                                                                                                                                                                                                                                                                          func (p *Predicate) GT(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                            GT appends a ">" predicate.

                                                                                                                                                                                                                                                                                                                                            func (*Predicate) GTE

                                                                                                                                                                                                                                                                                                                                            func (p *Predicate) GTE(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                              GTE appends a ">=" predicate.

                                                                                                                                                                                                                                                                                                                                              func (*Predicate) HasPrefix

                                                                                                                                                                                                                                                                                                                                              func (p *Predicate) HasPrefix(col, prefix string) *Predicate

                                                                                                                                                                                                                                                                                                                                                HasPrefix is a helper predicate that checks prefix using the LIKE predicate.

                                                                                                                                                                                                                                                                                                                                                func (*Predicate) HasSuffix

                                                                                                                                                                                                                                                                                                                                                func (p *Predicate) HasSuffix(col, suffix string) *Predicate

                                                                                                                                                                                                                                                                                                                                                  HasSuffix is a helper predicate that checks suffix using the LIKE predicate.

                                                                                                                                                                                                                                                                                                                                                  func (*Predicate) In

                                                                                                                                                                                                                                                                                                                                                  func (p *Predicate) In(col string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                                    In appends the `IN` predicate.

                                                                                                                                                                                                                                                                                                                                                    func (*Predicate) InInts

                                                                                                                                                                                                                                                                                                                                                    func (p *Predicate) InInts(col string, args ...int) *Predicate

                                                                                                                                                                                                                                                                                                                                                      InInts adds the `IN` predicate for ints.

                                                                                                                                                                                                                                                                                                                                                      func (*Predicate) InValues

                                                                                                                                                                                                                                                                                                                                                      func (p *Predicate) InValues(col string, args ...driver.Value) *Predicate

                                                                                                                                                                                                                                                                                                                                                        InValues adds the `IN` predicate for slice of driver.Value.

                                                                                                                                                                                                                                                                                                                                                        func (*Predicate) IsNull

                                                                                                                                                                                                                                                                                                                                                        func (p *Predicate) IsNull(col string) *Predicate

                                                                                                                                                                                                                                                                                                                                                          IsNull appends the `IS NULL` predicate.

                                                                                                                                                                                                                                                                                                                                                          func (*Predicate) LT

                                                                                                                                                                                                                                                                                                                                                          func (p *Predicate) LT(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                                            LT appends a "<" predicate.

                                                                                                                                                                                                                                                                                                                                                            func (*Predicate) LTE

                                                                                                                                                                                                                                                                                                                                                            func (p *Predicate) LTE(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                                              LTE appends a "<=" predicate.

                                                                                                                                                                                                                                                                                                                                                              func (*Predicate) Like

                                                                                                                                                                                                                                                                                                                                                              func (p *Predicate) Like(col, pattern string) *Predicate

                                                                                                                                                                                                                                                                                                                                                                Like appends the `LIKE` predicate.

                                                                                                                                                                                                                                                                                                                                                                func (*Predicate) NEQ

                                                                                                                                                                                                                                                                                                                                                                func (p *Predicate) NEQ(col string, arg interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                                                  NEQ appends a "<>" predicate.

                                                                                                                                                                                                                                                                                                                                                                  func (*Predicate) Not

                                                                                                                                                                                                                                                                                                                                                                  func (p *Predicate) Not() *Predicate

                                                                                                                                                                                                                                                                                                                                                                    Not appends NOT to the predicate.

                                                                                                                                                                                                                                                                                                                                                                    func (*Predicate) NotIn

                                                                                                                                                                                                                                                                                                                                                                    func (p *Predicate) NotIn(col string, args ...interface{}) *Predicate

                                                                                                                                                                                                                                                                                                                                                                      NotIn appends the `Not IN` predicate.

                                                                                                                                                                                                                                                                                                                                                                      func (*Predicate) NotNull

                                                                                                                                                                                                                                                                                                                                                                      func (p *Predicate) NotNull(col string) *Predicate

                                                                                                                                                                                                                                                                                                                                                                        NotNull appends the `IS NOT NULL` predicate.

                                                                                                                                                                                                                                                                                                                                                                        func (*Predicate) Query

                                                                                                                                                                                                                                                                                                                                                                        func (p *Predicate) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                          Query returns query representation of a predicate.

                                                                                                                                                                                                                                                                                                                                                                          type Querier

                                                                                                                                                                                                                                                                                                                                                                          type Querier interface {
                                                                                                                                                                                                                                                                                                                                                                          	// Query returns the query representation of the element
                                                                                                                                                                                                                                                                                                                                                                          	// and its arguments (if any).
                                                                                                                                                                                                                                                                                                                                                                          	Query() (string, []interface{})
                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                            Querier wraps the basic Query method that is implemented by the different builders in this file.

                                                                                                                                                                                                                                                                                                                                                                            func Expr

                                                                                                                                                                                                                                                                                                                                                                            func Expr(exr string, args ...interface{}) Querier

                                                                                                                                                                                                                                                                                                                                                                              Expr returns an SQL expression that implements the Querier interface.

                                                                                                                                                                                                                                                                                                                                                                              func Raw

                                                                                                                                                                                                                                                                                                                                                                              func Raw(s string) Querier

                                                                                                                                                                                                                                                                                                                                                                                Raw returns a raw SQL query that is placed as-is in the query.

                                                                                                                                                                                                                                                                                                                                                                                type Queries

                                                                                                                                                                                                                                                                                                                                                                                type Queries []Querier

                                                                                                                                                                                                                                                                                                                                                                                  Queries are list of queries join with space between them.

                                                                                                                                                                                                                                                                                                                                                                                  func (Queries) Query

                                                                                                                                                                                                                                                                                                                                                                                  func (n Queries) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                    Query returns query representation of Queriers.

                                                                                                                                                                                                                                                                                                                                                                                    type ReferenceBuilder

                                                                                                                                                                                                                                                                                                                                                                                    type ReferenceBuilder struct {
                                                                                                                                                                                                                                                                                                                                                                                    	Builder
                                                                                                                                                                                                                                                                                                                                                                                    	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                    }

                                                                                                                                                                                                                                                                                                                                                                                      ReferenceBuilder is a builder for the reference clause in constraints. For example, in foreign key creation.

                                                                                                                                                                                                                                                                                                                                                                                      func Reference

                                                                                                                                                                                                                                                                                                                                                                                      func Reference() *ReferenceBuilder

                                                                                                                                                                                                                                                                                                                                                                                        Reference create a reference builder for the reference_option clause.

                                                                                                                                                                                                                                                                                                                                                                                        Reference().Table("groups").Columns("id")
                                                                                                                                                                                                                                                                                                                                                                                        

                                                                                                                                                                                                                                                                                                                                                                                        func (*ReferenceBuilder) Columns

                                                                                                                                                                                                                                                                                                                                                                                        func (r *ReferenceBuilder) Columns(s ...string) *ReferenceBuilder

                                                                                                                                                                                                                                                                                                                                                                                          Columns sets the columns of the referenced table.

                                                                                                                                                                                                                                                                                                                                                                                          func (*ReferenceBuilder) Query

                                                                                                                                                                                                                                                                                                                                                                                          func (r *ReferenceBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                            Query returns query representation of a reference clause.

                                                                                                                                                                                                                                                                                                                                                                                            func (*ReferenceBuilder) Table

                                                                                                                                                                                                                                                                                                                                                                                              Table sets the referenced table.

                                                                                                                                                                                                                                                                                                                                                                                              type Result

                                                                                                                                                                                                                                                                                                                                                                                              type Result = sql.Result

                                                                                                                                                                                                                                                                                                                                                                                                Result is an alias to sql.Result.

                                                                                                                                                                                                                                                                                                                                                                                                type Rows

                                                                                                                                                                                                                                                                                                                                                                                                type Rows struct{ *sql.Rows }

                                                                                                                                                                                                                                                                                                                                                                                                  Rows wraps the sql.Rows to avoid locks copy.

                                                                                                                                                                                                                                                                                                                                                                                                  type SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                  type SelectTable struct {
                                                                                                                                                                                                                                                                                                                                                                                                  	Builder
                                                                                                                                                                                                                                                                                                                                                                                                  	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                  }

                                                                                                                                                                                                                                                                                                                                                                                                    SelectTable is a table selector.

                                                                                                                                                                                                                                                                                                                                                                                                    func Table

                                                                                                                                                                                                                                                                                                                                                                                                    func Table(name string) *SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                      Table returns a new table selector.

                                                                                                                                                                                                                                                                                                                                                                                                      t1 := Table("users").As("u")
                                                                                                                                                                                                                                                                                                                                                                                                      return Select(t1.C("name"))
                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                      func (*SelectTable) As

                                                                                                                                                                                                                                                                                                                                                                                                      func (s *SelectTable) As(alias string) *SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                        As adds the AS clause to the table selector.

                                                                                                                                                                                                                                                                                                                                                                                                        func (*SelectTable) C

                                                                                                                                                                                                                                                                                                                                                                                                        func (s *SelectTable) C(column string) string

                                                                                                                                                                                                                                                                                                                                                                                                          C returns a formatted string for the table column.

                                                                                                                                                                                                                                                                                                                                                                                                          func (*SelectTable) Columns

                                                                                                                                                                                                                                                                                                                                                                                                          func (s *SelectTable) Columns(columns ...string) []string

                                                                                                                                                                                                                                                                                                                                                                                                            Columns returns a list of formatted strings for the table columns.

                                                                                                                                                                                                                                                                                                                                                                                                            func (*SelectTable) Schema

                                                                                                                                                                                                                                                                                                                                                                                                            func (s *SelectTable) Schema(name string) *SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                              Schema sets the schema name of the table.

                                                                                                                                                                                                                                                                                                                                                                                                              func (*SelectTable) Unquote

                                                                                                                                                                                                                                                                                                                                                                                                              func (s *SelectTable) Unquote() *SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                                Unquote makes the table name to be formatted as raw string (unquoted). It is useful whe you don't want to query tables under the current database. For example: "INFORMATION_SCHEMA.TABLE_CONSTRAINTS" in MySQL.

                                                                                                                                                                                                                                                                                                                                                                                                                type Selector

                                                                                                                                                                                                                                                                                                                                                                                                                type Selector struct {
                                                                                                                                                                                                                                                                                                                                                                                                                	Builder
                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                  Selector is a builder for the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                  func Select

                                                                                                                                                                                                                                                                                                                                                                                                                  func Select(columns ...string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                    Select returns a new selector for the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                    t1 := Table("users").As("u")
                                                                                                                                                                                                                                                                                                                                                                                                                    t2 := Select().From(Table("groups")).Where(EQ("user_id", 10)).As("g")
                                                                                                                                                                                                                                                                                                                                                                                                                    return Select(t1.C("id"), t2.C("name")).
                                                                                                                                                                                                                                                                                                                                                                                                                    		From(t1).
                                                                                                                                                                                                                                                                                                                                                                                                                    		Join(t2).
                                                                                                                                                                                                                                                                                                                                                                                                                    		On(t1.C("id"), t2.C("user_id"))
                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Selector) As

                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Selector) As(alias string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                      As give this selection an alias.

                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Selector) C

                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Selector) C(column string) string

                                                                                                                                                                                                                                                                                                                                                                                                                        C returns a formatted string for a selected column from this statement.

                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Selector) Clone

                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Selector) Clone() *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                          Clone returns a duplicate of the selector, including all associated steps. It can be used to prepare common SELECT statements and use them differently after the clone is made.

                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Selector) Columns

                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Selector) Columns(columns ...string) []string

                                                                                                                                                                                                                                                                                                                                                                                                                            Columns returns a list of formatted strings for a selected columns from this statement.

                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Selector) Context

                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Selector) Context() context.Context

                                                                                                                                                                                                                                                                                                                                                                                                                              Context returns the Selector context or Background if nil.

                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Selector) Count

                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Selector) Count(columns ...string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                Count sets the Select statement to be a `SELECT COUNT(*)`.

                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Selector) Distinct

                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Selector) Distinct() *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                  Distinct adds the DISTINCT keyword to the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Selector) From

                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Selector) From(t TableView) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                    From sets the source of `FROM` clause.

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Selector) FromSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Selector) FromSelect(s2 *Selector) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                      FromSelect copies the predicate from a selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Selector) GroupBy

                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Selector) GroupBy(columns ...string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                        GroupBy appends the `GROUP BY` clause to the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Selector) Having

                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Selector) Having(p *Predicate) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                          Having appends a predicate for the `HAVING` clause.

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Selector) Join

                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Selector) Join(t TableView) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                            Join appends a `JOIN` clause to the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Selector) LeftJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Selector) LeftJoin(t TableView) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                              LeftJoin appends a `LEFT JOIN` clause to the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Selector) Limit

                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Selector) Limit(limit int) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                Limit adds the `LIMIT` clause to the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Selector) Not

                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Selector) Not() *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                  Not sets the next coming predicate with not.

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Selector) Offset

                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Selector) Offset(offset int) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                    Offset adds the `OFFSET` clause to the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Selector) On

                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Selector) On(c1, c2 string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                      On sets the `ON` clause for the `JOIN` operation.

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Selector) OnP

                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Selector) OnP(p *Predicate) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                        OnP sets or appends the given predicate for the `ON` clause of the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Selector) Or

                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Selector) Or() *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                          Or sets the next coming predicate with OR operator (disjunction).

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Selector) OrderBy

                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Selector) OrderBy(columns ...string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                            OrderBy appends the `ORDER BY` clause to the `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Selector) OrderExpr

                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Selector) OrderExpr(exprs ...Querier) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                              OrderExpr appends the `ORDER BY` clause to the `SELECT` statement with custom list of expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Selector) P

                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Selector) P() *Predicate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                P returns the predicate of a selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Selector) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (s *Selector) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Query returns query representation of a `SELECT` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Selector) RightJoin

                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (s *Selector) RightJoin(t TableView) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    RightJoin appends a `RIGHT JOIN` clause to the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Selector) Select

                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (s *Selector) Select(columns ...string) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Select changes the columns selection of the SELECT statement. Empty selection means all columns *.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*Selector) SetDistinct

                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (s *Selector) SetDistinct(v bool) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        SetDistinct sets explicitly if the returned rows are distinct or indistinct.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*Selector) SetP

                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (s *Selector) SetP(p *Predicate) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          SetP sets explicitly the predicate function for the selector and clear its previous state.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*Selector) Table

                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (s *Selector) Table() *SelectTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Table returns the selected table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Selector) Where

                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (s *Selector) Where(p *Predicate) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Where sets or appends the given predicate to the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Selector) WithContext

                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (s *Selector) WithContext(ctx context.Context) *Selector

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                WithContext sets the context into the *Selector.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type TableAlter struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Queries []Querier // columns and foreign-keys to add.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  TableAlter is a query builder for `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func AlterTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func AlterTable(name string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AlterTable returns a query builder for the `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    AlterTable("users").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AddColumn(Column("group_id").Type("int").Attr("UNIQUE")).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	AddForeignKey(ForeignKey().Columns("group_id").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    		Reference(Reference().Table("groups").Columns("id")).OnDelete("CASCADE")),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    	)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableAlter) AddColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TableAlter) AddColumn(c *ColumnBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      AddColumn appends the `ADD COLUMN` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TableAlter) AddForeignKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TableAlter) AddForeignKey(fk *ForeignKeyBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        AddForeignKey adds a foreign key constraint to the `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TableAlter) AddIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TableAlter) AddIndex(idx *IndexBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          AddIndex appends the `ADD INDEX` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TableAlter) ChangeColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TableAlter) ChangeColumn(name string, c *ColumnBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            ChangeColumn appends the `CHANGE COLUMN` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TableAlter) DropColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TableAlter) DropColumn(c *ColumnBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              DropColumn appends the `DROP COLUMN` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TableAlter) DropConstraint

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TableAlter) DropConstraint(ident string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                DropConstraint appends the `DROP CONSTRAINT` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TableAlter) DropForeignKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TableAlter) DropForeignKey(ident string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  DropForeignKey appends the `DROP FOREIGN KEY` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TableAlter) DropIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TableAlter) DropIndex(name string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    DropIndex appends the `DROP INDEX` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableAlter) ModifyColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TableAlter) ModifyColumn(c *ColumnBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      ModifyColumn appends the `MODIFY/ALTER COLUMN` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TableAlter) ModifyColumns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TableAlter) ModifyColumns(cs ...*ColumnBuilder) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        ModifyColumns calls ModifyColumn with each of the given builders.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TableAlter) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TableAlter) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Query returns query representation of the `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	ALTER TABLE name
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                             [alter_specification]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TableAlter) RenameColumn

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TableAlter) RenameColumn(old, new string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            RenameColumn appends the `RENAME COLUMN` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TableAlter) RenameIndex

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TableAlter) RenameIndex(curr, new string) *TableAlter

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              RenameIndex appends the `RENAME INDEX` clause to the given `ALTER TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              type TableBuilder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	Builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                TableBuilder is a query builder for `CREATE TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func CreateTable

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func CreateTable(name string) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreateTable returns a query builder for the `CREATE TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  CreateTable("users").
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	Columns(
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  		Column("id").Type("int").Attr("auto_increment"),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  		Column("name").Type("varchar(255)"),
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	).
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  	PrimaryKey("id")
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TableBuilder) Charset

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TableBuilder) Charset(s string) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Charset appends the `CHARACTER SET` clause to the statement. MySQL only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableBuilder) Collate

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TableBuilder) Collate(s string) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Collate appends the `COLLATE` clause to the statement. MySQL only.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*TableBuilder) Column

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (t *TableBuilder) Column(c *ColumnBuilder) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Column appends the given column to the `CREATE TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*TableBuilder) Columns

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (t *TableBuilder) Columns(columns ...*ColumnBuilder) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Columns appends the a list of columns to the builder.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*TableBuilder) Constraints

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (t *TableBuilder) Constraints(fks ...*ForeignKeyBuilder) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Constraints adds a list of foreign-key constraints to the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*TableBuilder) ForeignKeys

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (t *TableBuilder) ForeignKeys(fks ...*ForeignKeyBuilder) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              ForeignKeys adds a list of foreign-keys to the statement (without constraints).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*TableBuilder) IfNotExists

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (t *TableBuilder) IfNotExists() *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                IfNotExists appends the `IF NOT EXISTS` clause to the `CREATE TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*TableBuilder) Options

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (t *TableBuilder) Options(s string) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Options appends additional options to to the statement (MySQL only).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*TableBuilder) PrimaryKey

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (t *TableBuilder) PrimaryKey(column ...string) *TableBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    PrimaryKey adds a column to the primary-key constraint in the statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*TableBuilder) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (t *TableBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Query returns query representation of a `CREATE TABLE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      CREATE TABLE [IF NOT EXISTS] name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      (table definition)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      [charset and collation]
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TableView

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      type TableView interface {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      	// contains filtered or unexported methods
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        TableView is a view that returns a table view. Can ne a Table, Selector or a View (WITH statement).

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Tx

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        type Tx struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	dialect.ExecQuerier
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        	driver.Tx
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Tx implements dialect.Tx interface.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TxOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type TxOptions = sql.TxOptions

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            TxOptions holds the transaction options to be used in DB.BeginTx.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            type UpdateBuilder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	Builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              UpdateBuilder is a builder for `UPDATE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Update

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func Update(table string) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Update creates a builder for the `UPDATE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Update("users").Set("name", "foo").Set("age", 10)
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*UpdateBuilder) Add

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (u *UpdateBuilder) Add(column string, v interface{}) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  Add adds a numeric value to the given column.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*UpdateBuilder) Empty

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (u *UpdateBuilder) Empty() bool

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    Empty reports whether this builder does not contain update changes.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*UpdateBuilder) FromSelect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (u *UpdateBuilder) FromSelect(s *Selector) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      FromSelect makes it possible to update entities that match the sub-query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*UpdateBuilder) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (u *UpdateBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Query returns query representation of an `UPDATE` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*UpdateBuilder) Schema

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (u *UpdateBuilder) Schema(name string) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Schema sets the database name for the updated table.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (*UpdateBuilder) Set

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          func (u *UpdateBuilder) Set(column string, v interface{}) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Set sets a column and a its value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*UpdateBuilder) SetNull

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (u *UpdateBuilder) SetNull(column string) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              SetNull sets a column as null value.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*UpdateBuilder) Where

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (u *UpdateBuilder) Where(p *Predicate) *UpdateBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Where adds a where predicate for update statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WithBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                type WithBuilder struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	Builder
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  WithBuilder is the builder for the `WITH` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func With

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func With(name string) *WithBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    With returns a new builder for the `WITH` statement.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    n := Queries{With("users_view").As(Select().From(Table("users"))), Select().From(Table("users_view"))}
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    return n.Query()
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*WithBuilder) As

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (w *WithBuilder) As(s *Selector) *WithBuilder

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      As sets the view sub query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (*WithBuilder) Name

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      func (w *WithBuilder) Name() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        Name returns the name of the view.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (*WithBuilder) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                        func (w *WithBuilder) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          Query returns query representation of a `WITH` clause.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Wrapper

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          type Wrapper struct {
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          	// contains filtered or unexported fields
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                          }

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            Wrapper wraps a given Querier with different format. Used to prefix/suffix other queries.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (*Wrapper) Dialect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                            func (w *Wrapper) Dialect() string

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              Dialect calls Dialect on the wrapped query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (*Wrapper) Query

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                              func (w *Wrapper) Query() (string, []interface{})

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                Query returns query representation of a wrapped Querier.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (*Wrapper) SetDialect

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                func (w *Wrapper) SetDialect(name string)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  SetDialect calls SetDialect on the wrapped query.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (*Wrapper) SetTotal

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                  func (w *Wrapper) SetTotal(total int)

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    SetTotal sets the value of the total arguments. Used to pass this information between sub queries/expressions.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (*Wrapper) Total

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                    func (w *Wrapper) Total() int

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Total returns the total number of arguments so far.

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Directories

                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Path Synopsis
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package schema contains all schema migration logic for SQL dialects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package schema contains all schema migration logic for SQL dialects.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package sqlgraph provides graph abstraction capabilities on top of sql-based databases for ent codegen.
                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      Package sqlgraph provides graph abstraction capabilities on top of sql-based databases for ent codegen.