driver

package main

import (
	"context"
	"database/sql"
	"log"

	// Register hdb driver.
	_ "github.com/SAP/go-hdb/driver"
)

const (
	driverName = "hdb"
	hdbDsn     = "hdb://user:password@host:port"
)

func main() {
	db, err := sql.Open(driverName, hdbDsn)
	if err != nil {
		log.Fatal(err)
	}
	defer db.Close()

	if err := db.PingContext(context.Background()); err != nil {
		log.Fatal(err)
	}
}

Output:

ExampleBulkInsert inserts 2000 rows into a database table:

1000 rows are inserted via an extended argument list and
1000 rows are inserted with the help of an argument function

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"

	"github.com/SAP/go-hdb/driver"
)

func main() {
	const numRow = 1000 // Number of rows to be inserted into table.

	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableName := driver.RandomIdentifier("table_")

	// Create table.
	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create table %s (i integer, f double)", tableName)); err != nil {
		log.Fatal(err)
	}

	// Prepare statement.
	stmt, err := db.PrepareContext(ctx, fmt.Sprintf("insert into %s values (?, ?)", tableName))
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	// Bulk insert via 'extended' argument list.
	args := make([]any, numRow*2)
	for i := range numRow {
		args[i*2], args[i*2+1] = i, float64(i)
	}
	if _, err := stmt.ExecContext(ctx, args...); err != nil {
		log.Fatal(err)
	}

	// Bulk insert via function.
	i := 0
	if _, err := stmt.ExecContext(ctx, func(args []any) error {
		if i >= numRow {
			return driver.ErrEndOfRows
		}
		args[0], args[1] = i, float64(i)
		i++
		return nil
	}); err != nil {
		log.Fatal(err)
	}

	// Select number of inserted rows.
	var count int
	if err := db.QueryRowContext(ctx, fmt.Sprintf("select count(*) from %s", tableName)).Scan(&count); err != nil {
		log.Fatal(err)
	}
	fmt.Print(count)

	// Drop table.
	if _, err := db.ExecContext(ctx, fmt.Sprintf("drop table %s", tableName)); err != nil {
		log.Fatal(err)
	}

}

Output:
2000

ExampleBulkInsert inserts 2000 rows into a database table:

1000 rows are inserted via a slices chunk iterator
1000 rows are inserted via a custom iterator

package main

import (
	"context"
	"database/sql"
	"fmt"
	"iter"
	"log"
	"slices"

	"github.com/SAP/go-hdb/driver"
)

func main() {
	const numRow = 1000 // Number of rows to be inserted into table.

	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableName := driver.RandomIdentifier("table_")

	// Create table.
	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create table %s (i integer, f double)", tableName)); err != nil {
		log.Fatal(err)
	}

	// Prepare statement.
	stmt, err := db.PrepareContext(ctx, fmt.Sprintf("insert into %s values (?, ?)", tableName))
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	// Bulk insert via slices chunk iterator.
	args := make([]any, numRow*2)
	for i := range numRow {
		args[i*2], args[i*2+1] = i, float64(i)
	}

	if _, err := stmt.ExecContext(ctx, slices.Chunk(args, 2)); err != nil {
		log.Fatal(err)
	}

	// Bulk insert via custom iterator.
	var myIter iter.Seq[[]any] = func(yield func([]any) bool) {
		for i := range numRow {
			if !yield([]any{i, float64(i)}) {
				return
			}
		}
	}

	if _, err := stmt.ExecContext(ctx, myIter); err != nil {
		log.Fatal(err)
	}

	// Select number of inserted rows.
	var count int
	if err := db.QueryRowContext(ctx, fmt.Sprintf("select count(*) from %s", tableName)).Scan(&count); err != nil {
		log.Fatal(err)
	}
	fmt.Print(count)

	// Drop table.
	if _, err := db.ExecContext(ctx, fmt.Sprintf("drop table %s", tableName)); err != nil {
		log.Fatal(err)
	}

}

Output:
2000

//go:build !unit

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"

	"github.com/SAP/go-hdb/driver"
)

/*
callProcedureSimpleOut creates a stored procedure with one output parameter and executes it.
*/
func callProcedureSimpleOut() string {
	const procedureOut = `create procedure %s (out message nvarchar(1024))
language SQLSCRIPT as
begin
    message := 'Hello World!';
end
`

	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	procedureName := driver.RandomIdentifier("procOut_")

	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf(procedureOut, procedureName)); err != nil { // Create stored procedure.
		log.Fatal(err)
	}

	var out string
	if _, err := db.ExecContext(ctx, fmt.Sprintf("call %s(?)", procedureName), sql.Named("MESSAGE", sql.Out{Dest: &out})); err != nil {
		log.Fatal(err)
	}
	return out
}

