Documentation ¶
Overview ¶
package mssql implements the TDS protocol used to connect to MS SQL Server (sqlserver) database servers.
This package registers the driver:
sqlserver: uses native "@" parameter placeholder names and does no pre-processing.
If the ordinal position is used for query parameters, identifiers will be named "@p1", "@p2", ... "@pN".
Please refer to the README for the format of the DSN. There are multiple DSN formats accepted: ADO style, ODBC style, and URL style. The following is an example of a URL style DSN:
sqlserver://sa:mypass@localhost:1234?database=master&connection+timeout=30
Index ¶
- Variables
- func CopyIn(table string, options BulkOptions, columns ...string) string
- func IsSkipField(tvpTagValue string, isTvpValue bool, jsonTagValue string, isJsonTagValue bool) bool
- func NewAccessTokenConnector(dsn string, tokenProvider func() (string, error)) (driver.Connector, error)
- func SetLogger(logger Logger)
- type Bulk
- type BulkOptions
- type Conn
- func (c *Conn) Begin() (driver.Tx, error)
- func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)
- func (c *Conn) CheckNamedValue(nv *driver.NamedValue) error
- func (c *Conn) Close() error
- func (c *Conn) Commit() error
- func (cn *Conn) CreateBulk(table string, columns []string) (_ *Bulk)
- func (cn *Conn) CreateBulkContext(ctx context.Context, table string, columns []string) (_ *Bulk)
- func (c *Conn) Ping(ctx context.Context) error
- func (c *Conn) Prepare(query string) (driver.Stmt, error)
- func (c *Conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)
- func (c *Conn) ResetSession(ctx context.Context) error
- func (c *Conn) Rollback() error
- type Connector
- type DataValue
- type DateTime1
- type DateTimeOffset
- type Dialer
- type Driver
- type Error
- func (e Error) Error() string
- func (e Error) SQLErrorClass() uint8
- func (e Error) SQLErrorLineNo() int32
- func (e Error) SQLErrorMessage() string
- func (e Error) SQLErrorNumber() int32
- func (e Error) SQLErrorProcName() string
- func (e Error) SQLErrorServerName() string
- func (e Error) SQLErrorState() uint8
- type Logger
- type MssqlBulk
- type MssqlBulkOptions
- type MssqlConn
- type MssqlDriver
- type MssqlResult
- type MssqlRows
- type MssqlStmt
- type NVarCharMax
- type Result
- type ReturnStatus
- type Rows
- func (rc *Rows) Close() error
- func (r *Rows) ColumnTypeDatabaseTypeName(index int) string
- func (r *Rows) ColumnTypeLength(index int) (int64, bool)
- func (r *Rows) ColumnTypeNullable(index int) (nullable, ok bool)
- func (r *Rows) ColumnTypePrecisionScale(index int) (int64, int64, bool)
- func (r *Rows) ColumnTypeScanType(index int) reflect.Type
- func (rc *Rows) Columns() (res []string)
- func (rc *Rows) HasNextResultSet() bool
- func (rc *Rows) Next(dest []driver.Value) error
- func (rc *Rows) NextResultSet() error
- type Stmt
- func (s *Stmt) Close() error
- func (s *Stmt) Exec(args []driver.Value) (driver.Result, error)
- func (s *Stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error)
- func (s *Stmt) NumInput() int
- func (s *Stmt) Query(args []driver.Value) (driver.Rows, error)
- func (s *Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)
- func (s *Stmt) SetQueryNotification(id, options string, timeout time.Duration)
- type StreamError
- type TVP
- type UniqueIdentifier
- type VarChar
- type VarCharMax
Examples ¶
Constants ¶
This section is empty.
Variables ¶
var ( ErrorEmptyTVPTypeName = errors.New("TypeName must not be empty") ErrorTypeSlice = errors.New("TVP must be slice type") ErrorTypeSliceIsEmpty = errors.New("TVP mustn't be null value") ErrorSkip = errors.New("all fields mustn't skip") ErrorObjectName = errors.New("wrong tvp name") ErrorWrongTyping = errors.New("the number of elements in columnStr and tvpFieldIndexes do not align") )
Functions ¶
func CopyIn ¶
func CopyIn(table string, options BulkOptions, columns ...string) string
Example ¶
This example shows how to perform bulk imports
//go:build go1.10 // +build go1.10 package main import ( "database/sql" "flag" "fmt" "log" "strings" "unicode/utf8" "github.com/ArsenyVasilev/go-mssqldb" ) const ( createTestTable = `CREATE TABLE test_table( id int IDENTITY(1,1) NOT NULL, test_nvarchar nvarchar(50) NULL, test_varchar varchar(50) NULL, test_float float NULL, test_datetime2_3 datetime2(3) NULL, test_bitn bit NULL, test_bigint bigint NOT NULL, test_geom geometry NULL, CONSTRAINT PK_table_test_id PRIMARY KEY CLUSTERED ( id ASC ) ON [PRIMARY]);` dropTestTable = "IF OBJECT_ID('test_table', 'U') IS NOT NULL DROP TABLE test_table;" ) // This example shows how to perform bulk imports func main() { flag.Parse() if *debug { fmt.Printf(" password:%s\n", *password) fmt.Printf(" port:%d\n", *port) fmt.Printf(" server:%s\n", *server) fmt.Printf(" user:%s\n", *user) } connString := makeConnURL().String() if *debug { fmt.Printf(" connString:%s\n", connString) } db, err := sql.Open("sqlserver", connString) if err != nil { log.Fatal("Open connection failed:", err.Error()) } defer db.Close() txn, err := db.Begin() if err != nil { log.Fatal(err) } // Create table _, err = db.Exec(createTestTable) if err != nil { log.Fatal(err) } defer db.Exec(dropTestTable) // mssqldb.CopyIn creates string to be consumed by Prepare stmt, err := txn.Prepare(mssql.CopyIn("test_table", mssql.BulkOptions{}, "test_varchar", "test_nvarchar", "test_float", "test_bigint")) if err != nil { log.Fatal(err.Error()) } for i := 0; i < 10; i++ { _, err = stmt.Exec(generateString(0, 30), generateStringUnicode(0, 30), i, i) if err != nil { log.Fatal(err.Error()) } } result, err := stmt.Exec() if err != nil { log.Fatal(err) } err = stmt.Close() if err != nil { log.Fatal(err) } err = txn.Commit() if err != nil { log.Fatal(err) } rowCount, _ := result.RowsAffected() log.Printf("%d row copied\n", rowCount) log.Printf("bye\n") } func generateString(x int, n int) string { letters := "abcdefghijklmnopqrstuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ" b := make([]byte, n) for i := range b { b[i] = letters[(x+i)%len(letters)] } return string(b) } func generateStringUnicode(x int, n int) string { letters := []byte("ab©💾é?ghïjklmnopqЯ☀tuvwxyzABCDEFGHIJKLMNOPQRSTUVWXYZ") b := &strings.Builder{} for i := 0; i < n; i++ { r, sz := utf8.DecodeRune(letters[x%len(letters):]) x += sz b.WriteRune(r) } return b.String() }
Output:
func IsSkipField ¶
func NewAccessTokenConnector ¶
func NewAccessTokenConnector(dsn string, tokenProvider func() (string, error)) (driver.Connector, error)
NewAccessTokenConnector creates a new connector from a DSN and a token provider. The token provider func will be called when a new connection is requested and should return a valid access token. The returned connector may be used with sql.OpenDB.
Types ¶
type Bulk ¶
type Bulk struct { Options BulkOptions Debug bool // contains filtered or unexported fields }
type BulkOptions ¶
type Conn ¶
type Conn struct {
// contains filtered or unexported fields
}
func (*Conn) CheckNamedValue ¶
func (c *Conn) CheckNamedValue(nv *driver.NamedValue) error
func (*Conn) CreateBulkContext ¶
func (*Conn) Ping ¶
Ping is used to check if the remote server is available and satisfies the Pinger interface.
func (*Conn) PrepareContext ¶
type Connector ¶
type Connector struct { // SessionInitSQL is executed after marking a given session to be reset. // When not present, the next query will still reset the session to the // database defaults. // // When present the connection will immediately mark the session to // be reset, then execute the SessionInitSQL text to setup the session // that may be different from the base database defaults. // // For Example, the application relies on the following defaults // but is not allowed to set them at the database system level. // // SET XACT_ABORT ON; // SET TEXTSIZE -1; // SET ANSI_NULLS ON; // SET LOCK_TIMEOUT 10000; // // SessionInitSQL should not attempt to manually call sp_reset_connection. // This will happen at the TDS layer. // // SessionInitSQL is optional. The session will be reset even if // SessionInitSQL is empty. SessionInitSQL string // Dialer sets a custom dialer for all network operations. // If Dialer is not set, normal net dialers are used. Dialer Dialer // contains filtered or unexported fields }
Connector holds the parsed DSN and is ready to make a new connection at any time.
In the future, settings that cannot be passed through a string DSN may be set directly on the connector.
Example ¶
This example shows the usage of Connector type
//go:build go1.10 // +build go1.10 package main import ( "context" "database/sql" "flag" "fmt" "log" "net/url" "strconv" mssql "github.com/ArsenyVasilev/go-mssqldb" ) var ( debug = flag.Bool("debug", false, "enable debugging") password = flag.String("password", "", "the database password") port *int = flag.Int("port", 1433, "the database port") server = flag.String("server", "", "the database server") user = flag.String("user", "", "the database user") ) const ( createTableSql = "CREATE TABLE TestAnsiNull (bitcol bit, charcol char(1));" dropTableSql = "IF OBJECT_ID('TestAnsiNull', 'U') IS NOT NULL DROP TABLE TestAnsiNull;" insertQuery1 = "INSERT INTO TestAnsiNull VALUES (0, NULL);" insertQuery2 = "INSERT INTO TestAnsiNull VALUES (1, 'a');" selectNullFilter = "SELECT bitcol FROM TestAnsiNull WHERE charcol = NULL;" selectNotNullFilter = "SELECT bitcol FROM TestAnsiNull WHERE charcol <> NULL;" ) func makeConnURL() *url.URL { return &url.URL{ Scheme: "sqlserver", Host: *server + ":" + strconv.Itoa(*port), User: url.UserPassword(*user, *password), } } // This example shows the usage of Connector type func main() { flag.Parse() if *debug { fmt.Printf(" password:%s\n", *password) fmt.Printf(" port:%d\n", *port) fmt.Printf(" server:%s\n", *server) fmt.Printf(" user:%s\n", *user) } connString := makeConnURL().String() if *debug { fmt.Printf(" connString:%s\n", connString) } // Create a new connector object by calling NewConnector connector, err := mssql.NewConnector(connString) if err != nil { log.Println(err) return } // Use SessionInitSql to set any options that cannot be set with the dsn string // With ANSI_NULLS set to ON, compare NULL data with = NULL or <> NULL will return 0 rows connector.SessionInitSQL = "SET ANSI_NULLS ON" // Pass connector to sql.OpenDB to get a sql.DB object db := sql.OpenDB(connector) defer db.Close() // Create and populate table _, err = db.Exec(createTableSql) if err != nil { log.Println(err) return } defer db.Exec(dropTableSql) _, err = db.Exec(insertQuery1) if err != nil { log.Println(err) return } _, err = db.Exec(insertQuery2) if err != nil { log.Println(err) return } var bitval bool ctx, cancel := context.WithCancel(context.Background()) defer cancel() // (*Row) Scan should return ErrNoRows since ANSI_NULLS is set to ON err = db.QueryRowContext(ctx, selectNullFilter).Scan(&bitval) if err != nil { if err.Error() != "sql: no rows in result set" { log.Println(err) return } } else { log.Println("Expects an ErrNoRows error. No error is returned") return } // (*Row) Scan should return ErrNoRows since ANSI_NULLS is set to ON err = db.QueryRowContext(ctx, selectNotNullFilter).Scan(&bitval) if err != nil { if err.Error() != "sql: no rows in result set" { log.Println(err) return } } else { log.Println("Expects an ErrNoRows error. No error is returned") return } // Set ANSI_NULLS to OFF connector.SessionInitSQL = "SET ANSI_NULLS OFF" // (*Row) Scan should copy data to bitval err = db.QueryRowContext(ctx, selectNullFilter).Scan(&bitval) if err != nil { log.Println(err) return } if bitval != false { log.Println("Incorrect value retrieved.") return } // (*Row) Scan should copy data to bitval err = db.QueryRowContext(ctx, selectNotNullFilter).Scan(&bitval) if err != nil { log.Println(err) return } if bitval != true { log.Println("Incorrect value retrieved.") return } }
Output:
func NewConnector ¶
NewConnector creates a new connector from a DSN. The returned connector may be used with sql.OpenDB.
type DateTimeOffset ¶
DateTimeOffset encodes parameters to DateTimeOffset, preserving the UTC offset.
Example ¶
This example shows how to insert and retrieve date and time types data
//go:build go1.10 // +build go1.10 package main import ( "database/sql" "flag" "fmt" "log" "time" mssql "github.com/ArsenyVasilev/go-mssqldb" "github.com/golang-sql/civil" ) // This example shows how to insert and retrieve date and time types data func main() { flag.Parse() if *debug { fmt.Printf(" password:%s\n", *password) fmt.Printf(" port:%d\n", *port) fmt.Printf(" server:%s\n", *server) fmt.Printf(" user:%s\n", *user) } connString := makeConnURL().String() if *debug { fmt.Printf(" connString:%s\n", connString) } db, err := sql.Open("sqlserver", connString) if err != nil { log.Fatal("Open connection failed:", err.Error()) } defer db.Close() insertDateTime(db) retrieveDateTime(db) retrieveDateTimeOutParam(db) } func insertDateTime(db *sql.DB) { _, err := db.Exec("CREATE TABLE datetimeTable (timeCol TIME, dateCol DATE, smalldatetimeCol SMALLDATETIME, datetimeCol DATETIME, datetime2Col DATETIME2, datetimeoffsetCol DATETIMEOFFSET)") if err != nil { log.Fatal(err) } stmt, err := db.Prepare("INSERT INTO datetimeTable VALUES(@p1, @p2, @p3, @p4, @p5, @p6)") if err != nil { log.Fatal(err) } defer stmt.Close() tin, err := time.Parse(time.RFC3339, "2006-01-02T22:04:05.787-07:00") if err != nil { log.Fatal(err) } var timeCol civil.Time = civil.TimeOf(tin) var dateCol civil.Date = civil.DateOf(tin) var smalldatetimeCol string = "2006-01-02 22:04:00" var datetimeCol mssql.DateTime1 = mssql.DateTime1(tin) var datetime2Col civil.DateTime = civil.DateTimeOf(tin) var datetimeoffsetCol mssql.DateTimeOffset = mssql.DateTimeOffset(tin) _, err = stmt.Exec(timeCol, dateCol, smalldatetimeCol, datetimeCol, datetime2Col, datetimeoffsetCol) if err != nil { log.Fatal(err) } } func retrieveDateTime(db *sql.DB) { rows, err := db.Query("SELECT timeCol, dateCol, smalldatetimeCol, datetimeCol, datetime2Col, datetimeoffsetCol FROM datetimeTable") if err != nil { log.Fatal(err) } defer rows.Close() var c1, c2, c3, c4, c5, c6 time.Time for rows.Next() { err = rows.Scan(&c1, &c2, &c3, &c4, &c5, &c6) if err != nil { log.Fatal(err) } fmt.Printf("c1: %+v; c2: %+v; c3: %+v; c4: %+v; c5: %+v; c6: %+v;\n", c1, c2, c3, c4, c5, c6) } } func retrieveDateTimeOutParam(db *sql.DB) { CreateProcSql := ` CREATE PROCEDURE OutDatetimeProc @timeOutParam TIME OUTPUT, @dateOutParam DATE OUTPUT, @smalldatetimeOutParam SMALLDATETIME OUTPUT, @datetimeOutParam DATETIME OUTPUT, @datetime2OutParam DATETIME2 OUTPUT, @datetimeoffsetOutParam DATETIMEOFFSET OUTPUT AS SET NOCOUNT ON SET @timeOutParam = '22:04:05.7870015' SET @dateOutParam = '2006-01-02' SET @smalldatetimeOutParam = '2006-01-02 22:04:00' SET @datetimeOutParam = '2006-01-02 22:04:05.787' SET @datetime2OutParam = '2006-01-02 22:04:05.7870015' SET @datetimeoffsetOutParam = '2006-01-02 22:04:05.7870015 -07:00'` _, err := db.Exec(CreateProcSql) if err != nil { log.Fatal(err) } var ( timeOutParam, datetime2OutParam, datetimeoffsetOutParam mssql.DateTimeOffset dateOutParam, datetimeOutParam mssql.DateTime1 smalldatetimeOutParam string ) _, err = db.Exec("OutDatetimeProc", sql.Named("timeOutParam", sql.Out{Dest: &timeOutParam}), sql.Named("dateOutParam", sql.Out{Dest: &dateOutParam}), sql.Named("smalldatetimeOutParam", sql.Out{Dest: &smalldatetimeOutParam}), sql.Named("datetimeOutParam", sql.Out{Dest: &datetimeOutParam}), sql.Named("datetime2OutParam", sql.Out{Dest: &datetime2OutParam}), sql.Named("datetimeoffsetOutParam", sql.Out{Dest: &datetimeoffsetOutParam})) if err != nil { log.Fatal(err) } fmt.Printf("timeOutParam: %+v; dateOutParam: %+v; smalldatetimeOutParam: %s; datetimeOutParam: %+v; datetime2OutParam: %+v; datetimeoffsetOutParam: %+v;\n", time.Time(timeOutParam), time.Time(dateOutParam), smalldatetimeOutParam, time.Time(datetimeOutParam), time.Time(datetime2OutParam), time.Time(datetimeoffsetOutParam)) }
Output:
type Driver ¶
type Driver struct {
// contains filtered or unexported fields
}
func (*Driver) OpenConnector ¶
OpenConnector opens a new connector. Useful to dial with a context.
type Error ¶
type Error struct { Number int32 State uint8 Class uint8 Message string ServerName string ProcName string LineNo int32 }
Error represents an SQL Server error. This type includes methods for reading the contents of the struct, which allows calling programs to check for specific error conditions without having to import this package directly.
func (Error) SQLErrorClass ¶
func (Error) SQLErrorLineNo ¶
func (Error) SQLErrorMessage ¶
func (Error) SQLErrorNumber ¶
SQLErrorNumber returns the SQL Server error number.
func (Error) SQLErrorProcName ¶
func (Error) SQLErrorServerName ¶
func (Error) SQLErrorState ¶
type Logger ¶
type Logger interface { Printf(format string, v ...interface{}) Println(v ...interface{}) }
type MssqlBulk ¶
type MssqlBulk = Bulk // Deprecated: users should transition to the new name when possible.
type MssqlBulkOptions ¶
type MssqlBulkOptions = BulkOptions // Deprecated: users should transition to the new name when possible.
type MssqlConn ¶
type MssqlConn = Conn // Deprecated: users should transition to the new name when possible.
type MssqlDriver ¶
type MssqlDriver = Driver // Deprecated: users should transition to the new name when possible.
type MssqlResult ¶
type MssqlResult = Result // Deprecated: users should transition to the new name when possible.
type MssqlRows ¶
type MssqlRows = Rows // Deprecated: users should transition to the new name when possible.
type MssqlStmt ¶
type MssqlStmt = Stmt // Deprecated: users should transition to the new name when possible.
type NVarCharMax ¶
type NVarCharMax string
type Result ¶
type Result struct {
// contains filtered or unexported fields
}
func (*Result) LastInsertId ¶
func (*Result) RowsAffected ¶
type ReturnStatus ¶
type ReturnStatus int32
ReturnStatus may be used to return the return value from a proc.
var rs mssql.ReturnStatus _, err := db.Exec("theproc", &rs) log.Printf("return status = %d", rs)
type Rows ¶
type Rows struct {
// contains filtered or unexported fields
}
func (*Rows) ColumnTypeDatabaseTypeName ¶
RowsColumnTypeDatabaseTypeName may be implemented by Rows. It should return the database system type name without the length. Type names should be uppercase. Examples of returned types: "VARCHAR", "NVARCHAR", "VARCHAR2", "CHAR", "TEXT", "DECIMAL", "SMALLINT", "INT", "BIGINT", "BOOL", "[]BIGINT", "JSONB", "XML", "TIMESTAMP".
func (*Rows) ColumnTypeLength ¶
RowsColumnTypeLength may be implemented by Rows. It should return the length of the column type if the column is a variable length type. If the column is not a variable length type ok should return false. If length is not limited other than system limits, it should return math.MaxInt64. The following are examples of returned values for various types:
TEXT (math.MaxInt64, true) varchar(10) (10, true) nvarchar(10) (10, true) decimal (0, false) int (0, false) bytea(30) (30, true)
func (*Rows) ColumnTypeNullable ¶
The nullable value should be true if it is known the column may be null, or false if the column is known to be not nullable. If the column nullability is unknown, ok should be false.
func (*Rows) ColumnTypePrecisionScale ¶
It should return the precision and scale for decimal types. If not applicable, ok should be false. The following are examples of returned values for various types:
decimal(38, 4) (38, 4, true) int (0, 0, false) decimal (math.MaxInt64, math.MaxInt64, true)
func (*Rows) ColumnTypeScanType ¶
It should return the value type that can be used to scan types into. For example, the database column type "bigint" this should return "reflect.TypeOf(int64(0))".
func (*Rows) HasNextResultSet ¶
func (*Rows) NextResultSet ¶
type Stmt ¶
type Stmt struct {
// contains filtered or unexported fields
}
func (*Stmt) ExecContext ¶
func (*Stmt) QueryContext ¶
type StreamError ¶
type StreamError struct {
Message string
}
func (StreamError) Error ¶
func (e StreamError) Error() string
type TVP ¶
type TVP struct { //TypeName mustn't be default value TypeName string //Value must be the slice, mustn't be nil Value interface{} }
TVP is driver type, which allows supporting Table Valued Parameters (TVP) in SQL Server
Example ¶
This example shows how to use tvp type
const ( createTable = "CREATE TABLE Location (Name VARCHAR(50), CostRate INT, Availability BIT, ModifiedDate DATETIME2)" createTVP = `CREATE TYPE LocationTableType AS TABLE (LocationName VARCHAR(50), CostRate INT)` dropTVP = "IF type_id('LocationTableType') IS NOT NULL DROP TYPE LocationTableType" createProc = `CREATE PROCEDURE dbo.usp_InsertProductionLocation @TVP LocationTableType READONLY AS SET NOCOUNT ON INSERT INTO Location ( Name, CostRate, Availability, ModifiedDate) SELECT *, 0,GETDATE() FROM @TVP` dropProc = "IF OBJECT_ID('dbo.usp_InsertProductionLocation', 'P') IS NOT NULL DROP PROCEDURE dbo.usp_InsertProductionLocation" execTvp = "exec dbo.usp_InsertProductionLocation @TVP;" ) type LocationTableTvp struct { LocationName string LocationCountry string `tvp:"-"` CostRate int64 Currency string `json:"-"` } flag.Parse() if *debug { fmt.Printf(" password:%s\n", *password) fmt.Printf(" port:%d\n", *port) fmt.Printf(" server:%s\n", *server) fmt.Printf(" user:%s\n", *user) } connString := makeConnURL().String() if *debug { fmt.Printf(" connString:%s\n", connString) } db, err := sql.Open("sqlserver", connString) if err != nil { log.Fatal("Open connection failed:", err.Error()) } defer db.Close() _, err = db.Exec(createTable) if err != nil { log.Fatal(err) } _, err = db.Exec(createTVP) if err != nil { log.Fatal(err) } defer db.Exec(dropTVP) _, err = db.Exec(createProc) if err != nil { log.Fatal(err) } defer db.Exec(dropProc) locationTableTypeData := []LocationTableTvp{ { LocationName: "Alberta", LocationCountry: "Canada", CostRate: 0, Currency: "CAD", }, { LocationName: "British Columbia", LocationCountry: "Canada", CostRate: 1, Currency: "CAD", }, } tvpType := mssql.TVP{ TypeName: "LocationTableType", Value: locationTableTypeData, } _, err = db.Exec(execTvp, sql.Named("TVP", tvpType)) if err != nil { log.Fatal(err) } else { for _, locationData := range locationTableTypeData { fmt.Printf("Data for location %s, %s has been inserted.\n", locationData.LocationName, locationData.LocationCountry) } }
Output:
type UniqueIdentifier ¶
type UniqueIdentifier [16]byte
func (UniqueIdentifier) MarshalText ¶
func (u UniqueIdentifier) MarshalText() []byte
MarshalText converts Uniqueidentifier to bytes corresponding to the stringified hexadecimal representation of the Uniqueidentifier e.g., "AAAAAAAA-AAAA-AAAA-AAAA-AAAAAAAAAAAA" -> [65 65 65 65 65 65 65 65 45 65 65 65 65 45 65 65 65 65 45 65 65 65 65 65 65 65 65 65 65 65 65]
func (*UniqueIdentifier) Scan ¶
func (u *UniqueIdentifier) Scan(v interface{}) error
func (UniqueIdentifier) String ¶
func (u UniqueIdentifier) String() string
type VarCharMax ¶
type VarCharMax string
Source Files ¶
Directories ¶
Path | Synopsis |
---|---|
bach splits a single script containing multiple batches separated by a keyword into multiple scripts.
|
bach splits a single script containing multiple batches separated by a keyword into multiple scripts. |
examples
|
|
internal
|
|
querytext
Package querytext is the old query parser and parameter substitute process.
|
Package querytext is the old query parser and parameter substitute process. |