408 lines
9.9 KiB
Go
408 lines
9.9 KiB
Go
package database
|
||
|
||
import (
|
||
"io"
|
||
|
||
bin "gordenko.dev/dima/bin/little"
|
||
"gordenko.dev/dima/qb"
|
||
"gordenko.dev/dima/qb/atree"
|
||
"gordenko.dev/dima/qb/txlog"
|
||
)
|
||
|
||
// METRIC
|
||
|
||
const minBufferSize = 1024
|
||
|
||
var (
|
||
indexRecordSize = 8
|
||
)
|
||
|
||
type _metric struct {
|
||
metricType qb.MetricType
|
||
fracDigits byte
|
||
lastPageNo uint32
|
||
//SinceValue float64
|
||
//Since uint32
|
||
lastValue float64
|
||
//Until uint32
|
||
buffer []byte
|
||
timestamps qb.TimestampCompressor
|
||
values qb.ValueCompressor
|
||
XLock bool
|
||
RLocks int
|
||
WaitQueue []any
|
||
indexLevelTails []txlog.IndexLevelTail // root - last element
|
||
}
|
||
|
||
//IndexLevels [][]IndexRec // root - last element
|
||
|
||
// func (s *_metric) ReinitBy(timestamp uint32, value float64) {
|
||
// s.Timestamps.Renew()
|
||
// s.Values.Renew()
|
||
|
||
// s.Timestamps.Append(timestamp)
|
||
// s.Values.Append(value)
|
||
|
||
// s.Since = timestamp
|
||
// s.SinceValue = value
|
||
// s.Until = timestamp
|
||
// s.UntilValue = value
|
||
// }
|
||
|
||
func (s *_metric) DeleteMeasures() {
|
||
// s.Timestamps.Renew()
|
||
// s.Values.Renew()
|
||
|
||
// s.LastPageNo = 0
|
||
// s.Since = 0
|
||
// s.SinceValue = 0
|
||
// s.Until = 0
|
||
// s.UntilValue = 0
|
||
}
|
||
|
||
// func (s *_metric) startAppendMeasures(req tryAppendMeasuresReq, sendToStorage func(txlog.AppendedMeasures)) {
|
||
func (s *_metric) StartAppendMeasures(req tryAppendMeasuresReq, sendToStorage func(any)) {
|
||
var (
|
||
// AppendedMeasures struct {
|
||
// MetricID uint32
|
||
// TimestampsOffset int // (заповнені одразу)
|
||
// ValuesOffset int // (заповнені одразу)
|
||
// Timestamps [][]byte
|
||
// TimestampsSize int
|
||
// Values [][]byte
|
||
// ValuesSize int
|
||
// IndexLevels []*atree.IndexLevel
|
||
// DataPages []*atree.DataPage // fix - prevPageNo for the 1st data page
|
||
// }
|
||
|
||
timestamps = s.timestamps
|
||
values = s.values
|
||
|
||
dataPages []txlog.DataPayload
|
||
|
||
//written int
|
||
//resultCode byte
|
||
)
|
||
|
||
s.values.CaptureState()
|
||
s.timestamps.CaptureState()
|
||
|
||
for idx, measure := range req.Measures {
|
||
// if s.Since == 0 {
|
||
// s.Since = measure.Timestamp
|
||
// } else {
|
||
// FIX - у випадку помилки треба в транзакції зберегти що помилка, але також зафіксувати скільки елементів збережено.
|
||
// якщо idx == 0 - одразу знімаю блокування і нічого не відправляю в txlog
|
||
if measure.Timestamp <= s.timestamps.LastTimestamp() {
|
||
if idx == 0 {
|
||
s.values.ForgetCapturedState()
|
||
s.timestamps.ForgetCapturedState()
|
||
|
||
req.ResultCh <- tryAppendMeasuresResult{
|
||
ResultCode: ExpiredMeasure,
|
||
}
|
||
return
|
||
}
|
||
|
||
//resultCode = ExpiredMeasure
|
||
//written = idx
|
||
break
|
||
}
|
||
|
||
if s.metricType == qb.Cumulative && measure.Value < s.lastValue {
|
||
if idx == 0 {
|
||
s.values.ForgetCapturedState()
|
||
s.timestamps.ForgetCapturedState()
|
||
|
||
req.ResultCh <- tryAppendMeasuresResult{
|
||
ResultCode: NonMonotonicValue,
|
||
}
|
||
return
|
||
}
|
||
//resultCode = NonMonotonicValue
|
||
//written = idx
|
||
break
|
||
}
|
||
//}
|
||
|
||
// fix - 1 + 8 bytes
|
||
|
||
timestampCompressionWay, timestampRequiredSpace := timestamps.Evaluate(measure.Timestamp)
|
||
valueCompressionWay, valueRequiredSpace := values.Evaluate(measure.Value)
|
||
|
||
totalRequiredSpace := timestampRequiredSpace + valueRequiredSpace
|
||
|
||
if totalRequiredSpace <= len(s.buffer) {
|
||
// накопичую
|
||
timestamps.Compress(timestampCompressionWay, measure.Timestamp)
|
||
values.Compress(valueCompressionWay, measure.Value)
|
||
} else if len(s.buffer) < atree.DataPagePayloadSize {
|
||
// allocate bigger buffer
|
||
buffer := make([]byte, len(s.buffer)*2)
|
||
// copy timestamps
|
||
// copy values
|
||
// replace buffer in timestamps and values
|
||
|
||
s.buffer = buffer
|
||
|
||
timestamps.Compress(timestampCompressionWay, measure.Timestamp)
|
||
values.Compress(valueCompressionWay, measure.Value)
|
||
} else {
|
||
// сторінка заповнена
|
||
since := s.timestamps.ReplaceSinceWithUntil()
|
||
|
||
dataPages = append(dataPages, txlog.DataPayload{
|
||
Since: since,
|
||
Content: s.buffer,
|
||
TimestampsSize: timestamps.Size(),
|
||
ValuesSize: values.Size(),
|
||
})
|
||
|
||
buffer := make([]byte, minBufferSize)
|
||
|
||
timestamps.Rotate(buffer)
|
||
values.Rotate(buffer)
|
||
|
||
// renew
|
||
s.buffer = buffer
|
||
|
||
timestampCompressionWay, _ = timestamps.Evaluate(measure.Timestamp)
|
||
valueCompressionWay, _ = values.Evaluate(measure.Value)
|
||
|
||
timestamps.Compress(timestampCompressionWay, measure.Timestamp)
|
||
values.Compress(valueCompressionWay, measure.Value)
|
||
}
|
||
//
|
||
s.lastValue = measure.Value
|
||
}
|
||
|
||
// виділити змінені байти.
|
||
// скопіювати. Причому можна скопіювати зрізи chunks
|
||
|
||
if len(dataPages) > 0 {
|
||
// пишу в txlog довгим шляхом через redo файл і запис в data файл
|
||
sendToStorage(txlog.AppendedMeasures{
|
||
MetricID: req.MetricID,
|
||
LastPageNo: s.lastPageNo,
|
||
TimestampsOffset: timestamps.Offset(), // state.Pos() з якої позиції дописувати дані на сторінку 0 (при відновленні)
|
||
ValuesOffset: values.Offset(), // state.Pos()
|
||
//Payload: s.payload, // fix - timestamps + values ? or timestamps and values (for WAL)
|
||
IndexLevelTails: s.indexLevelTails,
|
||
DataPages: dataPages,
|
||
Timestamps: nil,
|
||
Values: nil,
|
||
//ResultCode: resultCode,
|
||
//WrittenCount: wri,
|
||
ResultCh: nil,
|
||
})
|
||
} else {
|
||
// короткий шлях - запис лише в txlog
|
||
}
|
||
|
||
}
|
||
|
||
func (s *_metric) FinAppendMeasures(rec txlog.AppendMeasuresSummary) {
|
||
// Видаляю state. Оригінальні Timestamps і Values вже мають останню версію
|
||
s.values.ForgetCapturedState()
|
||
s.timestamps.ForgetCapturedState()
|
||
|
||
if rec.LastPageNo > 0 {
|
||
s.lastPageNo = rec.LastPageNo
|
||
}
|
||
// В txlog я передав повний індекс. У нього додали елементи (можливо нові рівні).
|
||
// Тому проста заміна
|
||
s.indexLevelTails = rec.Index
|
||
}
|
||
|
||
// READ
|
||
|
||
func (s *_metric) StartRangeScan(req tryRangeScanReq) {
|
||
// if s.Since == 0 {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// return
|
||
// }
|
||
|
||
// if req.Since > s.Until {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// return
|
||
// }
|
||
|
||
// if req.Until < s.Since {
|
||
// if s.RootPageNo > 0 {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: UntilNotFound,
|
||
// RootPageNo: s.RootPageNo,
|
||
// FracDigits: s.FracDigits,
|
||
// }
|
||
// s.RLocks++
|
||
// return
|
||
// } else {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// return
|
||
// }
|
||
// }
|
||
|
||
// timestampDecompressor := s.Timestamps.CreateDecompressor()
|
||
// valueDecompressor := s.Values.CreateDecompressor(s.FracDigits)
|
||
|
||
// for {
|
||
// timestamp, done := timestampDecompressor.NextValue()
|
||
// if done {
|
||
// break
|
||
// }
|
||
|
||
// value, done := valueDecompressor.NextValue()
|
||
// if done {
|
||
// qb.Abort(qb.HasTimestampNoValueBug, ErrNoValueBug)
|
||
// }
|
||
|
||
// if timestamp <= req.Until {
|
||
// req.ResponseWriter.FeedNoSend(timestamp, value)
|
||
// if timestamp < req.Since {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// return
|
||
// }
|
||
// }
|
||
// }
|
||
|
||
// if s.LastPageNo > 0 {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: UntilFound,
|
||
// LastPageNo: s.LastPageNo,
|
||
// FracDigits: s.FracDigits,
|
||
// }
|
||
// s.RLocks++
|
||
// } else {
|
||
// req.ResultCh <- rangeScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// }
|
||
}
|
||
|
||
func (s *_metric) StartFullScan(req tryFullScanReq) {
|
||
// if s.Since == 0 {
|
||
// req.ResultCh <- fullScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// return
|
||
// }
|
||
|
||
// timestampDecompressor := s.Timestamps.CreateDecompressor()
|
||
// valueDecompressor := s.Values.CreateDecompressor()
|
||
|
||
// for {
|
||
// timestamp, done := timestampDecompressor.NextValue()
|
||
// if done {
|
||
// break
|
||
// }
|
||
// value, done := valueDecompressor.NextValue()
|
||
// if done {
|
||
// qb.Abort(qb.HasTimestampNoValueBug, ErrNoValueBug)
|
||
// }
|
||
// req.ResponseWriter.FeedNoSend(timestamp, value)
|
||
// }
|
||
|
||
// if s.LastPageNo > 0 {
|
||
// req.ResultCh <- fullScanResult{
|
||
// ResultCode: UntilFound,
|
||
// LastPageNo: s.LastPageNo,
|
||
// FracDigits: s.FracDigits,
|
||
// }
|
||
// s.RLocks++
|
||
// } else {
|
||
// req.ResultCh <- fullScanResult{
|
||
// ResultCode: QueryDone,
|
||
// }
|
||
// }
|
||
}
|
||
|
||
// індекси
|
||
// Metric encode format:
|
||
// metricID - 4b
|
||
// metricType - 1b
|
||
// fracDigits - 1b
|
||
// lastPageNo - 4b
|
||
// timestamps size - 2b
|
||
// values size - 2b
|
||
// timestams payload - Nb
|
||
// values payload - Nb
|
||
// index levels count - varsize
|
||
// [
|
||
// records qty - varsize
|
||
// records - Nb
|
||
// ]
|
||
|
||
func (s *_metric) WriteTo(w io.Writer) (err error) {
|
||
_, err = w.Write([]byte{
|
||
byte(s.metricType),
|
||
s.fracDigits,
|
||
})
|
||
if err != nil {
|
||
return
|
||
}
|
||
err = bin.WriteUint32(w, s.lastPageNo)
|
||
if err != nil {
|
||
return
|
||
}
|
||
err = bin.WriteUint16(w, uint16(s.timestamps.Size()))
|
||
if err != nil {
|
||
return
|
||
}
|
||
err = bin.WriteUint16(w, uint16(s.values.Size()))
|
||
if err != nil {
|
||
return
|
||
}
|
||
// timestamps payload
|
||
err = s.timestamps.WritePayloadTo(w)
|
||
if err != nil {
|
||
return
|
||
}
|
||
// values payload
|
||
err = s.values.WritePayloadTo(w)
|
||
if err != nil {
|
||
return
|
||
}
|
||
// indexes
|
||
_, err = bin.WriteVarSize(w, len(s.indexLevelTails))
|
||
if err != nil {
|
||
return
|
||
}
|
||
for _, level := range s.indexLevelTails {
|
||
_, err = bin.WriteVarSize(w, level.RecordsCount)
|
||
if err != nil {
|
||
return
|
||
}
|
||
_, err = w.Write(level.Buffer)
|
||
if err != nil {
|
||
return
|
||
}
|
||
}
|
||
return
|
||
}
|
||
|
||
// var (
|
||
// values qb.ValueCompressor
|
||
// )
|
||
// if s.metricType == qb.Cumulative {
|
||
// values = enc.NewCumulativeDeltaCompressor(s.buffer, s.fracDigits)
|
||
// } else {
|
||
// values = enc.NewInstantDeltaCompressor(s.buffer, s.fracDigits)
|
||
// }
|
||
// values.RestoreState(valuesSize)
|
||
// s.timestamps = enc.NewTimeDeltaCompressor(s.buffer)
|
||
// s.timestamps.RestoreState(timestampsSize, until)
|
||
// s.values = values
|
||
// s.lastValue = s.values.LastValue()
|
||
|
||
// since - 4b
|
||
// sinceValue - 8b -
|
||
// untilValue - 8b
|