-
Notifications
You must be signed in to change notification settings - Fork 5
/
repository.go
127 lines (111 loc) · 4.5 KB
/
repository.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
package cat
import (
"fmt"
"github.com/makerdao/vdb-mcd-transformers/transformers/shared"
"github.com/makerdao/vdb-mcd-transformers/transformers/shared/constants"
"github.com/makerdao/vulcanizedb/libraries/shared/storage"
"github.com/makerdao/vulcanizedb/pkg/datastore/postgres"
)
const (
InsertCatIlkChopQuery = `INSERT INTO maker.cat_ilk_chop (diff_id, header_id, ilk_id, chop) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING`
InsertCatIlkFlipQuery = `INSERT INTO maker.cat_ilk_flip (diff_id, header_id, ilk_id, flip) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING`
InsertCatIlkLumpQuery = `INSERT INTO maker.cat_ilk_lump (diff_id, header_id, ilk_id, lump) VALUES ($1, $2, $3, $4) ON CONFLICT DO NOTHING`
insertCatLiveQuery = `INSERT INTO maker.cat_live (diff_id, header_id, live) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`
insertCatVatQuery = `INSERT INTO maker.cat_vat (diff_id, header_id, vat) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`
insertCatVowQuery = `INSERT INTO maker.cat_vow (diff_id, header_id, vow) VALUES ($1, $2, $3) ON CONFLICT DO NOTHING`
)
type CatStorageRepository struct {
db *postgres.DB
}
func (repository *CatStorageRepository) Create(diffID, headerID int64, metadata storage.ValueMetadata, value interface{}) error {
switch metadata.Name {
case Live:
return repository.insertLive(diffID, headerID, value.(string))
case Vat:
return repository.insertVat(diffID, headerID, value.(string))
case Vow:
return repository.insertVow(diffID, headerID, value.(string))
case IlkChop:
return repository.insertIlkChop(diffID, headerID, metadata, value.(string))
case IlkFlip:
return repository.insertIlkFlip(diffID, headerID, metadata, value.(string))
case IlkLump:
return repository.insertIlkLump(diffID, headerID, metadata, value.(string))
default:
panic(fmt.Sprintf("unrecognized cat contract storage name: %s", metadata.Name))
}
}
func (repository *CatStorageRepository) SetDB(db *postgres.DB) {
repository.db = db
}
func (repository *CatStorageRepository) insertLive(diffID, headerID int64, live string) error {
_, writeErr := repository.db.Exec(insertCatLiveQuery, diffID, headerID, live)
return writeErr
}
func (repository *CatStorageRepository) insertVat(diffID, headerID int64, vat string) error {
_, writeErr := repository.db.Exec(insertCatVatQuery, diffID, headerID, vat)
return writeErr
}
func (repository *CatStorageRepository) insertVow(diffID, headerID int64, vow string) error {
_, writeErr := repository.db.Exec(insertCatVowQuery, diffID, headerID, vow)
return writeErr
}
// Ilks mapping: bytes32 => flip address; chop (ray), lump (wad) uint256
func (repository *CatStorageRepository) insertIlkFlip(diffID, headerID int64, metadata storage.ValueMetadata, flip string) error {
ilk, err := getIlk(metadata.Keys)
if err != nil {
return err
}
return repository.insertFieldWithIlk(diffID, headerID, ilk, IlkFlip, InsertCatIlkFlipQuery, flip)
}
func (repository *CatStorageRepository) insertIlkChop(diffID, headerID int64, metadata storage.ValueMetadata, chop string) error {
ilk, err := getIlk(metadata.Keys)
if err != nil {
return err
}
return repository.insertFieldWithIlk(diffID, headerID, ilk, IlkChop, InsertCatIlkChopQuery, chop)
}
func (repository *CatStorageRepository) insertIlkLump(diffID, headerID int64, metadata storage.ValueMetadata, lump string) error {
ilk, err := getIlk(metadata.Keys)
if err != nil {
return err
}
return repository.insertFieldWithIlk(diffID, headerID, ilk, IlkLump, InsertCatIlkLumpQuery, lump)
}
func (repository *CatStorageRepository) insertFieldWithIlk(diffID, headerID int64, ilk, variableName, query, value string) error {
tx, txErr := repository.db.Beginx()
if txErr != nil {
return txErr
}
ilkID, ilkErr := shared.GetOrCreateIlkInTransaction(ilk, tx)
if ilkErr != nil {
rollbackErr := tx.Rollback()
if rollbackErr != nil {
return shared.FormatRollbackError("ilk", ilkErr.Error())
}
return ilkErr
}
_, writeErr := tx.Exec(query, diffID, headerID, ilkID, value)
if writeErr != nil {
rollbackErr := tx.Rollback()
if rollbackErr != nil {
return shared.FormatRollbackError(variableName, writeErr.Error())
}
return writeErr
}
return tx.Commit()
}
func getIlk(keys map[storage.Key]string) (string, error) {
ilk, ok := keys[constants.Ilk]
if !ok {
return "", storage.ErrMetadataMalformed{MissingData: constants.Ilk}
}
return ilk, nil
}
func getFlip(keys map[storage.Key]string) (string, error) {
flip, ok := keys[constants.Flip]
if !ok {
return "", storage.ErrMetadataMalformed{MissingData: constants.Flip}
}
return flip, nil
}