sqlx

package
v1.1.32 Latest Latest
Warning

This package is not in the latest version of its module.

 Go to latest Published: Oct 18, 2021 License: MIT Imports: 8 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExpandAsColumns added in v0.0.43 

func ExpandAsColumns(cols ...string) []string

ExpandAsColumns expand columns with alias AS query := ExpandAsColumns("foo", "bar") // []string{"foo AS foo", "bar AS bar"}

func JoinColumns added in v0.0.27 

func JoinColumns(cols ...string) string

JoinColumns concatenates the elements of cols to column1, column2, ... query := JoinColumns("foo", "bar") // "foo,bar"

func JoinColumnsWithAs added in v0.0.45 

func JoinColumnsWithAs(cols ...string) string

JoinColumnsWithAs concatenates the elements of cols to column1, column2, ... query := JoinColumnsWithAs("foo", "bar") // "foo AS foo,bar AS bar"

func JoinNamedColumns 

func JoinNamedColumns(cols ...string) string

JoinNamedColumns concatenates the elements of cols to column1, column2, ... Deprecated: Use NamedInsertArguments instead.

func JoinNamedColumnsValues added in v0.0.27 

func JoinNamedColumnsValues(cols ...string) string

JoinNamedColumnsValues concatenates the elements of values to value1=:value1, value2=:value2 ... Deprecated: Use NamedUpdateArguments instead.

func JoinNamedCondition 

func JoinNamedCondition(cmp SqlCompare, operator SqlOperator, cols ...string) string

JoinNamedCondition concatenates the elements of values to value1=:value1 AND value2=:value2 ... query := JoinNamedCondition(SqlCompareEqual,SqlOperatorAnd,"foo", "bar") // "foo=:foo AND bar=:bar"

func JoinNamedTableColumns added in v0.0.35 

func JoinNamedTableColumns(table string, cols ...string) string

JoinNamedTableColumns concatenates the elements of cols in table to column1, column2, ... query := JoinNamedTableColumns("table", "foo", "bar") // "table.foo, table.bar"

func JoinNamedTableColumnsValues added in v0.0.35 

func JoinNamedTableColumnsValues(table string, cols ...string) string

JoinNamedTableColumnsValues concatenates the elements of values to table.value1=:value1, table.value2=:value2 ... query := JoinNamedTableColumnsValues("table", "foo", "bar") // "table.foo=:table.foo, table.bar=:table.bar"

func JoinNamedTableColumnsWithAs added in v0.0.45 

func JoinNamedTableColumnsWithAs(table string, cols ...string) string

func JoinNamedTableCondition added in v0.0.35 

func JoinNamedTableCondition(cmp SqlCompare, operator SqlOperator, table string, cols ...string) string

JoinNamedTableCondition concatenates the elements of values to table.value1=:value1 AND table.value2=:value2 ... query := JoinNamedTableCondition(SqlCompareEqual, SqlOperatorAnd, "table", "foo", "bar") // "table.foo=:table.foo AND table.bar=:table.bar"

func JoinNamedTableValues added in v0.0.35 

func JoinNamedTableValues(table string, cols ...string) string

JoinNamedTableValues concatenates the elements of values to :value1, :value2, ... query := JoinNamedTableValues("table", "foo", "bar") // ":table.foo,:table.bar" query := JoinNamedTableValues("table") // "DEFAULT"

func JoinNamedValues 

func JoinNamedValues(cols ...string) string

JoinNamedValues concatenates the elements of values to :value1, :value2, ... query := JoinNamedValues("foo", "bar") // ":foo,:bar" query := JoinNamedValues() // "DEFAULT" Deprecated: Use NamedInsertArguments instead.

func JoinTableColumns added in v0.0.35 

func JoinTableColumns(table string, cols ...string) string

JoinTableColumns concatenates the elements of cols to column1, column2, ... query := JoinTableColumns("table", "foo", "bar") // "table.foo, table.bar"

func JoinTableColumnsValues added in v0.0.38 

func JoinTableColumnsValues(table string, cols ...string) string

JoinTableColumnsValues concatenates the elements of values to table.value1=:value1, table.value2=:value2 ... query := JoinTableColumnsValues("table", "foo", "bar") // "table.foo=?, table.bar=?"

