order

type CreateTenantRow struct {
	TenantID int     `json:"tenant_id"`
	Rname    *string `json:"rname"`
	Name     string  `json:"name"`
}

type DBQuerier struct {
	// contains filtered or unexported fields
}

type FindOrdersByCustomerRow struct {
	OrderID    int32              `json:"order_id"`
	OrderDate  pgtype.Timestamptz `json:"order_date"`
	OrderTotal pgtype.Numeric     `json:"order_total"`
	CustomerID *int32             `json:"customer_id"`
}

type FindOrdersByPriceRow struct {
	OrderID    int32              `json:"order_id"`
	OrderDate  pgtype.Timestamptz `json:"order_date"`
	OrderTotal pgtype.Numeric     `json:"order_total"`
	CustomerID *int32             `json:"customer_id"`
}

type FindOrdersMRRRow struct {
	Month    pgtype.Timestamptz `json:"month"`
	OrderMRR pgtype.Numeric     `json:"order_mrr"`
}

type FindProductsInOrderRow struct {
	OrderID   *int32  `json:"order_id"`
	ProductID *int32  `json:"product_id"`
	Name      *string `json:"name"`
}

type InsertCustomerParams struct {
	FirstName string
	LastName  string
	Email     string
}

type InsertCustomerRow struct {
	CustomerID int32  `json:"customer_id"`
	FirstName  string `json:"first_name"`
	LastName   string `json:"last_name"`
	Email      string `json:"email"`
}

type InsertOrderParams struct {
	OrderDate  pgtype.Timestamptz
	OrderTotal pgtype.Numeric
	CustID     int32
}

type InsertOrderRow struct {
	OrderID    int32              `json:"order_id"`
	OrderDate  pgtype.Timestamptz `json:"order_date"`
	OrderTotal pgtype.Numeric     `json:"order_total"`
	CustomerID *int32             `json:"customer_id"`
}

type Querier interface {
	CreateTenant(ctx context.Context, key string, name string) (CreateTenantRow, error)
	// CreateTenantBatch enqueues a CreateTenant query into batch to be executed
	// later by the batch.
	CreateTenantBatch(batch genericBatch, key string, name string)
	// CreateTenantScan scans the result of an executed CreateTenantBatch query.
	CreateTenantScan(results pgx.BatchResults) (CreateTenantRow, error)

	FindOrdersByCustomer(ctx context.Context, customerID int32) ([]FindOrdersByCustomerRow, error)
	// FindOrdersByCustomerBatch enqueues a FindOrdersByCustomer query into batch to be executed
	// later by the batch.
	FindOrdersByCustomerBatch(batch genericBatch, customerID int32)
	// FindOrdersByCustomerScan scans the result of an executed FindOrdersByCustomerBatch query.
	FindOrdersByCustomerScan(results pgx.BatchResults) ([]FindOrdersByCustomerRow, error)

	FindProductsInOrder(ctx context.Context, orderID int32) ([]FindProductsInOrderRow, error)
	// FindProductsInOrderBatch enqueues a FindProductsInOrder query into batch to be executed
	// later by the batch.
	FindProductsInOrderBatch(batch genericBatch, orderID int32)
	// FindProductsInOrderScan scans the result of an executed FindProductsInOrderBatch query.
	FindProductsInOrderScan(results pgx.BatchResults) ([]FindProductsInOrderRow, error)

	InsertCustomer(ctx context.Context, params InsertCustomerParams) (InsertCustomerRow, error)
	// InsertCustomerBatch enqueues a InsertCustomer query into batch to be executed
	// later by the batch.
	InsertCustomerBatch(batch genericBatch, params InsertCustomerParams)
	// InsertCustomerScan scans the result of an executed InsertCustomerBatch query.
	InsertCustomerScan(results pgx.BatchResults) (InsertCustomerRow, error)

	InsertOrder(ctx context.Context, params InsertOrderParams) (InsertOrderRow, error)
	// InsertOrderBatch enqueues a InsertOrder query into batch to be executed
	// later by the batch.
	InsertOrderBatch(batch genericBatch, params InsertOrderParams)
	// InsertOrderScan scans the result of an executed InsertOrderBatch query.
	InsertOrderScan(results pgx.BatchResults) (InsertOrderRow, error)

	FindOrdersByPrice(ctx context.Context, minTotal pgtype.Numeric) ([]FindOrdersByPriceRow, error)
	// FindOrdersByPriceBatch enqueues a FindOrdersByPrice query into batch to be executed
	// later by the batch.
	FindOrdersByPriceBatch(batch genericBatch, minTotal pgtype.Numeric)
	// FindOrdersByPriceScan scans the result of an executed FindOrdersByPriceBatch query.
	FindOrdersByPriceScan(results pgx.BatchResults) ([]FindOrdersByPriceRow, error)

	FindOrdersMRR(ctx context.Context) ([]FindOrdersMRRRow, error)
	// FindOrdersMRRBatch enqueues a FindOrdersMRR query into batch to be executed
	// later by the batch.
	FindOrdersMRRBatch(batch genericBatch)
	// FindOrdersMRRScan scans the result of an executed FindOrdersMRRBatch query.
	FindOrdersMRRScan(results pgx.BatchResults) ([]FindOrdersMRRRow, error)
}

type QuerierConfig struct {
	// DataTypes contains pgtype.Value to use for encoding and decoding instead
	// of sqlgen-generated pgtype.ValueTranscoder.
	//
	// If OIDs are available for an input parameter type and all of its
	// transitive dependencies, sqlgen will use the binary encoding format for
	// the input parameter.
	DataTypes []pgtype.DataType
}