go-mssqldb: github.com/denisenkom/go-mssqldb Index | Examples | Files | Directories

package mssql

import "github.com/denisenkom/go-mssqldb"

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

Examples

Package Files

buf.go bulkcopy.go bulkcopy_sql.go convert.go decimal.go doc.go error.go log.go mssql.go mssql_go110.go mssql_go19.go net.go ntlm.go parser.go rpc.go tds.go token.go token_string.go tran.go tvp_go19.go types.go uniqueidentifier.go

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")
)

func CopyIn Uses

❖
func CopyIn(table string, options BulkOptions, columns ...string) string

This example shows how to perform bulk imports

Code:

// +build go1.10

package main

import (
    "database/sql"
    "flag"
    "fmt"
    "log"
    "strings"
    "unicode/utf8"

    "github.com/denisenkom/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()
}

func IsSkipField Uses

❖
func IsSkipField(tvpTagValue string, isTvpValue bool, jsonTagValue string, isJsonTagValue bool) bool

func SetLogger Uses

❖
func SetLogger(logger Logger)

type Bulk Uses

❖
type Bulk struct {
    Options BulkOptions
    Debug   bool
    // contains filtered or unexported fields
}

func (*Bulk) AddRow Uses

❖
func (b *Bulk) AddRow(row []interface{}) (err error)

AddRow immediately writes the row to the destination table. The arguments are the row values in the order they were specified.

func (*Bulk) Done Uses

❖
func (b *Bulk) Done() (rowcount int64, err error)

type BulkOptions Uses

❖
type BulkOptions struct {
    CheckConstraints  bool
    FireTriggers      bool
    KeepNulls         bool
    KilobytesPerBatch int
    RowsPerBatch      int
    Order             []string
    Tablock           bool
}

type Conn Uses

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

func (*Conn) Begin Uses

❖
func (c *Conn) Begin() (driver.Tx, error)

func (*Conn) BeginTx Uses

❖
func (c *Conn) BeginTx(ctx context.Context, opts driver.TxOptions) (driver.Tx, error)

BeginTx satisfies ConnBeginTx.

func (*Conn) CheckNamedValue Uses

❖
func (c *Conn) CheckNamedValue(nv *driver.NamedValue) error

func (*Conn) Close Uses

❖
func (c *Conn) Close() error

func (*Conn) Commit Uses

❖
func (c *Conn) Commit() error

func (*Conn) CreateBulk Uses

❖
func (cn *Conn) CreateBulk(table string, columns []string) (_ *Bulk)

func (*Conn) CreateBulkContext Uses

❖
func (cn *Conn) CreateBulkContext(ctx context.Context, table string, columns []string) (_ *Bulk)

func (*Conn) Ping Uses

❖
func (c *Conn) Ping(ctx context.Context) error

Ping is used to check if the remote server is available and satisfies the Pinger interface.

func (*Conn) Prepare Uses

❖
func (c *Conn) Prepare(query string) (driver.Stmt, error)

func (*Conn) PrepareContext Uses

❖
func (c *Conn) PrepareContext(ctx context.Context, query string) (driver.Stmt, error)

func (*Conn) ResetSession Uses

❖
func (c *Conn) ResetSession(ctx context.Context) error

func (*Conn) Rollback Uses

❖
func (c *Conn) Rollback() error

type Connector Uses

❖
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.

This example shows the usage of Connector type

Code:

// +build go1.10

package main

import (
    "context"
    "database/sql"
    "flag"
    "fmt"
    "log"
    "net/url"
    "strconv"

    mssql "github.com/denisenkom/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
    }
}

func NewConnector Uses

❖
func NewConnector(dsn string) (*Connector, error)

NewConnector creates a new connector from a DSN. The returned connector may be used with sql.OpenDB.

func (*Connector) Connect Uses

❖
func (c *Connector) Connect(ctx context.Context) (driver.Conn, error)

Connect to the server and return a TDS connection.

func (*Connector) Driver Uses

❖
func (c *Connector) Driver() driver.Driver

Driver underlying the Connector.

type DataValue Uses