func JoinTableColumnsWithAs added in v0.0.45 

func JoinTableColumnsWithAs(table string, cols ...string) string

JoinTableColumnsWithAs concatenates the elements of cols to column1, column2, ... query := JoinTableColumnsWithAs("table", "foo", "bar") // "table.foo AS table.foo, table.bar AS table.bar"

func JoinTableCondition added in v0.0.38 

func JoinTableCondition(cmp SqlCompare, operator SqlOperator, table string, cols ...string) string

JoinTableCondition concatenates the elements of values to table.value1=:value1 AND table.value2=:value2 ... query := JoinTableCondition(SqlCompareEqual, SqlOperatorAnd, "table", "foo", "bar") // "table.foo=? AND table.bar=?"

func JoinTableValues added in v0.0.38 

func JoinTableValues(cols ...string) string

JoinTableValues concatenates the elements of values to :value1, :value2, ... query := JoinTableValues("foo", "bar") // "?,?" query := JoinTableValues() // "DEFAULT"

func NamedColumns added in v0.0.27 

func NamedColumns(cols ...string) []string

NamedColumns returns the []string{value1, value2 ...} query := NamedColumns("foo", "bar") // []string{"foo", "bar"}

func NamedColumnsValues added in v0.0.27 

func NamedColumnsValues(cmp SqlCompare, cols ...string) []string

NamedColumnsValues returns the []string{value1=:value1, value2=:value2 ...} query := NamedColumnsValues("foo", "bar") // []string{"foo=:foo", bar=:bar"}

func NamedInsertArguments added in v0.0.18 

func NamedInsertArguments(cols ...string) (columns string, arguments string)

NamedInsertArguments returns columns and arguments for SQL INSERT statements based on columns. 

columns, arguments := NamedInsertArguments("foo", "bar")
query := fmt.Sprintf("INSERT INTO foo (%s) VALUES (%s)", columns, arguments)
// INSERT INTO foo (foo, bar) VALUES (:foo, :bar)

Deprecated: Use NamedInsertArgumentsCombined instead.

func NamedInsertArgumentsCombined added in v0.0.19 

func NamedInsertArgumentsCombined(cols ...string) (arguments string)

NamedInsertArgumentsCombined returns columns and arguments together for SQL INSERT statements based on columns. 

query := fmt.Sprintf("INSERT INTO foo %s", NamedInsertArgumentsCombined("foo", "bar"))
// INSERT INTO foo (foo, bar) VALUES (:foo, :bar)

query := fmt.Sprintf("INSERT INTO foo %s", NamedInsertArgumentsCombined())
// INSERT INTO foo (foo, bar) DEFAULT VALUES

func NamedSelectArguments added in v0.0.18 

func NamedSelectArguments(cols ...string) (arguments string)

NamedSelectArguments returns columns and arguments for SQL SELECT statements based on columns. 

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArguments("foo", "bar"))
// SELECT foo, bar FROM foo

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArguments("foo"))
// SELECT foo FROM foo

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArguments())
// SELECT * FROM foo

func NamedSelectArgumentsWithAs added in v0.0.44 

func NamedSelectArgumentsWithAs(cols ...string) (arguments string)

NamedSelectArgumentsWithAs returns columns and arguments for SQL SELECT statements based on columns with alias. 

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArgumentsWithAs("foo", "bar"))
// SELECT foo AS foo, bar AS bar FROM foo

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArgumentsWithAs("foo"))
// SELECT foo AS foo FROM foo

query := fmt.Sprintf("SELECT %s FROM foo", NamedSelectArgumentsWithAs())
// SELECT * FROM foo

func NamedTableColumns added in v0.0.35 

func NamedTableColumns(table string, cols ...string) []string

NamedTableColumns returns the []string{table.value1, table.value2 ...} query := NamedColumns("table", "foo", "bar") // []string{"table.foo", "table.bar"}

func NamedTableColumnsValues added in v0.0.35 

func NamedTableColumnsValues(cmp SqlCompare, table string, cols ...string) []string

