JakeHillion/storj
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

satellite/satellitedb: phase 2 getting rid of gob encodings in db

Browse Source 
For a thorough explanation of the overall transition, see the message on
commit c053bdbd70.

This change will rename the columns containing gob-encoded big.Floats
and add new columns which will contain the equivalent data in a more
sql-friendly format.

The change should *not* break already-running satellite processes,
because all functionality touching these tables has already been taught
to work with these new columns if it sees any "undefined column" errors.

Change-Id: I229324376533e383c5d05064b8aedad149cf825b
This commit is contained in:
paul cannon 2021-07-28 20:33:05 -05:00 committed by Ivan Fraixedes
parent 150be885b7
commit 3540f9b3ad
9 changed files with 1095 additions and 814 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

215
satellite/payments/stripecoinpayments/transactions_test.go
View File

@ -4,7 +4,6 @@
package stripecoinpayments_test
import (
"context"
"encoding/base64"
"errors"
"sync"
@ -326,7 +325,7 @@ func TestTransactionsDBRates(t *testing.T) {
satellitedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db satellite.DB) {
transactions := db.StripeCoinPayments().Transactions()
val, err := decimal.NewFromString("4.000000000000000005")
val, err := decimal.NewFromString("4.000000000000005")
require.NoError(t, err)
const txID = "tx_id"
@ -423,215 +422,3 @@ func TestTransactions_ApplyTransactionBalance(t *testing.T) {
require.EqualValues(t, "0.2", cbt.Metadata["storj_usd_rate"])
})
}
func TestDatabaseBigFloatTransition(t *testing.T) {
satellitedbtest.Run(t, func(ctx *testcontext.Context, t *testing.T, db satellite.DB) {
transactions := db.StripeCoinPayments().Transactions()
accountID := testrand.UUID()
amount, err := monetary.AmountFromString("100000000.00000001", monetary.StorjToken)
require.NoError(t, err)
received, err := monetary.AmountFromString("0.00000002", monetary.StorjToken)
require.NoError(t, err)
rate1, err := decimal.NewFromString("1001.23456789")
require.NoError(t, err)
rate2, err := decimal.NewFromString("3.14159265")
require.NoError(t, err)
tx1 := stripecoinpayments.Transaction{
ID: "abcdefg",
AccountID: accountID,
Address: "0xbeedeebeedeebeedeebeedeebeedeebeedeebeed",
Amount: amount,
Received: received,
Status: coinpayments.StatusPending,
Key: "beep beep im a sheep",
Timeout: time.Hour * 48,
}
tx2 := stripecoinpayments.Transaction{
ID: "hijklmn",
AccountID: accountID,
Address: "0x77687927642075206576656e20626f746865723f",
Amount: amount,
Received: received,
Status: coinpayments.StatusPending,
Key: "how now im a cow",
Timeout: 0,
}
// perform an Insert on old schema
{
createdAt, err := transactions.Insert(ctx, tx1)
require.NoError(t, err)
requireSaneTimestamp(t, createdAt)
tx1.CreatedAt = createdAt
}
// perform an Update on old schema
{
newReceived, err := monetary.AmountFromString("0.12345678", monetary.StorjToken)
require.NoError(t, err)
upd := stripecoinpayments.TransactionUpdate{
TransactionID: tx1.ID,
Status: coinpayments.StatusReceived,
Received: newReceived,
}
err = transactions.Update(ctx, []stripecoinpayments.TransactionUpdate{upd}, coinpayments.TransactionIDList{tx1.ID})
require.NoError(t, err)
tx1.Status = coinpayments.StatusReceived
tx1.Received = newReceived
}
// perform a ListAccount on old schema
{
accountTxs, err := transactions.ListAccount(ctx, accountID)
require.NoError(t, err)
require.Len(t, accountTxs, 1)
require.Equal(t, tx1, accountTxs[0])
}
// perform a ListPending on old schema
{
pendingTxs, err := transactions.ListPending(ctx, 0, 10, time.Now().UTC())
require.NoError(t, err)
require.Len(t, pendingTxs.Transactions, 1)
// ListPending doesn't get the timeout column, so set it manually in order to check equality of other fields
pendingTxs.Transactions[0].Timeout = tx1.Timeout
require.Equal(t, tx1, pendingTxs.Transactions[0])
require.False(t, pendingTxs.Next)
require.Equal(t, int64(0), pendingTxs.NextOffset)
}
// perform a ListUnapplied on old schema
{
unappliedTxs, err := transactions.ListUnapplied(ctx, 0, 10, time.Now().UTC())
require.NoError(t, err)
require.Len(t, unappliedTxs.Transactions, 1)
// ListUnapplied doesn't get the timeout column, so set it manually in order to check equality of other fields
unappliedTxs.Transactions[0].Timeout = tx1.Timeout
require.Equal(t, tx1, unappliedTxs.Transactions[0])
require.False(t, unappliedTxs.Next)
require.Equal(t, int64(0), unappliedTxs.NextOffset)
}
// perform a LockRate on old schema
{
err = transactions.LockRate(ctx, tx1.ID, rate1)
require.NoError(t, err)
}
// perform a GetLockedRate on old schema
{
gotRate, err := transactions.GetLockedRate(ctx, tx1.ID)
require.NoError(t, err)
require.Equal(t, rate1, gotRate)
}
// do schema update
{
transitionDB := transactions.(interface {
DebugPerformBigFloatTransition(ctx context.Context) error
})
err = transitionDB.DebugPerformBigFloatTransition(ctx)
require.NoError(t, err)
}
// perform an Insert on new schema
{
createdAt, err := transactions.Insert(ctx, tx2)
require.NoError(t, err)
requireSaneTimestamp(t, createdAt)
tx2.CreatedAt = createdAt
}
// perform a ListAccount on new schema, while tx1 has a received_gob
{
accountTxs, err := transactions.ListAccount(ctx, accountID)
require.NoError(t, err)
require.Len(t, accountTxs, 2)
// results should be ordered in reverse order of creation
require.Equal(t, tx2, accountTxs[0])
require.Equal(t, tx1, accountTxs[1])
}
// perform an Update on new schema, on a row with a received_gob
{
newReceived, err := monetary.AmountFromString("1.11111111", monetary.StorjToken)
require.NoError(t, err)
upd := stripecoinpayments.TransactionUpdate{
TransactionID: tx1.ID,
Status: coinpayments.StatusPending,
Received: newReceived,
}
err = transactions.Update(ctx, []stripecoinpayments.TransactionUpdate{upd}, nil)
require.NoError(t, err)
tx1.Status = coinpayments.StatusPending
tx1.Received = newReceived
}
// perform an Update on new schema, on a row with a received_numeric
{
newReceived, err := monetary.AmountFromString("2.12121212", monetary.StorjToken)
require.NoError(t, err)
upd := stripecoinpayments.TransactionUpdate{
TransactionID: tx2.ID,
Status: coinpayments.StatusCompleted,
Received: newReceived,
}
err = transactions.Update(ctx, []stripecoinpayments.TransactionUpdate{upd}, coinpayments.TransactionIDList{tx2.ID})
require.NoError(t, err)
tx2.Status = coinpayments.StatusCompleted
tx2.Received = newReceived
}
// perform a ListAccount on new schema, after the above changes
{
accountTxs, err := transactions.ListAccount(ctx, accountID)
require.NoError(t, err)
require.Len(t, accountTxs, 2)
// results should be ordered in reverse order of creation
require.Equal(t, tx2, accountTxs[0])
require.Equal(t, tx1, accountTxs[1])
}
// perform a ListPending on new schema
{
pendingTxs, err := transactions.ListPending(ctx, 0, 10, time.Now().UTC())
require.NoError(t, err)
require.Len(t, pendingTxs.Transactions, 1)
// ListPending doesn't get the timeout column, so set it manually in order to check equality of other fields
pendingTxs.Transactions[0].Timeout = tx1.Timeout
require.Equal(t, tx1, pendingTxs.Transactions[0])
require.False(t, pendingTxs.Next)
require.Equal(t, int64(0), pendingTxs.NextOffset)
}
// perform a ListUnapplied on new schema
{
unappliedTxs, err := transactions.ListUnapplied(ctx, 0, 10, time.Now().UTC())
require.NoError(t, err)
require.Len(t, unappliedTxs.Transactions, 1)
// ListUnapplied doesn't get the timeout column, so set it manually in order to check equality of other fields
unappliedTxs.Transactions[0].Timeout = tx2.Timeout
require.Equal(t, tx2, unappliedTxs.Transactions[0])
require.False(t, unappliedTxs.Next)
require.Equal(t, int64(0), unappliedTxs.NextOffset)
}
// perform a LockRate on new schema
{
err = transactions.LockRate(ctx, tx2.ID, rate2)
require.NoError(t, err)
}
// perform a GetLockedRate on new schema
{
gotRate, err := transactions.GetLockedRate(ctx, tx1.ID)
require.NoError(t, err)
require.Equal(t, rate1, gotRate)
gotRate, err = transactions.GetLockedRate(ctx, tx2.ID)
require.NoError(t, err)
require.Equal(t, rate2, gotRate)
}
})
}

575
satellite/satellitedb/coinpaymentstxs.go
View File

