query.sql.go

// Code generated by pggen. DO NOT EDIT.

package syntax

import (
	"context"
	"fmt"
	"github.com/jackc/pgconn"
	"github.com/jackc/pgtype"
	"github.com/jackc/pgx/v4"
)

// Querier is a typesafe Go interface backed by SQL queries.
type Querier interface {
	// Query to test escaping in generated Go.
	Backtick(ctx context.Context) (string, error)

	// Query to test escaping in generated Go.
	BacktickQuoteBacktick(ctx context.Context) (string, error)

	// Query to test escaping in generated Go.
	BacktickNewline(ctx context.Context) (string, error)

	// Query to test escaping in generated Go.
	BacktickDoubleQuote(ctx context.Context) (string, error)

	// Query to test escaping in generated Go.
	BacktickBackslashN(ctx context.Context) (string, error)

	// Illegal names.
	IllegalNameSymbols(ctx context.Context, helloWorld string) (IllegalNameSymbolsRow, error)

	// Space after pggen.arg
	SpaceAfter(ctx context.Context, space string) (string, error)

	// Enum named 123.
	BadEnumName(ctx context.Context) (UnnamedEnum123, error)

	GoKeyword(ctx context.Context, go_ string) (string, error)
}

var _ Querier = &DBQuerier{}

type DBQuerier struct {
	conn  genericConn   // underlying Postgres transport to use
	types *typeResolver // resolve types by name
}

// genericConn is a connection like *pgx.Conn, pgx.Tx, or *pgxpool.Pool.
type genericConn interface {
	Query(ctx context.Context, sql string, args ...any) (pgx.Rows, error)
	QueryRow(ctx context.Context, sql string, args ...any) pgx.Row
	Exec(ctx context.Context, sql string, arguments ...any) (pgconn.CommandTag, error)
}

// NewQuerier creates a DBQuerier that implements Querier.
func NewQuerier(conn genericConn) *DBQuerier {
	return &DBQuerier{conn: conn, types: newTypeResolver()}
}

// UnnamedEnum123 represents the Postgres enum "123".
type UnnamedEnum123 string

const (
	UnnamedEnum123InconvertibleEnumName UnnamedEnum123 = "inconvertible_enum_name"
	UnnamedEnum123UnnamedLabel1         UnnamedEnum123 = ""
	UnnamedEnum123UnnamedLabel2111      UnnamedEnum123 = "111"
	UnnamedEnum123UnnamedLabel3         UnnamedEnum123 = "!!"
)

func (u UnnamedEnum123) String() string { return string(u) }

// typeResolver looks up the pgtype.ValueTranscoder by Postgres type name.
type typeResolver struct {
	connInfo *pgtype.ConnInfo // types by Postgres type name
}

func newTypeResolver() *typeResolver {
	ci := pgtype.NewConnInfo()
	return &typeResolver{connInfo: ci}
}

// findValue find the OID, and pgtype.ValueTranscoder for a Postgres type name.
func (tr *typeResolver) findValue(name string) (uint32, pgtype.ValueTranscoder, bool) {
	typ, ok := tr.connInfo.DataTypeForName(name)
	if !ok {
		return 0, nil, false
	}
	v := pgtype.NewValue(typ.Value)
	return typ.OID, v.(pgtype.ValueTranscoder), true
}

// setValue sets the value of a ValueTranscoder to a value that should always
// work and panics if it fails.
func (tr *typeResolver) setValue(vt pgtype.ValueTranscoder, val interface{}) pgtype.ValueTranscoder {
	if err := vt.Set(val); err != nil {
		panic(fmt.Sprintf("set ValueTranscoder %T to %+v: %s", vt, val, err))
	}
	return vt
}

const backtickSQL = "SELECT '`';"

// Backtick implements Querier.Backtick.
func (q *DBQuerier) Backtick(ctx context.Context) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "Backtick")
	row := q.conn.QueryRow(ctx, backtickSQL)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query Backtick: %w", err)
	}
	return item, nil
}

const backtickQuoteBacktickSQL = "SELECT '`\"`';"

// BacktickQuoteBacktick implements Querier.BacktickQuoteBacktick.
func (q *DBQuerier) BacktickQuoteBacktick(ctx context.Context) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "BacktickQuoteBacktick")
	row := q.conn.QueryRow(ctx, backtickQuoteBacktickSQL)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query BacktickQuoteBacktick: %w", err)
	}
	return item, nil
}