NamedColumnsValues returns the []string{table.value1=:value1, table.value2=:value2 ...} query := NamedColumnsValues("table", "foo", "bar") // []string{"table.foo=:table.foo", "table.bar=:table.bar"}

func NamedTableInsertArguments added in v0.0.36 

func NamedTableInsertArguments(table string, cols ...string) (columns string, arguments string)

NamedTableInsertArguments returns columns and arguments for SQL INSERT statements based on columns. 

columns, arguments := NamedTableInsertArguments("table", "foo", "bar")
query := fmt.Sprintf("INSERT INTO table (%s) VALUES (%s)", columns, arguments)
// INSERT INTO table (table.foo, table.bar) VALUES (:table.foo, :table.bar)

Deprecated: Use NamedTableInsertArgumentsCombined instead.

func NamedTableInsertArgumentsCombined added in v0.0.36 

func NamedTableInsertArgumentsCombined(table string, cols ...string) (arguments string)

NamedTableInsertArgumentsCombined returns columns and arguments together for SQL INSERT statements based on columns. 

query := fmt.Sprintf("INSERT INTO table %s", NamedTableInsertArgumentsCombined("table", "foo", "bar"))
// INSERT INTO table (table.foo, table.bar) VALUES (:table.foo, :table.bar)

query := fmt.Sprintf("INSERT INTO table %s", NamedTableInsertArgumentsCombined("table"))
// INSERT INTO table (foo, bar) DEFAULT VALUES

func NamedTableSelectArguments added in v0.0.36 

func NamedTableSelectArguments(table string, cols ...string) (arguments string)

NamedTableSelectArguments returns columns and arguments for SQL SELECT statements based on columns. 

query := fmt.Sprintf("SELECT %s FROM foo", NamedTableSelectArguments("table", "foo", "bar"))
// SELECT table.foo AS table.foo, table.bar AS table.bar FROM table

query := fmt.Sprintf("SELECT %s FROM table", NamedTableSelectArguments("table", "foo"))
// SELECT table.foo AS table.foo FROM table

query := fmt.Sprintf("SELECT %s FROM table", NamedTableSelectArguments("table"))
// SELECT * FROM table

func NamedTableUpdateArguments added in v0.0.36 

func NamedTableUpdateArguments(table string, cols ...string) (arguments string)

NamedTableUpdateArguments returns columns and arguments for SQL UPDATE statements based on columns. 

statement := NamedTableUpdateArguments("table", "foo", "bar")
query := fmt.Sprintf("UPDATE table SET %s", statement)
// UPDATE foo SET table.foo=:table.foo, table.bar=:table.bar

func NamedTableValues added in v0.0.35 

func NamedTableValues(table string, cols ...string) []string

NamedTableValues returns the []string{:value1, :value2 ...} query := NamedTableValues("table", "foo", "bar") // []string{":table.foo", ":table.bar"}

func NamedTableWhereArguments added in v0.0.36 

func NamedTableWhereArguments(cmp SqlCompare, operator SqlOperator, table string, cols ...string) (arguments string)

NamedTableWhereArguments returns conditions for SQL WHERE statements based on columns. 

query := fmt.Sprintf("SELECT * FROM table WHERE %s", NamedTableWhereArguments(SqlCompareEqual, SqlOperatorAnd, "table", "foo", "bar"))
// SELECT * FROM table WHERE table.foo=:table.foo AND table.bar=:table.bar

query := fmt.Sprintf("SELECT * FROM table WHERE %s", NamedTableWhereArguments(SqlCompareEqual, SqlOperatorAnd, "table"))
// SELECT * FROM table WHERE TRUE

func NamedUpdateArguments added in v0.0.18 

func NamedUpdateArguments(cols ...string) (arguments string)

NamedUpdateArguments returns columns and arguments for SQL UPDATE statements based on columns. 

statement := NamedUpdateArguments("foo", "bar")
query := fmt.Sprintf("UPDATE foo SET %s", statement)
// UPDATE foo SET foo=:foo, bar=:bar

func NamedValues added in v0.0.27 

func NamedValues(cols ...string) []string

NamedValues returns the []string{:value1, :value2 ...} query := NamedValues("foo", "bar") // []string{":foo", ":bar"}