❖
type DataValue interface{}

type DateTime1 Uses

❖
type DateTime1 time.Time

DateTime1 encodes parameters to original DateTime SQL types.

type DateTimeOffset Uses

❖
type DateTimeOffset time.Time

DateTimeOffset encodes parameters to DateTimeOffset, preserving the UTC offset.

This example shows how to insert and retrieve date and time types data

Code:

// +build go1.10

package main

import (
    "database/sql"
    "flag"
    "fmt"
    "log"
    "time"

    "cloud.google.com/go/civil"
    "github.com/denisenkom/go-mssqldb"
)

// 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)
    }
    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))
}

type Decimal Uses

❖
type Decimal struct {
    // contains filtered or unexported fields
}

http://msdn.microsoft.com/en-us/library/ee780893.aspx

func Float64ToDecimal Uses

❖
func Float64ToDecimal(f float64) (Decimal, error)

func Float64ToDecimalScale Uses

❖
func Float64ToDecimalScale(f float64, scale uint8) (Decimal, error)

func (Decimal) BigInt Uses

❖
func (d Decimal) BigInt() big.Int

func (Decimal) Bytes Uses

❖
func (d Decimal) Bytes() []byte

func (Decimal) String Uses

❖
func (d Decimal) String() string

func (Decimal) ToFloat64 Uses

❖
func (d Decimal) ToFloat64() float64

func (Decimal) UnscaledBytes Uses

❖
func (d Decimal) UnscaledBytes() []byte

type Dialer Uses

❖
type Dialer interface {
    DialContext(ctx context.Context, network string, addr string) (net.Conn, error)
}

type Driver Uses

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

func (*Driver) Open Uses

❖
func (d *Driver) Open(dsn string) (driver.Conn, error)

func (*Driver) OpenConnection Uses

❖
func (d *Driver) OpenConnection(dsn string) (*Conn, error)

func (*Driver) OpenConnector Uses

❖
func (d *Driver) OpenConnector(dsn string) (*Connector, error)

OpenConnector opens a new connector. Useful to dial with a context.

func (*Driver) SetLogger Uses

❖
func (d *Driver) SetLogger(logger Logger)

type Error Uses

❖
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.

Code:

// call a function that might return a mssql error
err := callUsingMSSQL()

type ErrorWithNumber interface {
    SQLErrorNumber() int32
}

if errorWithNumber, ok := err.(ErrorWithNumber); ok {
    if errorWithNumber.SQLErrorNumber() == 1205 {
        fmt.Println("deadlock error")
    }
}

Code:

// call a function that might return a mssql error
err := callUsingMSSQL()

type SQLError interface {
    SQLErrorNumber() int32
    SQLErrorMessage() string
}

if sqlError, ok := err.(SQLError); ok {
    if sqlError.SQLErrorNumber() == 1205 {
        fmt.Println("deadlock error", sqlError.SQLErrorMessage())
    }
}

func (Error) Error Uses

❖
func (e Error) Error() string

func (Error) SQLErrorClass Uses

❖
func (e Error) SQLErrorClass() uint8

func (Error) SQLErrorLineNo Uses

❖
func (e Error) SQLErrorLineNo() int32

func (Error) SQLErrorMessage Uses

❖
func (e Error) SQLErrorMessage() string

func (Error) SQLErrorNumber Uses

❖
func (e Error) SQLErrorNumber() int32

SQLErrorNumber returns the SQL Server error number.

func (Error) SQLErrorProcName Uses

❖
func (e Error) SQLErrorProcName() string

func (Error) SQLErrorServerName Uses

❖
func (e Error) SQLErrorServerName() string

func (Error) SQLErrorState Uses

❖
func (e Error) SQLErrorState() uint8

type Logger Uses

❖
type Logger interface {
    Printf(format string, v ...interface{})
    Println(v ...interface{})
}

type MssqlBulk Uses

❖
type MssqlBulk = Bulk // Deprecated: users should transition to the new name when possible.

type MssqlBulkOptions Uses

❖
type MssqlBulkOptions = BulkOptions // Deprecated: users should transition to the new name when possible.