@ -8,12 +8,10 @@ import (
"math/big"
"time"
pgxerrcode "github.com/jackc/pgerrcode"
"github.com/shopspring/decimal"
"github.com/zeebo/errs"
"storj.io/common/uuid"
"storj.io/private/dbutil/pgutil/pgerrcode"
"storj.io/storj/satellite/payments/coinpayments"
"storj.io/storj/satellite/payments/monetary"
"storj.io/storj/satellite/payments/stripecoinpayments"
@ -49,56 +47,24 @@ type coinPaymentsTransactions struct {
func (db *coinPaymentsTransactions) Insert(ctx context.Context, tx stripecoinpayments.Transaction) (createTime time.Time, err error) {
defer mon.Task()(&ctx)(&err)
amount, err := tx.Amount.AsBigFloat().GobEncode()
if err != nil {
return time.Time{}, errs.Wrap(err)
}
received, err := tx.Received.AsBigFloat().GobEncode()
if err != nil {
return time.Time{}, errs.Wrap(err)
}
dbxCPTX, err := db.db.Create_CoinpaymentsTransaction(ctx,
dbx.CoinpaymentsTransaction_Id(tx.ID.String()),
dbx.CoinpaymentsTransaction_UserId(tx.AccountID[:]),
dbx.CoinpaymentsTransaction_Address(tx.Address),
dbx.CoinpaymentsTransaction_Amount(amount),
dbx.CoinpaymentsTransaction_Received(received),
dbx.CoinpaymentsTransaction_Status(tx.Status.Int()),
dbx.CoinpaymentsTransaction_Key(tx.Key),
dbx.CoinpaymentsTransaction_Timeout(int(tx.Timeout.Seconds())),
dbx.CoinpaymentsTransaction_Create_Fields{
AmountNumeric: dbx.CoinpaymentsTransaction_AmountNumeric(tx.Amount.BaseUnits()),
ReceivedNumeric: dbx.CoinpaymentsTransaction_ReceivedNumeric(tx.Received.BaseUnits()),
},
)
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.insertTransitionShim(ctx, tx)
}
return time.Time{}, err
}
return dbxCPTX.CreatedAt, nil
}
// insertTransitionShim inserts new coinpayments transaction into DB.
//
// It is to be used only during the transition from gob-encoded 'amount' and
// 'received' columns to 'amount_numeric'/'received_numeric'.
//
// When the transition is complete, this method will go away and Insert()
// will operate only on the _numeric columns.
func (db *coinPaymentsTransactions) insertTransitionShim(ctx context.Context, tx stripecoinpayments.Transaction) (createTime time.Time, err error) {
row := db.db.DB.QueryRowContext(ctx, db.db.Rebind(`
INSERT INTO coinpayments_transactions (
id, user_id, address, amount_numeric, received_numeric, status, key, timeout, created_at
) VALUES (
?, ?, ?, ?, ?, ?, ?, ?, now()
) RETURNING created_at;
`), tx.ID.String(), tx.AccountID[:], tx.Address, tx.Amount.BaseUnits(), tx.Received.BaseUnits(), tx.Status.Int(), tx.Key, int(tx.Timeout.Seconds()))
if err := row.Scan(&createTime); err != nil {
return time.Time{}, Error.Wrap(err)
}
return createTime, nil
}
// Update updates status and received for set of transactions.
func (db *coinPaymentsTransactions) Update(ctx context.Context, updates []stripecoinpayments.TransactionUpdate, applies coinpayments.TransactionIDList) (err error) {
defer mon.Task()(&ctx)(&err)
@ -109,16 +75,12 @@ func (db *coinPaymentsTransactions) Update(ctx context.Context, updates []stripe
err = db.db.WithTx(ctx, func(ctx context.Context, tx *dbx.Tx) error {
for _, update := range updates {
receivedGob, err := update.Received.AsBigFloat().GobEncode()
if err != nil {
return errs.Wrap(err)
}
_, err = tx.Update_CoinpaymentsTransaction_By_Id(ctx,
dbx.CoinpaymentsTransaction_Id(update.TransactionID.String()),
dbx.CoinpaymentsTransaction_Update_Fields{
Received: dbx.CoinpaymentsTransaction_Received(receivedGob),
Status: dbx.CoinpaymentsTransaction_Status(update.Status.Int()),
ReceivedNumeric: dbx.CoinpaymentsTransaction_ReceivedNumeric(update.Received.BaseUnits()),
ReceivedGob: dbx.CoinpaymentsTransaction_ReceivedGob_Null(),
Status: dbx.CoinpaymentsTransaction_Status(update.Status.Int()),
},
)
if err != nil {
@ -138,61 +100,9 @@ func (db *coinPaymentsTransactions) Update(ctx context.Context, updates []stripe
return nil
})
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.updateTransitionShim(ctx, updates, applies)
}
}
return err
}
// updateTransitionShim updates status and received for set of transactions.
//
// It is to be used only during the transition from gob-encoded 'amount' and
// 'received' columns to 'amount_numeric'/'received_numeric'. During the
// transition, the gob-encoded columns will still exist but under a different
// name ('amount_gob'/'received_gob'). If the _numeric column value for a given
// row is non-null, it takes precedence over the corresponding _gob column.
//
// When the transition is complete, this method will go away and
// Update() will operate only on the _numeric columns.
func (db *coinPaymentsTransactions) updateTransitionShim(ctx context.Context, updates []stripecoinpayments.TransactionUpdate, applies coinpayments.TransactionIDList) (err error) {
defer mon.Task()(&ctx)(&err)
if len(updates) == 0 {
return nil
}
return db.db.WithTx(ctx, func(ctx context.Context, tx *dbx.Tx) error {
for _, update := range updates {
query := db.db.Rebind(`
UPDATE coinpayments_transactions
SET
received_gob = NULL,
received_numeric = ?,
status = ?
WHERE id = ?
`)
_, err := tx.Tx.ExecContext(ctx, query, update.Received.BaseUnits(), update.Status.Int(), update.TransactionID.String())
if err != nil {
return err
}
}
for _, txID := range applies {
query := db.db.Rebind(`INSERT INTO stripecoinpayments_apply_balance_intents ( tx_id, state, created_at )
VALUES ( ?, ?, ? ) ON CONFLICT DO NOTHING`)
_, err = tx.Tx.ExecContext(ctx, query, txID.String(), applyBalanceIntentStateUnapplied.Int(), db.db.Hooks.Now().UTC())
if err != nil {
return err
}
}
return nil
})
}
// Consume marks transaction as consumed, so it won't participate in apply account balance loop.
func (db *coinPaymentsTransactions) Consume(ctx context.Context, id coinpayments.TransactionID) (err error) {
defer mon.Task()(&ctx)(&err)
@ -232,107 +142,66 @@ func (db *coinPaymentsTransactions) Consume(ctx context.Context, id coinpayments
func (db *coinPaymentsTransactions) LockRate(ctx context.Context, id coinpayments.TransactionID, rate decimal.Decimal) (err error) {
defer mon.Task()(&ctx)(&err)
buff, err := rate.BigFloat().GobEncode()
if err != nil {
return Error.Wrap(err)
rateFloat, exact := rate.Float64()
if !exact {
// It's not clear at the time of writing whether this
// inexactness will ever be something we need to worry about.
// According to the example in the API docs for
// coinpayments.net, exchange rates are given to 24 decimal
// places (!!), which is several digits more precision than we
// can represent exactly in IEEE754 double-precision floating
// point. However, that might not matter, since an exchange rate
// that is correct to ~15 decimal places multiplied by a precise
// monetary.Amount should give results that are correct to
// around 15 decimal places still. At current exchange rates,
// for example, a USD transaction would need to have a value of
// more than $1,000,000,000,000 USD before a calculation using
// this "inexact" rate would get the equivalent number of BTC
// wrong by a single satoshi (10^-8 BTC).
//
// We could avoid all of this by preserving the exact rates as
// given by our provider, but this would involve either (a)
// abuse of the SQL schema (e.g. storing rates as decimal values
// in VARCHAR), (b) storing rates in a way that is opaque to the
// db engine (e.g. gob-encoding, decimal coefficient with
// separate exponents), or (c) adding support for parameterized
// types like NUMERIC to dbx. None of those are very ideal
// either.
delta, _ := rate.Sub(decimal.NewFromFloat(rateFloat)).Float64()
mon.FloatVal("inexact-float64-exchange-rate-delta").Observe(delta)
}
_, err = db.db.Create_StripecoinpaymentsTxConversionRate(ctx,
dbx.StripecoinpaymentsTxConversionRate_TxId(id.String()),
dbx.StripecoinpaymentsTxConversionRate_Rate(buff))
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.lockRateTransitionShim(ctx, id, rate)
}
}
return Error.Wrap(err)
}
// lockRateTransitionShim locks conversion rate for transaction.
//
// It is to be used only during the transition from the gob-encoded 'rate'
// column to 'rate_numeric'.
//
// When the transition is complete, this method will go away and
// LockRate() will operate only on the _numeric column.
func (db *coinPaymentsTransactions) lockRateTransitionShim(ctx context.Context, id coinpayments.TransactionID, rate decimal.Decimal) (err error) {
defer mon.Task()(&ctx)(&err)
now := time.Now().UTC()
query := db.db.Rebind(`
INSERT INTO stripecoinpayments_tx_conversion_rates ( tx_id, rate_numeric, created_at ) VALUES ( ?, ?, ? )
`)
_, err = db.db.DB.ExecContext(ctx, query, id.String(), rate.String(), now)
dbx.StripecoinpaymentsTxConversionRate_Create_Fields{
RateNumeric: dbx.StripecoinpaymentsTxConversionRate_RateNumeric(rateFloat),
})
return Error.Wrap(err)
}
// GetLockedRate returns locked conversion rate for transaction or error if non exists.
func (db *coinPaymentsTransactions) GetLockedRate(ctx context.Context, id coinpayments.TransactionID) (_ decimal.Decimal, err error) {
func (db *coinPaymentsTransactions) GetLockedRate(ctx context.Context, id coinpayments.TransactionID) (rate decimal.Decimal, err error) {
defer mon.Task()(&ctx)(&err)
dbxRate, err := db.db.Get_StripecoinpaymentsTxConversionRate_By_TxId(ctx,
dbx.StripecoinpaymentsTxConversionRate_TxId(id.String()),
)
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.getLockedRateTransitionShim(ctx, id)
}
return decimal.Decimal{}, err
}
var rateF big.Float
if err = rateF.GobDecode(dbxRate.Rate); err != nil {
return decimal.Decimal{}, errs.Wrap(err)
}
rate, err := monetary.DecimalFromBigFloat(&rateF)
if err != nil {
return decimal.Decimal{}, errs.Wrap(err)
}
return rate, nil
}
// getLockedRateTransitionShim returns locked conversion rate for transaction
// or error if none exists.
//
// It is to be used only during the transition from the gob-encoded 'rate'
// column to 'rate_numeric'. During the transition, the gob-encoded column will
// still exist but under a different name ('rate_gob'). If rate_numeric for a
// given row is non-null, it takes precedence over rate_gob.
//
// When the transition is complete, this method will go away and
// GetLockedRate() will operate only on rate_numeric.
func (db *coinPaymentsTransactions) getLockedRateTransitionShim(ctx context.Context, id coinpayments.TransactionID) (_ decimal.Decimal, err error) {
defer mon.Task()(&ctx)(&err)
var rateGob []byte
var rateNumeric *string
query := db.db.Rebind(`
SELECT rate_gob, rate_numeric
FROM stripecoinpayments_tx_conversion_rates
WHERE tx_id = ?
`)
row := db.db.DB.QueryRowContext(ctx, query, id.String())
err = row.Scan(&rateGob, &rateNumeric)
if err != nil {
return decimal.Decimal{}, Error.Wrap(err)
}
if rateNumeric == nil {
if dbxRate.RateNumeric == nil {
// This row does not have a numeric rate value yet
var rateF big.Float
if err = rateF.GobDecode(rateGob); err != nil {
if err = rateF.GobDecode(dbxRate.RateGob); err != nil {
return decimal.Decimal{}, Error.Wrap(err)
}
rate, err := monetary.DecimalFromBigFloat(&rateF)
rate, err = monetary.DecimalFromBigFloat(&rateF)
return rate, Error.Wrap(err)
}
rate, err := decimal.NewFromString(*rateNumeric)
return rate, Error.Wrap(err)
rate = decimal.NewFromFloat(*dbxRate.RateNumeric)
return rate, nil
}
// ListAccount returns all transaction for specific user.
@ -343,10 +212,6 @@ func (db *coinPaymentsTransactions) ListAccount(ctx context.Context, userID uuid
dbx.CoinpaymentsTransaction_UserId(userID[:]),
)
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.listAccountTransitionShim(ctx, userID)
}
return nil, err
}
@ -363,81 +228,6 @@ func (db *coinPaymentsTransactions) ListAccount(ctx context.Context, userID uuid
return txs, nil
}
// listAccountTransitionShim returns all transaction for specific user.
//
// It is to be used only during the transition from gob-encoded 'amount' and
// 'received' columns to 'amount_numeric'/'received_numeric'. During the
// transition, the gob-encoded columns will still exist but under a different
// name ('amount_gob'/'received_gob'). If the _numeric column value for a given
// row is non-null, it takes precedence over the corresponding _gob column.
//
// When the transition is complete, this method will go away and ListAccount()
// will operate only on the _numeric columns.
func (db *coinPaymentsTransactions) listAccountTransitionShim(ctx context.Context, userID uuid.UUID) (_ []stripecoinpayments.Transaction, err error) {
defer mon.Task()(&ctx)(&err)
query := db.db.Rebind(`
SELECT
id,
user_id,
address,
amount_gob,
amount_numeric,
received_gob,
received_numeric,
status,
key,
timeout,
created_at
FROM coinpayments_transactions
WHERE user_id = ?
ORDER BY created_at DESC
`)
rows, err := db.db.DB.QueryContext(ctx, query, userID[:])
if err != nil {
return nil, err
}
defer func() { err = errs.Combine(err, rows.Close()) }()
var txs []stripecoinpayments.Transaction
for rows.Next() {
var tx stripecoinpayments.Transaction
var amountGob, receivedGob []byte
var amountNumeric, receivedNumeric *int64
var timeoutSeconds int
err := rows.Scan(&tx.ID, &tx.AccountID, &tx.Address, &amountGob, &amountNumeric, &receivedGob, &receivedNumeric, &tx.Status, &tx.Key, &timeoutSeconds, &tx.CreatedAt)
if err != nil {
return nil, Error.Wrap(err)
}
tx.Timeout = time.Second * time.Duration(timeoutSeconds)
if amountNumeric == nil {
tx.Amount, err = monetaryAmountFromGobEncodedBigFloat(amountGob, monetary.StorjToken)
if err != nil {
return nil, Error.New("amount column: %v", err)
}
} else {
tx.Amount = monetary.AmountFromBaseUnits(*amountNumeric, monetary.StorjToken)
}
if receivedNumeric == nil {
tx.Received, err = monetaryAmountFromGobEncodedBigFloat(receivedGob, monetary.StorjToken)
if err != nil {
return nil, Error.New("received column: %v", err)
}
} else {
tx.Received = monetary.AmountFromBaseUnits(*receivedNumeric, monetary.StorjToken)
}
txs = append(txs, tx)
}
if err = rows.Err(); err != nil {
return nil, err
}
return txs, nil
}
// ListPending returns paginated list of pending transactions.
func (db *coinPaymentsTransactions) ListPending(ctx context.Context, offset int64, limit int, before time.Time) (_ stripecoinpayments.TransactionsPage, err error) {
defer mon.Task()(&ctx)(&err)
@ -446,8 +236,10 @@ func (db *coinPaymentsTransactions) ListPending(ctx context.Context, offset int6
id,
user_id,
address,
amount,
received,
amount_gob,
amount_numeric,
received_gob,
received_numeric,
status,
key,
created_at
@ -457,104 +249,6 @@ func (db *coinPaymentsTransactions) ListPending(ctx context.Context, offset int6
ORDER by created_at DESC
LIMIT ? OFFSET ?`)
rows, err := db.db.QueryContext(ctx, query, coinpayments.StatusPending, coinpayments.StatusReceived, before, limit+1, offset)
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
// TEMPORARY: fall back to expected new schema to facilitate transition
return db.listPendingTransitionShim(ctx, offset, limit, before)
}
return stripecoinpayments.TransactionsPage{}, err
}
defer func() {
err = errs.Combine(err, rows.Close())
}()
var page stripecoinpayments.TransactionsPage
for rows.Next() {
var id, address string
var userID uuid.UUID
var amountB, receivedB []byte
var status int
var key string
var createdAt time.Time
err := rows.Scan(&id, &userID, &address, &amountB, &receivedB, &status, &key, &createdAt)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
// TODO: the currency here should be passed in to this function or stored
// in the database.
currency := monetary.StorjToken
amount, err := monetaryAmountFromGobEncodedBigFloat(amountB, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
received, err := monetaryAmountFromGobEncodedBigFloat(receivedB, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
page.Transactions = append(page.Transactions,
stripecoinpayments.Transaction{
ID: coinpayments.TransactionID(id),
AccountID: userID,
Address: address,
Amount: amount,
Received: received,
Status: coinpayments.Status(status),
Key: key,
CreatedAt: createdAt,
},
)
}
if err = rows.Err(); err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
if len(page.Transactions) == limit+1 {
page.Next = true
page.NextOffset = offset + int64(limit)
page.Transactions = page.Transactions[:len(page.Transactions)-1]
}
return page, nil
}
// listPendingTransitionShim returns paginated list of pending transactions.
//
// It is to be used only during the transition from gob-encoded 'amount' and
// 'received' columns to 'amount_numeric'/'received_numeric'. During the
// transition, the gob-encoded columns will still exist but under a different
// name ('amount_gob'/'received_gob'). If the _numeric column value for a given
// row is non-null, it takes precedence over the corresponding _gob column.
//
// When the transition is complete, this method will go away and ListPending()
// will operate only on the _numeric columns.
func (db *coinPaymentsTransactions) listPendingTransitionShim(ctx context.Context, offset int64, limit int, before time.Time) (_ stripecoinpayments.TransactionsPage, err error) {
defer mon.Task()(&ctx)(&err)
query := db.db.Rebind(`SELECT
id,
user_id,
address,
amount_gob,
amount_numeric,
received_gob,
received_numeric,
status,
key,
created_at
FROM coinpayments_transactions
WHERE status IN (?,?)
AND created_at <= ?
ORDER BY created_at DESC
LIMIT ? OFFSET ?`)
rows, err := db.db.QueryContext(ctx, query, coinpayments.StatusPending, coinpayments.StatusReceived, before, limit+1, offset)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
@ -578,26 +272,30 @@ func (db *coinPaymentsTransactions) listPendingTransitionShim(ctx context.Contex
err := rows.Scan(&id, &userID, &address, &amountGob, &amountNumeric, &receivedGob, &receivedNumeric, &status, &key, &createdAt)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
}
// TODO: the currency here should be passed in to this function or stored
// in the database.
currency := monetary.StorjToken
if amountNumeric == nil {
// 'amount' in this row hasn't yet been updated to a numeric value
amount, err = monetaryAmountFromGobEncodedBigFloat(amountGob, monetary.StorjToken)
amount, err = monetaryAmountFromGobEncodedBigFloat(amountGob, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
return stripecoinpayments.TransactionsPage{}, Error.New("invalid gob encoding in amount_gob under transaction id %x: %v", id, err)
}
} else {
amount = monetary.AmountFromBaseUnits(*amountNumeric, monetary.StorjToken)
amount = monetary.AmountFromBaseUnits(*amountNumeric, currency)
}
if receivedNumeric == nil {
// 'received' in this row hasn't yet been updated to a numeric value
received, err = monetaryAmountFromGobEncodedBigFloat(receivedGob, monetary.StorjToken)
received, err = monetaryAmountFromGobEncodedBigFloat(receivedGob, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
return stripecoinpayments.TransactionsPage{}, Error.New("invalid gob encoding in received_gob under transaction id %x: %v", id, err)
}
} else {
received = monetary.AmountFromBaseUnits(*receivedNumeric, monetary.StorjToken)
received = monetary.AmountFromBaseUnits(*receivedNumeric, currency)
}
page.Transactions = append(page.Transactions,
@ -631,102 +329,6 @@ func (db *coinPaymentsTransactions) listPendingTransitionShim(ctx context.Contex
func (db *coinPaymentsTransactions) ListUnapplied(ctx context.Context, offset int64, limit int, before time.Time) (_ stripecoinpayments.TransactionsPage, err error) {
defer mon.Task()(&ctx)(&err)
query := db.db.Rebind(`SELECT
txs.id,
txs.user_id,
txs.address,
txs.amount,
txs.received,
txs.status,
txs.key,
txs.created_at
FROM coinpayments_transactions as txs
INNER JOIN stripecoinpayments_apply_balance_intents as ints
ON txs.id = ints.tx_id
WHERE txs.status >= ?
AND txs.created_at <= ?
AND ints.state = ?
ORDER by txs.created_at DESC
LIMIT ? OFFSET ?`)
rows, err := db.db.QueryContext(ctx, query, coinpayments.StatusReceived, before, applyBalanceIntentStateUnapplied, limit+1, offset)
if err != nil {
if errCode := pgerrcode.FromError(err); errCode == pgxerrcode.UndefinedColumn {
return db.listUnappliedTransitionShim(ctx, offset, limit, before)
}
return stripecoinpayments.TransactionsPage{}, err
}
defer func() { err = errs.Combine(err, rows.Close()) }()
var page stripecoinpayments.TransactionsPage
for rows.Next() {
var id, address string
var userID uuid.UUID
var amountB, receivedB []byte
var status int
var key string
var createdAt time.Time
err := rows.Scan(&id, &userID, &address, &amountB, &receivedB, &status, &key, &createdAt)
if err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
// TODO: the currency here should be passed in to this function or stored
// in the database.
currency := monetary.StorjToken
amount, err := monetaryAmountFromGobEncodedBigFloat(amountB, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.New("amount column: %v", err)
}
received, err := monetaryAmountFromGobEncodedBigFloat(receivedB, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.New("received column: %v", err)
}
page.Transactions = append(page.Transactions,
stripecoinpayments.Transaction{
ID: coinpayments.TransactionID(id),
AccountID: userID,
Address: address,
Amount: amount,
Received: received,
Status: coinpayments.Status(status),
Key: key,
CreatedAt: createdAt,
},
)
}
if err = rows.Err(); err != nil {
return stripecoinpayments.TransactionsPage{}, err
}
if len(page.Transactions) == limit+1 {
page.Next = true
page.NextOffset = offset + int64(limit)
page.Transactions = page.Transactions[:len(page.Transactions)-1]
}
return page, nil
}
// listUnappliedTransitionShim returns TransactionsPage with a pending or
// completed status, that should be applied to account balance.
//
// It is to be used only during the transition from gob-encoded 'amount' and
// 'received' columns to 'amount_numeric'/'received_numeric'. During the
// transition, the gob-encoded columns will still exist but under a different
// name ('amount_gob'/'received_gob'). If the _numeric column value for a given
// row is non-null, it takes precedence over the corresponding _gob column.
//
// When the transition is complete, this method will go away and
// ListUnapplied() will operate only on the _numeric columns.
func (db *coinPaymentsTransactions) listUnappliedTransitionShim(ctx context.Context, offset int64, limit int, before time.Time) (_ stripecoinpayments.TransactionsPage, err error) {
defer mon.Task()(&ctx)(&err)
query := db.db.Rebind(`SELECT
txs.id,
txs.user_id,
@ -769,24 +371,28 @@ func (db *coinPaymentsTransactions) listUnappliedTransitionShim(ctx context.Cont
return stripecoinpayments.TransactionsPage{}, err
}
// TODO: the currency here should be passed in to this function or stored
// in the database.
currency := monetary.StorjToken
var amount, received monetary.Amount
if amountNumeric == nil {
// 'amount' in this row hasn't yet been updated to a numeric value
amount, err = monetaryAmountFromGobEncodedBigFloat(amountGob, monetary.StorjToken)
amount, err = monetaryAmountFromGobEncodedBigFloat(amountGob, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
return stripecoinpayments.TransactionsPage{}, Error.New("invalid gob encoding in amount_gob under transaction id %x: %v", id, err)
}
} else {
amount = monetary.AmountFromBaseUnits(*amountNumeric, monetary.StorjToken)
amount = monetary.AmountFromBaseUnits(*amountNumeric, currency)
}
if receivedNumeric == nil {
// 'received' in this row hasn't yet been updated to a numeric value
received, err = monetaryAmountFromGobEncodedBigFloat(receivedGob, monetary.StorjToken)
received, err = monetaryAmountFromGobEncodedBigFloat(receivedGob, currency)
if err != nil {
return stripecoinpayments.TransactionsPage{}, Error.Wrap(err)
return stripecoinpayments.TransactionsPage{}, Error.New("invalid gob encoding in received_gob under transaction id %x: %v", id, err)
}
} else {
received = monetary.AmountFromBaseUnits(*receivedNumeric, monetary.StorjToken)
received = monetary.AmountFromBaseUnits(*receivedNumeric, currency)
}
page.Transactions = append(page.Transactions,
@ -827,13 +433,23 @@ func fromDBXCoinpaymentsTransaction(dbxCPTX *dbx.CoinpaymentsTransaction) (*stri
// in the database.
currency := monetary.StorjToken
amount, err := monetaryAmountFromGobEncodedBigFloat(dbxCPTX.Amount, currency)
if err != nil {
return nil, Error.New("amount column: %v", err)
var amount, received monetary.Amount
if dbxCPTX.AmountNumeric == nil {
amount, err = monetaryAmountFromGobEncodedBigFloat(dbxCPTX.AmountGob, currency)
if err != nil {
return nil, Error.New("amount column: %v", err)
}
} else {
amount = monetary.AmountFromBaseUnits(*dbxCPTX.AmountNumeric, currency)
}
received, err := monetaryAmountFromGobEncodedBigFloat(dbxCPTX.Received, currency)
if err != nil {
return nil, Error.New("received column: %v", err)
if dbxCPTX.ReceivedNumeric == nil {
received, err = monetaryAmountFromGobEncodedBigFloat(dbxCPTX.ReceivedGob, currency)
if err != nil {
return nil, Error.New("received column: %v", err)
}
} else {
received = monetary.AmountFromBaseUnits(*dbxCPTX.ReceivedNumeric, currency)
}
return &stripecoinpayments.Transaction{
@ -856,24 +472,3 @@ func monetaryAmountFromGobEncodedBigFloat(encoded []byte, currency *monetary.Cur
}
return monetary.AmountFromBigFloat(&bf, currency)
}
// DebugPerformBigFloatTransition performs the schema changes expected as part
// of Step 2 of the transition away from gob-encoded big.Float columns in the
// database.
//
// This is for testing purposes only, to ensure that no data is lost and that
// code still works after the transition.
func (db *coinPaymentsTransactions) DebugPerformBigFloatTransition(ctx context.Context) error {
_, err := db.db.DB.ExecContext(ctx, `
ALTER TABLE coinpayments_transactions ALTER COLUMN amount DROP NOT NULL;
ALTER TABLE coinpayments_transactions ALTER COLUMN received DROP NOT NULL;
ALTER TABLE coinpayments_transactions RENAME COLUMN amount TO amount_gob;
ALTER TABLE coinpayments_transactions RENAME COLUMN received TO received_gob;
ALTER TABLE coinpayments_transactions ADD COLUMN amount_numeric INT8;
ALTER TABLE coinpayments_transactions ADD COLUMN received_numeric INT8;
ALTER TABLE stripecoinpayments_tx_conversion_rates ALTER COLUMN rate DROP NOT NULL;
ALTER TABLE stripecoinpayments_tx_conversion_rates RENAME COLUMN rate TO rate_gob;
ALTER TABLE stripecoinpayments_tx_conversion_rates ADD COLUMN rate_numeric NUMERIC(20, 8);
`)
return Error.Wrap(err)
}

21
satellite/satellitedb/dbx/satellitedb.dbx
View File

@ -1109,14 +1109,16 @@ read limitoffset (
model coinpayments_transaction (
key id
field id text
field user_id blob
field address text
field amount blob
field received blob ( updatable )
field status int ( updatable )
field key text
field timeout int
field id text
field user_id blob
field address text
field amount_gob blob ( nullable, updatable )
field amount_numeric int64 ( nullable, updatable )
field received_gob blob ( nullable, updatable )
field received_numeric int64 ( nullable, updatable )
field status int ( updatable )
field key text
field timeout int
field created_at timestamp ( autoinsert )
)
@ -1178,7 +1180,8 @@ model stripecoinpayments_tx_conversion_rate (
key tx_id
field tx_id text
field rate blob
field rate_gob blob ( nullable )
field rate_numeric float64 ( nullable )
field created_at timestamp ( autoinsert )
)

383
satellite/satellitedb/dbx/satellitedb.dbx.go
View File

@ -376,8 +376,10 @@ CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
amount_gob bytea,
amount_numeric bigint,
received_gob bytea,
received_numeric bigint,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
@ -718,7 +720,8 @@ CREATE TABLE stripecoinpayments_invoice_project_records (
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
@ -998,8 +1001,10 @@ CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
amount_gob bytea,
amount_numeric bigint,
received_gob bytea,
received_numeric bigint,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
@ -1340,7 +1345,8 @@ CREATE TABLE stripecoinpayments_invoice_project_records (
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
@ -2321,22 +2327,34 @@ func (f BucketStorageTally_MetadataSize_Field) value() interface{} {
func (BucketStorageTally_MetadataSize_Field) _Column() string { return "metadata_size" }
type CoinpaymentsTransaction struct {
Id string
UserId []byte
Address string
Amount []byte
Received []byte
Status int
Key string
Timeout int
CreatedAt time.Time
Id string
UserId []byte
Address string
AmountGob []byte
AmountNumeric *int64
ReceivedGob []byte
ReceivedNumeric *int64
Status int
Key string
Timeout int
CreatedAt time.Time
}
func (CoinpaymentsTransaction) _Table() string { return "coinpayments_transactions" }
type CoinpaymentsTransaction_Create_Fields struct {
AmountGob CoinpaymentsTransaction_AmountGob_Field
AmountNumeric CoinpaymentsTransaction_AmountNumeric_Field
ReceivedGob CoinpaymentsTransaction_ReceivedGob_Field
ReceivedNumeric CoinpaymentsTransaction_ReceivedNumeric_Field
}
type CoinpaymentsTransaction_Update_Fields struct {
Received CoinpaymentsTransaction_Received_Field
Status CoinpaymentsTransaction_Status_Field
AmountGob CoinpaymentsTransaction_AmountGob_Field
AmountNumeric CoinpaymentsTransaction_AmountNumeric_Field
ReceivedGob CoinpaymentsTransaction_ReceivedGob_Field
ReceivedNumeric CoinpaymentsTransaction_ReceivedNumeric_Field
Status CoinpaymentsTransaction_Status_Field
}
type CoinpaymentsTransaction_Id_Field struct {
@ -2396,43 +2414,141 @@ func (f CoinpaymentsTransaction_Address_Field) value() interface{} {
func (CoinpaymentsTransaction_Address_Field) _Column() string { return "address" }
type CoinpaymentsTransaction_Amount_Field struct {
type CoinpaymentsTransaction_AmountGob_Field struct {
_set bool
_null bool
_value []byte
}
func CoinpaymentsTransaction_Amount(v []byte) CoinpaymentsTransaction_Amount_Field {
return CoinpaymentsTransaction_Amount_Field{_set: true, _value: v}
func CoinpaymentsTransaction_AmountGob(v []byte) CoinpaymentsTransaction_AmountGob_Field {
return CoinpaymentsTransaction_AmountGob_Field{_set: true, _value: v}
}
func (f CoinpaymentsTransaction_Amount_Field) value() interface{} {
func CoinpaymentsTransaction_AmountGob_Raw(v []byte) CoinpaymentsTransaction_AmountGob_Field {
if v == nil {
return CoinpaymentsTransaction_AmountGob_Null()
}
return CoinpaymentsTransaction_AmountGob(v)
}
func CoinpaymentsTransaction_AmountGob_Null() CoinpaymentsTransaction_AmountGob_Field {
return CoinpaymentsTransaction_AmountGob_Field{_set: true, _null: true}
}
func (f CoinpaymentsTransaction_AmountGob_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f CoinpaymentsTransaction_AmountGob_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (CoinpaymentsTransaction_Amount_Field) _Column() string { return "amount" }
func (CoinpaymentsTransaction_AmountGob_Field) _Column() string { return "amount_gob" }
type CoinpaymentsTransaction_Received_Field struct {
type CoinpaymentsTransaction_AmountNumeric_Field struct {
_set bool
_null bool
_value []byte
_value *int64
}
func CoinpaymentsTransaction_Received(v []byte) CoinpaymentsTransaction_Received_Field {
return CoinpaymentsTransaction_Received_Field{_set: true, _value: v}
func CoinpaymentsTransaction_AmountNumeric(v int64) CoinpaymentsTransaction_AmountNumeric_Field {
return CoinpaymentsTransaction_AmountNumeric_Field{_set: true, _value: &v}
}
func (f CoinpaymentsTransaction_Received_Field) value() interface{} {
func CoinpaymentsTransaction_AmountNumeric_Raw(v *int64) CoinpaymentsTransaction_AmountNumeric_Field {
if v == nil {
return CoinpaymentsTransaction_AmountNumeric_Null()
}
return CoinpaymentsTransaction_AmountNumeric(*v)
}
func CoinpaymentsTransaction_AmountNumeric_Null() CoinpaymentsTransaction_AmountNumeric_Field {
return CoinpaymentsTransaction_AmountNumeric_Field{_set: true, _null: true}
}
func (f CoinpaymentsTransaction_AmountNumeric_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f CoinpaymentsTransaction_AmountNumeric_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (CoinpaymentsTransaction_Received_Field) _Column() string { return "received" }
func (CoinpaymentsTransaction_AmountNumeric_Field) _Column() string { return "amount_numeric" }
type CoinpaymentsTransaction_ReceivedGob_Field struct {
_set bool
_null bool
_value []byte
}
func CoinpaymentsTransaction_ReceivedGob(v []byte) CoinpaymentsTransaction_ReceivedGob_Field {
return CoinpaymentsTransaction_ReceivedGob_Field{_set: true, _value: v}
}
func CoinpaymentsTransaction_ReceivedGob_Raw(v []byte) CoinpaymentsTransaction_ReceivedGob_Field {
if v == nil {
return CoinpaymentsTransaction_ReceivedGob_Null()
}
return CoinpaymentsTransaction_ReceivedGob(v)
}
func CoinpaymentsTransaction_ReceivedGob_Null() CoinpaymentsTransaction_ReceivedGob_Field {
return CoinpaymentsTransaction_ReceivedGob_Field{_set: true, _null: true}
}
func (f CoinpaymentsTransaction_ReceivedGob_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f CoinpaymentsTransaction_ReceivedGob_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (CoinpaymentsTransaction_ReceivedGob_Field) _Column() string { return "received_gob" }
type CoinpaymentsTransaction_ReceivedNumeric_Field struct {
_set bool
_null bool
_value *int64
}
func CoinpaymentsTransaction_ReceivedNumeric(v int64) CoinpaymentsTransaction_ReceivedNumeric_Field {
return CoinpaymentsTransaction_ReceivedNumeric_Field{_set: true, _value: &v}
}
func CoinpaymentsTransaction_ReceivedNumeric_Raw(v *int64) CoinpaymentsTransaction_ReceivedNumeric_Field {
if v == nil {
return CoinpaymentsTransaction_ReceivedNumeric_Null()
}
return CoinpaymentsTransaction_ReceivedNumeric(*v)
}
func CoinpaymentsTransaction_ReceivedNumeric_Null() CoinpaymentsTransaction_ReceivedNumeric_Field {
return CoinpaymentsTransaction_ReceivedNumeric_Field{_set: true, _null: true}
}
func (f CoinpaymentsTransaction_ReceivedNumeric_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f CoinpaymentsTransaction_ReceivedNumeric_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (CoinpaymentsTransaction_ReceivedNumeric_Field) _Column() string { return "received_numeric" }
type CoinpaymentsTransaction_Status_Field struct {
_set bool
@ -8447,15 +8563,21 @@ func (f StripecoinpaymentsInvoiceProjectRecord_CreatedAt_Field) value() interfac
func (StripecoinpaymentsInvoiceProjectRecord_CreatedAt_Field) _Column() string { return "created_at" }
type StripecoinpaymentsTxConversionRate struct {
TxId string
Rate []byte
CreatedAt time.Time
TxId string
RateGob []byte
RateNumeric *float64
CreatedAt time.Time
}
func (StripecoinpaymentsTxConversionRate) _Table() string {
return "stripecoinpayments_tx_conversion_rates"
}
type StripecoinpaymentsTxConversionRate_Create_Fields struct {
RateGob StripecoinpaymentsTxConversionRate_RateGob_Field
RateNumeric StripecoinpaymentsTxConversionRate_RateNumeric_Field
}
type StripecoinpaymentsTxConversionRate_Update_Fields struct {
}
@ -8478,24 +8600,73 @@ func (f StripecoinpaymentsTxConversionRate_TxId_Field) value() interface{} {
func (StripecoinpaymentsTxConversionRate_TxId_Field) _Column() string { return "tx_id" }
type StripecoinpaymentsTxConversionRate_Rate_Field struct {
type StripecoinpaymentsTxConversionRate_RateGob_Field struct {
_set bool
_null bool
_value []byte
}
func StripecoinpaymentsTxConversionRate_Rate(v []byte) StripecoinpaymentsTxConversionRate_Rate_Field {
return StripecoinpaymentsTxConversionRate_Rate_Field{_set: true, _value: v}
func StripecoinpaymentsTxConversionRate_RateGob(v []byte) StripecoinpaymentsTxConversionRate_RateGob_Field {
return StripecoinpaymentsTxConversionRate_RateGob_Field{_set: true, _value: v}
}
func (f StripecoinpaymentsTxConversionRate_Rate_Field) value() interface{} {
func StripecoinpaymentsTxConversionRate_RateGob_Raw(v []byte) StripecoinpaymentsTxConversionRate_RateGob_Field {
if v == nil {
return StripecoinpaymentsTxConversionRate_RateGob_Null()
}
return StripecoinpaymentsTxConversionRate_RateGob(v)
}
func StripecoinpaymentsTxConversionRate_RateGob_Null() StripecoinpaymentsTxConversionRate_RateGob_Field {
return StripecoinpaymentsTxConversionRate_RateGob_Field{_set: true, _null: true}
}
func (f StripecoinpaymentsTxConversionRate_RateGob_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f StripecoinpaymentsTxConversionRate_RateGob_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (StripecoinpaymentsTxConversionRate_Rate_Field) _Column() string { return "rate" }
func (StripecoinpaymentsTxConversionRate_RateGob_Field) _Column() string { return "rate_gob" }
type StripecoinpaymentsTxConversionRate_RateNumeric_Field struct {
_set bool
_null bool
_value *float64
}
func StripecoinpaymentsTxConversionRate_RateNumeric(v float64) StripecoinpaymentsTxConversionRate_RateNumeric_Field {
return StripecoinpaymentsTxConversionRate_RateNumeric_Field{_set: true, _value: &v}
}
func StripecoinpaymentsTxConversionRate_RateNumeric_Raw(v *float64) StripecoinpaymentsTxConversionRate_RateNumeric_Field {
if v == nil {
return StripecoinpaymentsTxConversionRate_RateNumeric_Null()
}
return StripecoinpaymentsTxConversionRate_RateNumeric(*v)
}
func StripecoinpaymentsTxConversionRate_RateNumeric_Null() StripecoinpaymentsTxConversionRate_RateNumeric_Field {
return StripecoinpaymentsTxConversionRate_RateNumeric_Field{_set: true, _null: true}
}
func (f StripecoinpaymentsTxConversionRate_RateNumeric_Field) isnull() bool {
return !f._set || f._null || f._value == nil
}
func (f StripecoinpaymentsTxConversionRate_RateNumeric_Field) value() interface{} {
if !f._set || f._null {
return nil
}
return f._value
}
func (StripecoinpaymentsTxConversionRate_RateNumeric_Field) _Column() string { return "rate_numeric" }
type StripecoinpaymentsTxConversionRate_CreatedAt_Field struct {
_set bool
@ -11623,11 +11794,10 @@ func (obj *pgxImpl) Create_CoinpaymentsTransaction(ctx context.Context,
coinpayments_transaction_id CoinpaymentsTransaction_Id_Field,
coinpayments_transaction_user_id CoinpaymentsTransaction_UserId_Field,
coinpayments_transaction_address CoinpaymentsTransaction_Address_Field,
coinpayments_transaction_amount CoinpaymentsTransaction_Amount_Field,
coinpayments_transaction_received CoinpaymentsTransaction_Received_Field,
coinpayments_transaction_status CoinpaymentsTransaction_Status_Field,
coinpayments_transaction_key CoinpaymentsTransaction_Key_Field,
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field) (
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field,
optional CoinpaymentsTransaction_Create_Fields) (
coinpayments_transaction *CoinpaymentsTransaction, err error) {
defer mon.Task()(&ctx)(&err)
@ -11635,23 +11805,25 @@ func (obj *pgxImpl) Create_CoinpaymentsTransaction(ctx context.Context,
__id_val := coinpayments_transaction_id.value()
__user_id_val := coinpayments_transaction_user_id.value()
__address_val := coinpayments_transaction_address.value()
__amount_val := coinpayments_transaction_amount.value()
__received_val := coinpayments_transaction_received.value()
__amount_gob_val := optional.AmountGob.value()
__amount_numeric_val := optional.AmountNumeric.value()
__received_gob_val := optional.ReceivedGob.value()
__received_numeric_val := optional.ReceivedNumeric.value()
__status_val := coinpayments_transaction_status.value()
__key_val := coinpayments_transaction_key.value()
__timeout_val := coinpayments_transaction_timeout.value()
__created_at_val := __now
var __embed_stmt = __sqlbundle_Literal("INSERT INTO coinpayments_transactions ( id, user_id, address, amount, received, status, key, timeout, created_at ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO coinpayments_transactions ( id, user_id, address, amount_gob, amount_numeric, received_gob, received_numeric, status, key, timeout, created_at ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")
var __values []interface{}
__values = append(__values, __id_val, __user_id_val, __address_val, __amount_val, __received_val, __status_val, __key_val, __timeout_val, __created_at_val)
__values = append(__values, __id_val, __user_id_val, __address_val, __amount_gob_val, __amount_numeric_val, __received_gob_val, __received_numeric_val, __status_val, __key_val, __timeout_val, __created_at_val)
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
coinpayments_transaction = &CoinpaymentsTransaction{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err != nil {
return nil, obj.makeErr(err)
}
@ -11702,25 +11874,26 @@ func (obj *pgxImpl) Create_StripecoinpaymentsInvoiceProjectRecord(ctx context.Co
func (obj *pgxImpl) Create_StripecoinpaymentsTxConversionRate(ctx context.Context,
stripecoinpayments_tx_conversion_rate_tx_id StripecoinpaymentsTxConversionRate_TxId_Field,
stripecoinpayments_tx_conversion_rate_rate StripecoinpaymentsTxConversionRate_Rate_Field) (
optional StripecoinpaymentsTxConversionRate_Create_Fields) (
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error) {
defer mon.Task()(&ctx)(&err)
__now := obj.db.Hooks.Now().UTC()
__tx_id_val := stripecoinpayments_tx_conversion_rate_tx_id.value()
__rate_val := stripecoinpayments_tx_conversion_rate_rate.value()
__rate_gob_val := optional.RateGob.value()
__rate_numeric_val := optional.RateNumeric.value()
__created_at_val := __now
var __embed_stmt = __sqlbundle_Literal("INSERT INTO stripecoinpayments_tx_conversion_rates ( tx_id, rate, created_at ) VALUES ( ?, ?, ? ) RETURNING stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate, stripecoinpayments_tx_conversion_rates.created_at")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO stripecoinpayments_tx_conversion_rates ( tx_id, rate_gob, rate_numeric, created_at ) VALUES ( ?, ?, ?, ? ) RETURNING stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate_gob, stripecoinpayments_tx_conversion_rates.rate_numeric, stripecoinpayments_tx_conversion_rates.created_at")
var __values []interface{}
__values = append(__values, __tx_id_val, __rate_val, __created_at_val)
__values = append(__values, __tx_id_val, __rate_gob_val, __rate_numeric_val, __created_at_val)
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
stripecoinpayments_tx_conversion_rate = &StripecoinpaymentsTxConversionRate{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.Rate, &stripecoinpayments_tx_conversion_rate.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.RateGob, &stripecoinpayments_tx_conversion_rate.RateNumeric, &stripecoinpayments_tx_conversion_rate.CreatedAt)
if err != nil {
return nil, obj.makeErr(err)
}
@ -14190,7 +14363,7 @@ func (obj *pgxImpl) All_CoinpaymentsTransaction_By_UserId_OrderBy_Desc_CreatedAt
rows []*CoinpaymentsTransaction, err error) {
defer mon.Task()(&ctx)(&err)
var __embed_stmt = __sqlbundle_Literal("SELECT coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at FROM coinpayments_transactions WHERE coinpayments_transactions.user_id = ? ORDER BY coinpayments_transactions.created_at DESC")
var __embed_stmt = __sqlbundle_Literal("SELECT coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at FROM coinpayments_transactions WHERE coinpayments_transactions.user_id = ? ORDER BY coinpayments_transactions.created_at DESC")
var __values []interface{}
__values = append(__values, coinpayments_transaction_user_id.value())
@ -14208,7 +14381,7 @@ func (obj *pgxImpl) All_CoinpaymentsTransaction_By_UserId_OrderBy_Desc_CreatedAt
for __rows.Next() {
coinpayments_transaction := &CoinpaymentsTransaction{}
err = __rows.Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = __rows.Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err != nil {
return nil, err
}
@ -14310,7 +14483,7 @@ func (obj *pgxImpl) Get_StripecoinpaymentsTxConversionRate_By_TxId(ctx context.C
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error) {
defer mon.Task()(&ctx)(&err)
var __embed_stmt = __sqlbundle_Literal("SELECT stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate, stripecoinpayments_tx_conversion_rates.created_at FROM stripecoinpayments_tx_conversion_rates WHERE stripecoinpayments_tx_conversion_rates.tx_id = ?")
var __embed_stmt = __sqlbundle_Literal("SELECT stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate_gob, stripecoinpayments_tx_conversion_rates.rate_numeric, stripecoinpayments_tx_conversion_rates.created_at FROM stripecoinpayments_tx_conversion_rates WHERE stripecoinpayments_tx_conversion_rates.tx_id = ?")
var __values []interface{}
__values = append(__values, stripecoinpayments_tx_conversion_rate_tx_id.value())
@ -14319,7 +14492,7 @@ func (obj *pgxImpl) Get_StripecoinpaymentsTxConversionRate_By_TxId(ctx context.C
obj.logStmt(__stmt, __values...)
stripecoinpayments_tx_conversion_rate = &StripecoinpaymentsTxConversionRate{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.Rate, &stripecoinpayments_tx_conversion_rate.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.RateGob, &stripecoinpayments_tx_conversion_rate.RateNumeric, &stripecoinpayments_tx_conversion_rate.CreatedAt)
if err != nil {
return (*StripecoinpaymentsTxConversionRate)(nil), obj.makeErr(err)
}
@ -16140,15 +16313,30 @@ func (obj *pgxImpl) Update_CoinpaymentsTransaction_By_Id(ctx context.Context,
defer mon.Task()(&ctx)(&err)
var __sets = &__sqlbundle_Hole{}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE coinpayments_transactions SET "), __sets, __sqlbundle_Literal(" WHERE coinpayments_transactions.id = ? RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")}}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE coinpayments_transactions SET "), __sets, __sqlbundle_Literal(" WHERE coinpayments_transactions.id = ? RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")}}
__sets_sql := __sqlbundle_Literals{Join: ", "}
var __values []interface{}
var __args []interface{}
if update.Received._set {
__values = append(__values, update.Received.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received = ?"))
if update.AmountGob._set {
__values = append(__values, update.AmountGob.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("amount_gob = ?"))
}
if update.AmountNumeric._set {
__values = append(__values, update.AmountNumeric.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("amount_numeric = ?"))
}
if update.ReceivedGob._set {
__values = append(__values, update.ReceivedGob.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received_gob = ?"))
}
if update.ReceivedNumeric._set {
__values = append(__values, update.ReceivedNumeric.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received_numeric = ?"))
}
if update.Status._set {
@ -16169,7 +16357,7 @@ func (obj *pgxImpl) Update_CoinpaymentsTransaction_By_Id(ctx context.Context,
obj.logStmt(__stmt, __values...)
coinpayments_transaction = &CoinpaymentsTransaction{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err == sql.ErrNoRows {
return nil, nil
}
@ -17992,11 +18180,10 @@ func (obj *pgxcockroachImpl) Create_CoinpaymentsTransaction(ctx context.Context,
coinpayments_transaction_id CoinpaymentsTransaction_Id_Field,
coinpayments_transaction_user_id CoinpaymentsTransaction_UserId_Field,
coinpayments_transaction_address CoinpaymentsTransaction_Address_Field,
coinpayments_transaction_amount CoinpaymentsTransaction_Amount_Field,
coinpayments_transaction_received CoinpaymentsTransaction_Received_Field,
coinpayments_transaction_status CoinpaymentsTransaction_Status_Field,
coinpayments_transaction_key CoinpaymentsTransaction_Key_Field,
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field) (
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field,
optional CoinpaymentsTransaction_Create_Fields) (
coinpayments_transaction *CoinpaymentsTransaction, err error) {
defer mon.Task()(&ctx)(&err)
@ -18004,23 +18191,25 @@ func (obj *pgxcockroachImpl) Create_CoinpaymentsTransaction(ctx context.Context,
__id_val := coinpayments_transaction_id.value()
__user_id_val := coinpayments_transaction_user_id.value()
__address_val := coinpayments_transaction_address.value()
__amount_val := coinpayments_transaction_amount.value()
__received_val := coinpayments_transaction_received.value()
__amount_gob_val := optional.AmountGob.value()
__amount_numeric_val := optional.AmountNumeric.value()
__received_gob_val := optional.ReceivedGob.value()
__received_numeric_val := optional.ReceivedNumeric.value()
__status_val := coinpayments_transaction_status.value()
__key_val := coinpayments_transaction_key.value()
__timeout_val := coinpayments_transaction_timeout.value()
__created_at_val := __now
var __embed_stmt = __sqlbundle_Literal("INSERT INTO coinpayments_transactions ( id, user_id, address, amount, received, status, key, timeout, created_at ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO coinpayments_transactions ( id, user_id, address, amount_gob, amount_numeric, received_gob, received_numeric, status, key, timeout, created_at ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")
var __values []interface{}
__values = append(__values, __id_val, __user_id_val, __address_val, __amount_val, __received_val, __status_val, __key_val, __timeout_val, __created_at_val)
__values = append(__values, __id_val, __user_id_val, __address_val, __amount_gob_val, __amount_numeric_val, __received_gob_val, __received_numeric_val, __status_val, __key_val, __timeout_val, __created_at_val)
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
coinpayments_transaction = &CoinpaymentsTransaction{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err != nil {
return nil, obj.makeErr(err)
}
@ -18071,25 +18260,26 @@ func (obj *pgxcockroachImpl) Create_StripecoinpaymentsInvoiceProjectRecord(ctx c
func (obj *pgxcockroachImpl) Create_StripecoinpaymentsTxConversionRate(ctx context.Context,
stripecoinpayments_tx_conversion_rate_tx_id StripecoinpaymentsTxConversionRate_TxId_Field,
stripecoinpayments_tx_conversion_rate_rate StripecoinpaymentsTxConversionRate_Rate_Field) (
optional StripecoinpaymentsTxConversionRate_Create_Fields) (
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error) {
defer mon.Task()(&ctx)(&err)
__now := obj.db.Hooks.Now().UTC()
__tx_id_val := stripecoinpayments_tx_conversion_rate_tx_id.value()
__rate_val := stripecoinpayments_tx_conversion_rate_rate.value()
__rate_gob_val := optional.RateGob.value()
__rate_numeric_val := optional.RateNumeric.value()
__created_at_val := __now
var __embed_stmt = __sqlbundle_Literal("INSERT INTO stripecoinpayments_tx_conversion_rates ( tx_id, rate, created_at ) VALUES ( ?, ?, ? ) RETURNING stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate, stripecoinpayments_tx_conversion_rates.created_at")
var __embed_stmt = __sqlbundle_Literal("INSERT INTO stripecoinpayments_tx_conversion_rates ( tx_id, rate_gob, rate_numeric, created_at ) VALUES ( ?, ?, ?, ? ) RETURNING stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate_gob, stripecoinpayments_tx_conversion_rates.rate_numeric, stripecoinpayments_tx_conversion_rates.created_at")
var __values []interface{}
__values = append(__values, __tx_id_val, __rate_val, __created_at_val)
__values = append(__values, __tx_id_val, __rate_gob_val, __rate_numeric_val, __created_at_val)
var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt)
obj.logStmt(__stmt, __values...)
stripecoinpayments_tx_conversion_rate = &StripecoinpaymentsTxConversionRate{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.Rate, &stripecoinpayments_tx_conversion_rate.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.RateGob, &stripecoinpayments_tx_conversion_rate.RateNumeric, &stripecoinpayments_tx_conversion_rate.CreatedAt)
if err != nil {
return nil, obj.makeErr(err)
}
@ -20559,7 +20749,7 @@ func (obj *pgxcockroachImpl) All_CoinpaymentsTransaction_By_UserId_OrderBy_Desc_
rows []*CoinpaymentsTransaction, err error) {
defer mon.Task()(&ctx)(&err)
var __embed_stmt = __sqlbundle_Literal("SELECT coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at FROM coinpayments_transactions WHERE coinpayments_transactions.user_id = ? ORDER BY coinpayments_transactions.created_at DESC")
var __embed_stmt = __sqlbundle_Literal("SELECT coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at FROM coinpayments_transactions WHERE coinpayments_transactions.user_id = ? ORDER BY coinpayments_transactions.created_at DESC")
var __values []interface{}
__values = append(__values, coinpayments_transaction_user_id.value())
@ -20577,7 +20767,7 @@ func (obj *pgxcockroachImpl) All_CoinpaymentsTransaction_By_UserId_OrderBy_Desc_
for __rows.Next() {
coinpayments_transaction := &CoinpaymentsTransaction{}
err = __rows.Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = __rows.Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err != nil {
return nil, err
}
@ -20679,7 +20869,7 @@ func (obj *pgxcockroachImpl) Get_StripecoinpaymentsTxConversionRate_By_TxId(ctx
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error) {
defer mon.Task()(&ctx)(&err)
var __embed_stmt = __sqlbundle_Literal("SELECT stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate, stripecoinpayments_tx_conversion_rates.created_at FROM stripecoinpayments_tx_conversion_rates WHERE stripecoinpayments_tx_conversion_rates.tx_id = ?")
var __embed_stmt = __sqlbundle_Literal("SELECT stripecoinpayments_tx_conversion_rates.tx_id, stripecoinpayments_tx_conversion_rates.rate_gob, stripecoinpayments_tx_conversion_rates.rate_numeric, stripecoinpayments_tx_conversion_rates.created_at FROM stripecoinpayments_tx_conversion_rates WHERE stripecoinpayments_tx_conversion_rates.tx_id = ?")
var __values []interface{}
__values = append(__values, stripecoinpayments_tx_conversion_rate_tx_id.value())
@ -20688,7 +20878,7 @@ func (obj *pgxcockroachImpl) Get_StripecoinpaymentsTxConversionRate_By_TxId(ctx
obj.logStmt(__stmt, __values...)
stripecoinpayments_tx_conversion_rate = &StripecoinpaymentsTxConversionRate{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.Rate, &stripecoinpayments_tx_conversion_rate.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&stripecoinpayments_tx_conversion_rate.TxId, &stripecoinpayments_tx_conversion_rate.RateGob, &stripecoinpayments_tx_conversion_rate.RateNumeric, &stripecoinpayments_tx_conversion_rate.CreatedAt)
if err != nil {
return (*StripecoinpaymentsTxConversionRate)(nil), obj.makeErr(err)
}
@ -22509,15 +22699,30 @@ func (obj *pgxcockroachImpl) Update_CoinpaymentsTransaction_By_Id(ctx context.Co
defer mon.Task()(&ctx)(&err)
var __sets = &__sqlbundle_Hole{}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE coinpayments_transactions SET "), __sets, __sqlbundle_Literal(" WHERE coinpayments_transactions.id = ? RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount, coinpayments_transactions.received, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")}}
var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE coinpayments_transactions SET "), __sets, __sqlbundle_Literal(" WHERE coinpayments_transactions.id = ? RETURNING coinpayments_transactions.id, coinpayments_transactions.user_id, coinpayments_transactions.address, coinpayments_transactions.amount_gob, coinpayments_transactions.amount_numeric, coinpayments_transactions.received_gob, coinpayments_transactions.received_numeric, coinpayments_transactions.status, coinpayments_transactions.key, coinpayments_transactions.timeout, coinpayments_transactions.created_at")}}
__sets_sql := __sqlbundle_Literals{Join: ", "}
var __values []interface{}
var __args []interface{}
if update.Received._set {
__values = append(__values, update.Received.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received = ?"))
if update.AmountGob._set {
__values = append(__values, update.AmountGob.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("amount_gob = ?"))
}
if update.AmountNumeric._set {
__values = append(__values, update.AmountNumeric.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("amount_numeric = ?"))
}
if update.ReceivedGob._set {
__values = append(__values, update.ReceivedGob.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received_gob = ?"))
}
if update.ReceivedNumeric._set {
__values = append(__values, update.ReceivedNumeric.value())
__sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("received_numeric = ?"))
}
if update.Status._set {
@ -22538,7 +22743,7 @@ func (obj *pgxcockroachImpl) Update_CoinpaymentsTransaction_By_Id(ctx context.Co
obj.logStmt(__stmt, __values...)
coinpayments_transaction = &CoinpaymentsTransaction{}
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.Amount, &coinpayments_transaction.Received, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
err = obj.queryRowContext(ctx, __stmt, __values...).Scan(&coinpayments_transaction.Id, &coinpayments_transaction.UserId, &coinpayments_transaction.Address, &coinpayments_transaction.AmountGob, &coinpayments_transaction.AmountNumeric, &coinpayments_transaction.ReceivedGob, &coinpayments_transaction.ReceivedNumeric, &coinpayments_transaction.Status, &coinpayments_transaction.Key, &coinpayments_transaction.Timeout, &coinpayments_transaction.CreatedAt)
if err == sql.ErrNoRows {
return nil, nil
}
@ -23980,17 +24185,16 @@ func (rx *Rx) Create_CoinpaymentsTransaction(ctx context.Context,
coinpayments_transaction_id CoinpaymentsTransaction_Id_Field,
coinpayments_transaction_user_id CoinpaymentsTransaction_UserId_Field,
coinpayments_transaction_address CoinpaymentsTransaction_Address_Field,
coinpayments_transaction_amount CoinpaymentsTransaction_Amount_Field,
coinpayments_transaction_received CoinpaymentsTransaction_Received_Field,
coinpayments_transaction_status CoinpaymentsTransaction_Status_Field,
coinpayments_transaction_key CoinpaymentsTransaction_Key_Field,
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field) (
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field,
optional CoinpaymentsTransaction_Create_Fields) (
coinpayments_transaction *CoinpaymentsTransaction, err error) {
var tx *Tx
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Create_CoinpaymentsTransaction(ctx, coinpayments_transaction_id, coinpayments_transaction_user_id, coinpayments_transaction_address, coinpayments_transaction_amount, coinpayments_transaction_received, coinpayments_transaction_status, coinpayments_transaction_key, coinpayments_transaction_timeout)
return tx.Create_CoinpaymentsTransaction(ctx, coinpayments_transaction_id, coinpayments_transaction_user_id, coinpayments_transaction_address, coinpayments_transaction_status, coinpayments_transaction_key, coinpayments_transaction_timeout, optional)
}
@ -24208,13 +24412,13 @@ func (rx *Rx) Create_StripecoinpaymentsInvoiceProjectRecord(ctx context.Context,
func (rx *Rx) Create_StripecoinpaymentsTxConversionRate(ctx context.Context,
stripecoinpayments_tx_conversion_rate_tx_id StripecoinpaymentsTxConversionRate_TxId_Field,
stripecoinpayments_tx_conversion_rate_rate StripecoinpaymentsTxConversionRate_Rate_Field) (
optional StripecoinpaymentsTxConversionRate_Create_Fields) (
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error) {
var tx *Tx
if tx, err = rx.getTx(ctx); err != nil {
return
}
return tx.Create_StripecoinpaymentsTxConversionRate(ctx, stripecoinpayments_tx_conversion_rate_tx_id, stripecoinpayments_tx_conversion_rate_rate)
return tx.Create_StripecoinpaymentsTxConversionRate(ctx, stripecoinpayments_tx_conversion_rate_tx_id, optional)
}
@ -25423,11 +25627,10 @@ type Methods interface {
coinpayments_transaction_id CoinpaymentsTransaction_Id_Field,
coinpayments_transaction_user_id CoinpaymentsTransaction_UserId_Field,
coinpayments_transaction_address CoinpaymentsTransaction_Address_Field,
coinpayments_transaction_amount CoinpaymentsTransaction_Amount_Field,
coinpayments_transaction_received CoinpaymentsTransaction_Received_Field,
coinpayments_transaction_status CoinpaymentsTransaction_Status_Field,
coinpayments_transaction_key CoinpaymentsTransaction_Key_Field,
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field) (
coinpayments_transaction_timeout CoinpaymentsTransaction_Timeout_Field,
optional CoinpaymentsTransaction_Create_Fields) (
coinpayments_transaction *CoinpaymentsTransaction, err error)
Create_Coupon(ctx context.Context,
@ -25546,7 +25749,7 @@ type Methods interface {
Create_StripecoinpaymentsTxConversionRate(ctx context.Context,
stripecoinpayments_tx_conversion_rate_tx_id StripecoinpaymentsTxConversionRate_TxId_Field,
stripecoinpayments_tx_conversion_rate_rate StripecoinpaymentsTxConversionRate_Rate_Field) (
optional StripecoinpaymentsTxConversionRate_Create_Fields) (
stripecoinpayments_tx_conversion_rate *StripecoinpaymentsTxConversionRate, err error)
Create_User(ctx context.Context,

9
satellite/satellitedb/dbx/satellitedb.dbx.pgx.sql
View File

@ -56,8 +56,10 @@ CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
amount_gob bytea,
amount_numeric bigint,
received_gob bytea,
received_numeric bigint,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
@ -398,7 +400,8 @@ CREATE TABLE stripecoinpayments_invoice_project_records (
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);

9
satellite/satellitedb/dbx/satellitedb.dbx.pgxcockroach.sql
View File

@ -56,8 +56,10 @@ CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
amount_gob bytea,
amount_numeric bigint,
received_gob bytea,
received_numeric bigint,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
@ -398,7 +400,8 @@ CREATE TABLE stripecoinpayments_invoice_project_records (
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);

17
satellite/satellitedb/migrate.go
View File

@ -1814,7 +1814,22 @@ func (db *satelliteDB) PostgresMigration() *migrate.Migration {
WHERE owner_id NOT IN (SELECT id FROM users WHERE paid_tier = true);`,
},
},
{
DB: &db.migrationDB,
Description: "add columns to coinpayments tables to replace gob-encoded big.Floats",
Version: 189,
Action: migrate.SQL{
`ALTER TABLE coinpayments_transactions ALTER COLUMN amount DROP NOT NULL;`,
`ALTER TABLE coinpayments_transactions ALTER COLUMN received DROP NOT NULL;`,
`ALTER TABLE coinpayments_transactions RENAME COLUMN amount TO amount_gob;`,
`ALTER TABLE coinpayments_transactions RENAME COLUMN received TO received_gob;`,
`ALTER TABLE coinpayments_transactions ADD COLUMN amount_numeric int8;`,
`ALTER TABLE coinpayments_transactions ADD COLUMN received_numeric int8;`,
`ALTER TABLE stripecoinpayments_tx_conversion_rates ALTER COLUMN rate DROP NOT NULL;`,
`ALTER TABLE stripecoinpayments_tx_conversion_rates RENAME COLUMN rate TO rate_gob;`,
`ALTER TABLE stripecoinpayments_tx_conversion_rates ADD COLUMN rate_numeric double precision;`,
},
},
// NB: after updating testdata in `testdata`, run
// `go generate` to update `migratez.go`.
},

11
satellite/satellitedb/migratez.go
View File

@ -13,7 +13,7 @@ func (db *satelliteDB) testMigration() *migrate.Migration {
{
DB: &db.migrationDB,
Description: "Testing setup",
Version: 188,
Version: 189,
Action: migrate.SQL{`-- AUTOGENERATED BY storj.io/dbx
-- DO NOT EDIT
CREATE TABLE accounting_rollups (
@ -72,8 +72,10 @@ CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount bytea NOT NULL,
received bytea NOT NULL,
amount_gob bytea,
amount_numeric int8,
received_gob bytea,
received_numeric int8,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
@ -414,7 +416,8 @@ CREATE TABLE stripecoinpayments_invoice_project_records (
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate bytea NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);

669
satellite/satellitedb/testdata/postgres.v189.sql vendored Normal file
View File

@ -0,0 +1,669 @@
-- AUTOGENERATED BY storj.io/dbx
-- DO NOT EDIT
CREATE TABLE accounting_rollups (
node_id bytea NOT NULL,
start_time timestamp with time zone NOT NULL,
put_total bigint NOT NULL,
get_total bigint NOT NULL,
get_audit_total bigint NOT NULL,
get_repair_total bigint NOT NULL,
put_repair_total bigint NOT NULL,
at_rest_total double precision NOT NULL,
PRIMARY KEY ( node_id, start_time )
);
CREATE TABLE accounting_timestamps (
name text NOT NULL,
value timestamp with time zone NOT NULL,
PRIMARY KEY ( name )
);
CREATE TABLE bucket_bandwidth_rollups (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
inline bigint NOT NULL,
allocated bigint NOT NULL,
settled bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start, action )
);
CREATE TABLE bucket_bandwidth_rollup_archives (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
inline bigint NOT NULL,
allocated bigint NOT NULL,
settled bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start, action )
);
CREATE TABLE bucket_storage_tallies (
bucket_name bytea NOT NULL,
project_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
total_bytes bigint NOT NULL DEFAULT 0,
inline bigint NOT NULL,
remote bigint NOT NULL,
total_segments_count integer NOT NULL DEFAULT 0,
remote_segments_count integer NOT NULL,
inline_segments_count integer NOT NULL,
object_count integer NOT NULL,
metadata_size bigint NOT NULL,
PRIMARY KEY ( bucket_name, project_id, interval_start )
);
CREATE TABLE coinpayments_transactions (
id text NOT NULL,
user_id bytea NOT NULL,
address text NOT NULL,
amount_gob bytea,
amount_numeric int8,
received_gob bytea,
received_numeric int8,
status integer NOT NULL,
key text NOT NULL,
timeout integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE coupons (
id bytea NOT NULL,
user_id bytea NOT NULL,
amount bigint NOT NULL,
description text NOT NULL,
type integer NOT NULL,
status integer NOT NULL,
duration bigint NOT NULL,
billing_periods bigint,
coupon_code_name text,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE coupon_codes (
id bytea NOT NULL,
name text NOT NULL,
amount bigint NOT NULL,
description text NOT NULL,
type integer NOT NULL,
billing_periods bigint,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( name )
);
CREATE TABLE coupon_usages (
coupon_id bytea NOT NULL,
amount bigint NOT NULL,
status integer NOT NULL,
period timestamp with time zone NOT NULL,
PRIMARY KEY ( coupon_id, period )
);
CREATE TABLE graceful_exit_progress (
node_id bytea NOT NULL,
bytes_transferred bigint NOT NULL,
pieces_transferred bigint NOT NULL DEFAULT 0,
pieces_failed bigint NOT NULL DEFAULT 0,
updated_at timestamp with time zone NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE graceful_exit_segment_transfer_queue (
node_id bytea NOT NULL,
stream_id bytea NOT NULL,
position bigint NOT NULL,
piece_num integer NOT NULL,
root_piece_id bytea,
durability_ratio double precision NOT NULL,
queued_at timestamp with time zone NOT NULL,
requested_at timestamp with time zone,
last_failed_at timestamp with time zone,
last_failed_code integer,
failed_count integer,
finished_at timestamp with time zone,
order_limit_send_count integer NOT NULL DEFAULT 0,
PRIMARY KEY ( node_id, stream_id, position, piece_num )
);
CREATE TABLE nodes (
id bytea NOT NULL,
address text NOT NULL DEFAULT '',
last_net text NOT NULL,
last_ip_port text,
country_code text,
protocol integer NOT NULL DEFAULT 0,
type integer NOT NULL DEFAULT 0,
email text NOT NULL,
wallet text NOT NULL,
wallet_features text NOT NULL DEFAULT '',
free_disk bigint NOT NULL DEFAULT -1,
piece_count bigint NOT NULL DEFAULT 0,
major bigint NOT NULL DEFAULT 0,
minor bigint NOT NULL DEFAULT 0,
patch bigint NOT NULL DEFAULT 0,
hash text NOT NULL DEFAULT '',
timestamp timestamp with time zone NOT NULL DEFAULT '0001-01-01 00:00:00+00',
release boolean NOT NULL DEFAULT false,
latency_90 bigint NOT NULL DEFAULT 0,
vetted_at timestamp with time zone,
created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
last_contact_success timestamp with time zone NOT NULL DEFAULT 'epoch',
last_contact_failure timestamp with time zone NOT NULL DEFAULT 'epoch',
disqualified timestamp with time zone,
disqualification_reason integer,
suspended timestamp with time zone,
unknown_audit_suspended timestamp with time zone,
offline_suspended timestamp with time zone,
under_review timestamp with time zone,
exit_initiated_at timestamp with time zone,
exit_loop_completed_at timestamp with time zone,
exit_finished_at timestamp with time zone,
exit_success boolean NOT NULL DEFAULT false,
PRIMARY KEY ( id )
);
CREATE TABLE node_api_versions (
id bytea NOT NULL,
api_version integer NOT NULL,
created_at timestamp with time zone NOT NULL,
updated_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE oauth_clients (
id bytea NOT NULL,
encrypted_secret bytea NOT NULL,
redirect_url text NOT NULL,
user_id bytea NOT NULL,
app_name text NOT NULL,
app_logo_url text NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE oauth_codes (
client_id bytea NOT NULL,
user_id bytea NOT NULL,
scope text NOT NULL,
redirect_url text NOT NULL,
challenge text NOT NULL,
challenge_method text NOT NULL,
code text NOT NULL,
created_at timestamp with time zone NOT NULL,
expires_at timestamp with time zone NOT NULL,
claimed_at timestamp with time zone,
PRIMARY KEY ( code )
);
CREATE TABLE oauth_tokens (
client_id bytea NOT NULL,
user_id bytea NOT NULL,
scope text NOT NULL,
kind integer NOT NULL,
token bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
expires_at timestamp with time zone NOT NULL,
PRIMARY KEY ( token )
);
CREATE TABLE offers (
id serial NOT NULL,
name text NOT NULL,
description text NOT NULL,
award_credit_in_cents integer NOT NULL DEFAULT 0,
invitee_credit_in_cents integer NOT NULL DEFAULT 0,
award_credit_duration_days integer,
invitee_credit_duration_days integer,
redeemable_cap integer,
expires_at timestamp with time zone NOT NULL,
created_at timestamp with time zone NOT NULL,
status integer NOT NULL,
type integer NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE peer_identities (
node_id bytea NOT NULL,
leaf_serial_number bytea NOT NULL,
chain bytea NOT NULL,
updated_at timestamp with time zone NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE projects (
id bytea NOT NULL,
name text NOT NULL,
description text NOT NULL,
usage_limit bigint,
bandwidth_limit bigint,
segment_limit bigint DEFAULT 1000000,
rate_limit integer,
burst_limit integer,
max_buckets integer,
partner_id bytea,
user_agent bytea,
owner_id bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id )
);
CREATE TABLE project_bandwidth_daily_rollups (
project_id bytea NOT NULL,
interval_day date NOT NULL,
egress_allocated bigint NOT NULL,
egress_settled bigint NOT NULL,
egress_dead bigint NOT NULL DEFAULT 0,
PRIMARY KEY ( project_id, interval_day )
);
CREATE TABLE project_bandwidth_rollups (
project_id bytea NOT NULL,
interval_month date NOT NULL,
egress_allocated bigint NOT NULL,
PRIMARY KEY ( project_id, interval_month )
);
CREATE TABLE registration_tokens (
secret bytea NOT NULL,
owner_id bytea,
project_limit integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( secret ),
UNIQUE ( owner_id )
);
CREATE TABLE repair_queue (
stream_id bytea NOT NULL,
position bigint NOT NULL,
attempted_at timestamp with time zone,
updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
inserted_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
segment_health double precision NOT NULL DEFAULT 1,
PRIMARY KEY ( stream_id, position )
);
CREATE TABLE reputations (
id bytea NOT NULL,
audit_success_count bigint NOT NULL DEFAULT 0,
total_audit_count bigint NOT NULL DEFAULT 0,
vetted_at timestamp with time zone,
created_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
updated_at timestamp with time zone NOT NULL DEFAULT current_timestamp,
disqualified timestamp with time zone,
suspended timestamp with time zone,
unknown_audit_suspended timestamp with time zone,
offline_suspended timestamp with time zone,
under_review timestamp with time zone,
online_score double precision NOT NULL DEFAULT 1,
audit_history bytea NOT NULL,
audit_reputation_alpha double precision NOT NULL DEFAULT 1,
audit_reputation_beta double precision NOT NULL DEFAULT 0,
unknown_audit_reputation_alpha double precision NOT NULL DEFAULT 1,
unknown_audit_reputation_beta double precision NOT NULL DEFAULT 0,
PRIMARY KEY ( id )
);
CREATE TABLE reset_password_tokens (
secret bytea NOT NULL,
owner_id bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( secret ),
UNIQUE ( owner_id )
);
CREATE TABLE revocations (
revoked bytea NOT NULL,
api_key_id bytea NOT NULL,
PRIMARY KEY ( revoked )
);
CREATE TABLE segment_pending_audits (
node_id bytea NOT NULL,
stream_id bytea NOT NULL,
position bigint NOT NULL,
piece_id bytea NOT NULL,
stripe_index bigint NOT NULL,
share_size bigint NOT NULL,
expected_share_hash bytea NOT NULL,
reverify_count bigint NOT NULL,
PRIMARY KEY ( node_id )
);
CREATE TABLE storagenode_bandwidth_rollups (
storagenode_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
allocated bigint DEFAULT 0,
settled bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start, action )
);
CREATE TABLE storagenode_bandwidth_rollup_archives (
storagenode_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
allocated bigint DEFAULT 0,
settled bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start, action )
);
CREATE TABLE storagenode_bandwidth_rollups_phase2 (
storagenode_id bytea NOT NULL,
interval_start timestamp with time zone NOT NULL,
interval_seconds integer NOT NULL,
action integer NOT NULL,
allocated bigint DEFAULT 0,
settled bigint NOT NULL,
PRIMARY KEY ( storagenode_id, interval_start, action )
);
CREATE TABLE storagenode_payments (
id bigserial NOT NULL,
created_at timestamp with time zone NOT NULL,
node_id bytea NOT NULL,
period text NOT NULL,
amount bigint NOT NULL,
receipt text,
notes text,
PRIMARY KEY ( id )
);
CREATE TABLE storagenode_paystubs (
period text NOT NULL,
node_id bytea NOT NULL,
created_at timestamp with time zone NOT NULL,
codes text NOT NULL,
usage_at_rest double precision NOT NULL,
usage_get bigint NOT NULL,
usage_put bigint NOT NULL,
usage_get_repair bigint NOT NULL,
usage_put_repair bigint NOT NULL,
usage_get_audit bigint NOT NULL,
comp_at_rest bigint NOT NULL,
comp_get bigint NOT NULL,
comp_put bigint NOT NULL,
comp_get_repair bigint NOT NULL,
comp_put_repair bigint NOT NULL,
comp_get_audit bigint NOT NULL,
surge_percent bigint NOT NULL,
held bigint NOT NULL,
owed bigint NOT NULL,
disposed bigint NOT NULL,
paid bigint NOT NULL,
distributed bigint NOT NULL,
PRIMARY KEY ( period, node_id )
);
CREATE TABLE storagenode_storage_tallies (
node_id bytea NOT NULL,
interval_end_time timestamp with time zone NOT NULL,
data_total double precision NOT NULL,
PRIMARY KEY ( interval_end_time, node_id )
);
CREATE TABLE stripe_customers (
user_id bytea NOT NULL,
customer_id text NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( user_id ),
UNIQUE ( customer_id )
);
CREATE TABLE stripecoinpayments_invoice_project_records (
id bytea NOT NULL,
project_id bytea NOT NULL,
storage double precision NOT NULL,
egress bigint NOT NULL,
objects bigint,
segments bigint,
period_start timestamp with time zone NOT NULL,
period_end timestamp with time zone NOT NULL,
state integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( project_id, period_start, period_end )
);
CREATE TABLE stripecoinpayments_tx_conversion_rates (
tx_id text NOT NULL,
rate_gob bytea,
rate_numeric double precision,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
CREATE TABLE users (
id bytea NOT NULL,
email text NOT NULL,
normalized_email text NOT NULL,
full_name text NOT NULL,
short_name text,
password_hash bytea NOT NULL,
status integer NOT NULL,
partner_id bytea,
user_agent bytea,
created_at timestamp with time zone NOT NULL,
project_limit integer NOT NULL DEFAULT 0,
project_bandwidth_limit bigint NOT NULL DEFAULT 0,
project_storage_limit bigint NOT NULL DEFAULT 0,
project_segment_limit bigint NOT NULL DEFAULT 0,
paid_tier boolean NOT NULL DEFAULT false,
position text,
company_name text,
company_size integer,
working_on text,
is_professional boolean NOT NULL DEFAULT false,
employee_count text,
have_sales_contact boolean NOT NULL DEFAULT false,
mfa_enabled boolean NOT NULL DEFAULT false,
mfa_secret_key text,
mfa_recovery_codes text,
signup_promo_code text,
last_verification_reminder timestamp with time zone,
PRIMARY KEY ( id )
);
CREATE TABLE value_attributions (
project_id bytea NOT NULL,
bucket_name bytea NOT NULL,
partner_id bytea NOT NULL,
user_agent bytea,
last_updated timestamp with time zone NOT NULL,
PRIMARY KEY ( project_id, bucket_name )
);
CREATE TABLE api_keys (
id bytea NOT NULL,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
head bytea NOT NULL,
name text NOT NULL,
secret bytea NOT NULL,
partner_id bytea,
user_agent bytea,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( head ),
UNIQUE ( name, project_id )
);
CREATE TABLE bucket_metainfos (
id bytea NOT NULL,
project_id bytea NOT NULL REFERENCES projects( id ),
name bytea NOT NULL,
partner_id bytea,
user_agent bytea,
path_cipher integer NOT NULL,
created_at timestamp with time zone NOT NULL,
default_segment_size integer NOT NULL,
default_encryption_cipher_suite integer NOT NULL,
default_encryption_block_size integer NOT NULL,
default_redundancy_algorithm integer NOT NULL,
default_redundancy_share_size integer NOT NULL,
default_redundancy_required_shares integer NOT NULL,
default_redundancy_repair_shares integer NOT NULL,
default_redundancy_optimal_shares integer NOT NULL,
default_redundancy_total_shares integer NOT NULL,
placement integer,
PRIMARY KEY ( id ),
UNIQUE ( project_id, name )
);
CREATE TABLE project_members (
member_id bytea NOT NULL REFERENCES users( id ) ON DELETE CASCADE,
project_id bytea NOT NULL REFERENCES projects( id ) ON DELETE CASCADE,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( member_id, project_id )
);
CREATE TABLE stripecoinpayments_apply_balance_intents (
tx_id text NOT NULL REFERENCES coinpayments_transactions( id ) ON DELETE CASCADE,
state integer NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( tx_id )
);
CREATE TABLE user_credits (
id serial NOT NULL,
user_id bytea NOT NULL REFERENCES users( id ) ON DELETE CASCADE,
offer_id integer NOT NULL REFERENCES offers( id ),
referred_by bytea REFERENCES users( id ) ON DELETE SET NULL,
type text NOT NULL,
credits_earned_in_cents integer NOT NULL,
credits_used_in_cents integer NOT NULL,
expires_at timestamp with time zone NOT NULL,
created_at timestamp with time zone NOT NULL,
PRIMARY KEY ( id ),
UNIQUE ( id, offer_id )
);
CREATE INDEX accounting_rollups_start_time_index ON accounting_rollups ( start_time ) ;
CREATE INDEX bucket_bandwidth_rollups_project_id_action_interval_index ON bucket_bandwidth_rollups ( project_id, action, interval_start ) ;
CREATE INDEX bucket_bandwidth_rollups_action_interval_project_id_index ON bucket_bandwidth_rollups ( action, interval_start, project_id ) ;
CREATE INDEX bucket_bandwidth_rollups_archive_project_id_action_interval_index ON bucket_bandwidth_rollup_archives ( project_id, action, interval_start ) ;
CREATE INDEX bucket_bandwidth_rollups_archive_action_interval_project_id_index ON bucket_bandwidth_rollup_archives ( action, interval_start, project_id ) ;
CREATE INDEX bucket_storage_tallies_project_id_interval_start_index ON bucket_storage_tallies ( project_id, interval_start ) ;
CREATE INDEX graceful_exit_segment_transfer_nid_dr_qa_fa_lfa_index ON graceful_exit_segment_transfer_queue ( node_id, durability_ratio, queued_at, finished_at, last_failed_at ) ;
CREATE INDEX node_last_ip ON nodes ( last_net ) ;
CREATE INDEX nodes_dis_unk_off_exit_fin_last_success_index ON nodes ( disqualified, unknown_audit_suspended, offline_suspended, exit_finished_at, last_contact_success ) ;
CREATE INDEX nodes_type_last_cont_success_free_disk_ma_mi_patch_vetted_partial_index ON nodes ( type, last_contact_success, free_disk, major, minor, patch, vetted_at ) WHERE nodes.disqualified is NULL AND nodes.unknown_audit_suspended is NULL AND nodes.exit_initiated_at is NULL AND nodes.release = true AND nodes.last_net != '' ;
CREATE INDEX nodes_dis_unk_aud_exit_init_rel_type_last_cont_success_stored_index ON nodes ( disqualified, unknown_audit_suspended, exit_initiated_at, release, type, last_contact_success ) WHERE nodes.disqualified is NULL AND nodes.unknown_audit_suspended is NULL AND nodes.exit_initiated_at is NULL AND nodes.release = true ;
CREATE INDEX oauth_clients_user_id_index ON oauth_clients ( user_id ) ;
CREATE INDEX oauth_codes_user_id_index ON oauth_codes ( user_id ) ;
CREATE INDEX oauth_codes_client_id_index ON oauth_codes ( client_id ) ;
CREATE INDEX oauth_tokens_user_id_index ON oauth_tokens ( user_id ) ;
CREATE INDEX oauth_tokens_client_id_index ON oauth_tokens ( client_id ) ;
CREATE INDEX repair_queue_updated_at_index ON repair_queue ( updated_at ) ;
CREATE INDEX repair_queue_num_healthy_pieces_attempted_at_index ON repair_queue ( segment_health, attempted_at ) ;
CREATE INDEX storagenode_bandwidth_rollups_interval_start_index ON storagenode_bandwidth_rollups ( interval_start ) ;
CREATE INDEX storagenode_bandwidth_rollup_archives_interval_start_index ON storagenode_bandwidth_rollup_archives ( interval_start ) ;
CREATE INDEX storagenode_payments_node_id_period_index ON storagenode_payments ( node_id, period ) ;
CREATE INDEX storagenode_paystubs_node_id_index ON storagenode_paystubs ( node_id ) ;
CREATE INDEX storagenode_storage_tallies_node_id_index ON storagenode_storage_tallies ( node_id ) ;
CREATE UNIQUE INDEX credits_earned_user_id_offer_id ON user_credits ( id, offer_id ) ;
INSERT INTO "offers" ("id", "name", "description", "award_credit_in_cents", "invitee_credit_in_cents", "expires_at", "created_at", "status", "type", "award_credit_duration_days", "invitee_credit_duration_days") VALUES (1, 'Default referral offer', 'Is active when no other active referral offer', 300, 600, '2119-03-14 08:28:24.636949+00', '2019-07-14 08:28:24.636949+00', 1, 2, 365, 14);
INSERT INTO "offers" ("id", "name", "description", "award_credit_in_cents", "invitee_credit_in_cents", "expires_at", "created_at", "status", "type", "award_credit_duration_days", "invitee_credit_duration_days") VALUES (2, 'Default free credit offer', 'Is active when no active free credit offer', 0, 300, '2119-03-14 08:28:24.636949+00', '2019-07-14 08:28:24.636949+00', 1, 1, NULL, 14);
-- MAIN DATA --
INSERT INTO "accounting_rollups"("node_id", "start_time", "put_total", "get_total", "get_audit_total", "get_repair_total", "put_repair_total", "at_rest_total") VALUES (E'\\367M\\177\\251]t/\\022\\256\\214\\265\\025\\224\\204:\\217\\212\\0102<\\321\\374\\020&\\271Qc\\325\\261\\354\\246\\233'::bytea, '2019-02-09 00:00:00+00', 3000, 6000, 9000, 12000, 0, 15000);
INSERT INTO "accounting_timestamps" VALUES ('LastAtRestTally', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastRollup', '0001-01-01 00:00:00+00');
INSERT INTO "accounting_timestamps" VALUES ('LastBandwidthTally', '0001-01-01 00:00:00+00');
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001', '127.0.0.1:55516', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended","exit_success") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '127.0.0.1:55518', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended","exit_success") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014', '127.0.0.1:55517', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL,false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended","exit_success") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\015', '127.0.0.1:55519', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL,false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended","exit_success", "vetted_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', '127.0.0.1:55520', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false, '2020-03-18 12:00:00.000000+00');
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended","exit_success") VALUES (E'\\154\\313\\233\\074\\327\\177\\136\\070\\346\\001', '127.0.0.1:55516', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false);
INSERT INTO "nodes"("id", "address", "last_net", "last_ip_port", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success") VALUES (E'\\154\\313\\233\\074\\327\\177\\136\\070\\346\\002', '127.0.0.1:55516', '127.0.0.0', '127.0.0.1:55516', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NUll, NULL, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success") VALUES (E'\\363\\341\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', '127.0.0.1:55516', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "wallet_features", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success") VALUES (E'\\362\\341\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', '127.0.0.1:55516', '', 0, 4, '', '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at", "is_professional", "project_limit", "project_bandwidth_limit", "project_storage_limit", "paid_tier", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'Noahson', 'William', '1email1@mail.test', '1EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, NULL, '2019-02-14 08:28:24.614594+00', false, 10, 50000000000, 50000000000, false, 150000);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at", "position", "company_name", "working_on", "company_size", "is_professional", "employee_count", "project_limit", "project_bandwidth_limit", "project_storage_limit", "have_sales_contact", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\304\\313\\206\\311",'::bytea, 'Ian', 'Pires', '3email3@mail.test', '3EMAIL3@MAIL.TEST', E'some_readable_hash'::bytea, 2, NULL, '2020-03-18 10:28:24.614594+00', 'engineer', 'storj', 'data storage', 51, true, '1-50', 10, 50000000000, 50000000000, true, 150000);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at", "position", "company_name", "working_on", "company_size", "is_professional", "employee_count", "project_limit", "project_bandwidth_limit", "project_storage_limit", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\205\\312",'::bytea, 'Campbell', 'Wright', '4email4@mail.test', '4EMAIL4@MAIL.TEST', E'some_readable_hash'::bytea, 2, NULL, '2020-07-17 10:28:24.614594+00', 'engineer', 'storj', 'data storage', 82, true, '1-50', 10, 50000000000, 50000000000, 150000);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at", "position", "company_name", "working_on", "company_size", "is_professional", "project_limit", "project_bandwidth_limit", "project_storage_limit", "paid_tier", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\205\\311",'::bytea, 'Thierry', 'Berg', '2email2@mail.test', '2EMAIL2@MAIL.TEST', E'some_readable_hash'::bytea, 2, NULL, '2020-05-16 10:28:24.614594+00', 'engineer', 'storj', 'data storage', 55, true, 10, 50000000000, 50000000000, false, false, NULL, NULL, 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "max_buckets", "partner_id", "owner_id", "created_at", "segment_limit") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 'ProjectName', 'projects description', 5e11, 5e11, NULL, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:28:24.254934+00', 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "max_buckets", "partner_id", "owner_id", "created_at", "segment_limit") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 'projName1', 'Test project 1', 5e11, 5e11, NULL, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:28:24.636949+00', 150000);
INSERT INTO "project_members"("member_id", "project_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, '2019-02-14 08:28:24.677953+00');
INSERT INTO "project_members"("member_id", "project_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, '2019-02-13 08:28:24.677953+00');
INSERT INTO "registration_tokens" ("secret", "owner_id", "project_limit", "created_at") VALUES (E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, null, 1, '2019-02-14 08:28:24.677953+00');
INSERT INTO "storagenode_bandwidth_rollups" ("storagenode_id", "interval_start", "interval_seconds", "action", "allocated", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024);
INSERT INTO "storagenode_storage_tallies" VALUES (E'\\3510\\323\\225"~\\036<\\342\\330m\\0253Jhr\\246\\233K\\246#\\2303\\351\\256\\275j\\212UM\\362\\207', '2019-02-14 08:16:57.812849+00', 1000);
INSERT INTO "bucket_bandwidth_rollups" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024, 3024);
INSERT INTO "bucket_storage_tallies" ("bucket_name", "project_id", "interval_start", "inline", "remote", "remote_segments_count", "inline_segments_count", "object_count", "metadata_size") VALUES (E'testbucket'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea,'2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 4024, 5024, 0, 0, 0, 0);
INSERT INTO "bucket_bandwidth_rollups" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\170\\160\\157\\370\\274\\366\\113\\364\\272\\235\\301\\243\\321\\102\\321\\136'::bytea,'2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024, 3024);
INSERT INTO "bucket_storage_tallies" ("bucket_name", "project_id", "interval_start", "inline", "remote", "remote_segments_count", "inline_segments_count", "object_count", "metadata_size") VALUES (E'testbucket'::bytea, E'\\170\\160\\157\\370\\274\\366\\113\\364\\272\\235\\301\\243\\321\\102\\321\\136'::bytea,'2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 4024, 5024, 0, 0, 0, 0);
INSERT INTO "reset_password_tokens" ("secret", "owner_id", "created_at") VALUES (E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-05-08 08:28:24.677953+00');
INSERT INTO "api_keys" ("id", "project_id", "head", "name", "secret", "partner_id", "created_at") VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\111\\142\\147\\304\\132\\375\\070\\163\\270\\160\\251\\370\\126\\063\\351\\037\\257\\071\\143\\375\\351\\320\\253\\232\\220\\260\\075\\173\\306\\307\\115\\136'::bytea, 'key 2', E'\\254\\011\\315\\333\\273\\365\\001\\071\\024\\154\\253\\332\\301\\216\\361\\074\\221\\367\\251\\231\\274\\333\\300\\367\\001\\272\\327\\111\\315\\123\\042\\016'::bytea, NULL, '2019-02-14 08:28:24.267934+00');
INSERT INTO "value_attributions" ("project_id", "bucket_name", "partner_id", "user_agent", "last_updated") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, E''::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, NULL, '2019-02-14 08:07:31.028103+00');
INSERT INTO "user_credits" ("id", "user_id", "offer_id", "referred_by", "credits_earned_in_cents", "credits_used_in_cents", "type", "expires_at", "created_at") VALUES (1, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 1, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 200, 0, 'invalid', '2019-10-01 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00');
INSERT INTO "bucket_metainfos" ("id", "project_id", "name", "partner_id", "created_at", "path_cipher", "default_segment_size", "default_encryption_cipher_suite", "default_encryption_block_size", "default_redundancy_algorithm", "default_redundancy_share_size", "default_redundancy_required_shares", "default_redundancy_repair_shares", "default_redundancy_optimal_shares", "default_redundancy_total_shares") VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'testbucketuniquename'::bytea, NULL, '2019-06-14 08:28:24.677953+00', 1, 65536, 1, 8192, 1, 4096, 4, 6, 8, 10);
INSERT INTO "peer_identities" VALUES (E'\\334/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2019-02-14 08:07:31.335028+00');
INSERT INTO "graceful_exit_progress" ("node_id", "bytes_transferred", "pieces_transferred", "pieces_failed", "updated_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', 1000000000000000, 0, 0, '2019-09-12 10:07:31.028103+00');
INSERT INTO "stripe_customers" ("user_id", "customer_id", "created_at") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'stripe_id', '2019-06-01 08:28:24.267934+00');
INSERT INTO "stripecoinpayments_invoice_project_records"("id", "project_id", "storage", "egress", "objects", "period_start", "period_end", "state", "created_at") VALUES (E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\021\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 0, 0, 0, '2019-06-01 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00', 0, '2019-06-01 08:28:24.267934+00');
INSERT INTO "stripecoinpayments_tx_conversion_rates" ("tx_id", "rate_gob", "created_at") VALUES ('tx_id', E'\\363\\311\\033w\\222\\303Ci,'::bytea, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coinpayments_transactions" ("id", "user_id", "address", "amount_gob", "received_gob", "status", "key", "timeout", "created_at") VALUES ('tx_id', E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'address', E'\\363\\311\\033w'::bytea, E'\\363\\311\\033w'::bytea, 1, 'key', 60, '2019-06-01 08:28:24.267934+00');
INSERT INTO "storagenode_bandwidth_rollups" ("storagenode_id", "interval_start", "interval_seconds", "action", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2020-01-11 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 2024);
INSERT INTO "coupons" ("id", "user_id", "amount", "description", "type", "status", "duration", "billing_periods", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 50, 'description', 0, 0, 2, 2, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coupons" ("id", "user_id", "amount", "description", "type", "status", "duration", "billing_periods", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\012'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 50, 'description', 0, 0, 2, 2, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coupons" ("id", "user_id", "amount", "description", "type", "status", "duration", "billing_periods", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\015'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 50, 'description', 0, 0, 2, 2, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coupon_usages" ("coupon_id", "amount", "status", "period") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 22, 0, '2019-06-01 09:28:24.267934+00');
INSERT INTO "coupon_codes" ("id", "name", "amount", "description", "type", "billing_periods", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014'::bytea, 'STORJ50', 50, '$50 for your first 5 months', 0, NULL, '2019-06-01 08:28:24.267934+00');
INSERT INTO "coupon_codes" ("id", "name", "amount", "description", "type", "billing_periods", "created_at") VALUES (E'\\362\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\015'::bytea, 'STORJ75', 75, '$75 for your first 5 months', 0, 2, '2019-06-01 08:28:24.267934+00');
INSERT INTO "stripecoinpayments_apply_balance_intents" ("tx_id", "state", "created_at") VALUES ('tx_id', 0, '2019-06-01 08:28:24.267934+00');
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "max_buckets", "rate_limit", "partner_id", "owner_id", "created_at", "segment_limit") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\347'::bytea, 'projName1', 'Test project 1', 5e11, 5e11, NULL, 2000000, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2020-01-15 08:28:24.636949+00', 150000);
INSERT INTO "project_bandwidth_rollups"("project_id", "interval_month", egress_allocated) VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\347'::bytea, '2020-04-01', 10000);
INSERT INTO "project_bandwidth_daily_rollups"("project_id", "interval_day", egress_allocated, egress_settled, egress_dead) VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\347'::bytea, '2021-04-22', 10000, 5000, 0);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "max_buckets","rate_limit", "partner_id", "owner_id", "created_at", "segment_limit") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\345'::bytea, 'egress101', 'High Bandwidth Project', 5e11, 5e11, NULL, 2000000, NULL, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, '2020-05-15 08:46:24.000000+00', 150000);
INSERT INTO "storagenode_paystubs"("period", "node_id", "created_at", "codes", "usage_at_rest", "usage_get", "usage_put", "usage_get_repair", "usage_put_repair", "usage_get_audit", "comp_at_rest", "comp_get", "comp_put", "comp_get_repair", "comp_put_repair", "comp_get_audit", "surge_percent", "held", "owed", "disposed", "paid", "distributed") VALUES ('2020-01', '\xf2a3b4c4dfdf7221310382fd5db5aa73e1d227d6df09734ec4e5305000000000', '2020-04-07T20:14:21.479141Z', '', 1327959864508416, 294054066688, 159031363328, 226751, 0, 836608, 2861984, 5881081, 0, 226751, 0, 8, 300, 0, 26909472, 0, 26909472, 0);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success", "unknown_audit_suspended", "offline_suspended", "under_review") VALUES (E'\\153\\313\\233\\074\\327\\255\\136\\070\\346\\001', '127.0.0.1:55516', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false, '2019-02-14 08:07:31.108963+00', '2019-02-14 08:07:31.108963+00', '2019-02-14 08:07:31.108963+00');
INSERT INTO "node_api_versions"("id", "api_version", "created_at", "updated_at") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001', 1, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00');
INSERT INTO "node_api_versions"("id", "api_version", "created_at", "updated_at") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', 2, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00');
INSERT INTO "node_api_versions"("id", "api_version", "created_at", "updated_at") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\014', 3, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00');
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "rate_limit", "partner_id", "owner_id", "created_at", "max_buckets", "segment_limit") VALUES (E'300\\273|\\342N\\347\\347\\363\\342\\363\\371>+F\\256\\263'::bytea, 'egress102', 'High Bandwidth Project 2', 5e11, 5e11, 2000000, NULL, E'265\\343U\\303\\312\\312\\363\\311\\033w\\222\\303Ci",'::bytea, '2020-05-15 08:46:24.000000+00', 1000, 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "rate_limit", "partner_id", "owner_id", "created_at", "max_buckets", "segment_limit") VALUES (E'300\\273|\\342N\\347\\347\\363\\342\\363\\371>+F\\255\\244'::bytea, 'egress103', 'High Bandwidth Project 3', 5e11, 5e11, 2000000, NULL, E'265\\343U\\303\\312\\312\\363\\311\\033w\\222\\303Ci",'::bytea, '2020-05-15 08:46:24.000000+00', 1000, 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "rate_limit", "partner_id", "owner_id", "created_at", "max_buckets", "segment_limit") VALUES (E'300\\273|\\342N\\347\\347\\363\\342\\363\\371>+F\\253\\231'::bytea, 'Limit Test 1', 'This project is above the default', 50000000001, 50000000001, 2000000, NULL, E'265\\343U\\303\\312\\312\\363\\311\\033w\\222\\303Ci",'::bytea, '2020-10-14 10:10:10.000000+00', 101, 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "rate_limit", "partner_id", "owner_id", "created_at", "max_buckets", "segment_limit") VALUES (E'300\\273|\\342N\\347\\347\\363\\342\\363\\371>+F\\252\\230'::bytea, 'Limit Test 2', 'This project is below the default', 5e11, 5e11, 2000000, NULL, E'265\\343U\\303\\312\\312\\363\\311\\033w\\222\\303Ci",'::bytea, '2020-10-14 10:10:11.000000+00', NULL, 150000);
INSERT INTO "storagenode_bandwidth_rollups_phase2" ("storagenode_id", "interval_start", "interval_seconds", "action", "allocated", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024);
INSERT INTO "storagenode_bandwidth_rollup_archives" ("storagenode_id", "interval_start", "interval_seconds", "action", "allocated", "settled") VALUES (E'\\006\\223\\250R\\221\\005\\365\\377v>0\\266\\365\\216\\255?\\347\\244\\371?2\\264\\262\\230\\007<\\001\\262\\263\\237\\247n', '2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024);
INSERT INTO "bucket_bandwidth_rollup_archives" ("bucket_name", "project_id", "interval_start", "interval_seconds", "action", "inline", "allocated", "settled") VALUES (E'testbucket'::bytea, E'\\170\\160\\157\\370\\274\\366\\113\\364\\272\\235\\301\\243\\321\\102\\321\\136'::bytea,'2019-03-06 08:00:00.000000' AT TIME ZONE current_setting('TIMEZONE'), 3600, 1, 1024, 2024, 3024);
INSERT INTO "storagenode_paystubs"("period", "node_id", "created_at", "codes", "usage_at_rest", "usage_get", "usage_put", "usage_get_repair", "usage_put_repair", "usage_get_audit", "comp_at_rest", "comp_get", "comp_put", "comp_get_repair", "comp_put_repair", "comp_get_audit", "surge_percent", "held", "owed", "disposed", "paid", "distributed") VALUES ('2020-12', '\x1111111111111111111111111111111111111111111111111111111111111111', '2020-04-07T20:14:21.479141Z', '', 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111, 112, 113, 114, 115, 116, 117, 117);
INSERT INTO "storagenode_payments"("id", "created_at", "period", "node_id", "amount") VALUES (1, '2020-04-07T20:14:21.479141Z', '2020-12', '\x1111111111111111111111111111111111111111111111111111111111111111', 117);
INSERT INTO "reputations"("id", "audit_success_count", "total_audit_count", "created_at", "updated_at", "disqualified", "suspended", "audit_reputation_alpha", "audit_reputation_beta", "unknown_audit_reputation_alpha", "unknown_audit_reputation_beta", "online_score", "audit_history") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001', 0, 5, '2019-02-14 08:07:31.028103+00', '2019-02-14 08:07:31.108963+00', NULL, NULL, 50, 0, 1, 0, 1, '\x0a23736f2f6d616e792f69636f6e69632f70617468732f746f2f63686f6f73652f66726f6d120a0102030405060708090a');
INSERT INTO "graceful_exit_segment_transfer_queue" ("node_id", "stream_id", "position", "piece_num", "durability_ratio", "queued_at", "requested_at", "last_failed_at", "last_failed_code", "failed_count", "finished_at", "order_limit_send_count") VALUES (E'\\363\\342\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\016', E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 10 , 8, 1.0, '2019-09-12 10:07:31.028103+00', '2019-09-12 10:07:32.028103+00', null, null, 0, '2019-09-12 10:07:33.028103+00', 0);
INSERT INTO "segment_pending_audits" ("node_id", "piece_id", "stripe_index", "share_size", "expected_share_hash", "reverify_count", "stream_id", position) VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\001'::bytea, E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 5, 1024, E'\\070\\127\\144\\013\\332\\344\\102\\376\\306\\056\\303\\130\\106\\132\\321\\276\\321\\274\\170\\264\\054\\333\\221\\116\\154\\221\\335\\070\\220\\146\\344\\216'::bytea, 1, '\x010101', 1);
INSERT INTO "users"("id", "full_name", "short_name", "email", "normalized_email", "password_hash", "status", "partner_id", "created_at", "is_professional", "project_limit", "project_bandwidth_limit", "project_storage_limit", "paid_tier", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\266\\342U\\303\\312\\204",'::bytea, 'Noahson', 'William', '100email1@mail.test', '100EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, NULL, '2019-02-14 08:28:24.614594+00', false, 10, 100000000000000, 25000000000000, true, 1000000);
INSERT INTO "repair_queue" ("stream_id", "position", "attempted_at", "segment_health", "updated_at", "inserted_at") VALUES ('\x01', 1, null, 1, '2020-09-01 00:00:00.000000+00', '2021-09-01 00:00:00.000000+00');
INSERT INTO "users"("id", "full_name", "email", "normalized_email", "password_hash", "status", "created_at", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "project_limit", "project_bandwidth_limit", "project_storage_limit", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\266\\344U\\303\\312\\204",'::bytea, 'Noahson William', '101email1@mail.test', '101EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, '2019-02-14 08:28:24.614594+00', true, 'mfa secret key', '["1a2b3c4d","e5f6g7h8"]', 3, 50000000000, 50000000000, 150000);
INSERT INTO "projects"("id", "name", "description", "usage_limit", "bandwidth_limit", "rate_limit", "burst_limit", "partner_id", "owner_id", "created_at", "max_buckets", "segment_limit") VALUES (E'300\\273|\\342N\\347\\347\\363\\342\\363\\371>+F\\251\\247'::bytea, 'Limit Test 2', 'This project is below the default', 5e11, 5e11, 2000000, 4000000, NULL, E'265\\343U\\303\\312\\312\\363\\311\\033w\\222\\303Ci",'::bytea, '2020-10-14 10:10:11.000000+00', NULL, 150000);
INSERT INTO "users"("id", "full_name", "email", "normalized_email", "password_hash", "status", "created_at", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "signup_promo_code", "project_limit", "project_bandwidth_limit", "project_storage_limit", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\266\\344U\\303\\312\\205",'::bytea, 'Felicia Smith', '99email1@mail.test', '99EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, '2021-08-14 09:13:44.614594+00', true, 'mfa secret key', '["1a2b3c4d","e5f6d7h8"]', 'promo123', 3, 50000000000, 50000000000, 150000);
INSERT INTO "stripecoinpayments_invoice_project_records"("id", "project_id", "storage", "egress", "objects", "segments", "period_start", "period_end", "state", "created_at") VALUES (E'\\300\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'\\300\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, 0, 0, 0, 0, '2019-06-01 08:28:24.267934+00', '2019-06-01 08:28:24.267934+00', 0, '2019-06-01 08:28:24.267934+00');
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90", "created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success", "country_code") VALUES (E'\\153\\313\\233\\074\\327\\177\\136\\070\\346\\002', '127.0.0.1:55517', '', 0, 4, '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2021-02-14 08:07:31.028103+00', '2021-02-14 08:07:31.108963+00', 'epoch', 'epoch', NULL, NULL, NULL, false, 'DE');
INSERT INTO "bucket_metainfos" ("id", "project_id", "name", "partner_id", "created_at", "path_cipher", "default_segment_size", "default_encryption_cipher_suite", "default_encryption_block_size", "default_redundancy_algorithm", "default_redundancy_share_size", "default_redundancy_required_shares", "default_redundancy_repair_shares", "default_redundancy_optimal_shares", "default_redundancy_total_shares", "placement") VALUES (E'\\144/\\302;\\225\\355O\\323\\276f\\247\\354/6\\241\\033'::bytea, E'\\022\\217/\\014\\376!K\\023\\276\\031\\311}m\\236\\205\\300'::bytea, E'testbucketotheruniquename'::bytea, NULL, '2019-06-14 08:28:24.677953+00', 1, 65536, 1, 8192, 1, 4096, 4, 6, 8, 10, 1);
INSERT INTO "nodes"("id", "address", "last_net", "protocol", "type", "email", "wallet", "wallet_features", "free_disk", "piece_count", "major", "minor", "patch", "hash", "timestamp", "release","latency_90","created_at", "updated_at", "last_contact_success", "last_contact_failure", "disqualified", "disqualification_reason", "suspended", "exit_success", "country_code") VALUES (E'\\362\\341\\363\\371>+F\\256\\263\\300\\273|\\342N\\347\\017', '127.0.0.1:55517', '', 0, 4, '', '', '', -1, 0, 0, 1, 0, '', 'epoch', false, 0, '2020-02-14 08:07:31.028103+00', '2021-10-13 08:07:31.108963+00', 'epoch', 'epoch', '2021-10-13 08:07:31.108963+00', 0, NULL, false, NULL);
INSERT INTO "users"("id", "full_name", "email", "normalized_email", "password_hash", "status", "created_at", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "signup_promo_code", "project_limit", "project_bandwidth_limit", "project_storage_limit", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\267\\342U\\303\\312\\203",'::bytea, 'Jessica Thompson', '143email1@mail.test', '143EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, '2021-11-04 08:27:56.614594+00', true, 'mfa secret key', '["2b3c4d5e","f6a7e8e9"]', 'promo123', 3, '150000000000', '150000000000', 150000);
INSERT INTO "users"("id", "full_name", "email", "normalized_email", "password_hash", "status", "created_at", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "signup_promo_code", "project_limit", "project_bandwidth_limit", "project_storage_limit", "project_segment_limit") VALUES (E'\\363\\311\\033w\\222\\303Ci\\265\\342U\\303\\312\\202",'::bytea, 'Heather Jackson', '762email@mail.test', '762EMAIL1@MAIL.TEST', E'some_readable_hash'::bytea, 1, '2021-11-05 03:22:39.614594+00', true, 'mfa secret key', '["5e4d3c2b","e9e8a7f6"]', 'promo123', 3, '100000000000000', '25000000000000', 150000);
INSERT INTO "users"("id", "full_name", "email", "normalized_email", "password_hash", "status", "created_at", "mfa_enabled", "mfa_secret_key", "mfa_recovery_codes", "signup_promo_code", "project_limit", "project_bandwidth_limit", "project_storage_limit", "last_verification_reminder", "project_segment_limit") VALUES (E'\\364\\312\\033w\\222\\303Ci\\265\\342U\\303\\312\\202",'::bytea, 'Michael Mint', '333email2@mail.test', '333EMAIL2@MAIL.TEST', E'some_readable_hash'::bytea, 1, '2021-10-05 03:22:39.614594+00', true, 'mfa secret key', '["5e4d3c2c","e9e8a7f7"]', 'promo123', 3, '100000000000000', '25000000000000', '2021-12-05 03:22:39.614594+00', 150000);
INSERT INTO "oauth_clients"("id", "encrypted_secret", "redirect_url", "user_id", "app_name", "app_logo_url") VALUES (E'FD6209C0-7A17-4FC3-895C-E57A6C7CBBE1'::bytea, E'610B723B-E1FF-4B1D-B372-521250690C6E'::bytea, 'https://example.test/callback/storj', E'\\364\\312\\033w\\222\\303Ci\\265\\342U\\303\\312\\202",'::bytea, 'Example App', 'https://example.test/logo.png');
INSERT INTO "oauth_codes"("client_id", "user_id", "scope", "redirect_url", "challenge", "challenge_method", "code", "created_at", "expires_at", "claimed_at") VALUES (E'FD6209C0-7A17-4FC3-895C-E57A6C7CBBE1'::bytea, E'\\364\\312\\033w\\222\\303Ci\\265\\342U\\303\\312\\202",'::bytea, 'scope', 'http://localhost:12345/callback', 'challenge', 'challenge method', 'plaintext code', '2021-12-05 03:22:39.614594+00', '2021-12-05 03:22:39.614594+00', '2021-12-05 03:22:39.614594+00');
INSERT INTO "oauth_tokens"("client_id", "user_id", "scope", "kind", "token", "created_at", "expires_at") VALUES (E'FD6209C0-7A17-4FC3-895C-E57A6C7CBBE1'::bytea, E'\\364\\312\\033w\\222\\303Ci\\265\\342U\\303\\312\\202",'::bytea, 'scope', 1, E'B9C93D5F-CBD7-4615-9184-E714CFE14365'::bytea, '2021-12-05 03:22:39.614594+00', '2021-12-05 03:22:39.614594+00');
-- NEW DATA --
INSERT INTO "coinpayments_transactions" ("id", "user_id", "address", "amount_gob", "amount_numeric", "received_gob", "received_numeric", "status", "key", "timeout", "created_at") VALUES ('different_tx_id_from_before', E'\\363\\311\\033w\\222\\303Ci\\265\\343U\\303\\312\\204",'::bytea, 'address', E'\\x0112000000400000000b9cc6615b299c5b96'::bytea, 125419938429, E'\\x011200000040ffffffe6abcc77118461cefd'::bytea, 1, 1, 'key', 60, '2021-07-28 20:24:11.932313-05');
INSERT INTO "stripecoinpayments_tx_conversion_rates" ("tx_id", "rate_gob", "rate_numeric", "created_at") VALUES ('different_tx_id_from_before', E'\\x01020000004000000002c3890fdaa221774ec3a4'::bytea, 3.14159265359, '2021-07-28 20:24:11.932313-05');