sqlx

package module
v1.2.120 Latest Latest
Warning

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

 Go to latest Published: Oct 12, 2024 License: MIT Imports: 8 Imported by: 1

Documentation

Index

Constants

This section is empty.

Variables

This section is empty.

Functions

func ExpandAsColumns 

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

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

func JoinColumns 

func JoinColumns(cols ...string) string

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

func JoinColumnsWithAs 

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 

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 

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 

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 

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

func JoinNamedTableCondition 

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 

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 

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 

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 

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 

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 

func JoinTableValues(cols ...string) string

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

func NamedColumns 

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

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

func NamedColumnsValues 

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 deprecated 

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 

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 

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 

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 

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 

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 deprecated 

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 

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 

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 

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 

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 

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 

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 

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

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

func NamedWhereArguments 

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 

func Pagination(limit, offset int) string

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

func ShrinkEmptyColumns 

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

ShrinkEmptyColumns trim empty columns

func SqlCompareSliceContains 

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

SqlCompareSliceContains reports whether sunEnums is within enums.

func SqlCompareSliceContainsAny 

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

SqlCompareSliceContainsAny reports whether any sunEnum is within enums.

func SqlOperatorSliceContains 

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

SqlOperatorSliceContains reports whether sunEnums is within enums.

func SqlOperatorSliceContainsAny 

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

SqlOperatorSliceContainsAny reports whether any sunEnum is within enums.

func TableColumns 

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 

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 deprecated 

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 

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 

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 

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 

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

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

func TableWhereArguments 

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 

type InsertOption int
const (
	// InsertOptionInsert inserts new rows into an existing table.
	InsertOptionInsert InsertOption = iota
	// InsertOptionReplace 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
	// InsertOptionUpdate 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
	// InsertOptionIgnore If you use the IGNORE modifier, ignorable errors that occur while executing the INSERT statement
	// are ignored.
	InsertOptionIgnore InsertOption = iota
	// InsertOptionDelayed deprecated in MySQL 5.6. In MySQL 8.0, DELAYED is not supported
	// Deprecated: Use InsertOptionInsert instead.
	InsertOptionDelayed InsertOption = iota
)

type SimpleStatements 

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 

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 

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 

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 

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 

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 

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 

func SqlCompareValues() []SqlCompare

SqlCompareValues returns all values of the enum

func (SqlCompare) MarshalBinary 

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

MarshalBinary implements the encoding.BinaryMarshaler interface for SqlCompare

func (SqlCompare) MarshalJSON 

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

MarshalJSON implements the json.Marshaler interface for SqlCompare

func (SqlCompare) MarshalText 

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

MarshalText implements the encoding.TextMarshaler interface for SqlCompare

func (SqlCompare) MarshalYAML 

func (i SqlCompare) MarshalYAML() (any, error)

MarshalYAML implements a YAML Marshaler for SqlCompare

func (SqlCompare) Registered 

func (i SqlCompare) Registered() bool

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

func (*SqlCompare) Scan 

func (i *SqlCompare) Scan(value any) error

func (SqlCompare) String 

func (i SqlCompare) String() string

func (*SqlCompare) UnmarshalBinary 

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

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalText 

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

UnmarshalText implements the encoding.TextUnmarshaler interface for SqlCompare

func (*SqlCompare) UnmarshalYAML 

func (i *SqlCompare) UnmarshalYAML(unmarshal func(any) error) error

UnmarshalYAML implements a YAML Unmarshaler for SqlCompare

func (SqlCompare) Value 

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

type SqlOperator 

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

func ParseSqlOperatorString 

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 

func SqlOperatorValues() []SqlOperator

SqlOperatorValues returns all values of the enum

func (SqlOperator) MarshalBinary 

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

MarshalBinary implements the encoding.BinaryMarshaler interface for SqlOperator

func (SqlOperator) MarshalJSON 

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

MarshalJSON implements the json.Marshaler interface for SqlOperator

func (SqlOperator) MarshalText 

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

MarshalText implements the encoding.TextMarshaler interface for SqlOperator

func (SqlOperator) MarshalYAML 

func (i SqlOperator) MarshalYAML() (any, error)

MarshalYAML implements a YAML Marshaler for SqlOperator

func (SqlOperator) Registered 

func (i SqlOperator) Registered() bool

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

func (*SqlOperator) Scan 

func (i *SqlOperator) Scan(value any) error

func (SqlOperator) String 

func (i SqlOperator) String() string

func (*SqlOperator) UnmarshalBinary 

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

UnmarshalBinary implements the encoding.BinaryUnmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalJSON 

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

UnmarshalJSON implements the json.Unmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalText 

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

UnmarshalText implements the encoding.TextUnmarshaler interface for SqlOperator

func (*SqlOperator) UnmarshalYAML 

func (i *SqlOperator) UnmarshalYAML(unmarshal func(any) error) error

UnmarshalYAML implements a YAML Unmarshaler for SqlOperator

func (SqlOperator) Value 

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.