func PrepareAllQueries(ctx context.Context, p preparer) error {
	if _, err := p.Prepare(ctx, findEnumTypesSQL, findEnumTypesSQL); err != nil {
		return fmt.Errorf("prepare query 'FindEnumTypes': %w", err)
	}
	if _, err := p.Prepare(ctx, findArrayTypesSQL, findArrayTypesSQL); err != nil {
		return fmt.Errorf("prepare query 'FindArrayTypes': %w", err)
	}
	if _, err := p.Prepare(ctx, findCompositeTypesSQL, findCompositeTypesSQL); err != nil {
		return fmt.Errorf("prepare query 'FindCompositeTypes': %w", err)
	}
	if _, err := p.Prepare(ctx, findDescendantOIDsSQL, findDescendantOIDsSQL); err != nil {
		return fmt.Errorf("prepare query 'FindDescendantOIDs': %w", err)
	}
	if _, err := p.Prepare(ctx, findOIDByNameSQL, findOIDByNameSQL); err != nil {
		return fmt.Errorf("prepare query 'FindOIDByName': %w", err)
	}
	if _, err := p.Prepare(ctx, findOIDNameSQL, findOIDNameSQL); err != nil {
		return fmt.Errorf("prepare query 'FindOIDName': %w", err)
	}
	if _, err := p.Prepare(ctx, findOIDNamesSQL, findOIDNamesSQL); err != nil {
		return fmt.Errorf("prepare query 'FindOIDNames': %w", err)
	}
	return nil
}
PrepareAllQueries executes a PREPARE statement for all pggen generated SQL
queries in querier files. Typical usage is as the AfterConnect callback
for pgxpool.Config

pgx will use the prepared statement if available. Calling PrepareAllQueries
is an optional optimization to avoid a network round-trip the first time pgx
runs a query if pgx statement caching is enabled.
package pg
import (
	"context"
	"fmt"
	"github.com/jackc/pgconn"
	"github.com/jackc/pgtype"
	"github.com/jackc/pgx/v4"
)
type Querier interface {
	FindEnumTypes(ctx context.Context, oids []uint32) ([]FindEnumTypesRow, error)
	FindEnumTypesBatch(batch genericBatch, oids []uint32)
	FindEnumTypesScan(results pgx.BatchResults) ([]FindEnumTypesRow, error)
	FindArrayTypes(ctx context.Context, oids []uint32) ([]FindArrayTypesRow, error)
	FindArrayTypesBatch(batch genericBatch, oids []uint32)
	FindArrayTypesScan(results pgx.BatchResults) ([]FindArrayTypesRow, error)
	FindCompositeTypes(ctx context.Context, oids []uint32) ([]FindCompositeTypesRow, error)
	FindCompositeTypesBatch(batch genericBatch, oids []uint32)
	FindCompositeTypesScan(results pgx.BatchResults) ([]FindCompositeTypesRow, error)
	FindDescendantOIDs(ctx context.Context, oids []uint32) ([]pgtype.OID, error)
	FindDescendantOIDsBatch(batch genericBatch, oids []uint32)
	FindDescendantOIDsScan(results pgx.BatchResults) ([]pgtype.OID, error)
	FindOIDByName(ctx context.Context, name string) (pgtype.OID, error)
	FindOIDByNameBatch(batch genericBatch, name string)
	FindOIDByNameScan(results pgx.BatchResults) (pgtype.OID, error)
	FindOIDName(ctx context.Context, oid pgtype.OID) (pgtype.Name, error)
	FindOIDNameBatch(batch genericBatch, oid pgtype.OID)
	FindOIDNameScan(results pgx.BatchResults) (pgtype.Name, error)
	FindOIDNames(ctx context.Context, oid []uint32) ([]FindOIDNamesRow, error)
	FindOIDNamesBatch(batch genericBatch, oid []uint32)
	FindOIDNamesScan(results pgx.BatchResults) ([]FindOIDNamesRow, error)
}
type DBQuerier struct {
	conn  genericConn    
	types *typeResolver  
}
var _ Querier = &DBQuerier{}
type genericConn interface {
	Query(ctx context.Context, sql string, args ...interface{}) (pgx.Rows, error)
	QueryRow(ctx context.Context, sql string, args ...interface{}) pgx.Row
	Exec(ctx context.Context, sql string, arguments ...interface{}) (pgconn.CommandTag, error)
}
type genericBatch interface {
	Queue(query string, arguments ...interface{})
}
func NewQuerier(conn genericConn) *DBQuerier {
	return NewQuerierConfig(conn, QuerierConfig{})
}
type QuerierConfig struct {
	DataTypes []pgtype.DataType
}
func NewQuerierConfig(conn genericConn, cfg QuerierConfig) *DBQuerier {
	return &DBQuerier{conn: conn, types: newTypeResolver(cfg.DataTypes)}
}
func (q *DBQuerier) WithTx(tx pgx.Tx) (*DBQuerier, error) {
	return &DBQuerier{conn: tx}, nil
}
type preparer interface {
	Prepare(ctx context.Context, name, sql string) (sd *pgconn.StatementDescription, err error)
}