/*
callProcedureTableOut creates a stored procedure with one table output parameter and executes it
making use of sql.Rows scan parameters.
Stored procedures with table output parameters must be prepared by sql.Prepare as the statement needs to
be kept open until the output table values are retrieved.
*/
func callProcedureTableOut() (output []string) {
	const procedureTable = `create procedure %[1]s (out t %[2]s)
language SQLSCRIPT as
begin
  create local temporary table #test like %[2]s;
  insert into #test values('Hello, 世界');
  insert into #test values('SAP HANA');
  insert into #test values('Go driver');
  t = select * from #test;
  drop table #test;
end
`
	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableType := driver.RandomIdentifier("TableType_")
	procedureName := driver.RandomIdentifier("ProcTable_")

	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create type %s as table (x nvarchar(256))", tableType)); err != nil { // Create table type.
		log.Fatal(err)
	}

	if _, err := db.ExecContext(ctx, fmt.Sprintf(procedureTable, procedureName, tableType)); err != nil { // Create stored procedure.
		log.Fatal(err)
	}

	var tableRows sql.Rows // Scan variable of table output parameter.

	// Call stored procedure via prepare.
	stmt, err := db.PrepareContext(ctx, fmt.Sprintf("call %s(?)", procedureName))
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	if _, err := stmt.ExecContext(ctx, sql.Named("T", sql.Out{Dest: &tableRows})); err != nil {
		log.Fatal(err)
	}

	for tableRows.Next() {
		var x string
		if err := tableRows.Scan(&x); err != nil {
			log.Fatal(err)
		}
		output = append(output, x)
	}
	if err := tableRows.Err(); err != nil {
		log.Fatal(err)
	}
	return output
}

/*
callProcedureTableIn creates a stored procedure with one table input and one table output parameter
and executes it making use of sql.Rows scan parameters.
Stored procedure input parameters need to refer by name to an existing database table or temporary table.
Stored procedures with table output parameters must be prepared by sql.Prepare as the statement needs to
be kept open until the output table values are retrieved.
*/
func callProcedureTableIn() (output []string) {
	const procedureTable = `create procedure %[1]s (in t1 %[2]s, out t2 %[2]s)
language SQLSCRIPT as
begin
  t2 = select * from :t1;
end
`
	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableType := driver.RandomIdentifier("TableType_")
	tableName := driver.RandomIdentifier("#TableIn_") // local temp table needs to start with "#"
	procedureName := driver.RandomIdentifier("ProcTable_")

	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create type %s as table (x nvarchar(256))", tableType)); err != nil { // Create table type.
		log.Fatal(err)
	}

	if _, err := db.ExecContext(ctx, fmt.Sprintf(procedureTable, procedureName, tableType)); err != nil { // Create stored procedure.
		log.Fatal(err)
	}

	if _, err := db.ExecContext(ctx, fmt.Sprintf("create local temporary table %s like %s", tableName, tableType)); err != nil {
		log.Fatal(err)
	}

	if _, err := db.ExecContext(ctx, fmt.Sprintf("insert into %s values (?)", tableName), "Hello, 世界", "SAP HANA", "Go driver"); err != nil {
		log.Fatal(err)
	}

	var tableRows sql.Rows // Scan variable of table output parameter.

	// Call stored procedure via prepare.
	stmt, err := db.PrepareContext(ctx, fmt.Sprintf("call %s(%s, ?)", procedureName, tableName))
	if err != nil {
		log.Fatal(err)
	}
	defer stmt.Close()

	if _, err := stmt.ExecContext(ctx, sql.Named("T", sql.Out{Dest: &tableRows})); err != nil {
		log.Fatal(err)
	}

	for tableRows.Next() {
		var x string
		if err := tableRows.Scan(&x); err != nil {
			log.Fatal(err)
		}
		output = append(output, x)
	}
	if err := tableRows.Err(); err != nil {
		log.Fatal(err)
	}
	return output
}

func main() {
	fmt.Println(callProcedureSimpleOut())
	for _, s := range callProcedureTableOut() {
		fmt.Println(s)
	}
	for _, s := range callProcedureTableIn() {
		fmt.Println(s)
	}

}

Output:
Hello World!
Hello, 世界
SAP HANA
Go driver
Hello, 世界
SAP HANA
Go driver

Example_customDecimal creates a table with a single decimal attribute, inserts a record using a custom decimal type implementing the database/sql decimalDecompose and decimalCompose interfaces, and selects the entry afterwards scanning into the same custom type.

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"math/big"

	"github.com/SAP/go-hdb/driver"
)

// customDecimal is a minimal custom decimal type implementing the database/sql
// decimalDecompose and decimalCompose interfaces (unexported, defined in the Go
// standard library in database/sql/convert.go and database/sql/driver/types.go):
//
//	Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32)
//	Compose(form byte, negative bool, coefficient []byte, exponent int32) error
//
// with value = (-1)^negative × coefficient × 10^exponent   (form 0 = finite).
//
// It demonstrates that go-hdb can write and scan decimal / fixed database
// attributes via any type implementing these interfaces - without using
// driver.Decimal.
type customDecimal struct {
	form     byte
	negative bool
	coeff    *big.Int
	exp      int32
}

