gorp: github.com/coopernurse/gorp Index | Files

package gorp

import "github.com/coopernurse/gorp"

Package gorp provides a simple way to marshal Go structs to and from SQL databases. It uses the database/sql package, and should work with any compliant database/sql driver.

Source code and project home: https://github.com/coopernurse/gorp

Index

Package Files

dialect.go errors.go gorp.go

func NonFatalError Uses

func NonFatalError(err error) bool

returns true if the error is non-fatal (ie, we shouldn't immediately return)

func SelectFloat Uses

func SelectFloat(e SqlExecutor, query string, args ...interface{}) (float64, error)

SelectFloat executes the given query, which should be a SELECT statement for a single float column, and returns the value of the first row returned. If no rows are found, zero is returned.

func SelectInt Uses

func SelectInt(e SqlExecutor, query string, args ...interface{}) (int64, error)

SelectInt executes the given query, which should be a SELECT statement for a single integer column, and returns the value of the first row returned. If no rows are found, zero is returned.

func SelectNullFloat Uses

func SelectNullFloat(e SqlExecutor, query string, args ...interface{}) (sql.NullFloat64, error)

SelectNullFloat executes the given query, which should be a SELECT statement for a single float column, and returns the value of the first row returned. If no rows are found, the empty sql.NullInt64 value is returned.

func SelectNullInt Uses

func SelectNullInt(e SqlExecutor, query string, args ...interface{}) (sql.NullInt64, error)

SelectNullInt executes the given query, which should be a SELECT statement for a single integer column, and returns the value of the first row returned. If no rows are found, the empty sql.NullInt64 value is returned.

func SelectNullStr Uses

func SelectNullStr(e SqlExecutor, query string, args ...interface{}) (sql.NullString, error)

SelectNullStr executes the given query, which should be a SELECT statement for a single char/varchar column, and returns the value of the first row returned. If no rows are found, the empty sql.NullString is returned.

func SelectOne Uses

func SelectOne(m *DbMap, e SqlExecutor, holder interface{}, query string, args ...interface{}) error

SelectOne executes the given query (which should be a SELECT statement) and binds the result to holder, which must be a pointer.

If no row is found, an error (sql.ErrNoRows specifically) will be returned

If more than one row is found, an error will be returned.

func SelectStr Uses

func SelectStr(e SqlExecutor, query string, args ...interface{}) (string, error)

SelectStr executes the given query, which should be a SELECT statement for a single char/varchar column, and returns the value of the first row returned. If no rows are found, an empty string is returned.

type ColumnMap Uses

type ColumnMap struct {
    // Column name in db table
    ColumnName string

    // If true, this column is skipped in generated SQL statements
    Transient bool

    // If true, " unique" is added to create table statements.
    // Not used elsewhere
    Unique bool

    // Passed to Dialect.ToSqlType() to assist in informing the
    // correct column type to map to in CreateTables()
    // Not used elsewhere
    MaxSize int
    // contains filtered or unexported fields
}

ColumnMap represents a mapping between a Go struct field and a single column in a table. Unique and MaxSize only inform the CreateTables() function and are not used by Insert/Update/Delete/Get.

func (*ColumnMap) Rename Uses

func (c *ColumnMap) Rename(colname string) *ColumnMap

Rename allows you to specify the column name in the table

Example: table.ColMap("Updated").Rename("date_updated")

func (*ColumnMap) SetMaxSize Uses

func (c *ColumnMap) SetMaxSize(size int) *ColumnMap

SetMaxSize specifies the max length of values of this column. This is passed to the dialect.ToSqlType() function, which can use the value to alter the generated type for "create table" statements

func (*ColumnMap) SetNotNull Uses

func (c *ColumnMap) SetNotNull(nn bool) *ColumnMap

SetNotNull adds "not null" to the create table statements for this column, if nn is true.

func (*ColumnMap) SetTransient Uses

func (c *ColumnMap) SetTransient(b bool) *ColumnMap

SetTransient allows you to mark the column as transient. If true this column will be skipped when SQL statements are generated

func (*ColumnMap) SetUnique Uses

func (c *ColumnMap) SetUnique(b bool) *ColumnMap

SetUnique adds "unique" to the create table statements for this column, if b is true.

type CustomScanner Uses

type CustomScanner struct {
    // After a row is scanned, Holder will contain the value from the database column.
    // Initialize the CustomScanner with the concrete Go type you wish the database
    // driver to scan the raw column into.
    Holder interface{}
    // Target typically holds a pointer to the target struct field to bind the Holder
    // value to.
    Target interface{}
    // Binder is a custom function that converts the holder value to the target type
    // and sets target accordingly.  This function should return error if a problem
    // occurs converting the holder to the target.
    Binder func(holder interface{}, target interface{}) error
}

CustomScanner binds a database column value to a Go type

func (CustomScanner) Bind Uses

func (me CustomScanner) Bind() error

Bind is called automatically by gorp after Scan()

type DbMap Uses

type DbMap struct {
    // Db handle to use with this map
    Db  *sql.DB

    // Dialect implementation to use with this map
    Dialect Dialect

    TypeConverter TypeConverter
    // contains filtered or unexported fields
}

DbMap is the root gorp mapping object. Create one of these for each database schema you wish to map. Each DbMap contains a list of mapped tables.

Example:

dialect := gorp.MySQLDialect{"InnoDB", "UTF8"}
dbmap := &gorp.DbMap{Db: db, Dialect: dialect}

func (*DbMap) AddTable Uses

func (m *DbMap) AddTable(i interface{}) *TableMap

AddTable registers the given interface type with gorp. The table name will be given the name of the TypeOf(i). You must call this function, or AddTableWithName, for any struct type you wish to persist with the given DbMap.

This operation is idempotent. If i's type is already mapped, the existing *TableMap is returned

func (*DbMap) AddTableWithName Uses

func (m *DbMap) AddTableWithName(i interface{}, name string) *TableMap

AddTableWithName has the same behavior as AddTable, but sets table.TableName to name.

func (*DbMap) AddTableWithNameAndSchema Uses

func (m *DbMap) AddTableWithNameAndSchema(i interface{}, schema string, name string) *TableMap

AddTableWithNameAndSchema has the same behavior as AddTable, but sets table.TableName to name.

func (*DbMap) Begin Uses

func (m *DbMap) Begin() (*Transaction, error)

Begin starts a gorp Transaction

func (*DbMap) CreateTables Uses

func (m *DbMap) CreateTables() error

CreateTables iterates through TableMaps registered to this DbMap and executes "create table" statements against the database for each.

This is particularly useful in unit tests where you want to create and destroy the schema automatically.

func (*DbMap) CreateTablesIfNotExists Uses

func (m *DbMap) CreateTablesIfNotExists() error

CreateTablesIfNotExists is similar to CreateTables, but starts each statement with "create table if not exists" so that existing tables do not raise errors

func (*DbMap) Delete Uses

func (m *DbMap) Delete(list ...interface{}) (int64, error)

Delete runs a SQL DELETE statement for each element in list. List items must be pointers.

The hook functions PreDelete() and/or PostDelete() will be executed before/after the DELETE statement if the interface defines them.

Returns the number of rows deleted.

Returns an error if SetKeys has not been called on the TableMap Panics if any interface in the list has not been registered with AddTable

func (*DbMap) DropTable Uses

func (m *DbMap) DropTable(table interface{}) error

DropTable drops an individual table. Will throw an error if the table does not exist.

func (*DbMap) DropTableIfExists Uses

func (m *DbMap) DropTableIfExists(table interface{}) error

DropTable drops an individual table. Will NOT throw an error if the table does not exist.

func (*DbMap) DropTables Uses

func (m *DbMap) DropTables() error

DropTables iterates through TableMaps registered to this DbMap and executes "drop table" statements against the database for each.

func (*DbMap) DropTablesIfExists Uses

func (m *DbMap) DropTablesIfExists() error

DropTablesIfExists is the same as DropTables, but uses the "if exists" clause to avoid errors for tables that do not exist.

func (*DbMap) Exec Uses

func (m *DbMap) Exec(query string, args ...interface{}) (sql.Result, error)

Exec runs an arbitrary SQL statement. args represent the bind parameters. This is equivalent to running: Exec() using database/sql

func (*DbMap) Get Uses

func (m *DbMap) Get(i interface{}, keys ...interface{}) (interface{}, error)

Get runs a SQL SELECT to fetch a single row from the table based on the primary key(s)

i should be an empty value for the struct to load. keys should be the primary key value(s) for the row to load. If multiple keys exist on the table, the order should match the column order specified in SetKeys() when the table mapping was defined.

The hook function PostGet() will be executed after the SELECT statement if the interface defines them.

Returns a pointer to a struct that matches or nil if no row is found.

Returns an error if SetKeys has not been called on the TableMap Panics if any interface in the list has not been registered with AddTable

func (*DbMap) Insert Uses

func (m *DbMap) Insert(list ...interface{}) error

Insert runs a SQL INSERT statement for each element in list. List items must be pointers.

Any interface whose TableMap has an auto-increment primary key will have its last insert id bound to the PK field on the struct.

The hook functions PreInsert() and/or PostInsert() will be executed before/after the INSERT statement if the interface defines them.

Panics if any interface in the list has not been registered with AddTable

func (*DbMap) Prepare Uses

func (m *DbMap) Prepare(query string) (*sql.Stmt, error)

Prepare creates a prepared statement for later queries or executions. Multiple queries or executions may be run concurrently from the returned statement. This is equivalent to running: Prepare() using database/sql

func (*DbMap) Select Uses

func (m *DbMap) Select(i interface{}, query string, args ...interface{}) ([]interface{}, error)

Select runs an arbitrary SQL query, binding the columns in the result to fields on the struct specified by i. args represent the bind parameters for the SQL statement.

Column names on the SELECT statement should be aliased to the field names on the struct i. Returns an error if one or more columns in the result do not match. It is OK if fields on i are not part of the SQL statement.

The hook function PostGet() will be executed after the SELECT statement if the interface defines them.

Values are returned in one of two ways: 1. If i is a struct or a pointer to a struct, returns a slice of pointers to matching rows of type i. 2. If i is a pointer to a slice, the results will be appended to that slice and nil returned.

i does NOT need to be registered with AddTable()

func (*DbMap) SelectFloat Uses

func (m *DbMap) SelectFloat(query string, args ...interface{}) (float64, error)

SelectFloat is a convenience wrapper around the gorp.SelectFlot function

func (*DbMap) SelectInt Uses

func (m *DbMap) SelectInt(query string, args ...interface{}) (int64, error)

SelectInt is a convenience wrapper around the gorp.SelectInt function

func (*DbMap) SelectNullFloat Uses

func (m *DbMap) SelectNullFloat(query string, args ...interface{}) (sql.NullFloat64, error)

SelectNullFloat is a convenience wrapper around the gorp.SelectNullFloat function

func (*DbMap) SelectNullInt Uses

func (m *DbMap) SelectNullInt(query string, args ...interface{}) (sql.NullInt64, error)

SelectNullInt is a convenience wrapper around the gorp.SelectNullInt function

func (*DbMap) SelectNullStr Uses

func (m *DbMap) SelectNullStr(query string, args ...interface{}) (sql.NullString, error)

SelectNullStr is a convenience wrapper around the gorp.SelectNullStr function

func (*DbMap) SelectOne Uses

func (m *DbMap) SelectOne(holder interface{}, query string, args ...interface{}) error

SelectOne is a convenience wrapper around the gorp.SelectOne function

func (*DbMap) SelectStr Uses

func (m *DbMap) SelectStr(query string, args ...interface{}) (string, error)

SelectStr is a convenience wrapper around the gorp.SelectStr function

func (*DbMap) TableFor Uses

func (m *DbMap) TableFor(t reflect.Type, checkPK bool) (*TableMap, error)

TableFor returns the *TableMap corresponding to the given Go Type If no table is mapped to that type an error is returned. If checkPK is true and the mapped table has no registered PKs, an error is returned.

func (*DbMap) TraceOff Uses

func (m *DbMap) TraceOff()

TraceOff turns off tracing. It is idempotent.

func (*DbMap) TraceOn Uses

func (m *DbMap) TraceOn(prefix string, logger GorpLogger)

TraceOn turns on SQL statement logging for this DbMap. After this is called, all SQL statements will be sent to the logger. If prefix is a non-empty string, it will be written to the front of all logged strings, which can aid in filtering log lines.

Use TraceOn if you want to spy on the SQL statements that gorp generates.

Note that the base log.Logger type satisfies GorpLogger, but adapters can easily be written for other logging packages (e.g., the golang-sanctioned glog framework).

func (*DbMap) TruncateTables Uses

func (m *DbMap) TruncateTables() error

TruncateTables iterates through TableMaps registered to this DbMap and executes "truncate table" statements against the database for each, or in the case of sqlite, a "delete from" with no "where" clause, which uses the truncate optimization (http://www.sqlite.org/lang_delete.html)

func (*DbMap) Update Uses

func (m *DbMap) Update(list ...interface{}) (int64, error)

Update runs a SQL UPDATE statement for each element in list. List items must be pointers.

The hook functions PreUpdate() and/or PostUpdate() will be executed before/after the UPDATE statement if the interface defines them.

Returns the number of rows updated.

Returns an error if SetKeys has not been called on the TableMap Panics if any interface in the list has not been registered with AddTable

type Dialect Uses

type Dialect interface {

    // adds a suffix to any query, usually ";"
    QuerySuffix() string

    // ToSqlType returns the SQL column type to use when creating a
    // table of the given Go Type.  maxsize can be used to switch based on
    // size.  For example, in MySQL []byte could map to BLOB, MEDIUMBLOB,
    // or LONGBLOB depending on the maxsize
    ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

    // string to append to primary key column definitions
    AutoIncrStr() string

    // string to bind autoincrement columns to. Empty string will
    // remove reference to those columns in the INSERT statement.
    AutoIncrBindValue() string

    AutoIncrInsertSuffix(col *ColumnMap) string

    // string to append to "create table" statement for vendor specific
    // table attributes
    CreateTableSuffix() string

    // string to truncate tables
    TruncateClause() string

    // bind variable string to use when forming SQL statements
    // in many dbs it is "?", but Postgres appears to use $1
    //
    // i is a zero based index of the bind variable in this statement
    //
    BindVar(i int) string

    // Handles quoting of a field name to ensure that it doesn't raise any
    // SQL parsing exceptions by using a reserved word as a field name.
    QuoteField(field string) string

    // Handles building up of a schema.database string that is compatible with
    // the given dialect
    //
    // schema - The schema that <table> lives in
    // table - The table name
    QuotedTableForQuery(schema string, table string) string

    // Existance clause for table creation / deletion
    IfSchemaNotExists(command, schema string) string
    IfTableExists(command, schema, table string) string
    IfTableNotExists(command, schema, table string) string
}

The Dialect interface encapsulates behaviors that differ across SQL databases. At present the Dialect is only used by CreateTables() but this could change in the future

type GorpLogger Uses

type GorpLogger interface {
    Printf(format string, v ...interface{})
}

type HasPostDelete Uses

type HasPostDelete interface {
    PostDelete(SqlExecutor) error
}

PostUpdate() will be executed after the DELETE statement

type HasPostGet Uses

type HasPostGet interface {
    PostGet(SqlExecutor) error
}

PostUpdate() will be executed after the GET statement.

type HasPostInsert Uses

type HasPostInsert interface {
    PostInsert(SqlExecutor) error
}

PostInsert() will be executed after the INSERT statement

type HasPostUpdate Uses

type HasPostUpdate interface {
    PostUpdate(SqlExecutor) error
}

PostUpdate() will be executed after the UPDATE statement

type HasPreDelete Uses

type HasPreDelete interface {
    PreDelete(SqlExecutor) error
}

PreDelete() will be executed before the DELETE statement.

type HasPreInsert Uses

type HasPreInsert interface {
    PreInsert(SqlExecutor) error
}

PreInsert() will be executed before INSERT statement.

type HasPreUpdate Uses

type HasPreUpdate interface {
    PreUpdate(SqlExecutor) error
}

PreUpdate() will be executed before UPDATE statement.

type IntegerAutoIncrInserter Uses

type IntegerAutoIncrInserter interface {
    InsertAutoIncr(exec SqlExecutor, insertSql string, params ...interface{}) (int64, error)
}

IntegerAutoIncrInserter is implemented by dialects that can perform inserts with automatically incremented integer primary keys. If the dialect can handle automatic assignment of more than just integers, see TargetedAutoIncrInserter.

type MySQLDialect Uses

type MySQLDialect struct {

    // Engine is the storage engine to use "InnoDB" vs "MyISAM" for example
    Engine string

    // Encoding is the character encoding to use for created tables
    Encoding string
}

Implementation of Dialect for MySQL databases.

func (MySQLDialect) AutoIncrBindValue Uses

func (d MySQLDialect) AutoIncrBindValue() string

func (MySQLDialect) AutoIncrInsertSuffix Uses

func (d MySQLDialect) AutoIncrInsertSuffix(col *ColumnMap) string

func (MySQLDialect) AutoIncrStr Uses

func (d MySQLDialect) AutoIncrStr() string

Returns auto_increment

func (MySQLDialect) BindVar Uses

func (d MySQLDialect) BindVar(i int) string

Returns "?"

func (MySQLDialect) CreateTableSuffix Uses

func (d MySQLDialect) CreateTableSuffix() string

Returns engine=%s charset=%s based on values stored on struct

func (MySQLDialect) IfSchemaNotExists Uses

func (d MySQLDialect) IfSchemaNotExists(command, schema string) string

func (MySQLDialect) IfTableExists Uses

func (d MySQLDialect) IfTableExists(command, schema, table string) string

func (MySQLDialect) IfTableNotExists Uses

func (d MySQLDialect) IfTableNotExists(command, schema, table string) string

func (MySQLDialect) InsertAutoIncr Uses

func (d MySQLDialect) InsertAutoIncr(exec SqlExecutor, insertSql string, params ...interface{}) (int64, error)

func (MySQLDialect) QuerySuffix Uses

func (d MySQLDialect) QuerySuffix() string

func (MySQLDialect) QuoteField Uses

func (d MySQLDialect) QuoteField(f string) string

func (MySQLDialect) QuotedTableForQuery Uses

func (d MySQLDialect) QuotedTableForQuery(schema string, table string) string

func (MySQLDialect) ToSqlType Uses

func (d MySQLDialect) ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

func (MySQLDialect) TruncateClause Uses

func (d MySQLDialect) TruncateClause() string

type NoFieldInTypeError Uses

type NoFieldInTypeError struct {
    TypeName        string
    MissingColNames []string
}

A non-fatal error, when a select query returns columns that do not exist as fields in the struct it is being mapped to

func (*NoFieldInTypeError) Error Uses

func (err *NoFieldInTypeError) Error() string

type NullTime Uses

type NullTime struct {
    Time  time.Time
    Valid bool // Valid is true if Time is not NULL
}

A nullable Time value

func (*NullTime) Scan Uses

func (nt *NullTime) Scan(value interface{}) error

Scan implements the Scanner interface.

func (NullTime) Value Uses

func (nt NullTime) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type OptimisticLockError Uses

type OptimisticLockError struct {
    // Table name where the lock error occurred
    TableName string

    // Primary key values of the row being updated/deleted
    Keys []interface{}

    // true if a row was found with those keys, indicating the
    // LocalVersion is stale.  false if no value was found with those
    // keys, suggesting the row has been deleted since loaded, or
    // was never inserted to begin with
    RowExists bool

    // Version value on the struct passed to Update/Delete. This value is
    // out of sync with the database.
    LocalVersion int64
}

OptimisticLockError is returned by Update() or Delete() if the struct being modified has a Version field and the value is not equal to the current value in the database

func (OptimisticLockError) Error Uses

func (e OptimisticLockError) Error() string

Error returns a description of the cause of the lock error

type OracleDialect Uses

type OracleDialect struct{}

Implementation of Dialect for Oracle databases.

func (OracleDialect) AutoIncrBindValue Uses

func (d OracleDialect) AutoIncrBindValue() string

func (OracleDialect) AutoIncrInsertSuffix Uses

func (d OracleDialect) AutoIncrInsertSuffix(col *ColumnMap) string

func (OracleDialect) AutoIncrStr Uses

func (d OracleDialect) AutoIncrStr() string

Returns empty string

func (OracleDialect) BindVar Uses

func (d OracleDialect) BindVar(i int) string

Returns "$(i+1)"

func (OracleDialect) CreateTableSuffix Uses

func (d OracleDialect) CreateTableSuffix() string

Returns suffix

func (OracleDialect) IfSchemaNotExists Uses

func (d OracleDialect) IfSchemaNotExists(command, schema string) string

func (OracleDialect) IfTableExists Uses

func (d OracleDialect) IfTableExists(command, schema, table string) string

func (OracleDialect) IfTableNotExists Uses

func (d OracleDialect) IfTableNotExists(command, schema, table string) string

func (OracleDialect) InsertAutoIncr Uses

func (d OracleDialect) InsertAutoIncr(exec SqlExecutor, insertSql string, params ...interface{}) (int64, error)

func (OracleDialect) QuerySuffix Uses

func (d OracleDialect) QuerySuffix() string

func (OracleDialect) QuoteField Uses

func (d OracleDialect) QuoteField(f string) string

func (OracleDialect) QuotedTableForQuery Uses

func (d OracleDialect) QuotedTableForQuery(schema string, table string) string

func (OracleDialect) ToSqlType Uses

func (d OracleDialect) ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

func (OracleDialect) TruncateClause Uses

func (d OracleDialect) TruncateClause() string

type OracleString Uses

type OracleString struct {
    sql.NullString
}

Oracle String (empty string is null)

func (*OracleString) Scan Uses

func (os *OracleString) Scan(value interface{}) error

Scan implements the Scanner interface.

func (OracleString) Value Uses

func (os OracleString) Value() (driver.Value, error)

Value implements the driver Valuer interface.

type PostgresDialect Uses

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

func (PostgresDialect) AutoIncrBindValue Uses

func (d PostgresDialect) AutoIncrBindValue() string

func (PostgresDialect) AutoIncrInsertSuffix Uses

func (d PostgresDialect) AutoIncrInsertSuffix(col *ColumnMap) string

func (PostgresDialect) AutoIncrStr Uses

func (d PostgresDialect) AutoIncrStr() string

Returns empty string

func (PostgresDialect) BindVar Uses

func (d PostgresDialect) BindVar(i int) string

Returns "$(i+1)"

func (PostgresDialect) CreateTableSuffix Uses

func (d PostgresDialect) CreateTableSuffix() string

Returns suffix

func (PostgresDialect) IfSchemaNotExists Uses

func (d PostgresDialect) IfSchemaNotExists(command, schema string) string

func (PostgresDialect) IfTableExists Uses

func (d PostgresDialect) IfTableExists(command, schema, table string) string

func (PostgresDialect) IfTableNotExists Uses

func (d PostgresDialect) IfTableNotExists(command, schema, table string) string

func (PostgresDialect) InsertAutoIncrToTarget Uses

func (d PostgresDialect) InsertAutoIncrToTarget(exec SqlExecutor, insertSql string, target interface{}, params ...interface{}) error

func (PostgresDialect) QuerySuffix Uses

func (d PostgresDialect) QuerySuffix() string

func (PostgresDialect) QuoteField Uses

func (d PostgresDialect) QuoteField(f string) string

func (PostgresDialect) QuotedTableForQuery Uses

func (d PostgresDialect) QuotedTableForQuery(schema string, table string) string

func (PostgresDialect) ToSqlType Uses

func (d PostgresDialect) ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

func (PostgresDialect) TruncateClause Uses

func (d PostgresDialect) TruncateClause() string

type SqlExecutor Uses

type SqlExecutor interface {
    Get(i interface{}, keys ...interface{}) (interface{}, error)
    Insert(list ...interface{}) error
    Update(list ...interface{}) (int64, error)
    Delete(list ...interface{}) (int64, error)
    Exec(query string, args ...interface{}) (sql.Result, error)
    Select(i interface{}, query string,
        args ...interface{}) ([]interface{}, error)
    SelectInt(query string, args ...interface{}) (int64, error)
    SelectNullInt(query string, args ...interface{}) (sql.NullInt64, error)
    SelectFloat(query string, args ...interface{}) (float64, error)
    SelectNullFloat(query string, args ...interface{}) (sql.NullFloat64, error)
    SelectStr(query string, args ...interface{}) (string, error)
    SelectNullStr(query string, args ...interface{}) (sql.NullString, error)
    SelectOne(holder interface{}, query string, args ...interface{}) error
    // contains filtered or unexported methods
}

SqlExecutor exposes gorp operations that can be run from Pre/Post hooks. This hides whether the current operation that triggered the hook is in a transaction.

See the DbMap function docs for each of the functions below for more information.

type SqlServerDialect Uses

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

func (SqlServerDialect) AutoIncrBindValue Uses

func (d SqlServerDialect) AutoIncrBindValue() string

Empty string removes autoincrement columns from the INSERT statements.

func (SqlServerDialect) AutoIncrInsertSuffix Uses

func (d SqlServerDialect) AutoIncrInsertSuffix(col *ColumnMap) string

func (SqlServerDialect) AutoIncrStr Uses

func (d SqlServerDialect) AutoIncrStr() string

Returns auto_increment

func (SqlServerDialect) BindVar Uses

func (d SqlServerDialect) BindVar(i int) string

Returns "?"

func (SqlServerDialect) CreateTableSuffix Uses

func (d SqlServerDialect) CreateTableSuffix() string

Returns suffix

func (SqlServerDialect) IfSchemaNotExists Uses

func (d SqlServerDialect) IfSchemaNotExists(command, schema string) string

func (SqlServerDialect) IfTableExists Uses

func (d SqlServerDialect) IfTableExists(command, schema, table string) string

func (SqlServerDialect) IfTableNotExists Uses

func (d SqlServerDialect) IfTableNotExists(command, schema, table string) string

func (SqlServerDialect) InsertAutoIncr Uses

func (d SqlServerDialect) InsertAutoIncr(exec SqlExecutor, insertSql string, params ...interface{}) (int64, error)

func (SqlServerDialect) QuerySuffix Uses

func (d SqlServerDialect) QuerySuffix() string

func (SqlServerDialect) QuoteField Uses

func (d SqlServerDialect) QuoteField(f string) string

func (SqlServerDialect) QuotedTableForQuery Uses

func (d SqlServerDialect) QuotedTableForQuery(schema string, table string) string

func (SqlServerDialect) ToSqlType Uses

func (d SqlServerDialect) ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

func (SqlServerDialect) TruncateClause Uses

func (d SqlServerDialect) TruncateClause() string

type SqliteDialect Uses

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

func (SqliteDialect) AutoIncrBindValue Uses

func (d SqliteDialect) AutoIncrBindValue() string

func (SqliteDialect) AutoIncrInsertSuffix Uses

func (d SqliteDialect) AutoIncrInsertSuffix(col *ColumnMap) string

func (SqliteDialect) AutoIncrStr Uses

func (d SqliteDialect) AutoIncrStr() string

Returns autoincrement

func (SqliteDialect) BindVar Uses

func (d SqliteDialect) BindVar(i int) string

Returns "?"

func (SqliteDialect) CreateTableSuffix Uses

func (d SqliteDialect) CreateTableSuffix() string

Returns suffix

func (SqliteDialect) IfSchemaNotExists Uses

func (d SqliteDialect) IfSchemaNotExists(command, schema string) string

func (SqliteDialect) IfTableExists Uses

func (d SqliteDialect) IfTableExists(command, schema, table string) string

func (SqliteDialect) IfTableNotExists Uses

func (d SqliteDialect) IfTableNotExists(command, schema, table string) string

func (SqliteDialect) InsertAutoIncr Uses

func (d SqliteDialect) InsertAutoIncr(exec SqlExecutor, insertSql string, params ...interface{}) (int64, error)

func (SqliteDialect) QuerySuffix Uses

func (d SqliteDialect) QuerySuffix() string

func (SqliteDialect) QuoteField Uses

func (d SqliteDialect) QuoteField(f string) string

func (SqliteDialect) QuotedTableForQuery Uses

func (d SqliteDialect) QuotedTableForQuery(schema string, table string) string

sqlite does not have schemas like PostgreSQL does, so just escape it like normal

func (SqliteDialect) ToSqlType Uses

func (d SqliteDialect) ToSqlType(val reflect.Type, maxsize int, isAutoIncr bool) string

func (SqliteDialect) TruncateClause Uses

func (d SqliteDialect) TruncateClause() string

With sqlite, there technically isn't a TRUNCATE statement, but a DELETE FROM uses a truncate optimization: http://www.sqlite.org/lang_delete.html

type TableMap Uses

type TableMap struct {
    // Name of database table.
    TableName  string
    SchemaName string

    Columns []*ColumnMap
    // contains filtered or unexported fields
}

TableMap represents a mapping between a Go struct and a database table Use dbmap.AddTable() or dbmap.AddTableWithName() to create these

func (*TableMap) ColMap Uses

func (t *TableMap) ColMap(field string) *ColumnMap

ColMap returns the ColumnMap pointer matching the given struct field name. It panics if the struct does not contain a field matching this name.

func (*TableMap) ResetSql Uses

func (t *TableMap) ResetSql()

ResetSql removes cached insert/update/select/delete SQL strings associated with this TableMap. Call this if you've modified any column names or the table name itself.

func (*TableMap) SetKeys Uses

func (t *TableMap) SetKeys(isAutoIncr bool, fieldNames ...string) *TableMap

SetKeys lets you specify the fields on a struct that map to primary key columns on the table. If isAutoIncr is set, result.LastInsertId() will be used after INSERT to bind the generated id to the Go struct.

Automatically calls ResetSql() to ensure SQL statements are regenerated.

Panics if isAutoIncr is true, and fieldNames length != 1

func (*TableMap) SetUniqueTogether Uses

func (t *TableMap) SetUniqueTogether(fieldNames ...string) *TableMap

SetUniqueTogether lets you specify uniqueness constraints across multiple columns on the table. Each call adds an additional constraint for the specified columns.

Automatically calls ResetSql() to ensure SQL statements are regenerated.

Panics if fieldNames length < 2.

func (*TableMap) SetVersionCol Uses

func (t *TableMap) SetVersionCol(field string) *ColumnMap

SetVersionCol sets the column to use as the Version field. By default the "Version" field is used. Returns the column found, or panics if the struct does not contain a field matching this name.

Automatically calls ResetSql() to ensure SQL statements are regenerated.

type TargetedAutoIncrInserter Uses

type TargetedAutoIncrInserter interface {
    // InsertAutoIncrToTarget runs an insert operation and assigns the
    // automatically generated primary key directly to the passed in
    // target.  The target should be a pointer to the primary key
    // field of the value being inserted.
    InsertAutoIncrToTarget(exec SqlExecutor, insertSql string, target interface{}, params ...interface{}) error
}

TargetedAutoIncrInserter is implemented by dialects that can perform automatic assignment of any primary key type (i.e. strings for uuids, integers for serials, etc).

type Transaction Uses

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

Transaction represents a database transaction. Insert/Update/Delete/Get/Exec operations will be run in the context of that transaction. Transactions should be terminated with a call to Commit() or Rollback()

func (*Transaction) Commit Uses

func (t *Transaction) Commit() error

Commit commits the underlying database transaction.

func (*Transaction) Delete Uses

func (t *Transaction) Delete(list ...interface{}) (int64, error)

Delete has the same behavior as DbMap.Delete(), but runs in a transaction.

func (*Transaction) Exec Uses

func (t *Transaction) Exec(query string, args ...interface{}) (sql.Result, error)

Exec has the same behavior as DbMap.Exec(), but runs in a transaction.

func (*Transaction) Get Uses

func (t *Transaction) Get(i interface{}, keys ...interface{}) (interface{}, error)

Get has the same behavior as DbMap.Get(), but runs in a transaction.

func (*Transaction) Insert Uses

func (t *Transaction) Insert(list ...interface{}) error

Insert has the same behavior as DbMap.Insert(), but runs in a transaction.

func (*Transaction) Prepare Uses

func (t *Transaction) Prepare(query string) (*sql.Stmt, error)

Prepare has the same behavior as DbMap.Prepare(), but runs in a transaction.

func (*Transaction) ReleaseSavepoint Uses

func (t *Transaction) ReleaseSavepoint(savepoint string) error

ReleaseSavepint releases the savepoint with the given name. The name is interpolated directly into the SQL SAVEPOINT statement, so you must sanitize it if it is derived from user input.

func (*Transaction) Rollback Uses

func (t *Transaction) Rollback() error

Rollback rolls back the underlying database transaction.

func (*Transaction) RollbackToSavepoint Uses

func (t *Transaction) RollbackToSavepoint(savepoint string) error

RollbackToSavepoint rolls back to the savepoint with the given name. The name is interpolated directly into the SQL SAVEPOINT statement, so you must sanitize it if it is derived from user input.

func (*Transaction) Savepoint Uses

func (t *Transaction) Savepoint(name string) error

Savepoint creates a savepoint with the given name. The name is interpolated directly into the SQL SAVEPOINT statement, so you must sanitize it if it is derived from user input.

func (*Transaction) Select Uses

func (t *Transaction) Select(i interface{}, query string, args ...interface{}) ([]interface{}, error)

Select has the same behavior as DbMap.Select(), but runs in a transaction.

func (*Transaction) SelectFloat Uses

func (t *Transaction) SelectFloat(query string, args ...interface{}) (float64, error)

SelectFloat is a convenience wrapper around the gorp.SelectFloat function.

func (*Transaction) SelectInt Uses

func (t *Transaction) SelectInt(query string, args ...interface{}) (int64, error)

SelectInt is a convenience wrapper around the gorp.SelectInt function.

func (*Transaction) SelectNullFloat Uses

func (t *Transaction) SelectNullFloat(query string, args ...interface{}) (sql.NullFloat64, error)

SelectNullFloat is a convenience wrapper around the gorp.SelectNullFloat function.

func (*Transaction) SelectNullInt Uses

func (t *Transaction) SelectNullInt(query string, args ...interface{}) (sql.NullInt64, error)

SelectNullInt is a convenience wrapper around the gorp.SelectNullInt function.

func (*Transaction) SelectNullStr Uses

func (t *Transaction) SelectNullStr(query string, args ...interface{}) (sql.NullString, error)

SelectNullStr is a convenience wrapper around the gorp.SelectNullStr function.

func (*Transaction) SelectOne Uses

func (t *Transaction) SelectOne(holder interface{}, query string, args ...interface{}) error

SelectOne is a convenience wrapper around the gorp.SelectOne function.

func (*Transaction) SelectStr Uses

func (t *Transaction) SelectStr(query string, args ...interface{}) (string, error)

SelectStr is a convenience wrapper around the gorp.SelectStr function.

func (*Transaction) Update Uses

func (t *Transaction) Update(list ...interface{}) (int64, error)

Update had the same behavior as DbMap.Update(), but runs in a transaction.

type TypeConverter Uses

type TypeConverter interface {
    // ToDb converts val to another type. Called before INSERT/UPDATE operations
    ToDb(val interface{}) (interface{}, error)

    // FromDb returns a CustomScanner appropriate for this type. This will be used
    // to hold values returned from SELECT queries.
    //
    // In particular the CustomScanner returned should implement a Binder
    // function appropriate for the Go type you wish to convert the db value to
    //
    // If bool==false, then no custom scanner will be used for this field.
    FromDb(target interface{}) (CustomScanner, bool)
}

The TypeConverter interface provides a way to map a value of one type to another type when persisting to, or loading from, a database.

Example use cases: Implement type converter to convert bool types to "y"/"n" strings, or serialize a struct member as a JSON blob.

Package gorp imports 9 packages (graph) and is imported by 501 packages. Updated 2018-04-24. Refresh now. Tools for package owners.