gaze-indexer/modules/runes/repository/postgres/gen/batch.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.27.0
// source: batch.go

package gen

import (
	"context"
	"errors"

	"github.com/jackc/pgx/v5"
	"github.com/jackc/pgx/v5/pgtype"
)

var (
	ErrBatchAlreadyClosed = errors.New("batch already closed")
)

const createOutPointBalances = `-- name: CreateOutPointBalances :batchexec
INSERT INTO runes_outpoint_balances (rune_id, pkscript, tx_hash, tx_idx, amount, block_height, spent_height) VALUES ($1, $2, $3, $4, $5, $6, $7)
`

type CreateOutPointBalancesBatchResults struct {
	br     pgx.BatchResults
	tot    int
	closed bool
}

type CreateOutPointBalancesParams struct {
	RuneID      string
	Pkscript    string
	TxHash      string
	TxIdx       int32
	Amount      pgtype.Numeric
	BlockHeight int32
	SpentHeight pgtype.Int4
}

func (q *Queries) CreateOutPointBalances(ctx context.Context, arg []CreateOutPointBalancesParams) *CreateOutPointBalancesBatchResults {
	batch := &pgx.Batch{}
	for _, a := range arg {
		vals := []interface{}{
			a.RuneID,
			a.Pkscript,
			a.TxHash,
			a.TxIdx,
			a.Amount,
			a.BlockHeight,
			a.SpentHeight,
		}
		batch.Queue(createOutPointBalances, vals...)
	}
	br := q.db.SendBatch(ctx, batch)
	return &CreateOutPointBalancesBatchResults{br, len(arg), false}
}

func (b *CreateOutPointBalancesBatchResults) Exec(f func(int, error)) {
	defer b.br.Close()
	for t := 0; t < b.tot; t++ {
		if b.closed {
			if f != nil {
				f(t, ErrBatchAlreadyClosed)
			}
			continue
		}
		_, err := b.br.Exec()
		if f != nil {
			f(t, err)
		}
	}
}

func (b *CreateOutPointBalancesBatchResults) Close() error {
	b.closed = true
	return b.br.Close()
}

const createRuneBalanceAtBlock = `-- name: CreateRuneBalanceAtBlock :batchexec
INSERT INTO runes_balances (pkscript, block_height, rune_id, amount) VALUES ($1, $2, $3, $4)
`

type CreateRuneBalanceAtBlockBatchResults struct {
	br     pgx.BatchResults
	tot    int
	closed bool
}

type CreateRuneBalanceAtBlockParams struct {
	Pkscript    string
	BlockHeight int32
	RuneID      string
	Amount      pgtype.Numeric
}

func (q *Queries) CreateRuneBalanceAtBlock(ctx context.Context, arg []CreateRuneBalanceAtBlockParams) *CreateRuneBalanceAtBlockBatchResults {
	batch := &pgx.Batch{}
	for _, a := range arg {
		vals := []interface{}{
			a.Pkscript,
			a.BlockHeight,
			a.RuneID,
			a.Amount,
		}
		batch.Queue(createRuneBalanceAtBlock, vals...)
	}
	br := q.db.SendBatch(ctx, batch)
	return &CreateRuneBalanceAtBlockBatchResults{br, len(arg), false}
}

func (b *CreateRuneBalanceAtBlockBatchResults) Exec(f func(int, error)) {
	defer b.br.Close()
	for t := 0; t < b.tot; t++ {
		if b.closed {
			if f != nil {
				f(t, ErrBatchAlreadyClosed)
			}
			continue
		}
		_, err := b.br.Exec()
		if f != nil {
			f(t, err)
		}
	}
}

func (b *CreateRuneBalanceAtBlockBatchResults) Close() error {
	b.closed = true
	return b.br.Close()
}