-
Notifications
You must be signed in to change notification settings - Fork 0
/
account_data.go
144 lines (125 loc) · 4.15 KB
/
account_data.go
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
package history
import (
"context"
"encoding/base64"
sq "github.com/Masterminds/squirrel"
"github.com/shantanu-hashcash/go/support/errors"
"github.com/shantanu-hashcash/go/xdr"
)
func (q *Q) CountAccountsData(ctx context.Context) (int, error) {
sql := sq.Select("count(*)").From("accounts_data")
var count int
if err := q.Get(ctx, &count, sql); err != nil {
return 0, errors.Wrap(err, "could not run select query")
}
return count, nil
}
// GetAccountDataByName loads account data for a given account ID and data name
func (q *Q) GetAccountDataByName(ctx context.Context, id, name string) (Data, error) {
var data Data
sql := selectAccountData.Where(sq.Eq{
"account_id": id,
"name": name,
}).Limit(1)
err := q.Get(ctx, &data, sql)
return data, err
}
// GetAccountDataByAccountID loads account data for a given account ID
func (q *Q) GetAccountDataByAccountID(ctx context.Context, id string) ([]Data, error) {
var data []Data
sql := selectAccountData.Where(sq.Eq{"account_id": id})
err := q.Select(ctx, &data, sql)
return data, err
}
// GetAccountDataByKeys loads a row from the `accounts_data` table, selected by multiple keys.
func (q *Q) GetAccountDataByKeys(ctx context.Context, keys []AccountDataKey) ([]Data, error) {
var data []Data
lkeys := make([]string, 0, len(keys))
for _, key := range keys {
lkey, err := accountDataKeyToString(key)
if err != nil {
return nil, errors.Wrap(err, "Error running accountDataKeyToString")
}
lkeys = append(lkeys, lkey)
}
sql := selectAccountData.Where(map[string]interface{}{"accounts_data.ledger_key": lkeys})
err := q.Select(ctx, &data, sql)
return data, err
}
func accountDataKeyToString(key AccountDataKey) (string, error) {
var aid xdr.AccountId
err := aid.SetAddress(key.AccountID)
if err != nil {
return "", err
}
var ledgerKey xdr.LedgerKey
if err = ledgerKey.SetData(aid, key.DataName); err != nil {
return "", errors.Wrap(err, "Error running ledgerKey.SetData")
}
lKey, err := ledgerKey.MarshalBinary()
if err != nil {
return "", errors.Wrap(err, "Error running MarshalBinaryCompress")
}
return base64.StdEncoding.EncodeToString(lKey), nil
}
// UpsertAccountData upserts a batch of data in the account_Data table.
func (q *Q) UpsertAccountData(ctx context.Context, data []Data) error {
var ledgerKey, accountID, name, value, lastModifiedLedger, sponsor []interface{}
for _, d := range data {
key, err := accountDataKeyToString(AccountDataKey{
AccountID: d.AccountID,
DataName: d.Name,
})
if err != nil {
return err
}
ledgerKey = append(ledgerKey, key)
accountID = append(accountID, d.AccountID)
name = append(name, d.Name)
value = append(value, d.Value)
lastModifiedLedger = append(lastModifiedLedger, d.LastModifiedLedger)
sponsor = append(sponsor, d.Sponsor)
}
upsertFields := []upsertField{
{"ledger_key", "character varying(150)", ledgerKey},
{"account_id", "character varying(56)", accountID},
{"name", "character varying(64)", name},
{"value", "character varying(90)", value},
{"last_modified_ledger", "integer", lastModifiedLedger},
{"sponsor", "text", sponsor},
}
return q.upsertRows(ctx, "accounts_data", "ledger_key", upsertFields)
}
// RemoveAccountData deletes a row in the accounts_data table.
// Returns number of rows affected and error.
func (q *Q) RemoveAccountData(ctx context.Context, keys []AccountDataKey) (int64, error) {
lkeys := make([]string, 0, len(keys))
for _, key := range keys {
lkey, err := accountDataKeyToString(key)
if err != nil {
return 0, errors.Wrap(err, "Error running accountDataKeyToString")
}
lkeys = append(lkeys, lkey)
}
sql := sq.Delete("accounts_data").
Where(sq.Eq{"ledger_key": lkeys})
result, err := q.Exec(ctx, sql)
if err != nil {
return 0, err
}
return result.RowsAffected()
}
// GetAccountDataByAccountsID loads account data for a list of account ID
func (q *Q) GetAccountDataByAccountsID(ctx context.Context, id []string) ([]Data, error) {
var data []Data
sql := selectAccountData.Where(sq.Eq{"account_id": id})
err := q.Select(ctx, &data, sql)
return data, err
}
var selectAccountData = sq.Select(`
account_id,
name,
value,
last_modified_ledger,
sponsor
`).From("accounts_data")