func NamedWhereArguments added in v0.0.18 

func NamedWhereArguments(cmp SqlCompare, operator SqlOperator, cols ...string) (arguments string)

NamedWhereArguments returns conditions for SQL WHERE statements based on columns. 

query := fmt.Sprintf("SELECT * FROM foo WHERE %s", NamedWhereArguments(SqlCompareEqual, SqlOperatorAnd, "foo", "bar"))
// SELECT * FROM foo WHERE foo=:foo AND bar=:bar

query := fmt.Sprintf("SELECT * FROM foo WHERE %s", NamedWhereArguments(SqlCompareEqual, SqlOperatorAnd))
// SELECT * FROM foo WHERE TRUE

func Pagination added in v0.0.49 

func Pagination(limit, offset int) string

Pagination returns the "LIMIT %d, OFFSET %d" query := Pagination(0, 0) // "LIMIT 0, OFFSET 0"

func ShrinkEmptyColumns added in v0.0.41 

func ShrinkEmptyColumns(cols ...string) []string

ShrinkEmptyColumns trim empty columns

func SqlCompareSliceContains added in v0.0.29 

func SqlCompareSliceContains(enums []SqlCompare, sunEnums ...SqlCompare) bool

SqlCompareSliceContains reports whether sunEnums is within enums.

func SqlCompareSliceContainsAny added in v0.0.29 

func SqlCompareSliceContainsAny(enums []SqlCompare, sunEnums ...SqlCompare) bool

SqlCompareSliceContainsAny reports whether any sunEnum is within enums.

func SqlOperatorSliceContains added in v0.0.27 

func SqlOperatorSliceContains(enums []SqlOperator, sunEnums ...SqlOperator) bool

SqlOperatorSliceContains reports whether sunEnums is within enums.

func SqlOperatorSliceContainsAny added in v0.0.27 

func SqlOperatorSliceContainsAny(enums []SqlOperator, sunEnums ...SqlOperator) bool

SqlOperatorSliceContainsAny reports whether any sunEnum is within enums.

func TableColumns added in v0.0.38 

func TableColumns(table string, cols ...string) []string

TableColumns returns the []string{table.value1, table.value2 ...} query := Columns("table", "foo", "bar") // []string{"table.foo", "table.bar"}

func TableColumnsValues added in v0.0.38 

func TableColumnsValues(cmp SqlCompare, table string, cols ...string) []string

ColumnsValues returns the []string{table.value1=:value1, table.value2=:value2 ...} query := ColumnsValues("table", "foo", "bar") // []string{"table.foo=?", "table.bar=?"}

func TableInsertArguments added in v0.0.39 

func TableInsertArguments(table string, cols ...string) (columns string, arguments string)

TableInsertArguments returns columns and arguments for SQL INSERT statements based on columns. 

columns, arguments := TableInsertArguments("table", "foo", "bar")
query := fmt.Sprintf("INSERT INTO table (%s) VALUES (%s)", columns, arguments)
// INSERT INTO table (table.foo, table.bar) VALUES (?, ?)

Deprecated: Use TableInsertArgumentsCombined instead.

func TableInsertArgumentsCombined added in v0.0.39 

func TableInsertArgumentsCombined(table string, cols ...string) (arguments string)

TableInsertArgumentsCombined returns columns and arguments together for SQL INSERT statements based on columns. 

query := fmt.Sprintf("INSERT INTO table %s", TableInsertArgumentsCombined("table", "foo", "bar"))
// INSERT INTO table (table.foo, table.bar) VALUES (?, ?)

query := fmt.Sprintf("INSERT INTO table %s", TableInsertArgumentsCombined("table"))
// INSERT INTO table (foo, bar) DEFAULT VALUES

func TableSelectArguments added in v0.0.39 

func TableSelectArguments(table string, cols ...string) (arguments string)

TableSelectArguments returns columns and arguments for SQL SELECT statements based on columns. 

query := fmt.Sprintf("SELECT %s FROM foo", TableSelectArguments("table", "foo", "bar"))
// SELECT table.foo, table.bar FROM table