// String renders the decompose fields as coefficient and exponent.
func (d customDecimal) String() string {
	sign := ""
	if d.negative {
		sign = "-"
	}
	return fmt.Sprintf("%s%sE%d", sign, d.coeff, d.exp)
}

// Decompose implements the database/sql decimalDecompose interface (write side).
func (d customDecimal) Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32) {
	if d.form != 0 {
		return d.form, d.negative, nil, 0
	}
	n := (d.coeff.BitLen() + 7) / 8
	if cap(buf) >= n {
		buf = buf[:n]
		coefficient = d.coeff.FillBytes(buf)
	} else {
		coefficient = d.coeff.Bytes()
	}
	return 0, d.negative, coefficient, d.exp
}

// Compose implements the database/sql decimalCompose interface (scan side).
func (d *customDecimal) Compose(form byte, negative bool, coefficient []byte, exponent int32) error {
	d.form = form
	d.negative = negative
	if d.coeff == nil {
		d.coeff = new(big.Int)
	}
	d.coeff.SetBytes(coefficient)
	d.exp = exponent
	return nil
}

func main() {
	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableName := driver.RandomIdentifier("table_")

	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create table %s (x decimal)", tableName)); err != nil {
		log.Fatal(err)
	}

	// value 1 = 1 × 10^0
	in := customDecimal{form: 0, negative: false, coeff: big.NewInt(1), exp: 0}

	if _, err := db.ExecContext(ctx, fmt.Sprintf("insert into %s values(?)", tableName), in); err != nil {
		log.Fatal(err)
	}

	var out customDecimal

	if err := db.QueryRowContext(ctx, fmt.Sprintf("select * from %s", tableName)).Scan(&out); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Decimal value: %s", out)

}

Output:
Decimal value: 1E0

Example_customFixed is like Example_customDecimal but uses a fixed decimal column (decimal(precision, scale)), exercising the fixed encode/decode path with a custom decimal type implementing the database/sql decimalDecompose and decimalCompose interfaces.

package main

import (
	"context"
	"database/sql"
	"fmt"
	"log"
	"math/big"

	"github.com/SAP/go-hdb/driver"
)

// customDecimal is a minimal custom decimal type implementing the database/sql
// decimalDecompose and decimalCompose interfaces (unexported, defined in the Go
// standard library in database/sql/convert.go and database/sql/driver/types.go):
//
//	Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32)
//	Compose(form byte, negative bool, coefficient []byte, exponent int32) error
//
// with value = (-1)^negative × coefficient × 10^exponent   (form 0 = finite).
//
// It demonstrates that go-hdb can write and scan decimal / fixed database
// attributes via any type implementing these interfaces - without using
// driver.Decimal.
type customDecimal struct {
	form     byte
	negative bool
	coeff    *big.Int
	exp      int32
}

// String renders the decompose fields as coefficient and exponent.
func (d customDecimal) String() string {
	sign := ""
	if d.negative {
		sign = "-"
	}
	return fmt.Sprintf("%s%sE%d", sign, d.coeff, d.exp)
}

// Decompose implements the database/sql decimalDecompose interface (write side).
func (d customDecimal) Decompose(buf []byte) (form byte, negative bool, coefficient []byte, exponent int32) {
	if d.form != 0 {
		return d.form, d.negative, nil, 0
	}
	n := (d.coeff.BitLen() + 7) / 8
	if cap(buf) >= n {
		buf = buf[:n]
		coefficient = d.coeff.FillBytes(buf)
	} else {
		coefficient = d.coeff.Bytes()
	}
	return 0, d.negative, coefficient, d.exp
}

// Compose implements the database/sql decimalCompose interface (scan side).
func (d *customDecimal) Compose(form byte, negative bool, coefficient []byte, exponent int32) error {
	d.form = form
	d.negative = negative
	if d.coeff == nil {
		d.coeff = new(big.Int)
	}
	d.coeff.SetBytes(coefficient)
	d.exp = exponent
	return nil
}

func main() {
	db := sql.OpenDB(driver.MT.Connector())
	defer db.Close()

	tableName := driver.RandomIdentifier("table_")

	ctx := context.Background()
	if _, err := db.ExecContext(ctx, fmt.Sprintf("create table %s (x decimal(18,2))", tableName)); err != nil {
		log.Fatal(err)
	}

	// value -12.34 = -1234 × 10^-2
	in := customDecimal{form: 0, negative: true, coeff: big.NewInt(1234), exp: -2}

	if _, err := db.ExecContext(ctx, fmt.Sprintf("insert into %s values(?)", tableName), in); err != nil {
		log.Fatal(err)
	}

	var out customDecimal

	if err := db.QueryRowContext(ctx, fmt.Sprintf("select * from %s", tableName)).Scan(&out); err != nil {
		log.Fatal(err)
	}

	fmt.Printf("Fixed value: %s", out)

}

Output:
Fixed value: -1234E-2