Yimaru-BackEnd/gen/db/wallet_stats.sql.go

// Code generated by sqlc. DO NOT EDIT.
// versions:
//   sqlc v1.29.0
// source: wallet_stats.sql

package dbgen

import (
	"context"

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

const GetWalletStats = `-- name: GetWalletStats :many
SELECT DATE_TRUNC($1, interval_start)::timestamp AS interval_start,
    wallet_stats.wallet_id,
    wallet_stats.wallet_user_id,
    wallet_stats.wallet_user_first_name,
    wallet_stats.wallet_user_last_name,
    wallet_stats.wallet_type,
    wallet_stats.number_of_transactions,
    wallet_stats.total_transactions,
    wallet_stats.number_of_deposits,
    wallet_stats.total_deposits_amount,
    wallet_stats.number_of_withdraws,
    wallet_stats.total_withdraws_amount,
    wallet_stats.number_of_transfers,
    wallet_stats.total_transfers_amount,
    wallet_stats.updated_at
FROM wallet_stats
WHERE (
        wallet_stats.wallet_user_id = $2
        OR $2 IS NULL
    )
GROUP BY interval_start
ORDER BY interval_start DESC
`

type GetWalletStatsParams struct {
	Interval pgtype.Text `json:"interval"`
	UserID   pgtype.Int8 `json:"user_id"`
}

type GetWalletStatsRow struct {
	IntervalStart        pgtype.Timestamp `json:"interval_start"`
	WalletID             int64            `json:"wallet_id"`
	WalletUserID         int64            `json:"wallet_user_id"`
	WalletUserFirstName  string           `json:"wallet_user_first_name"`
	WalletUserLastName   string           `json:"wallet_user_last_name"`
	WalletType           string           `json:"wallet_type"`
	NumberOfTransactions int64            `json:"number_of_transactions"`
	TotalTransactions    int64            `json:"total_transactions"`
	NumberOfDeposits     int64            `json:"number_of_deposits"`
	TotalDepositsAmount  int64            `json:"total_deposits_amount"`
	NumberOfWithdraws    int64            `json:"number_of_withdraws"`
	TotalWithdrawsAmount int64            `json:"total_withdraws_amount"`
	NumberOfTransfers    int64            `json:"number_of_transfers"`
	TotalTransfersAmount int64            `json:"total_transfers_amount"`
	UpdatedAt            pgtype.Timestamp `json:"updated_at"`
}

func (q *Queries) GetWalletStats(ctx context.Context, arg GetWalletStatsParams) ([]GetWalletStatsRow, error) {
	rows, err := q.db.Query(ctx, GetWalletStats, arg.Interval, arg.UserID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []GetWalletStatsRow
	for rows.Next() {
		var i GetWalletStatsRow
		if err := rows.Scan(
			&i.IntervalStart,
			&i.WalletID,
			&i.WalletUserID,
			&i.WalletUserFirstName,
			&i.WalletUserLastName,
			&i.WalletType,
			&i.NumberOfTransactions,
			&i.TotalTransactions,
			&i.NumberOfDeposits,
			&i.TotalDepositsAmount,
			&i.NumberOfWithdraws,
			&i.TotalWithdrawsAmount,
			&i.NumberOfTransfers,
			&i.TotalTransfersAmount,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const GetWalletStatsByID = `-- name: GetWalletStatsByID :many
SELECT wallet_id, wallet_user_id, wallet_user_first_name, wallet_user_last_name, wallet_type, interval_start, number_of_transactions, total_transactions, number_of_deposits, total_deposits_amount, number_of_withdraws, total_withdraws_amount, number_of_transfers, total_transfers_amount, updated_at
FROM wallet_stats
WHERE wallet_id = $1
ORDER BY interval_start DESC
`

func (q *Queries) GetWalletStatsByID(ctx context.Context, walletID int64) ([]WalletStat, error) {
	rows, err := q.db.Query(ctx, GetWalletStatsByID, walletID)
	if err != nil {
		return nil, err
	}
	defer rows.Close()
	var items []WalletStat
	for rows.Next() {
		var i WalletStat
		if err := rows.Scan(
			&i.WalletID,
			&i.WalletUserID,
			&i.WalletUserFirstName,
			&i.WalletUserLastName,
			&i.WalletType,
			&i.IntervalStart,
			&i.NumberOfTransactions,
			&i.TotalTransactions,
			&i.NumberOfDeposits,
			&i.TotalDepositsAmount,
			&i.NumberOfWithdraws,
			&i.TotalWithdrawsAmount,
			&i.NumberOfTransfers,
			&i.TotalTransfersAmount,
			&i.UpdatedAt,
		); err != nil {
			return nil, err
		}
		items = append(items, i)
	}
	if err := rows.Err(); err != nil {
		return nil, err
	}
	return items, nil
}

const UpdateWalletStats = `-- name: UpdateWalletStats :exec
WITH all_transfers AS (
    SELECT sender_wallet_id AS wallet_id,
        amount,
        type
    FROM wallet_transfer
    WHERE sender_wallet_id IS NOT NULL
    UNION ALL
    SELECT receiver_wallet_id AS wallet_id,
        amount,
        type
    FROM wallet_transfer
    WHERE receiver_wallet_id IS NOT NULL
),
transfer_stats AS (
    SELECT wallet_id,
        COUNT(*) AS number_of_transactions,
        COALESCE(SUM(amount), 0) AS total_transactions,
        COUNT(*) FILTER (
            WHERE type = 'deposit'
        ) AS number_of_deposits,
        COALESCE(
            SUM(
                CASE
                    WHEN type = 'deposit' THEN amount
                    ELSE 0
                END
            ),
            0
        ) AS total_deposits_amount,
        COUNT(*) FILTER (
            WHERE type = 'withdraw'
        ) AS number_of_withdraws,
        COALESCE(
            SUM(
                CASE
                    WHEN type = 'withdraw' THEN amount
                    ELSE 0
                END
            ),
            0
        ) AS total_withdraws_amount,
        COUNT(*) FILTER (
            WHERE type = 'wallet'
        ) AS number_of_transfers,
        COALESCE(
            SUM(
                CASE
                    WHEN type = 'wallet' THEN amount
                    ELSE 0
                END
            ),
            0
        ) AS total_transfers_amount
    FROM all_transfers
    GROUP BY wallet_id
)
INSERT INTO wallet_stats(
        wallet_id,
        wallet_user_id,
        wallet_user_first_name,
        wallet_user_last_name,
        wallet_type,
        interval_start,
        number_of_transactions,
        total_transactions,
        number_of_deposits,
        total_deposits_amount,
        number_of_withdraws,
        total_withdraws_amount,
        number_of_transfers,
        total_transfers_amount,
        updated_at
    )
SELECT w.id AS wallet_id,
    w.user_id AS wallet_user_id,
    u.first_name AS wallet_user_first_name,
    u.last_name AS wallet_user_last_name,
    w.type AS wallet_type,
    DATE_TRUNC('day', NOW() AT TIME ZONE 'UTC') AS interval_start,
    COALESCE(ts.number_of_transactions, 0) AS number_of_transactions,
    COALESCE(ts.total_transactions, 0) AS total_transactions,
    COALESCE(ts.number_of_deposits, 0) AS number_of_deposits,
    COALESCE(ts.total_deposits_amount, 0) AS total_deposits_amount,
    COALESCE(ts.number_of_withdraws, 0) AS number_of_withdraws,
    COALESCE(ts.total_withdraws_amount, 0) AS total_withdraws_amount,
    COALESCE(ts.number_of_transfers, 0) AS number_of_transfers,
    COALESCE(ts.total_transfers_amount, 0) AS total_transfers_amount,
    NOW() AS updated_at
FROM wallets w
    LEFT JOIN users u ON u.id = w.user_id
    LEFT JOIN transfer_stats ts ON ts.wallet_id = w.id ON CONFLICT (wallet_id, interval_start) DO
UPDATE
SET number_of_transactions = EXCLUDED.number_of_transactions,
    total_transactions = EXCLUDED.total_transactions,
    number_of_deposits = EXCLUDED.number_of_deposits,
    total_deposits_amount = EXCLUDED.total_deposits_amount,
    number_of_withdraws = EXCLUDED.number_of_withdraws,
    total_withdraws_amount = EXCLUDED.total_withdraws_amount,
    number_of_transfers = EXCLUDED.number_of_transfers,
    total_transfers_amount = EXCLUDED.total_transfers_amount,
    updated_at = EXCLUDED.updated_at
`

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