ActiveGo 1.8Package pq
Overview ▹
Index ▹
Constants
Error severities
const (
Efatal = "FATAL"
Epanic = "PANIC"
Ewarning = "WARNING"
Enotice = "NOTICE"
Edebug = "DEBUG"
Einfo = "INFO"
Elog = "LOG"
)
Variables
Common error types
var (
ErrNotSupported = errors.New("pq: Unsupported command")
ErrInFailedTransaction = errors.New("pq: Could not complete operation in a failed transaction")
ErrSSLNotSupported = errors.New("pq: SSL is not enabled on the server")
ErrSSLKeyHasWorldPermissions = errors.New("pq: Private key file has group or world access. Permissions should be u=rw (0600) or less.")
ErrCouldNotDetectUsername = errors.New("pq: Could not detect default username. Please provide one explicitly.")
)
var ErrChannelAlreadyOpen = errors.New("pq: channel is already open")
var ErrChannelNotOpen = errors.New("pq: channel is not open")
func Array ¶
func Array(a interface{}) interface {
driver.Valuer
sql.Scanner
}
Array returns the optimal driver.Valuer and sql.Scanner for an array or slice of any dimension.
For example:
db.Query(`SELECT * FROM t WHERE id = ANY($1)`, pq.Array([]int{235, 401}))
var x []sql.NullInt64
db.QueryRow('SELECT ARRAY[235, 401]').Scan(pq.Array(&x))
Scanning multi-dimensional arrays is not supported. Arrays where the lower bound is not one (such as `[0:0]={1}') are not supported.
func CopyIn ¶
func CopyIn(table string, columns ...string) string
CopyIn creates a COPY FROM statement which can be prepared with Tx.Prepare(). The target table should be visible in search_path.
func CopyInSchema ¶
func CopyInSchema(schema, table string, columns ...string) string
CopyInSchema creates a COPY FROM statement which can be prepared with Tx.Prepare().
func DialOpen ¶
func DialOpen(d Dialer, name string) (_ driver.Conn, err error)
func EnableInfinityTs ¶
func EnableInfinityTs(negative time.Time, positive time.Time)
EnableInfinityTs controls the handling of Postgres' "-infinity" and "infinity" "timestamp"s.
If EnableInfinityTs is not called, "-infinity" and "infinity" will return []byte("-infinity") and []byte("infinity") respectively, and potentially cause error "sql: Scan error on column index 0: unsupported driver -> Scan pair: []uint8 -> *time.Time", when scanning into a time.Time value.
Once EnableInfinityTs has been called, all connections created using this driver will decode Postgres' "-infinity" and "infinity" for "timestamp", "timestamp with time zone" and "date" types to the predefined minimum and maximum times, respectively. When encoding time.Time values, any time which equals or precedes the predefined minimum time will be encoded to "-infinity". Any values at or past the maximum time will similarly be encoded to "infinity".
If EnableInfinityTs is called with negative >= positive, it will panic. Calling EnableInfinityTs after a connection has been established results in undefined behavior. If EnableInfinityTs is called more than once, it will panic.
func FormatTimestamp ¶
func FormatTimestamp(t time.Time) []byte
FormatTimestamp formats t into Postgres' text format for timestamps.
func Open ¶
func Open(name string) (_ driver.Conn, err error)
func ParseTimestamp ¶
func ParseTimestamp(currentLocation *time.Location, str string) (time.Time, error)
ParseTimestamp parses Postgres' text format. It returns a time.Time in currentLocation iff that time's offset agrees with the offset sent from the Postgres server. Otherwise, ParseTimestamp returns a time.Time with the fixed offset offset provided by the Postgres server.
func ParseURL ¶
func ParseURL(url string) (string, error)
ParseURL no longer needs to be used by clients of this library since supplying a URL as a connection string to sql.Open() is now supported:
sql.Open("postgres", "postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full")
It remains exported here for backwards-compatibility.
ParseURL converts a url to a connection string for driver.Open. Example:
"postgres://bob:secret@1.2.3.4:5432/mydb?sslmode=verify-full"
converts to:
"user=bob password=secret host=1.2.3.4 port=5432 dbname=mydb sslmode=verify-full"
A minimal example:
"postgres://"
This will be blank, causing driver.Open to use all of the defaults
func QuoteIdentifier ¶
func QuoteIdentifier(name string) string
QuoteIdentifier quotes an "identifier" (e.g. a table or a column name) to be used as part of an SQL statement. For example:
tblname := "my_table"
data := "my_data"
err = db.Exec(fmt.Sprintf("INSERT INTO %s VALUES ($1)", pq.QuoteIdentifier(tblname)), data)
Any double quotes in name will be escaped. The quoted identifier will be case sensitive when used in a query. If the input string contains a zero byte, the result will be truncated immediately before it.
type ArrayDelimiter ¶
ArrayDelimiter may be optionally implemented by driver.Valuer or sql.Scanner to override the array delimiter used by GenericArray.
type ArrayDelimiter interface {
// ArrayDelimiter returns the delimiter character(s) for this element's type.
ArrayDelimiter() string
}
type BoolArray ¶
BoolArray represents a one-dimensional array of the PostgreSQL boolean type.
type BoolArray []bool
func (*BoolArray) Scan ¶
func (a *BoolArray) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (BoolArray) Value ¶
func (a BoolArray) Value() (driver.Value, error)
Value implements the driver.Valuer interface.
type ByteaArray ¶
ByteaArray represents a one-dimensional array of the PostgreSQL bytea type.
type ByteaArray [][]byte
func (*ByteaArray) Scan ¶
func (a *ByteaArray) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (ByteaArray) Value ¶
func (a ByteaArray) Value() (driver.Value, error)
Value implements the driver.Valuer interface. It uses the "hex" format which is only supported on PostgreSQL 9.0 or newer.
type Dialer ¶
type Dialer interface {
Dial(network, address string) (net.Conn, error)
DialTimeout(network, address string, timeout time.Duration) (net.Conn, error)
}
type Driver ¶
type Driver struct{}
func (*Driver) Open ¶
func (d *Driver) Open(name string) (driver.Conn, error)
type Error ¶
Error represents an error communicating with the server.
See http://www.postgresql.org/docs/current/static/protocol-error-fields.html for details of the fields
type Error struct {
Severity string
Code ErrorCode
Message string
Detail string
Hint string
Position string
InternalPosition string
InternalQuery string
Where string
Schema string
Table string
Column string
DataTypeName string
Constraint string
File string
Line string
Routine string
}
func (Error) Error ¶
func (err Error) Error() string
func (*Error) Fatal ¶
func (err *Error) Fatal() bool
Fatal returns true if the Error Severity is fatal.
func (*Error) Get ¶
func (err *Error) Get(k byte) (v string)
Get implements the legacy PGError interface. New code should use the fields of the Error struct directly.
type ErrorClass ¶
ErrorClass is only the class part of an error code.
type ErrorClass string
func (ErrorClass) Name ¶
func (ec ErrorClass) Name() string
Name returns the condition name of an error class. It is equivalent to the condition name of the "standard" error code (i.e. the one having the last three characters "000").
type ErrorCode ¶
ErrorCode is a five-character error code.
type ErrorCode string
func (ErrorCode) Class ¶
func (ec ErrorCode) Class() ErrorClass
Class returns the error class, e.g. "28".
See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for details.
func (ErrorCode) Name ¶
func (ec ErrorCode) Name() string
Name returns a more human friendly rendering of the error code, namely the "condition name".
See http://www.postgresql.org/docs/9.3/static/errcodes-appendix.html for details.
type EventCallbackType ¶
type EventCallbackType func(event ListenerEventType, err error)
type Float64Array ¶
Float64Array represents a one-dimensional array of the PostgreSQL double precision type.
type Float64Array []float64
func (*Float64Array) Scan ¶
func (a *Float64Array) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (Float64Array) Value ¶
func (a Float64Array) Value() (driver.Value, error)
Value implements the driver.Valuer interface.
type GenericArray ¶
GenericArray implements the driver.Valuer and sql.Scanner interfaces for an array or slice of any dimension.
type GenericArray struct{ A interface{} }
func (GenericArray) Scan ¶
func (a GenericArray) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (GenericArray) Value ¶
func (a GenericArray) Value() (driver.Value, error)
Value implements the driver.Valuer interface.
type Int64Array ¶
Int64Array represents a one-dimensional array of the PostgreSQL integer types.
type Int64Array []int64
func (*Int64Array) Scan ¶
func (a *Int64Array) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (Int64Array) Value ¶
func (a Int64Array) Value() (driver.Value, error)
Value implements the driver.Valuer interface.
type Listener ¶
Listener provides an interface for listening to notifications from a PostgreSQL database. For general usage information, see section "Notifications".
Listener can safely be used from concurrently running goroutines.
type Listener struct {
// Channel for receiving notifications from the database. In some cases a
// nil value will be sent. See section "Notifications" above.
Notify chan *Notification
// contains filtered or unexported fields
}
func NewDialListener ¶
func NewDialListener(d Dialer,
name string,
minReconnectInterval time.Duration,
maxReconnectInterval time.Duration,
eventCallback EventCallbackType) *Listener
NewDialListener is like NewListener but it takes a Dialer.
func NewListener ¶
func NewListener(name string,
minReconnectInterval time.Duration,
maxReconnectInterval time.Duration,
eventCallback EventCallbackType) *Listener
NewListener creates a new database connection dedicated to LISTEN / NOTIFY.
name should be set to a connection string to be used to establish the database connection (see section "Connection String Parameters" above).
minReconnectInterval controls the duration to wait before trying to re-establish the database connection after connection loss. After each consecutive failure this interval is doubled, until maxReconnectInterval is reached. Successfully completing the connection establishment procedure resets the interval back to minReconnectInterval.
The last parameter eventCallback can be set to a function which will be called by the Listener when the state of the underlying database connection changes. This callback will be called by the goroutine which dispatches the notifications over the Notify channel, so you should try to avoid doing potentially time-consuming operations from the callback.
func (*Listener) Close ¶
func (l *Listener) Close() error
Close disconnects the Listener from the database and shuts it down. Subsequent calls to its methods will return an error. Close returns an error if the connection has already been closed.
func (*Listener) Listen ¶
func (l *Listener) Listen(channel string) error
Listen starts listening for notifications on a channel. Calls to this function will block until an acknowledgement has been received from the server. Note that Listener automatically re-establishes the connection after connection loss, so this function may block indefinitely if the connection can not be re-established.
Listen will only fail in three conditions:
1) The channel is already open. The returned error will be ErrChannelAlreadyOpen. 2) The query was executed on the remote server, but PostgreSQL returned an error message in response to the query. The returned error will be a pq.Error containing the information the server supplied. 3) Close is called on the Listener before the request could be completed.
The channel name is case-sensitive.
func (*Listener) NotificationChannel ¶
func (l *Listener) NotificationChannel() <-chan *Notification
Returns the notification channel for this listener. This is the same channel as Notify, and will not be recreated during the life time of the Listener.
func (*Listener) Ping ¶
func (l *Listener) Ping() error
Ping the remote server to make sure it's alive. Non-nil return value means that there is no active connection.
func (*Listener) Unlisten ¶
func (l *Listener) Unlisten(channel string) error
Unlisten removes a channel from the Listener's channel list. Returns ErrChannelNotOpen if the Listener is not listening on the specified channel. Returns immediately with no error if there is no connection. Note that you might still get notifications for this channel even after Unlisten has returned.
The channel name is case-sensitive.
func (*Listener) UnlistenAll ¶
func (l *Listener) UnlistenAll() error
UnlistenAll removes all channels from the Listener's channel list. Returns immediately with no error if there is no connection. Note that you might still get notifications for any of the deleted channels even after UnlistenAll has returned.
type ListenerConn ¶
ListenerConn is a low-level interface for waiting for notifications. You should use Listener instead.
type ListenerConn struct {
// contains filtered or unexported fields
}
func NewListenerConn ¶
func NewListenerConn(name string, notificationChan chan<- *Notification) (*ListenerConn, error)
Creates a new ListenerConn. Use NewListener instead.
func (*ListenerConn) Close ¶
func (l *ListenerConn) Close() error
func (*ListenerConn) Err ¶
func (l *ListenerConn) Err() error
Err() returns the reason the connection was closed. It is not safe to call this function until l.Notify has been closed.
func (*ListenerConn) ExecSimpleQuery ¶
func (l *ListenerConn) ExecSimpleQuery(q string) (executed bool, err error)
Execute a "simple query" (i.e. one with no bindable parameters) on the connection. The possible return values are:
1) "executed" is true; the query was executed to completion on the database server. If the query failed, err will be set to the error returned by the database, otherwise err will be nil. 2) If "executed" is false, the query could not be executed on the remote server. err will be non-nil.
After a call to ExecSimpleQuery has returned an executed=false value, the connection has either been closed or will be closed shortly thereafter, and all subsequently executed queries will return an error.
func (*ListenerConn) Listen ¶
func (l *ListenerConn) Listen(channel string) (bool, error)
Send a LISTEN query to the server. See ExecSimpleQuery.
func (*ListenerConn) Ping ¶
func (l *ListenerConn) Ping() error
Ping the remote server to make sure it's alive. Non-nil error means the connection has failed and should be abandoned.
func (*ListenerConn) Unlisten ¶
func (l *ListenerConn) Unlisten(channel string) (bool, error)
Send an UNLISTEN query to the server. See ExecSimpleQuery.
func (*ListenerConn) UnlistenAll ¶
func (l *ListenerConn) UnlistenAll() (bool, error)
Send `UNLISTEN *` to the server. See ExecSimpleQuery.
type ListenerEventType ¶
type ListenerEventType int
const (
// Emitted only when the database connection has been initially
// initialized. err will always be nil.
ListenerEventConnected ListenerEventType = iota
// Emitted after a database connection has been lost, either because of an
// error or because Close has been called. err will be set to the reason
// the database connection was lost.
ListenerEventDisconnected
// Emitted after a database connection has been re-established after
// connection loss. err will always be nil. After this event has been
// emitted, a nil pq.Notification is sent on the Listener.Notify channel.
ListenerEventReconnected
// Emitted after a connection to the database was attempted, but failed.
// err will be set to an error describing why the connection attempt did
// not succeed.
ListenerEventConnectionAttemptFailed
)
type Notification ¶
Notification represents a single notification from the database.
type Notification struct {
// Process ID (PID) of the notifying postgres backend.
BePid int
// Name of the channel the notification was sent on.
Channel string
// Payload, or the empty string if unspecified.
Extra string
}
type NullTime ¶
NullTime represents a time.Time that may be null. NullTime implements the sql.Scanner interface so it can be used as a scan destination, similar to sql.NullString.
type NullTime struct {
Time time.Time
Valid bool // Valid is true if Time is not NULL
}
func (*NullTime) Scan ¶
func (nt *NullTime) Scan(value interface{}) error
Scan implements the Scanner interface.
func (NullTime) Value ¶
func (nt NullTime) Value() (driver.Value, error)
Value implements the driver Valuer interface.
type PGError ¶
PGError is an interface used by previous versions of pq. It is provided only to support legacy code. New code should use the Error type.
type PGError interface {
Error() string
Fatal() bool
Get(k byte) (v string)
}
type StringArray ¶
StringArray represents a one-dimensional array of the PostgreSQL character types.
type StringArray []string
func (*StringArray) Scan ¶
func (a *StringArray) Scan(src interface{}) error
Scan implements the sql.Scanner interface.
func (StringArray) Value ¶
func (a StringArray) Value() (driver.Value, error)
Value implements the driver.Valuer interface.
Subdirectories
| Name | Synopsis |
|---|---|
| .. | |
| hstore | |
| listen_example | Below you will find a self-contained Go program which uses the LISTEN / NOTIFY mechanism to avoid polling the database while waiting for more work to arrive. |
| oid | Package oid contains OID constants as defined by the Postgres server. |