From 342dc857f57ad730e13bd98bc172fc7f9502aa65 Mon Sep 17 00:00:00 2001 From: Bill Thorp Date: Wed, 16 Jan 2019 14:30:33 -0500 Subject: [PATCH] rollup query (#1056) * implemention notes * more notes * starting rollup query * not working yet * fixed build * fixed cfg bug * change context cancelled errs to debugs * using byte hours for at rest tally * revert changes to go.mod * comment fixes * prevent double recording tallies in rollup * linting * stop leaking dbx * nodeid changes * fix build --- pkg/accounting/common.go | 2 + pkg/accounting/db.go | 38 +- pkg/accounting/rollup/config.go | 4 +- pkg/accounting/rollup/rollup.go | 66 +- pkg/accounting/tally/config.go | 2 +- pkg/accounting/tally/tally.go | 31 +- pkg/datarepair/checker/config.go | 2 +- pkg/datarepair/repairer/config.go | 2 +- satellite/satellitedb/accounting.go | 94 ++- satellite/satellitedb/dbx/satellitedb.dbx | 31 +- satellite/satellitedb/dbx/satellitedb.dbx.go | 610 ++++++++---------- .../dbx/satellitedb.dbx.postgres.sql | 17 +- .../dbx/satellitedb.dbx.sqlite3.sql | 17 +- satellite/satellitedb/locked.go | 23 +- 14 files changed, 523 insertions(+), 416 deletions(-) diff --git a/pkg/accounting/common.go b/pkg/accounting/common.go index 30e4ee4aa..60aa1a97c 100644 --- a/pkg/accounting/common.go +++ b/pkg/accounting/common.go @@ -18,4 +18,6 @@ const ( LastAtRestTally = "LastAtRestTally" // LastBandwidthTally represents the accounting timestamp for the bandwidth allocation query LastBandwidthTally = "LastBandwidthTally" + // LastRollup represents the accounting timestamp for rollup calculations + LastRollup = "LastRollup" ) diff --git a/pkg/accounting/db.go b/pkg/accounting/db.go index 5d4fe3a66..5401939ca 100644 --- a/pkg/accounting/db.go +++ b/pkg/accounting/db.go @@ -11,8 +11,34 @@ import ( "storj.io/storj/pkg/storj" ) -//BWTally is a convience alias -type BWTally [pb.PayerBandwidthAllocation_PUT_REPAIR + 1]map[string]int64 +//BWTally is a convenience alias +type BWTally [pb.PayerBandwidthAllocation_PUT_REPAIR + 1]map[storj.NodeID]int64 + +//RollupStats is a convenience alias +type RollupStats map[time.Time]map[storj.NodeID]*Rollup + +//Raw mirrors dbx.AccountingRaw, allowing us to use that struct without leaking dbx +type Raw struct { + ID int64 + NodeID storj.NodeID + IntervalEndTime time.Time + DataTotal float64 + DataType int + CreatedAt time.Time +} + +//Rollup mirrors dbx.AccountingRollup, allowing us to use that struct without leaking dbx +type Rollup struct { + ID int64 + NodeID storj.NodeID + StartTime time.Time + PutTotal int64 + GetTotal int64 + GetAuditTotal int64 + GetRepairTotal int64 + PutRepairTotal int64 + AtRestTotal float64 +} // DB stores information about bandwidth usage type DB interface { @@ -21,5 +47,11 @@ type DB interface { // SaveBWRaw records raw sums of agreement values to the database and updates the LastRawTime. SaveBWRaw(ctx context.Context, latestBwa time.Time, bwTotals BWTally) error // SaveAtRestRaw records raw tallies of at-rest-data. - SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]int64) error + SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]float64) error + // GetRaw retrieves all raw tallies + GetRaw(ctx context.Context) ([]*Raw, error) + // GetRawSince r retrieves all raw tallies sinces + GetRawSince(ctx context.Context, latestRollup time.Time) ([]*Raw, error) + // SaveRollup records raw tallies of at rest data to the database + SaveRollup(ctx context.Context, latestTally time.Time, stats RollupStats) error } diff --git a/pkg/accounting/rollup/config.go b/pkg/accounting/rollup/config.go index d616dfe1a..f44bda435 100644 --- a/pkg/accounting/rollup/config.go +++ b/pkg/accounting/rollup/config.go @@ -16,7 +16,7 @@ import ( // Config contains configurable values for rollup type Config struct { - Interval time.Duration `help:"how frequently rollup should run" default:"30s"` + Interval time.Duration `help:"how frequently rollup should run" default:"1h"` } // Initialize a rollup struct @@ -39,7 +39,7 @@ func (c Config) Run(ctx context.Context, server *provider.Provider) (err error) go func() { if err := rollup.Run(ctx); err != nil { defer cancel() - zap.L().Error("Error running rollup", zap.Error(err)) + zap.L().Debug("Rollup is shutting down", zap.Error(err)) } }() diff --git a/pkg/accounting/rollup/rollup.go b/pkg/accounting/rollup/rollup.go index 0bd6418f5..d953f870b 100644 --- a/pkg/accounting/rollup/rollup.go +++ b/pkg/accounting/rollup/rollup.go @@ -5,14 +5,16 @@ package rollup import ( "context" + "fmt" "time" "go.uber.org/zap" "storj.io/storj/pkg/accounting" + "storj.io/storj/pkg/storj" ) -// Rollup is the service for totalling data on storage nodes for 1, 7, 30 day intervals +// Rollup is the service for totalling data on storage nodes on daily intervals type Rollup interface { Run(ctx context.Context) error } @@ -34,13 +36,11 @@ func newRollup(logger *zap.Logger, db accounting.DB, interval time.Duration) *ro // Run the rollup loop func (r *rollup) Run(ctx context.Context) (err error) { defer mon.Task()(&ctx)(&err) - for { err = r.Query(ctx) if err != nil { r.logger.Error("Query failed", zap.Error(err)) } - select { case <-r.ticker.C: // wait for the next interval to happen case <-ctx.Done(): // or the rollup is canceled via context @@ -50,6 +50,62 @@ func (r *rollup) Run(ctx context.Context) (err error) { } func (r *rollup) Query(ctx context.Context) error { - //TODO - return nil + //only rollup new things - get LastRollup + var latestTally time.Time + lastRollup, isNil, err := r.db.LastRawTime(ctx, accounting.LastRollup) + if err != nil { + return Error.Wrap(err) + } + var tallies []*accounting.Raw + if isNil { + r.logger.Info("Rollup found no existing raw tally data") + tallies, err = r.db.GetRaw(ctx) + } else { + tallies, err = r.db.GetRawSince(ctx, lastRollup) + } + if err != nil { + return Error.Wrap(err) + } + if len(tallies) == 0 { + r.logger.Info("Rollup found no new tallies") + return nil + } + //loop through tallies and build rollup + rollupStats := make(accounting.RollupStats) + for _, tallyRow := range tallies { + node := tallyRow.NodeID + if tallyRow.CreatedAt.After(latestTally) { + latestTally = tallyRow.CreatedAt + } + //create or get AccoutingRollup + iDay := tallyRow.IntervalEndTime + iDay = time.Date(iDay.Year(), iDay.Month(), iDay.Day(), 0, 0, 0, 0, iDay.Location()) + if rollupStats[iDay] == nil { + rollupStats[iDay] = make(map[storj.NodeID]*accounting.Rollup) + } + if rollupStats[iDay][node] == nil { + rollupStats[iDay][node] = &accounting.Rollup{NodeID: node, StartTime: iDay} + } + //increment Rollups + switch tallyRow.DataType { + case accounting.BandwidthPut: + rollupStats[iDay][node].PutTotal += int64(tallyRow.DataTotal) + case accounting.BandwidthGet: + rollupStats[iDay][node].GetTotal += int64(tallyRow.DataTotal) + case accounting.BandwidthGetAudit: + rollupStats[iDay][node].GetAuditTotal += int64(tallyRow.DataTotal) + case accounting.BandwidthGetRepair: + rollupStats[iDay][node].GetRepairTotal += int64(tallyRow.DataTotal) + case accounting.BandwidthPutRepair: + rollupStats[iDay][node].PutRepairTotal += int64(tallyRow.DataTotal) + case accounting.AtRest: + rollupStats[iDay][node].AtRestTotal += tallyRow.DataTotal + default: + return Error.Wrap(fmt.Errorf("Bad tally datatype in rollup : %d", tallyRow.DataType)) + } + } + //remove the latest day (which we cannot know is complete), then push to DB + latestTally = time.Date(latestTally.Year(), latestTally.Month(), latestTally.Day(), 0, 0, 0, 0, latestTally.Location()) + delete(rollupStats, latestTally) + return Error.Wrap(r.db.SaveRollup(ctx, latestTally, rollupStats)) } diff --git a/pkg/accounting/tally/config.go b/pkg/accounting/tally/config.go index 62b13860b..33db2491f 100644 --- a/pkg/accounting/tally/config.go +++ b/pkg/accounting/tally/config.go @@ -53,7 +53,7 @@ func (c Config) Run(ctx context.Context, server *provider.Provider) (err error) go func() { if err := tally.Run(ctx); err != nil { defer cancel() - zap.L().Error("Error running tally", zap.Error(err)) + zap.L().Debug("Tally is shutting down", zap.Error(err)) } }() diff --git a/pkg/accounting/tally/tally.go b/pkg/accounting/tally/tally.go index 62bce6b7f..a216f5109 100644 --- a/pkg/accounting/tally/tally.go +++ b/pkg/accounting/tally/tally.go @@ -71,7 +71,13 @@ func (t *tally) Run(ctx context.Context) (err error) { // the amount of at-rest data stored on each respective node func (t *tally) calculateAtRestData(ctx context.Context) (err error) { defer mon.Task()(&ctx)(&err) - var nodeData = make(map[storj.NodeID]int64) + + latestTally, isNil, err := t.accountingDB.LastRawTime(ctx, accounting.LastAtRestTally) + if err != nil { + return Error.Wrap(err) + } + + var nodeData = make(map[storj.NodeID]float64) err = t.pointerdb.Iterate(ctx, &pb.IterateRequest{Recurse: true}, func(it storage.Iterator) error { var item storage.ListItem @@ -103,27 +109,25 @@ func (t *tally) calculateAtRestData(ctx context.Context) (err error) { } pieceSize := segmentSize / int64(minReq) for _, piece := range pieces { - nodeData[piece.NodeId] += pieceSize + nodeData[piece.NodeId] += float64(pieceSize) } } return nil }, ) - if err != nil { - return Error.Wrap(err) - } if len(nodeData) == 0 { return nil } - latestTally, isNil, err := t.accountingDB.LastRawTime(ctx, accounting.LastAtRestTally) if err != nil { return Error.Wrap(err) } - if err != nil { - return Error.Wrap(err) + //store byte hours, not just bytes + numHours := 1.0 //todo: something more considered? + if !isNil { + numHours = time.Now().UTC().Sub(latestTally).Hours() } - if isNil { - latestTally = time.Now().UTC() + for k := range nodeData { + nodeData[k] *= numHours } return Error.Wrap(t.accountingDB.SaveAtRestRaw(ctx, latestTally, nodeData)) } @@ -146,7 +150,6 @@ func (t *tally) queryBW(ctx context.Context) error { if err != nil { return Error.Wrap(err) } - if len(bwAgreements) == 0 { t.logger.Info("Tally found no new bandwidth allocations") return nil @@ -155,7 +158,7 @@ func (t *tally) queryBW(ctx context.Context) error { // sum totals by node id ... todo: add nodeid as SQL column so DB can do this? var bwTotals accounting.BWTally for i := range bwTotals { - bwTotals[i] = make(map[string]int64) + bwTotals[i] = make(map[storj.NodeID]int64) } var latestBwa time.Time for _, baRow := range bwAgreements { @@ -168,12 +171,10 @@ func (t *tally) queryBW(ctx context.Context) error { if err := proto.Unmarshal(rbad.GetPayerAllocation().GetData(), pbad); err != nil { return err } - if baRow.CreatedAt.After(latestBwa) { latestBwa = baRow.CreatedAt } - bwTotals[pbad.GetAction()][rbad.StorageNodeId.String()] += rbad.GetTotal() + bwTotals[pbad.GetAction()][rbad.StorageNodeId] += rbad.GetTotal() } - return Error.Wrap(t.accountingDB.SaveBWRaw(ctx, lastBwTally, bwTotals)) } diff --git a/pkg/datarepair/checker/config.go b/pkg/datarepair/checker/config.go index 0cd6b240d..59e9fe55b 100644 --- a/pkg/datarepair/checker/config.go +++ b/pkg/datarepair/checker/config.go @@ -54,7 +54,7 @@ func (c Config) Run(ctx context.Context, server *provider.Provider) (err error) go func() { if err := check.Run(ctx); err != nil { defer cancel() - zap.L().Error("Error running checker", zap.Error(err)) + zap.L().Debug("Checker is shutting down", zap.Error(err)) } }() diff --git a/pkg/datarepair/repairer/config.go b/pkg/datarepair/repairer/config.go index fa2a076b2..eccba0dde 100644 --- a/pkg/datarepair/repairer/config.go +++ b/pkg/datarepair/repairer/config.go @@ -50,7 +50,7 @@ func (c Config) Run(ctx context.Context, server *provider.Provider) (err error) go func() { if err := service.Run(ctx); err != nil { defer cancel() - zap.L().Error("Error running repair service", zap.Error(err)) + zap.L().Debug("Repair service is shutting down", zap.Error(err)) } }() diff --git a/satellite/satellitedb/accounting.go b/satellite/satellitedb/accounting.go index 8093ee4f6..1c8a8dfe8 100644 --- a/satellite/satellitedb/accounting.go +++ b/satellite/satellitedb/accounting.go @@ -31,12 +31,7 @@ func (db *accountingDB) LastRawTime(ctx context.Context, timestampType string) ( // and updates the LastRawTime func (db *accountingDB) SaveBWRaw(ctx context.Context, latestBwa time.Time, bwTotals accounting.BWTally) (err error) { // We use the latest bandwidth agreement value of a batch of records as the start of the next batch - // This enables us to not use: - // 1) local time (which may deviate from DB time) - // 2) absolute time intervals (where in processing time could exceed the interval, causing issues) - // 3) per-node latest times (which simply would require a lot more work, albeit more precise) - // Any change in these assumptions would result in a change to this function - // in particular, we should consider finding the sum of bwagreements using SQL sum() direct against the bwa table + // todo: consider finding the sum of bwagreements using SQL sum() direct against the bwa table if len(bwTotals) == 0 { return Error.New("In SaveBWRaw with empty bwtotals") } @@ -55,9 +50,9 @@ func (db *accountingDB) SaveBWRaw(ctx context.Context, latestBwa time.Time, bwTo //create a granular record per node id for actionType, bwActionTotals := range bwTotals { for k, v := range bwActionTotals { - nID := dbx.AccountingRaw_NodeId(k) + nID := dbx.AccountingRaw_NodeId(k.Bytes()) end := dbx.AccountingRaw_IntervalEndTime(latestBwa) - total := dbx.AccountingRaw_DataTotal(v) + total := dbx.AccountingRaw_DataTotal(float64(v)) dataType := dbx.AccountingRaw_DataType(actionType) _, err = tx.Create_AccountingRaw(ctx, nID, end, total, dataType) if err != nil { @@ -72,7 +67,7 @@ func (db *accountingDB) SaveBWRaw(ctx context.Context, latestBwa time.Time, bwTo } // SaveAtRestRaw records raw tallies of at rest data to the database -func (db *accountingDB) SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]int64) error { +func (db *accountingDB) SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]float64) error { if len(nodeData) == 0 { return Error.New("In SaveAtRestRaw with empty nodeData") } @@ -88,7 +83,7 @@ func (db *accountingDB) SaveAtRestRaw(ctx context.Context, latestTally time.Time } }() for k, v := range nodeData { - nID := dbx.AccountingRaw_NodeId(k.String()) + nID := dbx.AccountingRaw_NodeId(k.Bytes()) end := dbx.AccountingRaw_IntervalEndTime(latestTally) total := dbx.AccountingRaw_DataTotal(v) dataType := dbx.AccountingRaw_DataType(accounting.AtRest) @@ -101,3 +96,82 @@ func (db *accountingDB) SaveAtRestRaw(ctx context.Context, latestTally time.Time _, err = tx.Update_AccountingTimestamps_By_Name(ctx, dbx.AccountingTimestamps_Name(accounting.LastAtRestTally), update) return Error.Wrap(err) } + +// GetRaw retrieves all raw tallies +func (db *accountingDB) GetRaw(ctx context.Context) ([]*accounting.Raw, error) { + raws, err := db.db.All_AccountingRaw(ctx) + out := make([]*accounting.Raw, len(raws)) + for i, r := range raws { + nodeID, err := storj.NodeIDFromBytes(r.NodeId) + if err != nil { + return nil, Error.Wrap(err) + } + out[i] = &accounting.Raw{ + ID: r.Id, + NodeID: nodeID, + IntervalEndTime: r.IntervalEndTime, + DataTotal: r.DataTotal, + DataType: r.DataType, + CreatedAt: r.CreatedAt, + } + } + return out, Error.Wrap(err) +} + +// GetRawSince r retrieves all raw tallies sinces +func (db *accountingDB) GetRawSince(ctx context.Context, latestRollup time.Time) ([]*accounting.Raw, error) { + raws, err := db.db.All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx, dbx.AccountingRaw_IntervalEndTime(latestRollup)) + out := make([]*accounting.Raw, len(raws)) + for i, r := range raws { + nodeID, err := storj.NodeIDFromBytes(r.NodeId) + if err != nil { + return nil, Error.Wrap(err) + } + out[i] = &accounting.Raw{ + ID: r.Id, + NodeID: nodeID, + IntervalEndTime: r.IntervalEndTime, + DataTotal: r.DataTotal, + DataType: r.DataType, + CreatedAt: r.CreatedAt, + } + } + return out, Error.Wrap(err) +} + +// SaveRollup records raw tallies of at rest data to the database +func (db *accountingDB) SaveRollup(ctx context.Context, latestRollup time.Time, stats accounting.RollupStats) error { + if len(stats) == 0 { + return Error.New("In SaveRollup with empty nodeData") + } + tx, err := db.db.Open(ctx) + if err != nil { + return Error.Wrap(err) + } + defer func() { + if err == nil { + err = tx.Commit() + } else { + err = utils.CombineErrors(err, tx.Rollback()) + } + }() + for _, arsByDate := range stats { + for _, ar := range arsByDate { + nID := dbx.AccountingRollup_NodeId(ar.NodeID.Bytes()) + start := dbx.AccountingRollup_StartTime(ar.StartTime) + put := dbx.AccountingRollup_PutTotal(ar.PutTotal) + get := dbx.AccountingRollup_GetTotal(ar.GetTotal) + audit := dbx.AccountingRollup_GetAuditTotal(ar.GetAuditTotal) + getRepair := dbx.AccountingRollup_GetRepairTotal(ar.GetRepairTotal) + putRepair := dbx.AccountingRollup_PutRepairTotal(ar.PutRepairTotal) + atRest := dbx.AccountingRollup_AtRestTotal(ar.AtRestTotal) + _, err = tx.Create_AccountingRollup(ctx, nID, start, put, get, audit, getRepair, putRepair, atRest) + if err != nil { + return Error.Wrap(err) + } + } + } + update := dbx.AccountingTimestamps_Update_Fields{Value: dbx.AccountingTimestamps_Value(latestRollup)} + _, err = tx.Update_AccountingTimestamps_By_Name(ctx, dbx.AccountingTimestamps_Name(accounting.LastRollup), update) + return Error.Wrap(err) +} diff --git a/satellite/satellitedb/dbx/satellitedb.dbx b/satellite/satellitedb/dbx/satellitedb.dbx index bd295d56b..466472e81 100644 --- a/satellite/satellitedb/dbx/satellitedb.dbx +++ b/satellite/satellitedb/dbx/satellitedb.dbx @@ -77,17 +77,18 @@ read scalar ( model accounting_rollup ( key id - field id serial64 - field node_id text - field start_time timestamp - field interval int64 - field data_type int - field created_at timestamp ( autoinsert ) - field updated_at timestamp ( autoinsert, autoupdate ) + field id serial64 + field node_id blob + field start_time timestamp + field put_total int64 + field get_total int64 + field get_audit_total int64 + field get_repair_total int64 + field put_repair_total int64 + field at_rest_total float64 ) create accounting_rollup ( ) -update accounting_rollup ( where accounting_rollup.id = ? ) delete accounting_rollup ( where accounting_rollup.id = ? ) read one ( @@ -97,23 +98,21 @@ read one ( read all ( select accounting_rollup - where accounting_rollup.node_id = ? + where accounting_rollup.start_time >= ? ) model accounting_raw ( key id field id serial64 - field node_id text + field node_id blob field interval_end_time timestamp - field data_total int64 + field data_total float64 field data_type int field created_at timestamp ( autoinsert ) - field updated_at timestamp ( autoinsert, autoupdate ) ) create accounting_raw ( ) -update accounting_raw ( where accounting_raw.id = ? ) delete accounting_raw ( where accounting_raw.id = ? ) read one ( @@ -123,7 +122,11 @@ read one ( read all ( select accounting_raw - where accounting_raw.node_id = ? +) + +read all ( + select accounting_raw + where accounting_raw.interval_end_time >= ? ) //--- statdb ---// diff --git a/satellite/satellitedb/dbx/satellitedb.dbx.go b/satellite/satellitedb/dbx/satellitedb.dbx.go index 13ad82fa2..a34d943a2 100644 --- a/satellite/satellitedb/dbx/satellitedb.dbx.go +++ b/satellite/satellitedb/dbx/satellitedb.dbx.go @@ -275,22 +275,23 @@ func newpostgres(db *DB) *postgresDB { func (obj *postgresDB) Schema() string { return `CREATE TABLE accounting_raws ( id bigserial NOT NULL, - node_id text NOT NULL, + node_id bytea NOT NULL, interval_end_time timestamp with time zone NOT NULL, - data_total bigint NOT NULL, + data_total double precision NOT NULL, data_type integer NOT NULL, created_at timestamp with time zone NOT NULL, - updated_at timestamp with time zone NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_rollups ( id bigserial NOT NULL, - node_id text NOT NULL, + node_id bytea NOT NULL, start_time timestamp with time zone NOT NULL, - interval bigint NOT NULL, - data_type integer NOT NULL, - created_at timestamp with time zone NOT NULL, - updated_at timestamp with time zone NOT NULL, + put_total bigint NOT NULL, + get_total bigint NOT NULL, + get_audit_total bigint NOT NULL, + get_repair_total bigint NOT NULL, + put_repair_total bigint NOT NULL, + at_rest_total double precision NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_timestamps ( @@ -416,22 +417,23 @@ func newsqlite3(db *DB) *sqlite3DB { func (obj *sqlite3DB) Schema() string { return `CREATE TABLE accounting_raws ( id INTEGER NOT NULL, - node_id TEXT NOT NULL, + node_id BLOB NOT NULL, interval_end_time TIMESTAMP NOT NULL, - data_total INTEGER NOT NULL, + data_total REAL NOT NULL, data_type INTEGER NOT NULL, created_at TIMESTAMP NOT NULL, - updated_at TIMESTAMP NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_rollups ( id INTEGER NOT NULL, - node_id TEXT NOT NULL, + node_id BLOB NOT NULL, start_time TIMESTAMP NOT NULL, - interval INTEGER NOT NULL, - data_type INTEGER NOT NULL, - created_at TIMESTAMP NOT NULL, - updated_at TIMESTAMP NOT NULL, + put_total INTEGER NOT NULL, + get_total INTEGER NOT NULL, + get_audit_total INTEGER NOT NULL, + get_repair_total INTEGER NOT NULL, + put_repair_total INTEGER NOT NULL, + at_rest_total REAL NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_timestamps ( @@ -556,12 +558,11 @@ nextval: type AccountingRaw struct { Id int64 - NodeId string + NodeId []byte IntervalEndTime time.Time - DataTotal int64 + DataTotal float64 DataType int CreatedAt time.Time - UpdatedAt time.Time } func (AccountingRaw) _Table() string { return "accounting_raws" } @@ -591,10 +592,10 @@ func (AccountingRaw_Id_Field) _Column() string { return "id" } type AccountingRaw_NodeId_Field struct { _set bool _null bool - _value string + _value []byte } -func AccountingRaw_NodeId(v string) AccountingRaw_NodeId_Field { +func AccountingRaw_NodeId(v []byte) AccountingRaw_NodeId_Field { return AccountingRaw_NodeId_Field{_set: true, _value: v} } @@ -629,10 +630,10 @@ func (AccountingRaw_IntervalEndTime_Field) _Column() string { return "interval_e type AccountingRaw_DataTotal_Field struct { _set bool _null bool - _value int64 + _value float64 } -func AccountingRaw_DataTotal(v int64) AccountingRaw_DataTotal_Field { +func AccountingRaw_DataTotal(v float64) AccountingRaw_DataTotal_Field { return AccountingRaw_DataTotal_Field{_set: true, _value: v} } @@ -683,33 +684,16 @@ func (f AccountingRaw_CreatedAt_Field) value() interface{} { func (AccountingRaw_CreatedAt_Field) _Column() string { return "created_at" } -type AccountingRaw_UpdatedAt_Field struct { - _set bool - _null bool - _value time.Time -} - -func AccountingRaw_UpdatedAt(v time.Time) AccountingRaw_UpdatedAt_Field { - return AccountingRaw_UpdatedAt_Field{_set: true, _value: v} -} - -func (f AccountingRaw_UpdatedAt_Field) value() interface{} { - if !f._set || f._null { - return nil - } - return f._value -} - -func (AccountingRaw_UpdatedAt_Field) _Column() string { return "updated_at" } - type AccountingRollup struct { - Id int64 - NodeId string - StartTime time.Time - Interval int64 - DataType int - CreatedAt time.Time - UpdatedAt time.Time + Id int64 + NodeId []byte + StartTime time.Time + PutTotal int64 + GetTotal int64 + GetAuditTotal int64 + GetRepairTotal int64 + PutRepairTotal int64 + AtRestTotal float64 } func (AccountingRollup) _Table() string { return "accounting_rollups" } @@ -739,10 +723,10 @@ func (AccountingRollup_Id_Field) _Column() string { return "id" } type AccountingRollup_NodeId_Field struct { _set bool _null bool - _value string + _value []byte } -func AccountingRollup_NodeId(v string) AccountingRollup_NodeId_Field { +func AccountingRollup_NodeId(v []byte) AccountingRollup_NodeId_Field { return AccountingRollup_NodeId_Field{_set: true, _value: v} } @@ -774,81 +758,119 @@ func (f AccountingRollup_StartTime_Field) value() interface{} { func (AccountingRollup_StartTime_Field) _Column() string { return "start_time" } -type AccountingRollup_Interval_Field struct { +type AccountingRollup_PutTotal_Field struct { _set bool _null bool _value int64 } -func AccountingRollup_Interval(v int64) AccountingRollup_Interval_Field { - return AccountingRollup_Interval_Field{_set: true, _value: v} +func AccountingRollup_PutTotal(v int64) AccountingRollup_PutTotal_Field { + return AccountingRollup_PutTotal_Field{_set: true, _value: v} } -func (f AccountingRollup_Interval_Field) value() interface{} { +func (f AccountingRollup_PutTotal_Field) value() interface{} { if !f._set || f._null { return nil } return f._value } -func (AccountingRollup_Interval_Field) _Column() string { return "interval" } +func (AccountingRollup_PutTotal_Field) _Column() string { return "put_total" } -type AccountingRollup_DataType_Field struct { +type AccountingRollup_GetTotal_Field struct { _set bool _null bool - _value int + _value int64 } -func AccountingRollup_DataType(v int) AccountingRollup_DataType_Field { - return AccountingRollup_DataType_Field{_set: true, _value: v} +func AccountingRollup_GetTotal(v int64) AccountingRollup_GetTotal_Field { + return AccountingRollup_GetTotal_Field{_set: true, _value: v} } -func (f AccountingRollup_DataType_Field) value() interface{} { +func (f AccountingRollup_GetTotal_Field) value() interface{} { if !f._set || f._null { return nil } return f._value } -func (AccountingRollup_DataType_Field) _Column() string { return "data_type" } +func (AccountingRollup_GetTotal_Field) _Column() string { return "get_total" } -type AccountingRollup_CreatedAt_Field struct { +type AccountingRollup_GetAuditTotal_Field struct { _set bool _null bool - _value time.Time + _value int64 } -func AccountingRollup_CreatedAt(v time.Time) AccountingRollup_CreatedAt_Field { - return AccountingRollup_CreatedAt_Field{_set: true, _value: v} +func AccountingRollup_GetAuditTotal(v int64) AccountingRollup_GetAuditTotal_Field { + return AccountingRollup_GetAuditTotal_Field{_set: true, _value: v} } -func (f AccountingRollup_CreatedAt_Field) value() interface{} { +func (f AccountingRollup_GetAuditTotal_Field) value() interface{} { if !f._set || f._null { return nil } return f._value } -func (AccountingRollup_CreatedAt_Field) _Column() string { return "created_at" } +func (AccountingRollup_GetAuditTotal_Field) _Column() string { return "get_audit_total" } -type AccountingRollup_UpdatedAt_Field struct { +type AccountingRollup_GetRepairTotal_Field struct { _set bool _null bool - _value time.Time + _value int64 } -func AccountingRollup_UpdatedAt(v time.Time) AccountingRollup_UpdatedAt_Field { - return AccountingRollup_UpdatedAt_Field{_set: true, _value: v} +func AccountingRollup_GetRepairTotal(v int64) AccountingRollup_GetRepairTotal_Field { + return AccountingRollup_GetRepairTotal_Field{_set: true, _value: v} } -func (f AccountingRollup_UpdatedAt_Field) value() interface{} { +func (f AccountingRollup_GetRepairTotal_Field) value() interface{} { if !f._set || f._null { return nil } return f._value } -func (AccountingRollup_UpdatedAt_Field) _Column() string { return "updated_at" } +func (AccountingRollup_GetRepairTotal_Field) _Column() string { return "get_repair_total" } + +type AccountingRollup_PutRepairTotal_Field struct { + _set bool + _null bool + _value int64 +} + +func AccountingRollup_PutRepairTotal(v int64) AccountingRollup_PutRepairTotal_Field { + return AccountingRollup_PutRepairTotal_Field{_set: true, _value: v} +} + +func (f AccountingRollup_PutRepairTotal_Field) value() interface{} { + if !f._set || f._null { + return nil + } + return f._value +} + +func (AccountingRollup_PutRepairTotal_Field) _Column() string { return "put_repair_total" } + +type AccountingRollup_AtRestTotal_Field struct { + _set bool + _null bool + _value float64 +} + +func AccountingRollup_AtRestTotal(v float64) AccountingRollup_AtRestTotal_Field { + return AccountingRollup_AtRestTotal_Field{_set: true, _value: v} +} + +func (f AccountingRollup_AtRestTotal_Field) value() interface{} { + if !f._set || f._null { + return nil + } + return f._value +} + +func (AccountingRollup_AtRestTotal_Field) _Column() string { return "at_rest_total" } type AccountingTimestamps struct { Name string @@ -1933,25 +1955,29 @@ func (obj *postgresImpl) Create_AccountingTimestamps(ctx context.Context, func (obj *postgresImpl) Create_AccountingRollup(ctx context.Context, accounting_rollup_node_id AccountingRollup_NodeId_Field, accounting_rollup_start_time AccountingRollup_StartTime_Field, - accounting_rollup_interval AccountingRollup_Interval_Field, - accounting_rollup_data_type AccountingRollup_DataType_Field) ( + accounting_rollup_put_total AccountingRollup_PutTotal_Field, + accounting_rollup_get_total AccountingRollup_GetTotal_Field, + accounting_rollup_get_audit_total AccountingRollup_GetAuditTotal_Field, + accounting_rollup_get_repair_total AccountingRollup_GetRepairTotal_Field, + accounting_rollup_put_repair_total AccountingRollup_PutRepairTotal_Field, + accounting_rollup_at_rest_total AccountingRollup_AtRestTotal_Field) ( accounting_rollup *AccountingRollup, err error) { - - __now := obj.db.Hooks.Now().UTC() __node_id_val := accounting_rollup_node_id.value() __start_time_val := accounting_rollup_start_time.value() - __interval_val := accounting_rollup_interval.value() - __data_type_val := accounting_rollup_data_type.value() - __created_at_val := __now - __updated_at_val := __now + __put_total_val := accounting_rollup_put_total.value() + __get_total_val := accounting_rollup_get_total.value() + __get_audit_total_val := accounting_rollup_get_audit_total.value() + __get_repair_total_val := accounting_rollup_get_repair_total.value() + __put_repair_total_val := accounting_rollup_put_repair_total.value() + __at_rest_total_val := accounting_rollup_at_rest_total.value() - var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_rollups ( node_id, start_time, interval, data_type, created_at, updated_at ) VALUES ( ?, ?, ?, ?, ?, ? ) RETURNING accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at") + var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_rollups ( node_id, start_time, put_total, get_total, get_audit_total, get_repair_total, put_repair_total, at_rest_total ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? ) RETURNING accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __node_id_val, __start_time_val, __interval_val, __data_type_val, __created_at_val, __updated_at_val) + obj.logStmt(__stmt, __node_id_val, __start_time_val, __put_total_val, __get_total_val, __get_audit_total_val, __get_repair_total_val, __put_repair_total_val, __at_rest_total_val) accounting_rollup = &AccountingRollup{} - err = obj.driver.QueryRow(__stmt, __node_id_val, __start_time_val, __interval_val, __data_type_val, __created_at_val, __updated_at_val).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __node_id_val, __start_time_val, __put_total_val, __get_total_val, __get_audit_total_val, __get_repair_total_val, __put_repair_total_val, __at_rest_total_val).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -1972,15 +1998,14 @@ func (obj *postgresImpl) Create_AccountingRaw(ctx context.Context, __data_total_val := accounting_raw_data_total.value() __data_type_val := accounting_raw_data_type.value() __created_at_val := __now - __updated_at_val := __now - var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_raws ( node_id, interval_end_time, data_total, data_type, created_at, updated_at ) VALUES ( ?, ?, ?, ?, ?, ? ) RETURNING accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at") + var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_raws ( node_id, interval_end_time, data_total, data_type, created_at ) VALUES ( ?, ?, ?, ?, ? ) RETURNING accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val, __updated_at_val) + obj.logStmt(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val) accounting_raw = &AccountingRaw{} - err = obj.driver.QueryRow(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val, __updated_at_val).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -2259,7 +2284,7 @@ func (obj *postgresImpl) Get_AccountingRollup_By_Id(ctx context.Context, accounting_rollup_id AccountingRollup_Id_Field) ( accounting_rollup *AccountingRollup, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE accounting_rollups.id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total FROM accounting_rollups WHERE accounting_rollups.id = ?") var __values []interface{} __values = append(__values, accounting_rollup_id.value()) @@ -2268,7 +2293,7 @@ func (obj *postgresImpl) Get_AccountingRollup_By_Id(ctx context.Context, obj.logStmt(__stmt, __values...) accounting_rollup = &AccountingRollup{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -2276,14 +2301,14 @@ func (obj *postgresImpl) Get_AccountingRollup_By_Id(ctx context.Context, } -func (obj *postgresImpl) All_AccountingRollup_By_NodeId(ctx context.Context, - accounting_rollup_node_id AccountingRollup_NodeId_Field) ( +func (obj *postgresImpl) All_AccountingRollup_By_StartTime_GreaterOrEqual(ctx context.Context, + accounting_rollup_start_time_greater_or_equal AccountingRollup_StartTime_Field) ( rows []*AccountingRollup, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE accounting_rollups.node_id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total FROM accounting_rollups WHERE accounting_rollups.start_time >= ?") var __values []interface{} - __values = append(__values, accounting_rollup_node_id.value()) + __values = append(__values, accounting_rollup_start_time_greater_or_equal.value()) var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, __values...) @@ -2296,7 +2321,7 @@ func (obj *postgresImpl) All_AccountingRollup_By_NodeId(ctx context.Context, for __rows.Next() { accounting_rollup := &AccountingRollup{} - err = __rows.Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = __rows.Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -2313,7 +2338,7 @@ func (obj *postgresImpl) Get_AccountingRaw_By_Id(ctx context.Context, accounting_raw_id AccountingRaw_Id_Field) ( accounting_raw *AccountingRaw, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE accounting_raws.id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws WHERE accounting_raws.id = ?") var __values []interface{} __values = append(__values, accounting_raw_id.value()) @@ -2322,7 +2347,7 @@ func (obj *postgresImpl) Get_AccountingRaw_By_Id(ctx context.Context, obj.logStmt(__stmt, __values...) accounting_raw = &AccountingRaw{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -2330,14 +2355,13 @@ func (obj *postgresImpl) Get_AccountingRaw_By_Id(ctx context.Context, } -func (obj *postgresImpl) All_AccountingRaw_By_NodeId(ctx context.Context, - accounting_raw_node_id AccountingRaw_NodeId_Field) ( +func (obj *postgresImpl) All_AccountingRaw(ctx context.Context) ( rows []*AccountingRaw, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE accounting_raws.node_id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws") var __values []interface{} - __values = append(__values, accounting_raw_node_id.value()) + __values = append(__values) var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, __values...) @@ -2350,7 +2374,40 @@ func (obj *postgresImpl) All_AccountingRaw_By_NodeId(ctx context.Context, for __rows.Next() { accounting_raw := &AccountingRaw{} - err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) + if err != nil { + return nil, obj.makeErr(err) + } + rows = append(rows, accounting_raw) + } + if err := __rows.Err(); err != nil { + return nil, obj.makeErr(err) + } + return rows, nil + +} + +func (obj *postgresImpl) All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx context.Context, + accounting_raw_interval_end_time_greater_or_equal AccountingRaw_IntervalEndTime_Field) ( + rows []*AccountingRaw, err error) { + + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws WHERE accounting_raws.interval_end_time >= ?") + + var __values []interface{} + __values = append(__values, accounting_raw_interval_end_time_greater_or_equal.value()) + + var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) + obj.logStmt(__stmt, __values...) + + __rows, err := obj.driver.Query(__stmt, __values...) + if err != nil { + return nil, obj.makeErr(err) + } + defer __rows.Close() + + for __rows.Next() { + accounting_raw := &AccountingRaw{} + err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -2605,78 +2662,6 @@ func (obj *postgresImpl) Update_AccountingTimestamps_By_Name(ctx context.Context return accounting_timestamps, nil } -func (obj *postgresImpl) Update_AccountingRollup_By_Id(ctx context.Context, - accounting_rollup_id AccountingRollup_Id_Field, - update AccountingRollup_Update_Fields) ( - accounting_rollup *AccountingRollup, err error) { - var __sets = &__sqlbundle_Hole{} - - var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE accounting_rollups SET "), __sets, __sqlbundle_Literal(" WHERE accounting_rollups.id = ? RETURNING accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at")}} - - __sets_sql := __sqlbundle_Literals{Join: ", "} - var __values []interface{} - var __args []interface{} - - __now := obj.db.Hooks.Now().UTC() - - __values = append(__values, __now) - __sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("updated_at = ?")) - - __args = append(__args, accounting_rollup_id.value()) - - __values = append(__values, __args...) - __sets.SQL = __sets_sql - - var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __values...) - - accounting_rollup = &AccountingRollup{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) - if err == sql.ErrNoRows { - return nil, nil - } - if err != nil { - return nil, obj.makeErr(err) - } - return accounting_rollup, nil -} - -func (obj *postgresImpl) Update_AccountingRaw_By_Id(ctx context.Context, - accounting_raw_id AccountingRaw_Id_Field, - update AccountingRaw_Update_Fields) ( - accounting_raw *AccountingRaw, err error) { - var __sets = &__sqlbundle_Hole{} - - var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE accounting_raws SET "), __sets, __sqlbundle_Literal(" WHERE accounting_raws.id = ? RETURNING accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at")}} - - __sets_sql := __sqlbundle_Literals{Join: ", "} - var __values []interface{} - var __args []interface{} - - __now := obj.db.Hooks.Now().UTC() - - __values = append(__values, __now) - __sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("updated_at = ?")) - - __args = append(__args, accounting_raw_id.value()) - - __values = append(__values, __args...) - __sets.SQL = __sets_sql - - var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __values...) - - accounting_raw = &AccountingRaw{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) - if err == sql.ErrNoRows { - return nil, nil - } - if err != nil { - return nil, obj.makeErr(err) - } - return accounting_raw, nil -} - func (obj *postgresImpl) Update_Node_By_Id(ctx context.Context, node_id Node_Id_Field, update Node_Update_Fields) ( @@ -3237,24 +3222,28 @@ func (obj *sqlite3Impl) Create_AccountingTimestamps(ctx context.Context, func (obj *sqlite3Impl) Create_AccountingRollup(ctx context.Context, accounting_rollup_node_id AccountingRollup_NodeId_Field, accounting_rollup_start_time AccountingRollup_StartTime_Field, - accounting_rollup_interval AccountingRollup_Interval_Field, - accounting_rollup_data_type AccountingRollup_DataType_Field) ( + accounting_rollup_put_total AccountingRollup_PutTotal_Field, + accounting_rollup_get_total AccountingRollup_GetTotal_Field, + accounting_rollup_get_audit_total AccountingRollup_GetAuditTotal_Field, + accounting_rollup_get_repair_total AccountingRollup_GetRepairTotal_Field, + accounting_rollup_put_repair_total AccountingRollup_PutRepairTotal_Field, + accounting_rollup_at_rest_total AccountingRollup_AtRestTotal_Field) ( accounting_rollup *AccountingRollup, err error) { - - __now := obj.db.Hooks.Now().UTC() __node_id_val := accounting_rollup_node_id.value() __start_time_val := accounting_rollup_start_time.value() - __interval_val := accounting_rollup_interval.value() - __data_type_val := accounting_rollup_data_type.value() - __created_at_val := __now - __updated_at_val := __now + __put_total_val := accounting_rollup_put_total.value() + __get_total_val := accounting_rollup_get_total.value() + __get_audit_total_val := accounting_rollup_get_audit_total.value() + __get_repair_total_val := accounting_rollup_get_repair_total.value() + __put_repair_total_val := accounting_rollup_put_repair_total.value() + __at_rest_total_val := accounting_rollup_at_rest_total.value() - var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_rollups ( node_id, start_time, interval, data_type, created_at, updated_at ) VALUES ( ?, ?, ?, ?, ?, ? )") + var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_rollups ( node_id, start_time, put_total, get_total, get_audit_total, get_repair_total, put_repair_total, at_rest_total ) VALUES ( ?, ?, ?, ?, ?, ?, ?, ? )") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __node_id_val, __start_time_val, __interval_val, __data_type_val, __created_at_val, __updated_at_val) + obj.logStmt(__stmt, __node_id_val, __start_time_val, __put_total_val, __get_total_val, __get_audit_total_val, __get_repair_total_val, __put_repair_total_val, __at_rest_total_val) - __res, err := obj.driver.Exec(__stmt, __node_id_val, __start_time_val, __interval_val, __data_type_val, __created_at_val, __updated_at_val) + __res, err := obj.driver.Exec(__stmt, __node_id_val, __start_time_val, __put_total_val, __get_total_val, __get_audit_total_val, __get_repair_total_val, __put_repair_total_val, __at_rest_total_val) if err != nil { return nil, obj.makeErr(err) } @@ -3279,14 +3268,13 @@ func (obj *sqlite3Impl) Create_AccountingRaw(ctx context.Context, __data_total_val := accounting_raw_data_total.value() __data_type_val := accounting_raw_data_type.value() __created_at_val := __now - __updated_at_val := __now - var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_raws ( node_id, interval_end_time, data_total, data_type, created_at, updated_at ) VALUES ( ?, ?, ?, ?, ?, ? )") + var __embed_stmt = __sqlbundle_Literal("INSERT INTO accounting_raws ( node_id, interval_end_time, data_total, data_type, created_at ) VALUES ( ?, ?, ?, ?, ? )") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val, __updated_at_val) + obj.logStmt(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val) - __res, err := obj.driver.Exec(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val, __updated_at_val) + __res, err := obj.driver.Exec(__stmt, __node_id_val, __interval_end_time_val, __data_total_val, __data_type_val, __created_at_val) if err != nil { return nil, obj.makeErr(err) } @@ -3578,7 +3566,7 @@ func (obj *sqlite3Impl) Get_AccountingRollup_By_Id(ctx context.Context, accounting_rollup_id AccountingRollup_Id_Field) ( accounting_rollup *AccountingRollup, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE accounting_rollups.id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total FROM accounting_rollups WHERE accounting_rollups.id = ?") var __values []interface{} __values = append(__values, accounting_rollup_id.value()) @@ -3587,7 +3575,7 @@ func (obj *sqlite3Impl) Get_AccountingRollup_By_Id(ctx context.Context, obj.logStmt(__stmt, __values...) accounting_rollup = &AccountingRollup{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -3595,14 +3583,14 @@ func (obj *sqlite3Impl) Get_AccountingRollup_By_Id(ctx context.Context, } -func (obj *sqlite3Impl) All_AccountingRollup_By_NodeId(ctx context.Context, - accounting_rollup_node_id AccountingRollup_NodeId_Field) ( +func (obj *sqlite3Impl) All_AccountingRollup_By_StartTime_GreaterOrEqual(ctx context.Context, + accounting_rollup_start_time_greater_or_equal AccountingRollup_StartTime_Field) ( rows []*AccountingRollup, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE accounting_rollups.node_id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total FROM accounting_rollups WHERE accounting_rollups.start_time >= ?") var __values []interface{} - __values = append(__values, accounting_rollup_node_id.value()) + __values = append(__values, accounting_rollup_start_time_greater_or_equal.value()) var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, __values...) @@ -3615,7 +3603,7 @@ func (obj *sqlite3Impl) All_AccountingRollup_By_NodeId(ctx context.Context, for __rows.Next() { accounting_rollup := &AccountingRollup{} - err = __rows.Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = __rows.Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -3632,7 +3620,7 @@ func (obj *sqlite3Impl) Get_AccountingRaw_By_Id(ctx context.Context, accounting_raw_id AccountingRaw_Id_Field) ( accounting_raw *AccountingRaw, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE accounting_raws.id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws WHERE accounting_raws.id = ?") var __values []interface{} __values = append(__values, accounting_raw_id.value()) @@ -3641,7 +3629,7 @@ func (obj *sqlite3Impl) Get_AccountingRaw_By_Id(ctx context.Context, obj.logStmt(__stmt, __values...) accounting_raw = &AccountingRaw{} - err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = obj.driver.QueryRow(__stmt, __values...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -3649,14 +3637,13 @@ func (obj *sqlite3Impl) Get_AccountingRaw_By_Id(ctx context.Context, } -func (obj *sqlite3Impl) All_AccountingRaw_By_NodeId(ctx context.Context, - accounting_raw_node_id AccountingRaw_NodeId_Field) ( +func (obj *sqlite3Impl) All_AccountingRaw(ctx context.Context) ( rows []*AccountingRaw, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE accounting_raws.node_id = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws") var __values []interface{} - __values = append(__values, accounting_raw_node_id.value()) + __values = append(__values) var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, __values...) @@ -3669,7 +3656,40 @@ func (obj *sqlite3Impl) All_AccountingRaw_By_NodeId(ctx context.Context, for __rows.Next() { accounting_raw := &AccountingRaw{} - err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) + if err != nil { + return nil, obj.makeErr(err) + } + rows = append(rows, accounting_raw) + } + if err := __rows.Err(); err != nil { + return nil, obj.makeErr(err) + } + return rows, nil + +} + +func (obj *sqlite3Impl) All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx context.Context, + accounting_raw_interval_end_time_greater_or_equal AccountingRaw_IntervalEndTime_Field) ( + rows []*AccountingRaw, err error) { + + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws WHERE accounting_raws.interval_end_time >= ?") + + var __values []interface{} + __values = append(__values, accounting_raw_interval_end_time_greater_or_equal.value()) + + var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) + obj.logStmt(__stmt, __values...) + + __rows, err := obj.driver.Query(__stmt, __values...) + if err != nil { + return nil, obj.makeErr(err) + } + defer __rows.Close() + + for __rows.Next() { + accounting_raw := &AccountingRaw{} + err = __rows.Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -3944,98 +3964,6 @@ func (obj *sqlite3Impl) Update_AccountingTimestamps_By_Name(ctx context.Context, return accounting_timestamps, nil } -func (obj *sqlite3Impl) Update_AccountingRollup_By_Id(ctx context.Context, - accounting_rollup_id AccountingRollup_Id_Field, - update AccountingRollup_Update_Fields) ( - accounting_rollup *AccountingRollup, err error) { - var __sets = &__sqlbundle_Hole{} - - var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE accounting_rollups SET "), __sets, __sqlbundle_Literal(" WHERE accounting_rollups.id = ?")}} - - __sets_sql := __sqlbundle_Literals{Join: ", "} - var __values []interface{} - var __args []interface{} - - __now := obj.db.Hooks.Now().UTC() - - __values = append(__values, __now) - __sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("updated_at = ?")) - - __args = append(__args, accounting_rollup_id.value()) - - __values = append(__values, __args...) - __sets.SQL = __sets_sql - - var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __values...) - - accounting_rollup = &AccountingRollup{} - _, err = obj.driver.Exec(__stmt, __values...) - if err != nil { - return nil, obj.makeErr(err) - } - - var __embed_stmt_get = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE accounting_rollups.id = ?") - - var __stmt_get = __sqlbundle_Render(obj.dialect, __embed_stmt_get) - obj.logStmt("(IMPLIED) "+__stmt_get, __args...) - - err = obj.driver.QueryRow(__stmt_get, __args...).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) - if err == sql.ErrNoRows { - return nil, nil - } - if err != nil { - return nil, obj.makeErr(err) - } - return accounting_rollup, nil -} - -func (obj *sqlite3Impl) Update_AccountingRaw_By_Id(ctx context.Context, - accounting_raw_id AccountingRaw_Id_Field, - update AccountingRaw_Update_Fields) ( - accounting_raw *AccountingRaw, err error) { - var __sets = &__sqlbundle_Hole{} - - var __embed_stmt = __sqlbundle_Literals{Join: "", SQLs: []__sqlbundle_SQL{__sqlbundle_Literal("UPDATE accounting_raws SET "), __sets, __sqlbundle_Literal(" WHERE accounting_raws.id = ?")}} - - __sets_sql := __sqlbundle_Literals{Join: ", "} - var __values []interface{} - var __args []interface{} - - __now := obj.db.Hooks.Now().UTC() - - __values = append(__values, __now) - __sets_sql.SQLs = append(__sets_sql.SQLs, __sqlbundle_Literal("updated_at = ?")) - - __args = append(__args, accounting_raw_id.value()) - - __values = append(__values, __args...) - __sets.SQL = __sets_sql - - var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) - obj.logStmt(__stmt, __values...) - - accounting_raw = &AccountingRaw{} - _, err = obj.driver.Exec(__stmt, __values...) - if err != nil { - return nil, obj.makeErr(err) - } - - var __embed_stmt_get = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE accounting_raws.id = ?") - - var __stmt_get = __sqlbundle_Render(obj.dialect, __embed_stmt_get) - obj.logStmt("(IMPLIED) "+__stmt_get, __args...) - - err = obj.driver.QueryRow(__stmt_get, __args...).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) - if err == sql.ErrNoRows { - return nil, nil - } - if err != nil { - return nil, obj.makeErr(err) - } - return accounting_raw, nil -} - func (obj *sqlite3Impl) Update_Node_By_Id(ctx context.Context, node_id Node_Id_Field, update Node_Update_Fields) ( @@ -4488,13 +4416,13 @@ func (obj *sqlite3Impl) getLastAccountingRollup(ctx context.Context, pk int64) ( accounting_rollup *AccountingRollup, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.interval, accounting_rollups.data_type, accounting_rollups.created_at, accounting_rollups.updated_at FROM accounting_rollups WHERE _rowid_ = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_rollups.id, accounting_rollups.node_id, accounting_rollups.start_time, accounting_rollups.put_total, accounting_rollups.get_total, accounting_rollups.get_audit_total, accounting_rollups.get_repair_total, accounting_rollups.put_repair_total, accounting_rollups.at_rest_total FROM accounting_rollups WHERE _rowid_ = ?") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, pk) accounting_rollup = &AccountingRollup{} - err = obj.driver.QueryRow(__stmt, pk).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.Interval, &accounting_rollup.DataType, &accounting_rollup.CreatedAt, &accounting_rollup.UpdatedAt) + err = obj.driver.QueryRow(__stmt, pk).Scan(&accounting_rollup.Id, &accounting_rollup.NodeId, &accounting_rollup.StartTime, &accounting_rollup.PutTotal, &accounting_rollup.GetTotal, &accounting_rollup.GetAuditTotal, &accounting_rollup.GetRepairTotal, &accounting_rollup.PutRepairTotal, &accounting_rollup.AtRestTotal) if err != nil { return nil, obj.makeErr(err) } @@ -4506,13 +4434,13 @@ func (obj *sqlite3Impl) getLastAccountingRaw(ctx context.Context, pk int64) ( accounting_raw *AccountingRaw, err error) { - var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at, accounting_raws.updated_at FROM accounting_raws WHERE _rowid_ = ?") + var __embed_stmt = __sqlbundle_Literal("SELECT accounting_raws.id, accounting_raws.node_id, accounting_raws.interval_end_time, accounting_raws.data_total, accounting_raws.data_type, accounting_raws.created_at FROM accounting_raws WHERE _rowid_ = ?") var __stmt = __sqlbundle_Render(obj.dialect, __embed_stmt) obj.logStmt(__stmt, pk) accounting_raw = &AccountingRaw{} - err = obj.driver.QueryRow(__stmt, pk).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt, &accounting_raw.UpdatedAt) + err = obj.driver.QueryRow(__stmt, pk).Scan(&accounting_raw.Id, &accounting_raw.NodeId, &accounting_raw.IntervalEndTime, &accounting_raw.DataTotal, &accounting_raw.DataType, &accounting_raw.CreatedAt) if err != nil { return nil, obj.makeErr(err) } @@ -4719,24 +4647,33 @@ func (rx *Rx) Rollback() (err error) { return err } -func (rx *Rx) All_AccountingRaw_By_NodeId(ctx context.Context, - accounting_raw_node_id AccountingRaw_NodeId_Field) ( +func (rx *Rx) All_AccountingRaw(ctx context.Context) ( rows []*AccountingRaw, err error) { var tx *Tx if tx, err = rx.getTx(ctx); err != nil { return } - return tx.All_AccountingRaw_By_NodeId(ctx, accounting_raw_node_id) + return tx.All_AccountingRaw(ctx) } -func (rx *Rx) All_AccountingRollup_By_NodeId(ctx context.Context, - accounting_rollup_node_id AccountingRollup_NodeId_Field) ( +func (rx *Rx) All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx context.Context, + accounting_raw_interval_end_time_greater_or_equal AccountingRaw_IntervalEndTime_Field) ( + rows []*AccountingRaw, err error) { + var tx *Tx + if tx, err = rx.getTx(ctx); err != nil { + return + } + return tx.All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx, accounting_raw_interval_end_time_greater_or_equal) +} + +func (rx *Rx) All_AccountingRollup_By_StartTime_GreaterOrEqual(ctx context.Context, + accounting_rollup_start_time_greater_or_equal AccountingRollup_StartTime_Field) ( rows []*AccountingRollup, err error) { var tx *Tx if tx, err = rx.getTx(ctx); err != nil { return } - return tx.All_AccountingRollup_By_NodeId(ctx, accounting_rollup_node_id) + return tx.All_AccountingRollup_By_StartTime_GreaterOrEqual(ctx, accounting_rollup_start_time_greater_or_equal) } func (rx *Rx) All_Bwagreement(ctx context.Context) ( @@ -4775,14 +4712,18 @@ func (rx *Rx) Create_AccountingRaw(ctx context.Context, func (rx *Rx) Create_AccountingRollup(ctx context.Context, accounting_rollup_node_id AccountingRollup_NodeId_Field, accounting_rollup_start_time AccountingRollup_StartTime_Field, - accounting_rollup_interval AccountingRollup_Interval_Field, - accounting_rollup_data_type AccountingRollup_DataType_Field) ( + accounting_rollup_put_total AccountingRollup_PutTotal_Field, + accounting_rollup_get_total AccountingRollup_GetTotal_Field, + accounting_rollup_get_audit_total AccountingRollup_GetAuditTotal_Field, + accounting_rollup_get_repair_total AccountingRollup_GetRepairTotal_Field, + accounting_rollup_put_repair_total AccountingRollup_PutRepairTotal_Field, + accounting_rollup_at_rest_total AccountingRollup_AtRestTotal_Field) ( accounting_rollup *AccountingRollup, err error) { var tx *Tx if tx, err = rx.getTx(ctx); err != nil { return } - return tx.Create_AccountingRollup(ctx, accounting_rollup_node_id, accounting_rollup_start_time, accounting_rollup_interval, accounting_rollup_data_type) + return tx.Create_AccountingRollup(ctx, accounting_rollup_node_id, accounting_rollup_start_time, accounting_rollup_put_total, accounting_rollup_get_total, accounting_rollup_get_audit_total, accounting_rollup_get_repair_total, accounting_rollup_put_repair_total, accounting_rollup_at_rest_total) } @@ -5071,28 +5012,6 @@ func (rx *Rx) Limited_OverlayCacheNode_By_NodeId_GreaterOrEqual(ctx context.Cont return tx.Limited_OverlayCacheNode_By_NodeId_GreaterOrEqual(ctx, overlay_cache_node_node_id_greater_or_equal, limit, offset) } -func (rx *Rx) Update_AccountingRaw_By_Id(ctx context.Context, - accounting_raw_id AccountingRaw_Id_Field, - update AccountingRaw_Update_Fields) ( - accounting_raw *AccountingRaw, err error) { - var tx *Tx - if tx, err = rx.getTx(ctx); err != nil { - return - } - return tx.Update_AccountingRaw_By_Id(ctx, accounting_raw_id, update) -} - -func (rx *Rx) Update_AccountingRollup_By_Id(ctx context.Context, - accounting_rollup_id AccountingRollup_Id_Field, - update AccountingRollup_Update_Fields) ( - accounting_rollup *AccountingRollup, err error) { - var tx *Tx - if tx, err = rx.getTx(ctx); err != nil { - return - } - return tx.Update_AccountingRollup_By_Id(ctx, accounting_rollup_id, update) -} - func (rx *Rx) Update_AccountingTimestamps_By_Name(ctx context.Context, accounting_timestamps_name AccountingTimestamps_Name_Field, update AccountingTimestamps_Update_Fields) ( @@ -5138,12 +5057,15 @@ func (rx *Rx) Update_OverlayCacheNode_By_NodeId(ctx context.Context, } type Methods interface { - All_AccountingRaw_By_NodeId(ctx context.Context, - accounting_raw_node_id AccountingRaw_NodeId_Field) ( + All_AccountingRaw(ctx context.Context) ( rows []*AccountingRaw, err error) - All_AccountingRollup_By_NodeId(ctx context.Context, - accounting_rollup_node_id AccountingRollup_NodeId_Field) ( + All_AccountingRaw_By_IntervalEndTime_GreaterOrEqual(ctx context.Context, + accounting_raw_interval_end_time_greater_or_equal AccountingRaw_IntervalEndTime_Field) ( + rows []*AccountingRaw, err error) + + All_AccountingRollup_By_StartTime_GreaterOrEqual(ctx context.Context, + accounting_rollup_start_time_greater_or_equal AccountingRollup_StartTime_Field) ( rows []*AccountingRollup, err error) All_Bwagreement(ctx context.Context) ( @@ -5163,8 +5085,12 @@ type Methods interface { Create_AccountingRollup(ctx context.Context, accounting_rollup_node_id AccountingRollup_NodeId_Field, accounting_rollup_start_time AccountingRollup_StartTime_Field, - accounting_rollup_interval AccountingRollup_Interval_Field, - accounting_rollup_data_type AccountingRollup_DataType_Field) ( + accounting_rollup_put_total AccountingRollup_PutTotal_Field, + accounting_rollup_get_total AccountingRollup_GetTotal_Field, + accounting_rollup_get_audit_total AccountingRollup_GetAuditTotal_Field, + accounting_rollup_get_repair_total AccountingRollup_GetRepairTotal_Field, + accounting_rollup_put_repair_total AccountingRollup_PutRepairTotal_Field, + accounting_rollup_at_rest_total AccountingRollup_AtRestTotal_Field) ( accounting_rollup *AccountingRollup, err error) Create_AccountingTimestamps(ctx context.Context, @@ -5295,16 +5221,6 @@ type Methods interface { limit int, offset int64) ( rows []*OverlayCacheNode, err error) - Update_AccountingRaw_By_Id(ctx context.Context, - accounting_raw_id AccountingRaw_Id_Field, - update AccountingRaw_Update_Fields) ( - accounting_raw *AccountingRaw, err error) - - Update_AccountingRollup_By_Id(ctx context.Context, - accounting_rollup_id AccountingRollup_Id_Field, - update AccountingRollup_Update_Fields) ( - accounting_rollup *AccountingRollup, err error) - Update_AccountingTimestamps_By_Name(ctx context.Context, accounting_timestamps_name AccountingTimestamps_Name_Field, update AccountingTimestamps_Update_Fields) ( diff --git a/satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql b/satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql index 32fe5fed3..d40e980e8 100644 --- a/satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql +++ b/satellite/satellitedb/dbx/satellitedb.dbx.postgres.sql @@ -2,22 +2,23 @@ -- DO NOT EDIT CREATE TABLE accounting_raws ( id bigserial NOT NULL, - node_id text NOT NULL, + node_id bytea NOT NULL, interval_end_time timestamp with time zone NOT NULL, - data_total bigint NOT NULL, + data_total double precision NOT NULL, data_type integer NOT NULL, created_at timestamp with time zone NOT NULL, - updated_at timestamp with time zone NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_rollups ( id bigserial NOT NULL, - node_id text NOT NULL, + node_id bytea NOT NULL, start_time timestamp with time zone NOT NULL, - interval bigint NOT NULL, - data_type integer NOT NULL, - created_at timestamp with time zone NOT NULL, - updated_at timestamp with time zone NOT NULL, + put_total bigint NOT NULL, + get_total bigint NOT NULL, + get_audit_total bigint NOT NULL, + get_repair_total bigint NOT NULL, + put_repair_total bigint NOT NULL, + at_rest_total double precision NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_timestamps ( diff --git a/satellite/satellitedb/dbx/satellitedb.dbx.sqlite3.sql b/satellite/satellitedb/dbx/satellitedb.dbx.sqlite3.sql index 08aa02d49..9d7257cef 100644 --- a/satellite/satellitedb/dbx/satellitedb.dbx.sqlite3.sql +++ b/satellite/satellitedb/dbx/satellitedb.dbx.sqlite3.sql @@ -2,22 +2,23 @@ -- DO NOT EDIT CREATE TABLE accounting_raws ( id INTEGER NOT NULL, - node_id TEXT NOT NULL, + node_id BLOB NOT NULL, interval_end_time TIMESTAMP NOT NULL, - data_total INTEGER NOT NULL, + data_total REAL NOT NULL, data_type INTEGER NOT NULL, created_at TIMESTAMP NOT NULL, - updated_at TIMESTAMP NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_rollups ( id INTEGER NOT NULL, - node_id TEXT NOT NULL, + node_id BLOB NOT NULL, start_time TIMESTAMP NOT NULL, - interval INTEGER NOT NULL, - data_type INTEGER NOT NULL, - created_at TIMESTAMP NOT NULL, - updated_at TIMESTAMP NOT NULL, + put_total INTEGER NOT NULL, + get_total INTEGER NOT NULL, + get_audit_total INTEGER NOT NULL, + get_repair_total INTEGER NOT NULL, + put_repair_total INTEGER NOT NULL, + at_rest_total REAL NOT NULL, PRIMARY KEY ( id ) ); CREATE TABLE accounting_timestamps ( diff --git a/satellite/satellitedb/locked.go b/satellite/satellitedb/locked.go index 33701ca66..8e2be09c6 100644 --- a/satellite/satellitedb/locked.go +++ b/satellite/satellitedb/locked.go @@ -94,6 +94,27 @@ type lockedAccounting struct { db accounting.DB } +// GetRaw retrieves all raw tallies +func (m *lockedAccounting) GetRaw(ctx context.Context) ([]*accounting.Raw, error) { + m.Lock() + defer m.Unlock() + return m.db.GetRaw(ctx) +} + +// GetRawSince r retrieves all raw tallies sinces +func (m *lockedAccounting) GetRawSince(ctx context.Context, latestRollup time.Time) ([]*accounting.Raw, error) { + m.Lock() + defer m.Unlock() + return m.db.GetRawSince(ctx, latestRollup) +} + +// SaveRollup records raw tallies of at rest data to the database +func (m *lockedAccounting) SaveRollup(ctx context.Context, latestTally time.Time, stats accounting.RollupStats) error { + m.Lock() + defer m.Unlock() + return m.db.SaveRollup(ctx, latestTally, stats) +} + // LastRawTime records the latest last tallied time. func (m *lockedAccounting) LastRawTime(ctx context.Context, timestampType string) (time.Time, bool, error) { m.Lock() @@ -102,7 +123,7 @@ func (m *lockedAccounting) LastRawTime(ctx context.Context, timestampType string } // SaveAtRestRaw records raw tallies of at-rest-data. -func (m *lockedAccounting) SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]int64) error { +func (m *lockedAccounting) SaveAtRestRaw(ctx context.Context, latestTally time.Time, nodeData map[storj.NodeID]float64) error { m.Lock() defer m.Unlock() return m.db.SaveAtRestRaw(ctx, latestTally, nodeData)