package pgdialect

Import Path
	github.com/uptrace/bun/dialect/pgdialect (on go.dev)

Dependency Relation
	imports 18 packages, and imported by one package

Involved Source Files

	      append.go
	      array.go
	      array_parser.go
	      array_scan.go
	      dialect.go
	      scan.go
	      sqltype.go
	      unsafe.go
Package-Level Type Names (total 3, in which 2 are exported)

	/* sort exporteds by: alphabet | popularity */
	 type ArrayValue (struct)

		Fields (total 3, none are exported)
			/* 3 unexporteds ... *//* 3 unexporteds: */
			append schema.AppenderFunc
			scan schema.ScannerFunc
			v reflect.Value
		Methods (total 3, all are exported)
			(*T) AppendQuery(fmter schema.Formatter, b []byte) ([]byte, error)
			(*T) Scan(src interface{}) error
			(*T) Value() interface{}
		Implements (at least 2, both are exported)
			*T : github.com/uptrace/bun/schema.QueryAppender
			*T : database/sql.Scanner
		As Outputs Of (at least one exported)
			func Array(vi interface{}) *ArrayValue

	 type Dialect (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			appenderMap sync.Map
			features feature.Feature
			scannerMap sync.Map
			tables *schema.Tables
		Methods (total 11, in which 10 are exported)
			(*T) Append(fmter schema.Formatter, b []byte, v interface{}) []byte
			(*T) Appender(typ reflect.Type) schema.AppenderFunc
			(*T) Features() feature.Feature
			(*T) FieldAppender(field *schema.Field) schema.AppenderFunc
			(*T) IdentQuote() byte
			(*T) Init(*sql.DB)
			(*T) Name() dialect.Name
			(*T) OnTable(table *schema.Table)
			(*T) Scanner(typ reflect.Type) schema.ScannerFunc
			(*T) Tables() *schema.Tables
			/* one unexported ... *//* one unexported: */
			(*T) onField(field *schema.Field)
		Implements (at least one exported)
			*T : github.com/uptrace/bun/schema.Dialect
		As Outputs Of (at least one exported)
			func New() *Dialect

	/* one unexported ... *//* one unexported: */
	 type arrayParser (struct)

		Fields (total 4, none are exported)
			/* 4 unexporteds ... *//* 4 unexporteds: */
			b []byte
			buf []byte
			err error
			i int
		Methods (total 8, in which 1 are exported)
			(*T) NextElem() ([]byte, error)
			/* 7 unexporteds ... *//* 7 unexporteds: */
			(*T) peek() byte
			(*T) readByte() (byte, error)
			(*T) readSimple() []byte
			(*T) readSubstring() ([]byte, error)
			(*T) skipNext()
			(*T) unreadByte()
			(*T) valid() bool
		As Outputs Of (at least one unexported)
			/* at least one unexported ... *//* at least one unexported: */
			func newArrayParser(b []byte) *arrayParser


Package-Level Functions (total 35, in which 2 are exported)

	 func Array(vi interface{}) *ArrayValue
		Array accepts a slice and returns a wrapper for working with PostgreSQL
		array data type.

		For struct fields you can use array tag:

		   Emails  []string `bun:",array"`

	 func New() *Dialect
	/* 33 unexporteds ... *//* 33 unexporteds: */
	 func appendFloat64Slice(b []byte, floats []float64) []byte
	 func appendFloat64SliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func appendInt64Slice(b []byte, ints []int64) []byte
	 func appendInt64SliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func appendIntSlice(b []byte, ints []int) []byte
	 func appendIntSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func appendStringSlice(b []byte, ss []string) []byte
	 func appendStringSliceValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func appendUint32ValueAsInt(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func appendUint64ValueAsInt(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func arrayAppend(fmter schema.Formatter, b []byte, v interface{}) []byte
	 func arrayAppendDriverValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func arrayAppender(typ reflect.Type) schema.AppenderFunc
	 func arrayAppendString(b []byte, s string) []byte
	 func arrayAppendStringValue(fmter schema.Formatter, b []byte, v reflect.Value) []byte
	 func arrayElemAppender(typ reflect.Type) schema.AppenderFunc
	 func arrayScanner(typ reflect.Type) schema.ScannerFunc
	 func bytesToString(b []byte) string
	 func customAppender(typ reflect.Type) schema.AppenderFunc
	 func decodeInt64Slice(src interface{}) ([]int64, error)
	 func decodeIntSlice(src interface{}) ([]int, error)
	 func decodeStringSlice(src interface{}) ([]string, error)
	 func fieldSQLType(field *schema.Field) string
	 func newArrayParser(b []byte) *arrayParser
	 func scanFloat64Slice(src interface{}) ([]float64, error)
	 func scanFloat64SliceValue(dest reflect.Value, src interface{}) error
	 func scanInt64SliceValue(dest reflect.Value, src interface{}) error
	 func scanIntSliceValue(dest reflect.Value, src interface{}) error
	 func scanner(typ reflect.Type) schema.ScannerFunc
	 func scanStringSliceValue(dest reflect.Value, src interface{}) error
	 func sqlType(typ reflect.Type) string
	 func stringToBytes(s string) []byte
	 func toBytes(src interface{}) ([]byte, error)
Package-Level Variables (total 13, none are exported)

	/* 13 unexporteds ... *//* 13 unexporteds: */
	  var driverValuerType reflect.Type
	  var float64Type reflect.Type
	  var int64Type reflect.Type
	  var intType reflect.Type
	  var ipNetType reflect.Type
	  var ipType reflect.Type
	  var jsonRawMessageType reflect.Type
	  var sliceFloat64Type reflect.Type
	  var sliceInt64Type reflect.Type
	  var sliceIntType reflect.Type
	  var sliceStringType reflect.Type
	  var stringType reflect.Type
	  var timeType reflect.Type
Package-Level Constants (total 16, none are exported)

	/* 16 unexporteds ... *//* 16 unexporteds: */
	const pgTypeBigSerial = "BIGSERIAL" // 8 byte autoincrementing integer
	const pgTypeBytea = "BYTEA" // binary string
		Binary Data Types

	const pgTypeChar = "CHAR" // fixed length string (blank padded)
		Character Types

	const pgTypeCidr = "CIDR" // IPv4 or IPv6 networks
	const pgTypeDate = "DATE" // Date
	const pgTypeInet = "INET" // IPv4 or IPv6 hosts and networks
		Network Addresses

	const pgTypeInterval = "INTERVAL" // Time Interval
	const pgTypeJSON = "JSON" // text representation of json data
		JSON Types

	const pgTypeJSONB = "JSONB" // binary representation of json data
	const pgTypeMacaddr = "MACADDR" // MAC addresses
	const pgTypeSerial = "SERIAL" // 4 byte autoincrementing integer
	const pgTypeSmallSerial = "SMALLSERIAL" // 2 byte autoincrementing integer
		Serial Types

	const pgTypeText = "TEXT" // variable length string without limit
	const pgTypeTime = "TIME" // Time without a time zone
	const pgTypeTimestampTz = "TIMESTAMPTZ" // Timestamp with a time zone
		Date / Time

	const pgTypeTimeTz = "TIME WITH TIME ZONE" // Time with a time zone

The pages are generated with Golds v0.3.6. (GOOS=darwin GOARCH=amd64)
Golds is a Go 101 project developed by Tapir Liu.
PR and bug reports are welcome and can be submitted to the issue list.
Please follow @Go100and1 (reachable from the left QR code) to get the latest news of Golds.