const backtickNewlineSQL = "SELECT '`\n';"

// BacktickNewline implements Querier.BacktickNewline.
func (q *DBQuerier) BacktickNewline(ctx context.Context) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "BacktickNewline")
	row := q.conn.QueryRow(ctx, backtickNewlineSQL)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query BacktickNewline: %w", err)
	}
	return item, nil
}

const backtickDoubleQuoteSQL = "SELECT '`\"';"

// BacktickDoubleQuote implements Querier.BacktickDoubleQuote.
func (q *DBQuerier) BacktickDoubleQuote(ctx context.Context) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "BacktickDoubleQuote")
	row := q.conn.QueryRow(ctx, backtickDoubleQuoteSQL)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query BacktickDoubleQuote: %w", err)
	}
	return item, nil
}

const backtickBackslashNSQL = "SELECT '`\\n';"

// BacktickBackslashN implements Querier.BacktickBackslashN.
func (q *DBQuerier) BacktickBackslashN(ctx context.Context) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "BacktickBackslashN")
	row := q.conn.QueryRow(ctx, backtickBackslashNSQL)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query BacktickBackslashN: %w", err)
	}
	return item, nil
}

const illegalNameSymbolsSQL = "SELECT '`\\n' as \"$\", $1 as \"foo.bar!@#$%&*()\"\"--+\";"

type IllegalNameSymbolsRow struct {
	UnnamedColumn0 string `json:"$"`
	FooBar         string `json:"foo.bar!@#$%&*()\"--+"`
}

// IllegalNameSymbols implements Querier.IllegalNameSymbols.
func (q *DBQuerier) IllegalNameSymbols(ctx context.Context, helloWorld string) (IllegalNameSymbolsRow, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "IllegalNameSymbols")
	row := q.conn.QueryRow(ctx, illegalNameSymbolsSQL, helloWorld)
	var item IllegalNameSymbolsRow
	if err := row.Scan(&item.UnnamedColumn0, &item.FooBar); err != nil {
		return item, fmt.Errorf("query IllegalNameSymbols: %w", err)
	}
	return item, nil
}

const spaceAfterSQL = `SELECT $1;`

// SpaceAfter implements Querier.SpaceAfter.
func (q *DBQuerier) SpaceAfter(ctx context.Context, space string) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "SpaceAfter")
	row := q.conn.QueryRow(ctx, spaceAfterSQL, space)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query SpaceAfter: %w", err)
	}
	return item, nil
}

const badEnumNameSQL = `SELECT 'inconvertible_enum_name'::"123";`

// BadEnumName implements Querier.BadEnumName.
func (q *DBQuerier) BadEnumName(ctx context.Context) (UnnamedEnum123, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "BadEnumName")
	row := q.conn.QueryRow(ctx, badEnumNameSQL)
	var item UnnamedEnum123
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query BadEnumName: %w", err)
	}
	return item, nil
}

const goKeywordSQL = `SELECT $1::text;`

// GoKeyword implements Querier.GoKeyword.
func (q *DBQuerier) GoKeyword(ctx context.Context, go_ string) (string, error) {
	ctx = context.WithValue(ctx, "pggen_query_name", "GoKeyword")
	row := q.conn.QueryRow(ctx, goKeywordSQL, go_)
	var item string
	if err := row.Scan(&item); err != nil {
		return item, fmt.Errorf("query GoKeyword: %w", err)
	}
	return item, nil
}

// textPreferrer wraps a pgtype.ValueTranscoder and sets the preferred encoding
// format to text instead binary (the default). pggen uses the text format
// when the OID is unknownOID because the binary format requires the OID.
// Typically occurs for unregistered types.
type textPreferrer struct {
	pgtype.ValueTranscoder
	typeName string
}

// PreferredParamFormat implements pgtype.ParamFormatPreferrer.
func (t textPreferrer) PreferredParamFormat() int16 { return pgtype.TextFormatCode }

func (t textPreferrer) NewTypeValue() pgtype.Value {
	return textPreferrer{ValueTranscoder: pgtype.NewValue(t.ValueTranscoder).(pgtype.ValueTranscoder), typeName: t.typeName}
}

func (t textPreferrer) TypeName() string {
	return t.typeName
}

// unknownOID means we don't know the OID for a type. This is okay for decoding
// because pgx call DecodeText or DecodeBinary without requiring the OID. For
// encoding parameters, pggen uses textPreferrer if the OID is unknown.
const unknownOID = 0