mirror of
https://github.com/status-im/status-go.git
synced 2025-01-25 05:58:59 +00:00
5b6f7226bb
Extended the migration process with a generic way of applying custom migration code on top of the SQL files. The implementation provides a safer way to run GO code along with the SQL migrations and possibility of rolling back the changes in case of failure to keep the database consistent. This custom GO migration is needed to extract the status from the JSON blob receipt and store it in transfers table. Other changes: - Add NULL DB value tracking to JSONBlob helper - Index status column on transfers table - Remove unnecessary panic calls - Move log_parser to wallet's common package and use to extract token identity from the logs Notes: - there is already an index on transfers table, sqlite creates one for each unique constraint therefore add only status to a new index - the planned refactoring and improvements to the database have been postponed due to time constraints. Got the time to migrate the data though, extracting it can be done later for a more efficient implementation Update status-desktop #10746
90 lines
1.7 KiB
Go
90 lines
1.7 KiB
Go
package sqlite
|
|
|
|
import (
|
|
"database/sql/driver"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"math"
|
|
"math/big"
|
|
"reflect"
|
|
)
|
|
|
|
// JSONBlob type for marshaling/unmarshaling inner type to json.
|
|
type JSONBlob struct {
|
|
Data interface{}
|
|
Valid bool
|
|
}
|
|
|
|
// Scan implements interface.
|
|
func (blob *JSONBlob) Scan(value interface{}) error {
|
|
dataVal := reflect.ValueOf(blob.Data)
|
|
blob.Valid = false
|
|
if value == nil || dataVal.Kind() == reflect.Ptr && dataVal.IsNil() {
|
|
return nil
|
|
}
|
|
|
|
var bytes []byte
|
|
ok := true
|
|
switch v := value.(type) {
|
|
case []byte:
|
|
bytes, ok = value.([]byte)
|
|
case string:
|
|
bytes = []byte(v)
|
|
default:
|
|
ok = false
|
|
}
|
|
if !ok {
|
|
return errors.New("not a byte slice or string")
|
|
}
|
|
if len(bytes) == 0 {
|
|
return nil
|
|
}
|
|
err := json.Unmarshal(bytes, blob.Data)
|
|
blob.Valid = err == nil
|
|
return err
|
|
}
|
|
|
|
// Value implements interface.
|
|
func (blob *JSONBlob) Value() (driver.Value, error) {
|
|
dataVal := reflect.ValueOf(blob.Data)
|
|
if (blob.Data == nil) || (dataVal.Kind() == reflect.Ptr && dataVal.IsNil()) {
|
|
return nil, nil
|
|
}
|
|
|
|
switch dataVal.Kind() {
|
|
case reflect.Slice, reflect.Array, reflect.Map:
|
|
if dataVal.Len() == 0 {
|
|
return nil, nil
|
|
}
|
|
}
|
|
|
|
return json.Marshal(blob.Data)
|
|
}
|
|
|
|
func BigIntToClampedInt64(val *big.Int) *int64 {
|
|
if val == nil {
|
|
return nil
|
|
}
|
|
var v int64
|
|
if val.IsInt64() {
|
|
v = val.Int64()
|
|
} else {
|
|
v = math.MaxInt64
|
|
}
|
|
return &v
|
|
}
|
|
|
|
// BigIntToPadded128BitsStr converts a big.Int to a string, padding it with 0 to account for 128 bits size
|
|
// Returns nil if input val is nil
|
|
// This should work to sort and compare big.Ints values in SQLite
|
|
func BigIntToPadded128BitsStr(val *big.Int) *string {
|
|
if val == nil {
|
|
return nil
|
|
}
|
|
hexStr := val.Text(16)
|
|
res := new(string)
|
|
*res = fmt.Sprintf("%032s", hexStr)
|
|
return res
|
|
}
|