lpgx

README

litsql-db lpgx

Golang pgx DB wrappers for litsql.

Installation

go get -u github.com/rrgmc/litsql-db/lpgx

Examples

Query

func ExampleConn() {
    ctx := context.Background()

    conn, err := pgx.Connect(ctx, "test")
    if err != nil {
        panic(err)
    }

    // wrap *pgx.Conn instance
    dconn := lpgx.NewConn(conn)

    query := psql.Select(
        sm.Columns("film_id", "title", "length"),
        sm.From("film"),
        sm.WhereClause("length > ?", sq.NamedArg("length")),
        sm.Limit(10),
    )

    // generate SQL string from litsql and execute it, replacing named parameters.
    rows, err := dconn.Query(ctx, query, map[string]any{
        "length": 90,
    })
    if err != nil {
        panic(err)
    }
    defer rows.Close()

    for rows.Next() {
        var film_id, length int
        var title string
        err = rows.Scan(&film_id, &title, &length)
        if err != nil {
            panic(err)
        }
    }

    if rows.Err() != nil {
        panic(err)
    }
}

Prepared statement

func ExampleStmt() {
    ctx := context.Background()

    conn, err := pgx.Connect(ctx, "test")
    if err != nil {
        panic(err)
    }

    // wrap *pgx.Conn instance
    dconn := lpgx.NewConn(conn)

    query := psql.Select(
        sm.Columns("film_id", "title", "length"),
        sm.From("film"),
        sm.WhereClause("length > ?", sq.NamedArg("length")),
        sm.Limit(10),
    )

    queryName := "query1"

    // generate SQL string from litsql and prepare it, storing the named parameters to be replaced later
    dstmt, err := dconn.Prepare(ctx, queryName, query)
    if err != nil {
        panic(err)
    }

    // execute prepared query, replacing named parameters
    rows, err := dstmt.Query(ctx, map[string]any{
        "length": 90,
    })
    if err != nil {
        panic(err)
    }
    defer rows.Close()

    for rows.Next() {
        var film_id, length int
        var title string
        err = rows.Scan(&film_id, &title, &length)
        if err != nil {
            panic(err)
        }
    }

    if rows.Err() != nil {
        panic(err)
    }
}

Author

Rangel Reale (rangelreale@gmail.com)

Documentation

Index

• type Conn
  • func NewConn(conn *pgx.Conn, options ...Option) *Conn
• type Option
  • func WithQueryHandler(queryHandler sq.Handler) Option
• type Pool
  • func NewPool(conn *pgxpool.Pool, options ...Option) *Pool
• type PoolConn
  • func NewPoolConn(conn *pgxpool.Conn, options ...Option) *PoolConn
• type Querier
• type QuerierConn
• type QuerierPool
• type QuerierPoolConn
• type QuerierPoolTx
• type QuerierStmt
• type QuerierTx
• type StmtConn
• type StmtPoolTx
• type StmtTx
• type Tx
  • func NewTx(tx pgx.Tx, options ...Option) *Tx

Examples

• Conn

Types

type Conn

type Conn = lpgxt.Conn[*pgx.Conn]

Conn wraps a pgx.Conn.

Example

ctx := context.Background()

conn, err := pgx.Connect(ctx, "test")
if err != nil {
	panic(err)
}

// wrap *pgx.Conn instance
dconn := lpgx.NewConn(conn)

query := psql.Select(
	sm.Columns("film_id", "title", "length"),
	sm.From("film"),
	sm.WhereClause("length > ?", sq.NamedArg("length")),
	sm.Limit(10),
)

// generate SQL string from litsql and execute it, replacing named parameters.
rows, err := dconn.Query(ctx, query, map[string]any{
	"length": 90,
})
if err != nil {
	panic(err)
}
defer rows.Close()

for rows.Next() {
	var film_id, length int
	var title string
	err = rows.Scan(&film_id, &title, &length)
	if err != nil {
		panic(err)
	}
}

if rows.Err() != nil {
	panic(err)
}

func NewConn

func NewConn(conn *pgx.Conn, options ...Option) *Conn

NewConn wraps a pgx.Conn.

type Option

type Option = lpgxt.Option

func WithQueryHandler

func WithQueryHandler(queryHandler sq.Handler) Option

type Pool

type Pool = lpgxt.Pool[*pgxpool.Pool]

Pool wraps a pgxpool.Pool.

func NewPool

func NewPool(conn *pgxpool.Pool, options ...Option) *Pool

NewPool wraps a pgxpool.Pool.

type PoolConn

type PoolConn = lpgxt.PoolConn[*pgxpool.Conn]

PoolConn wraps a pgxpool.Conn.

func NewPoolConn

func NewPoolConn(conn *pgxpool.Conn, options ...Option) *PoolConn

NewPoolConn wraps a pgxpool.Conn.

type Querier

type Querier = lpgxt.Querier

type QuerierConn

type QuerierConn = lpgxt.QuerierConn[*pgx.Conn]

type QuerierPool

type QuerierPool = lpgxt.QuerierPool

type QuerierPoolConn

type QuerierPoolConn = lpgxt.QuerierPoolConn

type QuerierPoolTx

type QuerierPoolTx = lpgxt.QuerierTx[*pgxpool.Tx]

type QuerierStmt

type QuerierStmt = lpgxt.QuerierStmt

type QuerierTx

type QuerierTx = lpgxt.QuerierTx[pgx.Tx]

type StmtConn

type StmtConn = lpgxt.Stmt[*pgx.Conn]

type StmtPoolTx

type StmtPoolTx = lpgxt.Stmt[*pgxpool.Tx]

type StmtTx

type StmtTx = lpgxt.Stmt[pgx.Tx]

type Tx

type Tx = lpgxt.Tx[pgx.Tx]

Tx wraps a pgx.Tx.

func NewTx

func NewTx(tx pgx.Tx, options ...Option) *Tx

NewTx wraps a pgx.Tx.