gaze-indexer/modules/bitcoin/repository/postgres/gen/data.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.26.0
// source: data.sql

package gen

import (
	"context"

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

const batchInsertBlocks = `-- name: BatchInsertBlocks :exec
INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce")
VALUES (
	unnest($1::INT[]),
	unnest($2::TEXT[]),
	unnest($3::INT[]),
	unnest($4::TEXT[]),
	unnest($5::TEXT[]),
	unnest($6::TIMESTAMP WITH TIME ZONE[]), -- or use TIMESTAMPTZ
	unnest($7::BIGINT[]),
	unnest($8::BIGINT[])
)
`

type BatchInsertBlocksParams struct {
	BlockHeightArr   []int32
	BlockHashArr     []string
	VersionArr       []int32
	MerkleRootArr    []string
	PrevBlockHashArr []string
	TimestampArr     []pgtype.Timestamptz
	BitsArr          []int64
	NonceArr         []int64
}

func (q *Queries) BatchInsertBlocks(ctx context.Context, arg BatchInsertBlocksParams) error {
	_, err := q.db.Exec(ctx, batchInsertBlocks,
		arg.BlockHeightArr,
		arg.BlockHashArr,
		arg.VersionArr,
		arg.MerkleRootArr,
		arg.PrevBlockHashArr,
		arg.TimestampArr,
		arg.BitsArr,
		arg.NonceArr,
	)
	return err
}

const batchInsertTransactionTxIns = `-- name: BatchInsertTransactionTxIns :exec
WITH update_txout AS (
	UPDATE "bitcoin_transaction_txouts"
	SET "is_spent" = true
	FROM (SELECT unnest($1::TEXT[]) as tx_hash, unnest($2::INT[]) as tx_idx) as txin
	WHERE "bitcoin_transaction_txouts"."tx_hash" = txin.tx_hash AND "bitcoin_transaction_txouts"."tx_idx" = txin.tx_idx AND "is_spent" = false
	RETURNING "bitcoin_transaction_txouts"."tx_hash", "bitcoin_transaction_txouts"."tx_idx", "pkscript"
), prepare_insert AS (
	SELECT input.tx_hash, input.tx_idx, prevout_tx_hash, prevout_tx_idx, update_txout.pkscript as prevout_pkscript, scriptsig, witness, sequence
		FROM (
			SELECT 
				unnest($3::TEXT[]) as tx_hash,
				unnest($4::INT[]) as tx_idx,
				unnest($1::TEXT[]) as prevout_tx_hash,
				unnest($2::INT[]) as prevout_tx_idx,
				unnest($5::TEXT[]) as scriptsig,
				unnest($6::TEXT[]) as witness,
				unnest($7::INT[]) as sequence
		) input LEFT JOIN update_txout ON "update_txout"."tx_hash" = "input"."prevout_tx_hash" AND "update_txout"."tx_idx" = "input"."prevout_tx_idx"
)
INSERT INTO bitcoin_transaction_txins ("tx_hash","tx_idx","prevout_tx_hash","prevout_tx_idx", "prevout_pkscript","scriptsig","witness","sequence") 
SELECT "tx_hash", "tx_idx", "prevout_tx_hash", "prevout_tx_idx", "prevout_pkscript", "scriptsig", "witness", "sequence" FROM prepare_insert
`

type BatchInsertTransactionTxInsParams struct {
	PrevoutTxHashArr []string
	PrevoutTxIdxArr  []int32
	TxHashArr        []string
	TxIdxArr         []int32
	ScriptsigArr     []string
	WitnessArr       []string
	SequenceArr      []int32
}

func (q *Queries) BatchInsertTransactionTxIns(ctx context.Context, arg BatchInsertTransactionTxInsParams) error {
	_, err := q.db.Exec(ctx, batchInsertTransactionTxIns,
		arg.PrevoutTxHashArr,
		arg.PrevoutTxIdxArr,
		arg.TxHashArr,
		arg.TxIdxArr,
		arg.ScriptsigArr,
		arg.WitnessArr,
		arg.SequenceArr,
	)
	return err
}

const batchInsertTransactionTxOuts = `-- name: BatchInsertTransactionTxOuts :exec
INSERT INTO bitcoin_transaction_txouts ("tx_hash","tx_idx","pkscript","value")
VALUES (
	unnest($1::TEXT[]),
	unnest($2::INT[]),
	unnest($3::TEXT[]),
	unnest($4::BIGINT[])
)
`

type BatchInsertTransactionTxOutsParams struct {
	TxHashArr   []string
	TxIdxArr    []int32
	PkscriptArr []string
	ValueArr    []int64
}

func (q *Queries) BatchInsertTransactionTxOuts(ctx context.Context, arg BatchInsertTransactionTxOutsParams) error {
	_, err := q.db.Exec(ctx, batchInsertTransactionTxOuts,
		arg.TxHashArr,
		arg.TxIdxArr,
		arg.PkscriptArr,
		arg.ValueArr,
	)
	return err
}

const batchInsertTransactions = `-- name: BatchInsertTransactions :exec
INSERT INTO bitcoin_transactions ("tx_hash","version","locktime","block_height","block_hash","idx")
VALUES (
	unnest($1::TEXT[]),
	unnest($2::INT[]),
	unnest($3::BIGINT[]),
	unnest($4::INT[]),
	unnest($5::TEXT[]),
	unnest($6::INT[])
)
`

type BatchInsertTransactionsParams struct {
	TxHashArr      []string
	VersionArr     []int32
	LocktimeArr    []int64
	BlockHeightArr []int32
	BlockHashArr   []string
	IdxArr         []int32
}

func (q *Queries) BatchInsertTransactions(ctx context.Context, arg BatchInsertTransactionsParams) error {
	_, err := q.db.Exec(ctx, batchInsertTransactions,
		arg.TxHashArr,
		arg.VersionArr,
		arg.LocktimeArr,
		arg.BlockHeightArr,
		arg.BlockHashArr,
		arg.IdxArr,
	)
	return err
}

const getBlockByHeight = `-- name: GetBlockByHeight :one
SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks WHERE block_height = $1
`

func (q *Queries) GetBlockByHeight(ctx context.Context, blockHeight int32) (BitcoinBlock, error) {
	row := q.db.QueryRow(ctx, getBlockByHeight, blockHeight)
	var i BitcoinBlock
	err := row.Scan(
		&i.BlockHeight,
		&i.BlockHash,
		&i.Version,
		&i.MerkleRoot,
		&i.PrevBlockHash,
		&i.Timestamp,
		&i.Bits,
		&i.Nonce,
	)
	return i, err
}

const getBlocksByHeightRange = `-- name: GetBlocksByHeightRange :many
SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks WHERE block_height >= $1 AND block_height <= $2 ORDER BY block_height ASC
`

type GetBlocksByHeightRangeParams struct {
	FromHeight int32
	ToHeight   int32
}

func (q *Queries) GetBlocksByHeightRange(ctx context.Context, arg GetBlocksByHeightRangeParams) ([]BitcoinBlock, error) {
	rows, err := q.db.Query(ctx, getBlocksByHeightRange, arg.FromHeight, arg.ToHeight)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BitcoinBlock
	for rows.Next() {
		var i BitcoinBlock
		if err := rows.Scan(
			&i.BlockHeight,
			&i.BlockHash,
			&i.Version,
			&i.MerkleRoot,
			&i.PrevBlockHash,
			&i.Timestamp,
			&i.Bits,
			&i.Nonce,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getLatestBlockHeader = `-- name: GetLatestBlockHeader :one
SELECT block_height, block_hash, version, merkle_root, prev_block_hash, timestamp, bits, nonce FROM bitcoin_blocks ORDER BY block_height DESC LIMIT 1
`

func (q *Queries) GetLatestBlockHeader(ctx context.Context) (BitcoinBlock, error) {
	row := q.db.QueryRow(ctx, getLatestBlockHeader)
	var i BitcoinBlock
	err := row.Scan(
		&i.BlockHeight,
		&i.BlockHash,
		&i.Version,
		&i.MerkleRoot,
		&i.PrevBlockHash,
		&i.Timestamp,
		&i.Bits,
		&i.Nonce,
	)
	return i, err
}

const getTransactionByHash = `-- name: GetTransactionByHash :one
SELECT tx_hash, version, locktime, block_height, block_hash, idx FROM bitcoin_transactions WHERE tx_hash = $1
`

func (q *Queries) GetTransactionByHash(ctx context.Context, txHash string) (BitcoinTransaction, error) {
	row := q.db.QueryRow(ctx, getTransactionByHash, txHash)
	var i BitcoinTransaction
	err := row.Scan(
		&i.TxHash,
		&i.Version,
		&i.Locktime,
		&i.BlockHeight,
		&i.BlockHash,
		&i.Idx,
	)
	return i, err
}

const getTransactionTxInsByTxHashes = `-- name: GetTransactionTxInsByTxHashes :many
SELECT tx_hash, tx_idx, prevout_tx_hash, prevout_tx_idx, prevout_pkscript, scriptsig, witness, sequence FROM bitcoin_transaction_txins WHERE tx_hash = ANY($1::TEXT[])
`

func (q *Queries) GetTransactionTxInsByTxHashes(ctx context.Context, txHashes []string) ([]BitcoinTransactionTxin, error) {
	rows, err := q.db.Query(ctx, getTransactionTxInsByTxHashes, txHashes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BitcoinTransactionTxin
	for rows.Next() {
		var i BitcoinTransactionTxin
		if err := rows.Scan(
			&i.TxHash,
			&i.TxIdx,
			&i.PrevoutTxHash,
			&i.PrevoutTxIdx,
			&i.PrevoutPkscript,
			&i.Scriptsig,
			&i.Witness,
			&i.Sequence,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTransactionTxOutsByTxHashes = `-- name: GetTransactionTxOutsByTxHashes :many
SELECT tx_hash, tx_idx, pkscript, value, is_spent FROM bitcoin_transaction_txouts WHERE tx_hash = ANY($1::TEXT[])
`

func (q *Queries) GetTransactionTxOutsByTxHashes(ctx context.Context, txHashes []string) ([]BitcoinTransactionTxout, error) {
	rows, err := q.db.Query(ctx, getTransactionTxOutsByTxHashes, txHashes)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BitcoinTransactionTxout
	for rows.Next() {
		var i BitcoinTransactionTxout
		if err := rows.Scan(
			&i.TxHash,
			&i.TxIdx,
			&i.Pkscript,
			&i.Value,
			&i.IsSpent,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const getTransactionsByHeightRange = `-- name: GetTransactionsByHeightRange :many
SELECT tx_hash, version, locktime, block_height, block_hash, idx FROM bitcoin_transactions WHERE block_height >= $1 AND block_height <= $2
`

type GetTransactionsByHeightRangeParams struct {
	FromHeight int32
	ToHeight   int32
}

func (q *Queries) GetTransactionsByHeightRange(ctx context.Context, arg GetTransactionsByHeightRangeParams) ([]BitcoinTransaction, error) {
	rows, err := q.db.Query(ctx, getTransactionsByHeightRange, arg.FromHeight, arg.ToHeight)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []BitcoinTransaction
	for rows.Next() {
		var i BitcoinTransaction
		if err := rows.Scan(
			&i.TxHash,
			&i.Version,
			&i.Locktime,
			&i.BlockHeight,
			&i.BlockHash,
			&i.Idx,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const insertBlock = `-- name: InsertBlock :exec
INSERT INTO bitcoin_blocks ("block_height","block_hash","version","merkle_root","prev_block_hash","timestamp","bits","nonce") VALUES ($1, $2, $3, $4, $5, $6, $7, $8)
`

type InsertBlockParams struct {
	BlockHeight   int32
	BlockHash     string
	Version       int32
	MerkleRoot    string
	PrevBlockHash string
	Timestamp     pgtype.Timestamptz
	Bits          int64
	Nonce         int64
}

func (q *Queries) InsertBlock(ctx context.Context, arg InsertBlockParams) error {
	_, err := q.db.Exec(ctx, insertBlock,
		arg.BlockHeight,
		arg.BlockHash,
		arg.Version,
		arg.MerkleRoot,
		arg.PrevBlockHash,
		arg.Timestamp,
		arg.Bits,
		arg.Nonce,
	)
	return err
}

const revertData = `-- name: RevertData :exec
WITH delete_tx AS (
	DELETE FROM "bitcoin_transactions" WHERE "block_height" >= $1
	RETURNING "tx_hash"
), delete_txin AS (
	DELETE FROM  "bitcoin_transaction_txins" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
	RETURNING "prevout_tx_hash", "prevout_tx_idx"
), delete_txout AS (
	DELETE FROM  "bitcoin_transaction_txouts" WHERE "tx_hash" = ANY(SELECT "tx_hash" FROM delete_tx)
	RETURNING "tx_hash", "tx_idx"
), revert_txout_spent AS (
	UPDATE "bitcoin_transaction_txouts"
	SET "is_spent" = false
	WHERE 
		("tx_hash", "tx_idx") IN (SELECT "prevout_tx_hash", "prevout_tx_idx" FROM delete_txin) AND 
		("tx_hash", "tx_idx") NOT IN (SELECT "tx_hash", "tx_idx" FROM delete_txout) -- avoid to modified same row twice (modified the same row twice in a single statement is not supported)
	RETURNING NULL
)
DELETE FROM "bitcoin_blocks" WHERE "bitcoin_blocks"."block_height" >= $1
`

func (q *Queries) RevertData(ctx context.Context, fromHeight int32) error {
	_, err := q.db.Exec(ctx, revertData, fromHeight)
	return err
}