type MssqlConn Uses

❖
type MssqlConn = Conn // Deprecated: users should transition to the new name when possible.

type MssqlDriver Uses

❖
type MssqlDriver = Driver // Deprecated: users should transition to the new name when possible.

type MssqlResult Uses

❖
type MssqlResult = Result // Deprecated: users should transition to the new name when possible.

type MssqlRows Uses

❖
type MssqlRows = Rows // Deprecated: users should transition to the new name when possible.

type MssqlStmt Uses

❖
type MssqlStmt = Stmt // Deprecated: users should transition to the new name when possible.

type NVarCharMax Uses

❖
type NVarCharMax string

type Result Uses

❖
type Result struct {
    // contains filtered or unexported fields
}

func (*Result) LastInsertId Uses

❖
func (r *Result) LastInsertId() (int64, error)

func (*Result) RowsAffected Uses

❖
func (r *Result) RowsAffected() (int64, error)

type ReturnStatus Uses

❖
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 Uses

❖
type Rows struct {
    // contains filtered or unexported fields
}

func (*Rows) Close Uses

❖
func (rc *Rows) Close() error

func (*Rows) ColumnTypeDatabaseTypeName Uses

❖
func (r *Rows) ColumnTypeDatabaseTypeName(index int) string

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 Uses

❖
func (r *Rows) ColumnTypeLength(index int) (int64, bool)

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 Uses

❖
func (r *Rows) ColumnTypeNullable(index int) (nullable, ok bool)

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 Uses

❖
func (r *Rows) ColumnTypePrecisionScale(index int) (int64, int64, bool)

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 Uses

❖
func (r *Rows) ColumnTypeScanType(index int) reflect.Type

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) Columns Uses

❖
func (rc *Rows) Columns() (res []string)

func (*Rows) HasNextResultSet Uses

❖
func (rc *Rows) HasNextResultSet() bool

func (*Rows) Next Uses

❖
func (rc *Rows) Next(dest []driver.Value) error

func (*Rows) NextResultSet Uses

❖
func (rc *Rows) NextResultSet() error

type Stmt Uses

❖
type Stmt struct {
    // contains filtered or unexported fields
}

func (*Stmt) Close Uses

❖
func (s *Stmt) Close() error

func (*Stmt) Exec Uses

❖
func (s *Stmt) Exec(args []driver.Value) (driver.Result, error)

func (*Stmt) ExecContext Uses

❖
func (s *Stmt) ExecContext(ctx context.Context, args []driver.NamedValue) (driver.Result, error)

func (*Stmt) NumInput Uses

❖
func (s *Stmt) NumInput() int

func (*Stmt) Query Uses

❖
func (s *Stmt) Query(args []driver.Value) (driver.Rows, error)

func (*Stmt) QueryContext Uses

❖
func (s *Stmt) QueryContext(ctx context.Context, args []driver.NamedValue) (driver.Rows, error)

func (*Stmt) SetQueryNotification Uses

❖
func (s *Stmt) SetQueryNotification(id, options string, timeout time.Duration)

type StreamError Uses

❖
type StreamError struct {
    Message string
}

func (StreamError) Error Uses

❖
func (e StreamError) Error() string

type TVP Uses

❖
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

type UniqueIdentifier Uses

❖
type UniqueIdentifier [16]byte

func (*UniqueIdentifier) Scan Uses

❖
func (u *UniqueIdentifier) Scan(v interface{}) error

func (UniqueIdentifier) String Uses

❖
func (u UniqueIdentifier) String() string

func (UniqueIdentifier) Value Uses

❖
func (u UniqueIdentifier) Value() (driver.Value, error)

type VarChar Uses

❖
type VarChar string

VarChar parameter types.

type VarCharMax Uses

❖
type VarCharMax string

Directories

PathSynopsis
batchbach splits a single script containing multiple batches separated by a keyword into multiple scripts.
internal/cp

Package mssql imports 33 packages (graph) and is imported by 293 packages. Updated 2019-04-24. Refresh now. Tools for package owners.