Golang ModelTx.Exec方法代码示例

func SaveAPIKey(tx *db.ModelTx, apiKey *APIKey) *APIKey {
	_, err := tx.Exec(
		`INSERT INTO auth_api_key (`+APIKeyModel.FieldsInsert+`)
         VALUES (`+APIKeyModel.Placeholders+`)`,
		apiKey,
	)
	if err != nil {
		panic(err)
	}
	return apiKey
}

// NOTE: This should be called in a serializable transaction to ensure that
// the user's balance gets updated in a safe manner.
func UpdateDepositSetStatus(tx *db.ModelTx, depositId int64, status int32) {
	updated := time.Now().Unix()
	_, err := tx.Exec(
		`UPDATE account_deposit
         SET status=?, updated=?
         WHERE id=?`,
		status, updated, depositId,
	)
	if err != nil {
		panic(err)
	}
}

func UpdatePriceLog(tx *db.ModelTx, plog *PriceLog) {
	_, err := tx.Exec(
		`UPDATE exchange_price_log
         SET low=?, high=?, close=?, ask_volume=?, bid_volume=?
         WHERE market=? AND interval=? AND time=?`,
		plog.Low, plog.High, plog.Close, plog.AskVolume, plog.BidVolume,
		plog.Market, plog.Interval, plog.Time,
	)
	if err != nil {
		panic(err)
	}
}

func UpdateOrder(tx *db.ModelTx, order *Order) {
	order.Updated = time.Now().Unix()
	_, err := tx.Exec(
		`UPDATE exchange_order
         SET status=?, filled=?, basis_filled=?, updated=?
         WHERE id=?`,
		order.Status, order.Filled, order.BasisFilled, order.Updated, order.Id,
	)
	if err != nil {
		panic(err)
	}
}

func UpdateWithdrawals(tx *db.ModelTx, wthIds []interface{}, oldStatus, newStatus int, wtxId int64) {
	if len(wthIds) == 0 {
		return
	}

	res, err := tx.Exec(
		`UPDATE account_withdrawal
         SET status=?, wtx_id=?, updated=?
         WHERE status=? AND id IN (`+Placeholders(len(wthIds))+`)`,
		append([]interface{}{newStatus, wtxId, time.Now().Unix(), oldStatus}, wthIds...)...,
	)
	if err != nil {
		panic(err)
	}
	count, err := res.RowsAffected()
	if err != nil {
		panic(err)
	}
	if int(count) != len(wthIds) {
		panic(NewError("Unexpected affected rows count: %v Expected %v", count, len(wthIds)))
	}
}

func UpdatePaymentsSpent(tx *db.ModelTx, paymentIds []interface{}, oldStatus, newStatus int, wtxId int64) {
	if len(paymentIds) == 0 {
		return
	}
	now := time.Now().Unix()

	res, err := tx.Exec(
		`UPDATE payment
         SET spent=?, wtx_id=?, updated=?
         WHERE spent=? AND id IN (`+Placeholders(len(paymentIds))+`)`,
		append([]interface{}{newStatus, wtxId, now, oldStatus}, paymentIds...)...,
	)
	if err != nil {
		panic(err)
	}
	count, err := res.RowsAffected()
	if int(count) != len(paymentIds) {
		panic(NewError("Unexpected affected rows count: %v Expected %v", count, len(paymentIds)))
	}
	if err != nil {
		panic(err)
	}
}

// Adds or subtracts an amount to a user's wallet.
// nonnegative: panics with INSUFFICIENT_FUNDS_ERROR if resulting balance is negative.
// Returns the new balance
func UpdateBalanceByWallet(tx *db.ModelTx, userId int64, wallet string, coin string, diff int64, nonnegative bool) *Balance {
	var balance Balance

	// Get existing balance.
	err := tx.QueryRow(
		`SELECT `+BalanceModel.FieldsSimple+`
         FROM account_balance WHERE
         user_id=? AND wallet=? AND coin=?`,
		userId, wallet, coin,
	).Scan(&balance)

	// Ensure nonnegative
	if nonnegative && balance.Amount+diff < 0 {
		panic(INSUFFICIENT_FUNDS_ERROR)
	}

	// First time balance?
	if err == sql.ErrNoRows {
		// Create new balance
		balance := Balance{UserId: userId, Wallet: wallet, Coin: coin, Amount: diff}
		SaveBalance(tx, &balance)
		return &balance
	}

	// Update balance
	balance.Amount += diff
	_, err = tx.Exec(
		`UPDATE account_balance
         SET amount=?
         WHERE user_id=? AND wallet=? AND coin=?`,
		balance.Amount, userId, wallet, coin,
	)
	if err != nil {
		panic(err)
	}
	return &balance
}