query := fmt.Sprintf("SELECT %s FROM table", TableSelectArguments(table", "foo"))
// SELECT table.foo FROM table

query := fmt.Sprintf("SELECT %s FROM table", TableSelectArguments())
// SELECT * FROM table

func TableUpdateArguments added in v0.0.39 

func TableUpdateArguments(table string, cols ...string) (arguments string)

TableUpdateArguments returns columns and arguments for SQL UPDATE statements based on columns. 

statement := TableUpdateArguments("table", "foo", "bar")
query := fmt.Sprintf("UPDATE table SET %s", statement)
// UPDATE foo SET table.foo=?, table.bar=?

func TableValues added in v0.0.38 

func TableValues(cols ...string) []string

TableValues returns the []string{:value1, :value2 ...} query := TableValues("foo", "bar") // []string{"?", "?"}

func TableWhereArguments added in v0.0.39 

func TableWhereArguments(cmp SqlCompare, operator SqlOperator, table string, cols ...string) (arguments string)

TableWhereArguments returns conditions for SQL WHERE statements based on columns. 

query := fmt.Sprintf("SELECT * FROM table WHERE %s", TableWhereArguments(SqlCompareEqual, SqlOperatorAnd, "table", "foo", "bar"))
// SELECT * FROM table WHERE table.foo=? AND table.bar=?

query := fmt.Sprintf("SELECT * FROM table WHERE %s", TableWhereArguments(SqlCompareEqual, SqlOperatorAnd, "table"))
// SELECT * FROM table WHERE TRUE

Types

type InsertOption added in v0.0.58 

type InsertOption int
const (
	// INSERT inserts new rows into an existing table.
	InsertOptionInsert InsertOption = iota
	// REPLACE works exactly like INSERT, except that if an old row in the table has the same value as a
	// new row for a PRIMARY KEY or a UNIQUE index, the old row is deleted before the new row is inserted.
	InsertOptionReplace InsertOption = iota
	// If you specify an ON DUPLICATE KEY UPDATE clause and a row to be inserted would cause a duplicate
	// value in a UNIQUE index or PRIMARY KEY, an UPDATE of the old row occurs.
	InsertOptionUpdate InsertOption = iota
	// If you use the IGNORE modifier, ignorable errors that occur while executing the INSERT statement
	// are ignored.
	InsertOptionIgnore InsertOption = iota
	// deprecated in MySQL 5.6. In MySQL 8.0, DELAYED is not supported
	// Deprecated: Use InsertOptionInsert instead.
	InsertOptionDelayed InsertOption = iota
)

type SimpleStatements added in v0.0.20 

type SimpleStatements struct {
	TableName      string
	Columns        []string
	Conditions     []string    // take effect only in WHERE clause, that exists in SELECT, UPDATE, DELETE, or UPDATE in INSERT
	Compare        SqlCompare  // take effect only in WHERE clause, that exists in SELECT, UPDATE, DELETE
	Operator       SqlOperator // take effect only in WHERE clause, that exists in SELECT, UPDATE, DELETE
	Limit          int         // take effect only in SELECT
	Offset         int         // take effect only in SELECT
	GroupByColumns []string    // take effect only in WHERE clause, that exists in SELECT, UPDATE, DELETE
	OrderByColumns []string    // take effect only in WHERE clause, that exists in SELECT, UPDATE, DELETE

	// INSERT
	InsertOption InsertOption // take effect only in INSERT
}

SimpleStatements is a simple render for simple SQL

func (SimpleStatements) NamedDeleteStatement added in v0.0.20 

func (s SimpleStatements) NamedDeleteStatement(appends ...string) string

NamedDeleteStatement returns a simple sql statement for SQL DELETE statements based on columns. 

query := SimpleStatements{
	TableName: foo,
	Conditions: []string{"thud", "grunt"}
}.NamedUpdateStatement()

// DELETE FROM foo WHERE thud=:thud AND grunt=:grunt

query := SimpleStatements{
	TableName: foo,
	Columns: []string{"foo"}
}.NamedUpdateStatement()

// DELETE FROM foo WHERE TRUE

func (SimpleStatements) NamedInsertStatement added in v0.0.20 

func (s SimpleStatements) NamedInsertStatement(update bool, appends ...string) string

NamedInsertStatement returns a simple sql statement for SQL INSERT statements based on columns. 

statement := SimpleStatements{
	TableName: foo,
	Columns: []string{"foo", "bar"},
	Conditions: []string{"qux"},
}
query := statement.NamedInsertStatement(false)

// INSERT INTO foo (foo, bar, qux) VALUES (:foo, :bar, :qux)

query := statement.NamedInsertStatement(true)

// INSERT INTO foo (foo, bar, qux) VALUES (:foo, :bar, :qux) ON DUPLICATE KEY UPDATE foo=:foo, bar=:bar

statement := SimpleStatements{
	TableName: foo,
}
query := statement.NamedSelectStatement(false)

// INSERT INTO foo DEFAULT VALUES

query := statement.NamedSelectStatement(true)

// INSERT INTO foo DEFAULT VALUES

func (SimpleStatements) NamedSelectStatement added in v0.0.20 

func (s SimpleStatements) NamedSelectStatement(appends ...string) string

NamedSelectStatement returns a simple sql statement for SQL SELECT statements based on columns. 

query := SimpleStatements{
	TableName: foo,
	Columns: []string{"foo", "bar"}
	Conditions: []string{"thud", "grunt"}
}.NamedSelectStatement()

// SELECT foo, bar FROM foo WHERE thud=:thud AND grunt=:grunt

query := SimpleStatements{
	TableName: foo,
}.NamedSelectStatement()

// SELECT * FROM foo WHERE TRUE

func (SimpleStatements) NamedUpdateStatement added in v0.0.20 

func (s SimpleStatements) NamedUpdateStatement(insert bool, appends ...string) string

NamedUpdateStatement returns a simple sql statement for SQL UPDATE statements based on columns. 

	statement := SimpleStatements{
		TableName: foo,
		Columns: []string{"foo", "bar"},
		Conditions: []string{"thud", "grunt"},
		Operator: SqlOperatorAnd,
	}
	query := statement.NamedUpdateStatement(false)

	// UPDATE foo SET foo=:foo, bar=:bar WHERE thud=:thud AND grunt=:grunt

	query := statement.NamedUpdateStatement(true)

	// INSERT INTO foo (foo, bar) VALUES (:foo, :bar) ON DUPLICATE KEY UPDATE foo=:foo, bar=:bar

	statement := SimpleStatements{
		TableName: foo,
		Columns: []string{"foo"},
	}
	query := statement.NamedUpdateStatement(false)

	// UPDATE foo SET foo=:foo WHERE TRUE

	query := statement.NamedUpdateStatement(true)

	// INSERT INTO foo (foo) VALUES (:foo) ON DUPLICATE KEY UPDATE foo=:foo

	statement := SimpleStatements{
		TableName: foo,
	}
	query := statement.NamedUpdateStatement(false)

 // Malformed SQL
	// UPDATE foo SET WHERE TRUE

	query := statement.NamedUpdateStatement(true)

	// INSERT INTO foo DEFAULT VALUES

type SqlCompare added in v0.0.29 

type SqlCompare int
const (
	SqlCompareEqual      SqlCompare = iota //=
	SqlCompareNotEqual   SqlCompare = iota //<>
	SqlCompareGreater    SqlCompare = iota //>
	SqlCompareLessThan   SqlCompare = iota //<
	SqlCompareGreatEqual SqlCompare = iota //>=
	SqlCompareLessEqual  SqlCompare = iota //<=
	SqlCompareLike       SqlCompare = iota //LIKE
)

func ParseSqlCompareString added in v0.0.29 

func ParseSqlCompareString(s string) (SqlCompare, error)

ParseSqlCompareString retrieves an enum value from the enum constants string name. Throws an error if the param is not part of the enum.

func SqlCompareValues added in v0.0.29 

func SqlCompareValues() []SqlCompare

SqlCompareValues returns all values of the enum

func (SqlCompare) MarshalBinary added in v0.0.29 

func (i SqlCompare) MarshalBinary() (data []byte, err error)

MarshalBinary implements the encoding.BinaryMarshaler interface for SqlCompare

func (SqlCompare) MarshalJSON added in v0.0.29 

func (i SqlCompare) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface for SqlCompare

func (SqlCompare) MarshalText added in v0.0.29 

func (i SqlCompare) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface for SqlCompare

func (SqlCompare) MarshalYAML added in v0.0.29 

func (i SqlCompare) MarshalYAML() (interface{}, error)

MarshalYAML implements a YAML Marshaler for SqlCompare

func (SqlCompare) Registered added in v0.0.29 

func (i SqlCompare) Registered() bool

IsASqlCompare returns "true" if the value is listed in the enum definition. "false" otherwise

func (*SqlCompare) Scan added in v0.0.29 

func (i *SqlCompare) Scan(value interface{}) error

func (SqlCompare) String added in v0.0.29 

func (i SqlCompare) String() string

func (*SqlCompare) UnmarshalBinary added in v0.0.29 

func (i *SqlCompare) UnmarshalBinary(data []byte) error

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalJSON added in v0.0.29 

func (i *SqlCompare) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalText added in v0.0.29 

func (i *SqlCompare) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalYAML added in v0.0.29 

func (i *SqlCompare) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML implements a YAML Unmarshaler for SqlCompare

func (SqlCompare) Value added in v0.0.29 

func (i SqlCompare) Value() (driver.Value, error)

type SqlOperator added in v0.0.27 

type SqlOperator int
const (
	SqlOperatorAnd SqlOperator = 0
	SqlOperatorOr  SqlOperator = 1
	SqlOperatorNot SqlOperator = 2
)

func ParseSqlOperatorString added in v0.0.27 

func ParseSqlOperatorString(s string) (SqlOperator, error)

ParseSqlOperatorString retrieves an enum value from the enum constants string name. Throws an error if the param is not part of the enum.

func SqlOperatorValues added in v0.0.27 

func SqlOperatorValues() []SqlOperator

SqlOperatorValues returns all values of the enum

func (SqlOperator) MarshalBinary added in v0.0.27 

func (i SqlOperator) MarshalBinary() (data []byte, err error)

MarshalBinary implements the encoding.BinaryMarshaler interface for SqlOperator

func (SqlOperator) MarshalJSON added in v0.0.27 

func (i SqlOperator) MarshalJSON() ([]byte, error)

MarshalJSON implements the json.Marshaler interface for SqlOperator

func (SqlOperator) MarshalText added in v0.0.27 

func (i SqlOperator) MarshalText() ([]byte, error)

MarshalText implements the encoding.TextMarshaler interface for SqlOperator

func (SqlOperator) MarshalYAML added in v0.0.27 

func (i SqlOperator) MarshalYAML() (interface{}, error)

MarshalYAML implements a YAML Marshaler for SqlOperator

func (SqlOperator) Registered added in v0.0.27 

func (i SqlOperator) Registered() bool

IsASqlOperator returns "true" if the value is listed in the enum definition. "false" otherwise

func (*SqlOperator) Scan added in v0.0.27 

func (i *SqlOperator) Scan(value interface{}) error

func (SqlOperator) String added in v0.0.27 

func (i SqlOperator) String() string

func (*SqlOperator) UnmarshalBinary added in v0.0.27 

func (i *SqlOperator) UnmarshalBinary(data []byte) error

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalJSON added in v0.0.27 

func (i *SqlOperator) UnmarshalJSON(data []byte) error

UnmarshalJSON implements the json.Unmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalText added in v0.0.27 

func (i *SqlOperator) UnmarshalText(text []byte) error

UnmarshalText implements the encoding.TextUnmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalYAML added in v0.0.27 

func (i *SqlOperator) UnmarshalYAML(unmarshal func(interface{}) error) error

UnmarshalYAML implements a YAML Unmarshaler for SqlOperator

func (SqlOperator) Value added in v0.0.27 

func (i SqlOperator) Value() (driver.Value, error)

Source Files

View all Source files

Jump to

Keyboard shortcuts

? : This menu
/ : Search site
f or F : Jump to
y or Y : Canonical URL
go.dev uses cookies from Google to deliver and enhance the quality of its services and to analyze traffic. Learn more.