Skip to content

Use QueryRow instead of Query when getting single record #764

New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

Sign up for GitHub

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

Merged
merged 3 commits into from
Apr 21, 2020
Merged

Use QueryRow instead of Query when getting single record #764

Show file tree
Hide file tree
Changes from all commits
Commits
Show all changes
3 commits
Select commit Hold shift + click to select a range
fad264d
removeNodeReg.Validate better to use QueryRow
astaphobia Apr 20, 2020
74dc2fb
nodeRegistrationUpdate.ApplyUnconfirmed better to use QueryRow
astaphobia Apr 21, 2020
27667f6
Merge branch 'develop' into query-row-instead-of-query
andy-shi88 Apr 21, 2020
File filter

Filter by extension

Filter by extension
Conversations
Failed to load comments.
Loading
Jump to
Jump to file
Failed to load files.
Loading
Diff view
Diff view
23 changes: 11 additions & 12 deletions common/transaction/nodeRegistrationUpdate.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -143,29 +143,28 @@ ApplyUnconfirmed is func that for applying to unconfirmed Transaction `UpdateNod
func (tx *UpdateNodeRegistration) ApplyUnconfirmed() error {

var (
err error
prevNodeRegistration *model.NodeRegistration
effectiveBalanceToLock int64
nodeReg model.NodeRegistration
err error
row *sql.Row
)

// update sender balance by reducing his spendable balance of the tx fee + new balance to be lock
// (delta between old locked balance and updatee locked balance)
// (delta between old locked balance and update locked balance)
if tx.Body.LockedBalance > 0 {
// get the latest noderegistration by owner (sender account)
// get the latest node registration by owner (sender account)
qry, args := tx.NodeRegistrationQuery.GetNodeRegistrationByAccountAddress(tx.SenderAddress)
rows, err := tx.QueryExecutor.ExecuteSelect(qry, false, args...)
row, _ = tx.QueryExecutor.ExecuteSelectRow(qry, false, args...)
err = tx.NodeRegistrationQuery.Scan(&nodeReg, row)
if err != nil {
return err
}
defer rows.Close()
nr, err := tx.NodeRegistrationQuery.BuildModel([]*model.NodeRegistration{}, rows)
if (err != nil) || len(nr) == 0 {
if err != sql.ErrNoRows {
return err
}
return blocker.NewBlocker(blocker.AppErr, "NodeNotFoundWithAccountAddress")
}
prevNodeRegistration = nr[0]

// delta amount to be locked
effectiveBalanceToLock = tx.Body.LockedBalance - prevNodeRegistration.LockedBalance
effectiveBalanceToLock = tx.Body.GetLockedBalance() - nodeReg.GetLockedBalance()
}

accountBalanceSenderQ, accountBalanceSenderQArgs := tx.AccountBalanceQuery.AddAccountSpendableBalance(
Expand Down
46 changes: 28 additions & 18 deletions common/transaction/nodeRegistrationUpdate_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -5,6 +5,7 @@ import (
"errors"
"reflect"
"regexp"
"strings"
"testing"

"github.com/DATA-DOG/go-sqlmock"
Expand Down Expand Up @@ -85,16 +86,11 @@ func (*mockExecutorValidateFailNodeDeleted) ExecuteSelect(qe string, tx bool, ar
return nil, nil
}

func (*mockExecutorValidateFailNodeNotFoundRU) ExecuteSelect(qe string, tx bool, args ...interface{}) (*sql.Rows, error) {
func (*mockExecutorValidateFailNodeNotFoundRU) ExecuteSelectRow(qe string, _ bool, _ ...interface{}) (*sql.Row, error) {
db, mock, _ := sqlmock.New()
defer db.Close()
if qe == "SELECT id, node_public_key, account_address, registration_height, node_address,"+
" locked_balance, registration_status, latest, height FROM node_registry WHERE account_address = ? AND latest=1 "+
"ORDER BY height DESC LIMIT 1" {
mock.ExpectQuery("").WillReturnRows(sqlmock.NewRows([]string{}))
return db.Query("")
}
return nil, nil
mock.ExpectQuery("SELECT").WillReturnRows(mock.NewRows(query.NewNodeRegistrationQuery().Fields))
return db.QueryRow(qe), nil
}

func (*mockExecutorValidateFailNodeAlreadyRegisteredRU) ExecuteSelect(qe string, tx bool, args ...interface{}) (*sql.Rows, error) {
Expand Down Expand Up @@ -306,22 +302,36 @@ func (*mockExecutorValidateSuccessRU) ExecuteSelect(qe string, tx bool, args ...

func (*mockExecutorValidateSuccessRU) ExecuteSelectRow(qStr string, tx bool, args ...interface{}) (*sql.Row, error) {
db, mock, _ := sqlmock.New()
mock.ExpectQuery(regexp.QuoteMeta(qStr)).
WillReturnRows(sqlmock.NewRows([]string{
"account_address",
"block_height",
"spendable_balance",
"balance",
"pop_revenue",
"latest",
}).AddRow(
defer db.Close()

var mockedRows *sqlmock.Rows
switch {
case strings.Contains(qStr, "account_balance"):
mockedRows = mock.NewRows(query.NewAccountBalanceQuery().Fields)
mockedRows.AddRow(
senderAddress1,
uint32(1),
int64(1000000000000),
int64(1000000000000),
int64(100000000),
true,
))
)
default:
mockedRows = mock.NewRows(query.NewNodeRegistrationQuery().Fields)
mockedRows.AddRow(
int64(10000),
nodePubKey1,
senderAddress1,
uint32(1),
"10.10.10.10",
int64(1000),
model.NodeRegistrationState_NodeRegistered,
true,
uint32(1),
)
}
mock.ExpectQuery(regexp.QuoteMeta(qStr)).
WillReturnRows(mockedRows)
return db.QueryRow(qStr), nil
}

Expand Down
21 changes: 13 additions & 8 deletions common/transaction/removeNodeRegistration.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -150,24 +150,29 @@ func (tx *RemoveNodeRegistration) UndoApplyUnconfirmed() error {
// Validate validate node registration transaction and tx body
func (tx *RemoveNodeRegistration) Validate(dbTx bool) error {
var (
nodeRegistrations []*model.NodeRegistration
nodeReg model.NodeRegistration
err error
row *sql.Row
)

// check for duplication
nodeRow, err := tx.QueryExecutor.ExecuteSelect(tx.NodeRegistrationQuery.GetNodeRegistrationByNodePublicKey(), dbTx, tx.Body.NodePublicKey)
row, err = tx.QueryExecutor.ExecuteSelectRow(tx.NodeRegistrationQuery.GetNodeRegistrationByNodePublicKey(), dbTx, tx.Body.GetNodePublicKey())
if err != nil {
return err
}
defer nodeRow.Close()
nodeRegistrations, err = tx.NodeRegistrationQuery.BuildModel(nodeRegistrations, nodeRow)
if (err != nil) || len(nodeRegistrations) == 0 {
err = tx.NodeRegistrationQuery.Scan(&nodeReg, row)
if err != nil {
if err != sql.ErrNoRows {
return err
}
return blocker.NewBlocker(blocker.AppErr, "NodeNotRegistered")
}
nr := nodeRegistrations[0]

// sender must be node owner
if tx.SenderAddress != nr.AccountAddress {
if tx.SenderAddress != nodeReg.GetAccountAddress() {
return blocker.NewBlocker(blocker.AuthErr, "AccountNotNodeOwner")
}
if nr.RegistrationStatus == uint32(model.NodeRegistrationState_NodeDeleted) {
if nodeReg.GetRegistrationStatus() == uint32(model.NodeRegistrationState_NodeDeleted) {
return blocker.NewBlocker(blocker.AuthErr, "NodeAlreadyDeleted")
}
return nil
Expand Down
92 changes: 29 additions & 63 deletions common/transaction/removeNodeRegistration_test.go
View file
Open in desktop
Original file line number Diff line number Diff line change
Expand Up @@ -114,81 +114,47 @@ func (*mockExecutorApplyUnconfirmedRemoveNodeRegistrationFail) ExecuteTransactio
return errors.New("MockdeError")
}

func (*mockExecutorValidateRemoveNodeRegistrationSuccess) ExecuteSelect(qe string, tx bool,
args ...interface{}) (*sql.Rows, error) {
func (*mockExecutorValidateRemoveNodeRegistrationSuccess) ExecuteSelectRow(qe string, _ bool, _ ...interface{}) (*sql.Row, error) {
body, _ := GetFixturesForRemoveNoderegistration()
db, mock, _ := sqlmock.New()
defer db.Close()

if qe == "SELECT id, node_public_key, account_address, registration_height, node_address, locked_balance, registration_status,"+
" latest, height FROM node_registry WHERE node_public_key = ? AND latest=1 ORDER BY height DESC LIMIT 1" {
mock.ExpectQuery("A").WillReturnRows(sqlmock.NewRows([]string{
"NodeID",
"NodePublicKey",
"AccountAddress",
"RegistrationHeight",
"NodeAddress",
"LockedBalance",
"RegistrationStatus",
"Latest",
"Height",
}).AddRow(
0,
body.NodePublicKey,
"BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN",
1,
"10.10.10.10",
1,
1,
1,
1,
))
return db.Query("A")
}
return nil, nil
mock.ExpectQuery("SELECT").WillReturnRows(mock.NewRows(query.NewNodeRegistrationQuery().Fields).AddRow(
0,
body.NodePublicKey,
"BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN",
1,
"10.10.10.10",
1,
1,
1,
1,
))

return db.QueryRow(qe), nil
}

func (*mockExecutorValidateRemoveNodeRegistrationFailNodeAlreadyDeleted) ExecuteSelect(qe string, tx bool,
args ...interface{}) (*sql.Rows, error) {
func (*mockExecutorValidateRemoveNodeRegistrationFailNodeAlreadyDeleted) ExecuteSelectRow(qe string, _ bool, _ ...interface{}) (*sql.Row, error) {
body, _ := GetFixturesForRemoveNoderegistration()
db, mock, _ := sqlmock.New()
defer db.Close()

if qe == "SELECT id, node_public_key, account_address, registration_height, node_address, locked_balance, registration_status,"+
" latest, height FROM node_registry WHERE node_public_key = ? AND latest=1 ORDER BY height DESC LIMIT 1" {
mock.ExpectQuery("A").WillReturnRows(sqlmock.NewRows([]string{
"NodeID",
"NodePublicKey",
"AccountAddress",
"RegistrationHeight",
"NodeAddress",
"LockedBalance",
"RegistrationStatus",
"Latest",
"Height",
}).AddRow(
0,
body.NodePublicKey,
"BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN",
1,
"10.10.10.10",
1,
uint32(model.NodeRegistrationState_NodeDeleted),
1,
1,
))
return db.Query("A")
}
return nil, nil
mock.ExpectQuery("SELECT").WillReturnRows(mock.NewRows(query.NewNodeRegistrationQuery().Fields).AddRow(
0,
body.NodePublicKey,
"BCZnSfqpP5tqFQlMTYkDeBVFWnbyVK7vLr5ORFpTjgtN",
1,
"10.10.10.10",
1,
uint32(model.NodeRegistrationState_NodeDeleted),
1,
1,
))
return db.QueryRow(qe), nil
}

func (*mockExecutorValidateRemoveNodeRegistrationFailGetRNode) ExecuteSelect(qe string, tx bool,
args ...interface{}) (*sql.Rows, error) {
if qe == "SELECT id, node_public_key, account_address, registration_height, node_address, locked_balance, registration_status,"+
" latest, height FROM node_registry WHERE node_public_key = ? AND latest=1 ORDER BY height DESC LIMIT 1" {
return nil, errors.New("MockedError")
}
return nil, nil
func (*mockExecutorValidateRemoveNodeRegistrationFailGetRNode) ExecuteSelectRow(qe string, _ bool, _ ...interface{}) (*sql.Row, error) {
return nil, errors.New("MockedError")
}

func (*mockExecutorApplyConfirmedRemoveNodeRegistrationSuccess) ExecuteSelectRow(qe string, _ bool, _ ...interface{}) (*sql.Row, error) {
Expand Down