README
¶
go-grpc-sql 
This repository provides the grpcsql package, which can be used
to expose a Go SQL driver.Driver instance over gRPC.
For example you could cross-compile a Godror gateway for every possible architecture (using xgo), and use that gateway everywhere, instead of cross-compiling your app with cgo.
Documentation
The documentation for this package can be found on Godoc.
Documentation
¶
Overview ¶
Package grpcsql exposes a SQL database over a gRPC endpoint.
Example ¶
listener, err := net.Listen("tcp", ":0")
if err != nil {
log.Fatalf("failed to create listener: %v", err)
}
server := grpcsql.NewServer(godror.NewDriver())
go server.Serve(listener)
defer server.Stop()
dialer := func() (*grpc.ClientConn, error) {
return grpc.Dial(listener.Addr().String(), grpc.WithInsecure())
}
driver := grpcsql.NewDriver(dialer)
sql.Register("grpc", driver)
db, err := sql.Open("grpc", testDSN)
if err != nil {
log.Fatalf("failed to create grpc database: %v", err)
}
defer db.Close()
tx, err := db.Begin()
if err != nil {
log.Fatalf("failed to create grpc transaction: %v", err)
}
defer tx.Rollback()
const tbl = "test_grpc"
tx.Exec("DROP TABLE " + tbl)
defer tx.Exec("DROP TABLE " + tbl)
if _, err := tx.Exec("CREATE TABLE " + tbl + " (n INTEGER)"); err != nil {
log.Fatalf("failed to execute create table statement over grpc: %v", err)
}
if _, err := tx.Exec("INSERT INTO " + tbl + "(n) VALUES (1)"); err != nil {
log.Fatalf("failed to execute INSERT statement over grpc: %v", err)
}
result, err := tx.Exec("INSERT INTO " + tbl + "(n) VALUES (2)")
if err != nil {
log.Fatalf("failed to execute insert statement over grpc: %v", err)
}
rows, err := tx.Query("SELECT n FROM " + tbl + " ORDER BY n")
if err != nil {
log.Fatalf("failed to select rows over grpc: %s", err)
}
types, err := rows.ColumnTypes()
if len(types) != 1 {
log.Fatalf("wrong count of column types: %d", len(types))
}
name := types[0].DatabaseTypeName()
if err != nil {
log.Fatalf("failed to fetch column types over grpc: %s", err)
}
numbers := []int{}
for rows.Next() {
var n int
if err := rows.Scan(&n); err != nil {
log.Fatalf("failed to scan row over grpc: %s", err)
}
numbers = append(numbers, n)
}
if err := rows.Err(); err != nil {
log.Fatalf("rows error over grpc: %s", err)
}
defer rows.Close()
Output: 2 <nil> 1 <nil> INTEGER [1 2]
Index ¶
- func NewServer(driver driver.DriverContext, opt ...grpc.ServerOption) *grpc.Server
- 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) Close() error
- func (c *Conn) Exec(query string, args []driver.Value) (driver.Result, error)deprecated
- func (c *Conn) Prepare(query string) (driver.Stmt, error)
- type Dialer
- type Driver
- type Gateway
- type Result
- type Rows
- type Stmt
- type Tx
Examples ¶
Constants ¶
This section is empty.
Variables ¶
This section is empty.
Functions ¶
func NewServer ¶
func NewServer(driver driver.DriverContext, opt ...grpc.ServerOption) *grpc.Server
NewServer is a convenience for creating a gRPC server with a registered SQL gateway backed by the given driver.
Types ¶
type Conn ¶
type Conn struct {
// contains filtered or unexported fields
}
Conn wraps a connection to a gRPC SQL gateway.
func (*Conn) Close ¶
Close invalidates and potentially stops any current prepared statements and transactions, marking this connection as no longer in use.
type Dialer ¶
type Dialer func() (conn *grpc.ClientConn, err error)
Dialer is a function that can create a gRPC connection.
type Driver ¶
type Driver struct {
// contains filtered or unexported fields
}
Driver implements the database/sql/driver interface and executes the relevant statements over gRPC.
func NewDriver ¶
NewDriver creates a new gRPC SQL driver for creating connections to backend gateways.
type Gateway ¶
type Gateway struct {
protocol.UnimplementedSQLServer
// contains filtered or unexported fields
}
Gateway mapping gRPC requests to SQL queries.
func NewGateway ¶
func NewGateway(drv driver.DriverContext) *Gateway
NewGateway creates a new gRPC gateway executing requests against the given SQL driver.
type Result ¶
type Result struct {
// contains filtered or unexported fields
}
Result is the result of a query execution.
func (*Result) LastInsertId ¶
LastInsertId returns the database's auto-generated ID.
func (*Result) RowsAffected ¶
RowsAffected returns the number of rows affected by the query.
type Rows ¶
type Rows struct {
// contains filtered or unexported fields
}
Rows is an iterator over an executed query's results.
func (*Rows) ColumnTypeDatabaseTypeName ¶
ColumnTypeDatabaseTypeName implements RowsColumnTypeDatabaseTypeName.
func (*Rows) ColumnTypeScanType ¶
ColumnTypeScanType implements RowsColumnTypeScanType.
type Stmt ¶
type Stmt struct {
// contains filtered or unexported fields
}
Stmt is a prepared statement. It is bound to a Conn and not used by multiple goroutines concurrently.
Source Files
Directories