gopkg/pgx
2
0
Fork 0
Code Activity

Large objects use context

Browse Source
This commit is contained in:
Jack Christensen
2019-05-11 11:49:59 -05:00
parent 79f49ce300
commit 03abfc6452
2 changed files with 57 additions and 51 deletions
Download Patch File Download Diff File Expand all files Collapse all files
large_objects.go
+34 -35
View File
@@ -8,8 +8,8 @@ import (
errors "golang.org/x/xerrors"
)
// LargeObjects is a structure used to access the large objects API. It is only
// valid within the transaction where it was created.
// LargeObjects is a structure used to access the large objects API. It is only valid within the transaction where it
// was created.
//
// For more details see: http://www.postgresql.org/docs/current/static/largeobjects.html
type LargeObjects struct {
@@ -44,42 +44,42 @@ const (
LargeObjectModeRead LargeObjectMode = 0x40000
)
// Create creates a new large object. If oid is zero, the server assigns an
// unused OID.
func (o *LargeObjects) Create(oid pgtype.OID) (pgtype.OID, error) {
_, err := o.tx.Prepare(context.TODO(), "lo_create", "select lo_create($1)")
// Create creates a new large object. If oid is zero, the server assigns an unused OID.
func (o *LargeObjects) Create(ctx context.Context, oid pgtype.OID) (pgtype.OID, error) {
_, err := o.tx.Prepare(ctx, "lo_create", "select lo_create($1)")
if err != nil {
return 0, err
}
err = o.tx.QueryRow(context.TODO(), "lo_create", oid).Scan(&oid)
err = o.tx.QueryRow(ctx, "lo_create", oid).Scan(&oid)
return oid, err
}
// Open opens an existing large object with the given mode.
func (o *LargeObjects) Open(oid pgtype.OID, mode LargeObjectMode) (*LargeObject, error) {
_, err := o.tx.Prepare(context.TODO(), "lo_open", "select lo_open($1, $2)")
// Open opens an existing large object with the given mode. ctx will also be used for all operations on the opened large
// object.
func (o *LargeObjects) Open(ctx context.Context, oid pgtype.OID, mode LargeObjectMode) (*LargeObject, error) {
_, err := o.tx.Prepare(ctx, "lo_open", "select lo_open($1, $2)")
if err != nil {
return nil, err
}
var fd int32
err = o.tx.QueryRow(context.TODO(), "lo_open", oid, mode).Scan(&fd)
err = o.tx.QueryRow(ctx, "lo_open", oid, mode).Scan(&fd)
if err != nil {
return nil, err
}
return &LargeObject{fd: fd, tx: o.tx}, nil
return &LargeObject{fd: fd, tx: o.tx, ctx: ctx}, nil
}
// Unlink removes a large object from the database.
func (o *LargeObjects) Unlink(oid pgtype.OID) error {
_, err := o.tx.Prepare(context.TODO(), "lo_unlink", "select lo_unlink($1)")
func (o *LargeObjects) Unlink(ctx context.Context, oid pgtype.OID) error {
_, err := o.tx.Prepare(ctx, "lo_unlink", "select lo_unlink($1)")
if err != nil {
return err
}
var result int32
err = o.tx.QueryRow(context.TODO(), "lo_unlink", oid).Scan(&result)
err = o.tx.QueryRow(ctx, "lo_unlink", oid).Scan(&result)
if err != nil {
return err
}
@@ -91,28 +91,28 @@ func (o *LargeObjects) Unlink(oid pgtype.OID) error {
return nil
}
// A LargeObject is a large object stored on the server. It is only valid within
// the transaction that it was initialized in. It implements these interfaces:
// A LargeObject is a large object stored on the server. It is only valid within the transaction that it was initialized
// in. It uses the context it was initialized with for all operations. It implements these interfaces:
//
// io.Writer
// io.Reader
// io.Seeker
// io.Closer
type LargeObject struct {
fd int32
tx *Tx
ctx context.Context
tx *Tx
fd int32
}
// Write writes p to the large object and returns the number of bytes written
// and an error if not all of p was written.
// Write writes p to the large object and returns the number of bytes written and an error if not all of p was written.
func (o *LargeObject) Write(p []byte) (int, error) {
_, err := o.tx.Prepare(context.TODO(), "lowrite", "select lowrite($1, $2)")
_, err := o.tx.Prepare(o.ctx, "lowrite", "select lowrite($1, $2)")
if err != nil {
return 0, err
}
var n int
err = o.tx.QueryRow(context.TODO(), "lowrite", o.fd, p).Scan(&n)
err = o.tx.QueryRow(o.ctx, "lowrite", o.fd, p).Scan(&n)
if err != nil {
return n, err
}
@@ -126,13 +126,13 @@ func (o *LargeObject) Write(p []byte) (int, error) {
// Read reads up to len(p) bytes into p returning the number of bytes read.
func (o *LargeObject) Read(p []byte) (int, error) {
_, err := o.tx.Prepare(context.TODO(), "loread", "select loread($1, $2)")
_, err := o.tx.Prepare(o.ctx, "loread", "select loread($1, $2)")
if err != nil {
return 0, err
}
var res []byte
err = o.tx.QueryRow(context.TODO(), "loread", o.fd, len(p)).Scan(&res)
err = o.tx.QueryRow(o.ctx, "loread", o.fd, len(p)).Scan(&res)
copy(p, res)
if err != nil {
return len(res), err
@@ -146,45 +146,44 @@ func (o *LargeObject) Read(p []byte) (int, error) {
// Seek moves the current location pointer to the new location specified by offset.
func (o *LargeObject) Seek(offset int64, whence int) (n int64, err error) {
_, err = o.tx.Prepare(context.TODO(), "lo_lseek64", "select lo_lseek64($1, $2, $3)")
_, err = o.tx.Prepare(o.ctx, "lo_lseek64", "select lo_lseek64($1, $2, $3)")
if err != nil {
return 0, err
}
err = o.tx.QueryRow(context.TODO(), "lo_lseek64", o.fd, offset, whence).Scan(&n)
err = o.tx.QueryRow(o.ctx, "lo_lseek64", o.fd, offset, whence).Scan(&n)
return n, err
}
// Tell returns the current read or write location of the large object
// descriptor.
// Tell returns the current read or write location of the large object descriptor.
func (o *LargeObject) Tell() (n int64, err error) {
_, err = o.tx.Prepare(context.TODO(), "lo_tell64", "select lo_tell64($1)")
_, err = o.tx.Prepare(o.ctx, "lo_tell64", "select lo_tell64($1)")
if err != nil {
return 0, err
}
err = o.tx.QueryRow(context.TODO(), "lo_tell64", o.fd).Scan(&n)
err = o.tx.QueryRow(o.ctx, "lo_tell64", o.fd).Scan(&n)
return n, err
}
// Trunctes the large object to size.
func (o *LargeObject) Truncate(size int64) (err error) {
_, err = o.tx.Prepare(context.TODO(), "lo_truncate64", "select lo_truncate64($1, $2)")
_, err = o.tx.Prepare(o.ctx, "lo_truncate64", "select lo_truncate64($1, $2)")
if err != nil {
return err
}
_, err = o.tx.Exec(context.TODO(), "lo_truncate64", o.fd, size)
_, err = o.tx.Exec(o.ctx, "lo_truncate64", o.fd, size)
return err
}
// Close closees the large object descriptor.
func (o *LargeObject) Close() error {
_, err := o.tx.Prepare(context.TODO(), "lo_close", "select lo_close($1)")
_, err := o.tx.Prepare(o.ctx, "lo_close", "select lo_close($1)")
if err != nil {
return err
}
_, err = o.tx.Exec(context.TODO(), "lo_close", o.fd)
_, err = o.tx.Exec(o.ctx, "lo_close", o.fd)
return err
}