1st

database/api.go

@@ -0,0 +1,891 @@
+package database
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"net"
+
+	diploma "gordenko.dev/dima/qb"
+	"gordenko.dev/dima/qb/atree"
+	"gordenko.dev/dima/qb/bin"
+	"gordenko.dev/dima/qb/bufreader"
+	"gordenko.dev/dima/qb/chunkenc"
+	"gordenko.dev/dima/qb/conbuf"
+	"gordenko.dev/dima/qb/proto"
+	"gordenko.dev/dima/qb/transform"
+	"gordenko.dev/dima/qb/txlog"
+)
+
+var (
+	ErrNoValueBug         = errors.New("has timestamp but no value")
+	ErrWrongResultCodeBug = errors.New("bug: wrong result code")
+
+	successMsg = []byte{
+		proto.RespSuccess,
+	}
+)
+
+func reply(conn io.Writer, errcode uint16) {
+	var answer []byte
+	if errcode == 0 {
+		answer = successMsg
+	} else {
+		answer = []byte{
+			proto.RespError,
+			0, 0,
+		}
+		bin.PutUint16(answer[1:], errcode)
+	}
+
+	_, err := conn.Write(answer)
+	if err != nil {
+		return
+	}
+}
+
+func (s *Database) handleTCPConn(conn net.Conn) {
+	defer conn.Close()
+
+	r := bufreader.New(conn, 128)
+
+	for {
+		err := s.processRequest(conn, r)
+		if err != nil {
+			if err != io.EOF {
+				s.logger.Println(err)
+			}
+			return
+		}
+	}
+}
+
+func (s *Database) processRequest(conn net.Conn, r *bufreader.BufferedReader) (err error) {
+	messageType, err := r.ReadByte()
+	if err != nil {
+		if err != io.EOF {
+			return fmt.Errorf("read messageType: %s", err)
+		} else {
+			return err
+		}
+	}
+
+	switch messageType {
+	case proto.TypeGetMetric:
+		req, err := proto.ReadGetMetricReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadGetMetricReq: %s", err)
+		}
+		if err = s.GetMetric(conn, req); err != nil {
+			return fmt.Errorf("GetMetric: %s", err)
+		}
+
+	case proto.TypeAddMetric:
+		req, err := proto.ReadAddMetricReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadAddMetricReq: %s", err)
+		}
+		reply(conn, s.AddMetric(req))
+
+	case proto.TypeDeleteMetric:
+		req, err := proto.ReadDeleteMetricReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadDeleteMetricReq: %s", err)
+		}
+		reply(conn, s.DeleteMetric(req))
+
+	case proto.TypeAppendMeasure:
+		req, err := proto.ReadAppendMeasureReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadAppendMeasureReq: %s", err)
+		}
+		//fmt.Println("append measure", req.MetricID, conn.RemoteAddr().String())
+		reply(conn, s.AppendMeasure(req))
+
+	case proto.TypeAppendMeasures:
+		req, err := proto.ReadAppendMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadAppendMeasuresReq: %s", err)
+		}
+		//fmt.Println("append measure", req.MetricID, conn.RemoteAddr().String())
+		reply(conn, s.AppendMeasures(req))
+
+	case proto.TypeListInstantMeasures:
+		req, err := proto.ReadListInstantMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListInstantMeasuresReq: %s", err)
+		}
+		if err = s.ListInstantMeasures(conn, req); err != nil {
+			return fmt.Errorf("ListInstantMeasures: %s", err)
+		}
+
+	case proto.TypeListCumulativeMeasures:
+		req, err := proto.ReadListCumulativeMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListCumulativeMeasuresReq: %s", err)
+		}
+		if err = s.ListCumulativeMeasures(conn, req); err != nil {
+			return fmt.Errorf("ListCumulativeMeasures: %s", err)
+		}
+
+	case proto.TypeListInstantPeriods:
+		req, err := proto.ReadListInstantPeriodsReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListInstantPeriodsReq: %s", err)
+		}
+		if err = s.ListInstantPeriods(conn, req); err != nil {
+			return fmt.Errorf("ListInstantPeriods: %s", err)
+		}
+
+	case proto.TypeListCumulativePeriods:
+		req, err := proto.ReadListCumulativePeriodsReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListCumulativePeriodsReq: %s", err)
+		}
+		if err = s.ListCumulativePeriods(conn, req); err != nil {
+			return fmt.Errorf("ListCumulativePeriods: %s", err)
+		}
+
+	case proto.TypeListCurrentValues:
+		req, err := proto.ReadListCurrentValuesReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ListCurrentValuesReq: %s", err)
+		}
+		if err = s.ListCurrentValues(conn, req); err != nil {
+			return fmt.Errorf("ListCurrentValues: %s", err)
+		}
+
+	case proto.TypeDeleteMeasures:
+		req, err := proto.ReadDeleteMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadDeleteMeasuresReq: %s", err)
+		}
+		reply(conn, s.DeleteMeasures(req))
+
+	case proto.TypeListAllInstantMeasures:
+		req, err := proto.ReadListAllInstantMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListAllInstantMeasuresReq: %s", err)
+		}
+		if err = s.ListAllInstantMeasures(conn, req); err != nil {
+			return fmt.Errorf("ListAllInstantMeasures: %s", err)
+		}
+
+	case proto.TypeListAllCumulativeMeasures:
+		req, err := proto.ReadListAllCumulativeMeasuresReq(r)
+		if err != nil {
+			return fmt.Errorf("proto.ReadListAllCumulativeMeasuresReq: %s", err)
+		}
+
+		if err = s.ListAllCumulativeMeasures(conn, req); err != nil {
+			return fmt.Errorf("ListAllCumulativeMeasures: %s", err)
+		}
+
+	default:
+		return fmt.Errorf("unknown messageType: %d", messageType)
+	}
+	return
+}
+
+// API
+
+func (s *Database) AddMetric(req proto.AddMetricReq) uint16 {
+	// Валидация
+	if req.MetricID == 0 {
+		return proto.ErrEmptyMetricID
+	}
+	if byte(req.FracDigits) > diploma.MaxFracDigits {
+		return proto.ErrWrongFracDigits
+	}
+	switch req.MetricType {
+	case diploma.Cumulative, diploma.Instant:
+		// ok
+	default:
+		return proto.ErrWrongMetricType
+	}
+
+	resultCh := make(chan byte, 1)
+
+	s.appendJobToWorkerQueue(tryAddMetricReq{
+		MetricID: req.MetricID,
+		ResultCh: resultCh,
+	})
+
+	resultCode := <-resultCh
+
+	switch resultCode {
+	case Succeed:
+		waitCh := s.txlog.WriteAddedMetric(txlog.AddedMetric{
+			MetricID:   req.MetricID,
+			MetricType: req.MetricType,
+			FracDigits: req.FracDigits,
+		})
+		<-waitCh
+
+	case MetricDuplicate:
+		return proto.ErrDuplicate
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return 0
+}
+
+type Metric struct {
+	MetricType diploma.MetricType
+	FracDigits byte
+	ResultCode byte
+}
+
+func (s *Database) GetMetric(conn io.Writer, req proto.GetMetricReq) error {
+	resultCh := make(chan Metric, 1)
+
+	s.appendJobToWorkerQueue(tryGetMetricReq{
+		MetricID: req.MetricID,
+		ResultCh: resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case Succeed:
+		answer := []byte{
+			proto.RespValue,
+			0, 0, 0, 0, // metricID
+			byte(result.MetricType),
+			result.FracDigits,
+		}
+		bin.PutUint32(answer[1:], req.MetricID)
+
+		_, err := conn.Write(answer)
+		if err != nil {
+			return err
+		}
+
+	case NoMetric:
+		reply(conn, proto.ErrNoMetric)
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return nil
+}
+
+type tryDeleteMetricResult struct {
+	ResultCode byte
+	RootPageNo uint32
+}
+
+func (s *Database) DeleteMetric(req proto.DeleteMetricReq) uint16 {
+	resultCh := make(chan tryDeleteMetricResult, 1)
+
+	s.appendJobToWorkerQueue(tryDeleteMetricReq{
+		MetricID: req.MetricID,
+		ResultCh: resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case Succeed:
+		var (
+			freeDataPages  []uint32
+			freeIndexPages []uint32
+		)
+		if result.RootPageNo > 0 {
+			pageLists, err := s.atree.GetAllPages(result.RootPageNo)
+			if err != nil {
+				diploma.Abort(diploma.FailedAtreeRequest, err)
+			}
+			freeDataPages = pageLists.DataPages
+			freeIndexPages = pageLists.IndexPages
+		}
+		waitCh := s.txlog.WriteDeletedMetric(txlog.DeletedMetric{
+			MetricID:       req.MetricID,
+			FreeDataPages:  freeDataPages,
+			FreeIndexPages: freeIndexPages,
+		})
+		<-waitCh
+
+	case NoMetric:
+		return proto.ErrNoMetric
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return 0
+}
+
+type FilledPage struct {
+	Since            uint32
+	RootPageNo       uint32
+	PrevPageNo       uint32
+	TimestampsChunks [][]byte
+	TimestampsSize   uint16
+	ValuesChunks     [][]byte
+	ValuesSize       uint16
+}
+
+type tryAppendMeasureResult struct {
+	MetricID   uint32
+	Timestamp  uint32
+	Value      float64
+	FilledPage *FilledPage
+	ResultCode byte
+}
+
+func (s *Database) AppendMeasure(req proto.AppendMeasureReq) uint16 {
+	resultCh := make(chan tryAppendMeasureResult, 1)
+
+	s.appendJobToWorkerQueue(tryAppendMeasureReq{
+		MetricID:  req.MetricID,
+		Timestamp: req.Timestamp,
+		Value:     req.Value,
+		ResultCh:  resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case CanAppend:
+		waitCh := s.txlog.WriteAppendMeasure(txlog.AppendedMeasure{
+			MetricID:  req.MetricID,
+			Timestamp: req.Timestamp,
+			Value:     req.Value,
+		})
+		<-waitCh
+
+	case NewPage:
+		filled := result.FilledPage
+		report, err := s.atree.AppendDataPage(atree.AppendDataPageReq{
+			MetricID:         req.MetricID,
+			Timestamp:        req.Timestamp,
+			Value:            req.Value,
+			Since:            filled.Since,
+			RootPageNo:       filled.RootPageNo,
+			PrevPageNo:       filled.PrevPageNo,
+			TimestampsChunks: filled.TimestampsChunks,
+			TimestampsSize:   filled.TimestampsSize,
+			ValuesChunks:     filled.ValuesChunks,
+			ValuesSize:       filled.ValuesSize,
+		})
+		if err != nil {
+			diploma.Abort(diploma.WriteToAtreeFailed, err)
+		}
+		waitCh := s.txlog.WriteAppendedMeasureWithOverflow(
+			txlog.AppendedMeasureWithOverflow{
+				MetricID:         req.MetricID,
+				Timestamp:        req.Timestamp,
+				Value:            req.Value,
+				IsDataPageReused: report.IsDataPageReused,
+				DataPageNo:       report.DataPageNo,
+				IsRootChanged:    report.IsRootChanged,
+				RootPageNo:       report.NewRootPageNo,
+				ReusedIndexPages: report.ReusedIndexPages,
+			},
+			report.FileName,
+			false,
+		)
+		<-waitCh
+
+	case NoMetric:
+		return proto.ErrNoMetric
+
+	case ExpiredMeasure:
+		return proto.ErrExpiredMeasure
+
+	case NonMonotonicValue:
+		return proto.ErrNonMonotonicValue
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return 0
+}
+
+type tryAppendMeasuresResult struct {
+	ResultCode    byte
+	MetricType    diploma.MetricType
+	FracDigits    byte
+	Since         uint32
+	Until         uint32
+	UntilValue    float64
+	RootPageNo    uint32
+	PrevPageNo    uint32
+	TimestampsBuf *conbuf.ContinuousBuffer
+	ValuesBuf     *conbuf.ContinuousBuffer
+	Timestamps    diploma.TimestampCompressor
+	Values        diploma.ValueCompressor
+}
+
+func (s *Database) AppendMeasures(req proto.AppendMeasuresReq) uint16 {
+	resultCh := make(chan tryAppendMeasuresResult, 1)
+
+	s.appendJobToWorkerQueue(tryAppendMeasuresReq{
+		MetricID: req.MetricID,
+		ResultCh: resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case CanAppend:
+		var (
+			rootPageNo    = result.RootPageNo
+			prevPageNo    = result.PrevPageNo
+			timestampsBuf = result.TimestampsBuf
+			valuesBuf     = result.ValuesBuf
+			timestamps    = result.Timestamps
+			values        = result.Values
+			since         = result.Since
+			until         = result.Until
+			untilValue    = result.UntilValue
+			//
+			toAppendMeasures []proto.Measure
+		)
+
+		for idx, measure := range req.Measures {
+			if since == 0 {
+				since = measure.Timestamp
+			} else {
+				if measure.Timestamp <= until {
+					if len(toAppendMeasures) > 0 {
+						waitCh := s.txlog.WriteAppendMeasures(
+							txlog.AppendedMeasures{
+								MetricID: req.MetricID,
+								Measures: toAppendMeasures,
+							},
+							false,
+						)
+						<-waitCh
+					}
+					return proto.ErrExpiredMeasure
+				}
+
+				if result.MetricType == diploma.Cumulative && measure.Value < untilValue {
+					if len(toAppendMeasures) > 0 {
+						waitCh := s.txlog.WriteAppendMeasures(
+							txlog.AppendedMeasures{
+								MetricID: req.MetricID,
+								Measures: toAppendMeasures,
+							},
+							false,
+						)
+						<-waitCh
+					}
+					return proto.ErrNonMonotonicValue
+				}
+			}
+
+			extraSpace := timestamps.CalcRequiredSpace(measure.Timestamp) +
+				values.CalcRequiredSpace(measure.Value)
+
+			totalSpace := timestamps.Size() + values.Size() + extraSpace
+
+			if totalSpace <= atree.DataPagePayloadSize {
+				timestamps.Append(measure.Timestamp)
+				values.Append(measure.Value)
+				toAppendMeasures = append(toAppendMeasures, measure)
+			} else {
+				if len(toAppendMeasures) > 0 {
+					waitCh := s.txlog.WriteAppendMeasures(
+						txlog.AppendedMeasures{
+							MetricID: req.MetricID,
+							Measures: toAppendMeasures,
+						},
+						true,
+					)
+					<-waitCh
+
+					toAppendMeasures = nil
+				}
+				report, err := s.atree.AppendDataPage(atree.AppendDataPageReq{
+					MetricID:         req.MetricID,
+					Timestamp:        until,
+					Value:            untilValue,
+					Since:            since,
+					RootPageNo:       rootPageNo,
+					PrevPageNo:       prevPageNo,
+					TimestampsChunks: timestampsBuf.Chunks(),
+					TimestampsSize:   uint16(timestamps.Size()),
+					ValuesChunks:     valuesBuf.Chunks(),
+					ValuesSize:       uint16(values.Size()),
+				})
+				if err != nil {
+					diploma.Abort(diploma.WriteToAtreeFailed, err)
+				}
+
+				prevPageNo = report.DataPageNo
+				if report.IsRootChanged {
+					rootPageNo = report.NewRootPageNo
+				}
+				waitCh := s.txlog.WriteAppendedMeasureWithOverflow(
+					txlog.AppendedMeasureWithOverflow{
+						MetricID:         req.MetricID,
+						Timestamp:        measure.Timestamp,
+						Value:            measure.Value,
+						IsDataPageReused: report.IsDataPageReused,
+						DataPageNo:       report.DataPageNo,
+						IsRootChanged:    report.IsRootChanged,
+						RootPageNo:       report.NewRootPageNo,
+						ReusedIndexPages: report.ReusedIndexPages,
+					},
+					report.FileName,
+					(idx+1) < len(req.Measures),
+				)
+				<-waitCh
+
+				timestampsBuf = conbuf.New(nil)
+				valuesBuf = conbuf.New(nil)
+
+				timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor(
+					timestampsBuf, 0)
+				if result.MetricType == diploma.Cumulative {
+					values = chunkenc.NewReverseCumulativeDeltaCompressor(
+						valuesBuf, 0, result.FracDigits)
+				} else {
+					values = chunkenc.NewReverseInstantDeltaCompressor(
+						valuesBuf, 0, result.FracDigits)
+				}
+
+				timestamps.Append(measure.Timestamp)
+				values.Append(measure.Value)
+
+				since = measure.Timestamp
+			}
+
+			until = measure.Timestamp
+			untilValue = measure.Value
+		}
+
+		if len(toAppendMeasures) > 0 {
+			waitCh := s.txlog.WriteAppendMeasures(
+				txlog.AppendedMeasures{
+					MetricID: req.MetricID,
+					Measures: toAppendMeasures,
+				},
+				false,
+			)
+			<-waitCh
+		}
+
+	case NoMetric:
+		return proto.ErrNoMetric
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return 0
+}
+
+type tryDeleteMeasuresResult struct {
+	ResultCode byte
+	RootPageNo uint32
+}
+
+func (s *Database) DeleteMeasures(req proto.DeleteMeasuresReq) uint16 {
+	resultCh := make(chan tryDeleteMeasuresResult, 1)
+
+	s.appendJobToWorkerQueue(tryDeleteMeasuresReq{
+		MetricID: req.MetricID,
+		Since:    req.Since,
+		ResultCh: resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case NoMeasuresToDelete:
+		// ok
+
+	case DeleteFromAtreeNotNeeded:
+		// регистрирую удаление в TransactionLog
+		waitCh := s.txlog.WriteDeletedMeasures(txlog.DeletedMeasures{
+			MetricID: req.MetricID,
+		})
+		<-waitCh
+
+	case DeleteFromAtreeRequired:
+		// собираю номера всех data и index страниц метрики (типа запись REDO лога).
+		pageLists, err := s.atree.GetAllPages(req.MetricID)
+		if err != nil {
+			diploma.Abort(diploma.FailedAtreeRequest, err)
+		}
+		// регистрирую удаление в TransactionLog
+		waitCh := s.txlog.WriteDeletedMeasures(txlog.DeletedMeasures{
+			MetricID:       req.MetricID,
+			FreeDataPages:  pageLists.DataPages,
+			FreeIndexPages: pageLists.IndexPages,
+		})
+		<-waitCh
+
+	case NoMetric:
+		return proto.ErrNoMetric
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return 0
+}
+
+// SELECT
+
+type fullScanResult struct {
+	ResultCode byte
+	FracDigits byte
+	LastPageNo uint32
+}
+
+func (s *Database) ListAllInstantMeasures(conn net.Conn, req proto.ListAllInstantMetricMeasuresReq) error {
+	responseWriter := transform.NewInstantMeasureWriter(conn, 0)
+
+	return s.fullScan(fullScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Instant,
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+func (s *Database) ListAllCumulativeMeasures(conn io.Writer, req proto.ListAllCumulativeMeasuresReq) error {
+	responseWriter := transform.NewCumulativeMeasureWriter(conn, 0)
+
+	return s.fullScan(fullScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Cumulative,
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+func (s *Database) ListInstantMeasures(conn net.Conn, req proto.ListInstantMeasuresReq) error {
+	if req.Since > req.Until {
+		reply(conn, proto.ErrInvalidRange)
+		return nil
+	}
+
+	responseWriter := transform.NewInstantMeasureWriter(conn, req.Since)
+
+	return s.rangeScan(rangeScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Instant,
+		Since:          req.Since,
+		Until:          req.Until - 1,
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+func (s *Database) ListCumulativeMeasures(conn net.Conn, req proto.ListCumulativeMeasuresReq) error {
+	if req.Since > req.Until {
+		reply(conn, proto.ErrInvalidRange)
+		return nil
+	}
+
+	responseWriter := transform.NewCumulativeMeasureWriter(conn, req.Since)
+
+	return s.rangeScan(rangeScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Cumulative,
+		Since:          req.Since,
+		Until:          req.Until - 1,
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+type rangeScanResult struct {
+	ResultCode byte
+	FracDigits byte
+	RootPageNo uint32
+	LastPageNo uint32
+}
+
+func (s *Database) ListInstantPeriods(conn net.Conn, req proto.ListInstantPeriodsReq) error {
+	since, until := timeBoundsOfAggregation(req.Since, req.Until, req.GroupBy, req.FirstHourOfDay)
+	if since.After(until) {
+		reply(conn, proto.ErrInvalidRange)
+		return nil
+	}
+
+	responseWriter, err := transform.NewInstantPeriodsWriter(transform.InstantPeriodsWriterOptions{
+		Dst:            conn,
+		GroupBy:        req.GroupBy,
+		AggregateFuncs: req.AggregateFuncs,
+		FirstHourOfDay: req.FirstHourOfDay,
+	})
+	if err != nil {
+		reply(conn, proto.ErrUnexpected)
+		return nil
+	}
+
+	return s.rangeScan(rangeScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Instant,
+		Since:          uint32(since.Unix()),
+		Until:          uint32(until.Unix()),
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+func (s *Database) ListCumulativePeriods(conn net.Conn, req proto.ListCumulativePeriodsReq) error {
+	since, until := timeBoundsOfAggregation(req.Since, req.Until, req.GroupBy, req.FirstHourOfDay)
+	if since.After(until) {
+		reply(conn, proto.ErrInvalidRange)
+		return nil
+	}
+
+	responseWriter, err := transform.NewCumulativePeriodsWriter(transform.CumulativePeriodsWriterOptions{
+		Dst:            conn,
+		GroupBy:        req.GroupBy,
+		FirstHourOfDay: req.FirstHourOfDay,
+	})
+	if err != nil {
+		reply(conn, proto.ErrUnexpected)
+		return nil
+	}
+
+	return s.rangeScan(rangeScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     diploma.Cumulative,
+		Since:          uint32(since.Unix()),
+		Until:          uint32(until.Unix()),
+		Conn:           conn,
+		ResponseWriter: responseWriter,
+	})
+}
+
+type rangeScanReq struct {
+	MetricID       uint32
+	MetricType     diploma.MetricType
+	Since          uint32
+	Until          uint32
+	Conn           io.Writer
+	ResponseWriter atree.PeriodsWriter
+}
+
+func (s *Database) rangeScan(req rangeScanReq) error {
+	resultCh := make(chan rangeScanResult, 1)
+
+	s.appendJobToWorkerQueue(tryRangeScanReq{
+		MetricID:       req.MetricID,
+		Since:          req.Since,
+		Until:          req.Until,
+		MetricType:     req.MetricType,
+		ResponseWriter: req.ResponseWriter,
+		ResultCh:       resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case QueryDone:
+		req.ResponseWriter.Close()
+
+	case UntilFound:
+		err := s.atree.ContinueRangeScan(atree.ContinueRangeScanReq{
+			FracDigits:     result.FracDigits,
+			ResponseWriter: req.ResponseWriter,
+			LastPageNo:     result.LastPageNo,
+			Since:          req.Since,
+		})
+		s.metricRUnlock(req.MetricID)
+
+		if err != nil {
+			reply(req.Conn, proto.ErrUnexpected)
+		} else {
+			req.ResponseWriter.Close()
+		}
+
+	case UntilNotFound:
+		err := s.atree.RangeScan(atree.RangeScanReq{
+			FracDigits:     result.FracDigits,
+			ResponseWriter: req.ResponseWriter,
+			RootPageNo:     result.RootPageNo,
+			Since:          req.Since,
+			Until:          req.Until,
+		})
+		s.metricRUnlock(req.MetricID)
+
+		if err != nil {
+			reply(req.Conn, proto.ErrUnexpected)
+		} else {
+			req.ResponseWriter.Close()
+		}
+
+	case NoMetric:
+		reply(req.Conn, proto.ErrNoMetric)
+
+	case WrongMetricType:
+		reply(req.Conn, proto.ErrWrongMetricType)
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return nil
+}
+
+type fullScanReq struct {
+	MetricID       uint32
+	MetricType     diploma.MetricType
+	Conn           io.Writer
+	ResponseWriter atree.PeriodsWriter
+}
+
+func (s *Database) fullScan(req fullScanReq) error {
+	resultCh := make(chan fullScanResult, 1)
+
+	s.appendJobToWorkerQueue(tryFullScanReq{
+		MetricID:       req.MetricID,
+		MetricType:     req.MetricType,
+		ResponseWriter: req.ResponseWriter,
+		ResultCh:       resultCh,
+	})
+
+	result := <-resultCh
+
+	switch result.ResultCode {
+	case QueryDone:
+		req.ResponseWriter.Close()
+
+	case UntilFound:
+		err := s.atree.ContinueFullScan(atree.ContinueFullScanReq{
+			FracDigits:     result.FracDigits,
+			ResponseWriter: req.ResponseWriter,
+			LastPageNo:     result.LastPageNo,
+		})
+		s.metricRUnlock(req.MetricID)
+		if err != nil {
+			reply(req.Conn, proto.ErrUnexpected)
+		} else {
+			req.ResponseWriter.Close()
+		}
+
+	case NoMetric:
+		reply(req.Conn, proto.ErrNoMetric)
+
+	case WrongMetricType:
+		reply(req.Conn, proto.ErrWrongMetricType)
+
+	default:
+		diploma.Abort(diploma.WrongResultCodeBug, ErrWrongResultCodeBug)
+	}
+	return nil
+}
+
+func (s *Database) ListCurrentValues(conn net.Conn, req proto.ListCurrentValuesReq) error {
+	responseWriter := transform.NewCurrentValueWriter(conn)
+	defer responseWriter.Close()
+
+	resultCh := make(chan struct{})
+
+	s.appendJobToWorkerQueue(tryListCurrentValuesReq{
+		MetricIDs:      req.MetricIDs,
+		ResponseWriter: responseWriter,
+		ResultCh:       resultCh,
+	})
+
+	<-resultCh
+	return nil
+}

database/database.go

@@ -0,0 +1,460 @@
+package database
+
+import (
+	"errors"
+	"fmt"
+	"hash/crc32"
+	"io"
+	"log"
+	"net"
+	"os"
+	"path/filepath"
+	"regexp"
+	"sync"
+	"time"
+
+	diploma "gordenko.dev/dima/qb"
+	"gordenko.dev/dima/qb/atree"
+	"gordenko.dev/dima/qb/atree/redo"
+	"gordenko.dev/dima/qb/bin"
+	"gordenko.dev/dima/qb/chunkenc"
+	"gordenko.dev/dima/qb/conbuf"
+	"gordenko.dev/dima/qb/freelist"
+	"gordenko.dev/dima/qb/recovery"
+	"gordenko.dev/dima/qb/txlog"
+)
+
+func JoinSnapshotFileName(dir string, logNumber int) string {
+	return filepath.Join(dir, fmt.Sprintf("%d.snapshot", logNumber))
+}
+
+type metricLockEntry struct {
+	XLock     bool
+	RLocks    int
+	WaitQueue []any
+}
+
+type Database struct {
+	mutex             sync.Mutex
+	workerSignalCh    chan struct{}
+	workerQueue       []any
+	rLocksToRelease   []uint32
+	metrics           map[uint32]*_metric
+	metricLockEntries map[uint32]*metricLockEntry
+	dataFreeList      *freelist.FreeList
+	indexFreeList     *freelist.FreeList
+	dir               string
+	databaseName      string
+	redoDir           string
+	txlog             *txlog.Writer
+	atree             *atree.Atree
+	tcpPort           int
+	logfile           *os.File
+	logger            *log.Logger
+	exitCh            chan struct{}
+	waitGroup         *sync.WaitGroup
+}
+
+type Options struct {
+	TCPPort      int
+	Dir          string
+	DatabaseName string
+	RedoDir      string
+	Logfile      *os.File
+	ExitCh       chan struct{}
+	WaitGroup    *sync.WaitGroup
+}
+
+func New(opt Options) (_ *Database, err error) {
+	if opt.TCPPort <= 0 {
+		return nil, errors.New("TCPPort option is required")
+	}
+	if opt.Dir == "" {
+		return nil, errors.New("Dir option is required")
+	}
+	if opt.DatabaseName == "" {
+		return nil, errors.New("DatabaseName option is required")
+	}
+	if opt.RedoDir == "" {
+		return nil, errors.New("RedoDir option is required")
+	}
+	if opt.Logfile == nil {
+		return nil, errors.New("Logfile option is required")
+	}
+	if opt.ExitCh == nil {
+		return nil, errors.New("ExitCh option is required")
+	}
+	if opt.WaitGroup == nil {
+		return nil, errors.New("WaitGroup option is required")
+	}
+
+	s := &Database{
+		workerSignalCh:    make(chan struct{}, 1),
+		dir:               opt.Dir,
+		databaseName:      opt.DatabaseName,
+		redoDir:           opt.RedoDir,
+		metrics:           make(map[uint32]*_metric),
+		metricLockEntries: make(map[uint32]*metricLockEntry),
+		dataFreeList:      freelist.New(),
+		indexFreeList:     freelist.New(),
+		tcpPort:           opt.TCPPort,
+		logfile:           opt.Logfile,
+		logger:            log.New(opt.Logfile, "", log.LstdFlags),
+		exitCh:            opt.ExitCh,
+		waitGroup:         opt.WaitGroup,
+	}
+	return s, nil
+}
+
+func (s *Database) ListenAndServe() (err error) {
+	listener, err := net.Listen("tcp", fmt.Sprintf(":%d", s.tcpPort))
+	if err != nil {
+		return fmt.Errorf("net.Listen: %s; port=%d", err, s.tcpPort)
+	}
+
+	s.atree, err = atree.New(atree.Options{
+		Dir:           s.dir,
+		DatabaseName:  s.databaseName,
+		RedoDir:       s.redoDir,
+		DataFreeList:  s.dataFreeList,
+		IndexFreeList: s.indexFreeList,
+	})
+	if err != nil {
+		return fmt.Errorf("atree.New: %s", err)
+	}
+	s.atree.Run()
+
+	go s.worker()
+
+	s.recovery()
+
+	s.logger.Println("database started")
+	for {
+		// Listen for an incoming connection.
+		conn, err := listener.Accept()
+		if err != nil {
+			s.logger.Printf("listener.Accept: %s\n", err)
+			time.Sleep(time.Second)
+		} else {
+			go s.handleTCPConn(conn)
+		}
+	}
+}
+
+func (s *Database) recovery() {
+	advisor, err := recovery.NewRecoveryAdvisor(recovery.RecoveryAdvisorOptions{
+		Dir:            s.dir,
+		VerifySnapshot: s.verifySnapshot,
+	})
+	if err != nil {
+		panic(err)
+	}
+
+	recipe, err := advisor.GetRecipe()
+	if err != nil {
+		diploma.Abort(diploma.GetRecoveryRecipeFailed, err)
+	}
+
+	var logNumber int
+
+	if recipe != nil {
+		if recipe.Snapshot != "" {
+			err = s.loadSnapshot(recipe.Snapshot)
+			if err != nil {
+				diploma.Abort(diploma.LoadSnapshotFailed, err)
+			}
+		}
+		for _, changesFileName := range recipe.Changes {
+			err = s.replayChanges(changesFileName)
+			if err != nil {
+				diploma.Abort(diploma.ReplayChangesFailed, err)
+			}
+		}
+		logNumber = recipe.LogNumber
+	}
+
+	s.txlog, err = txlog.NewWriter(txlog.WriterOptions{
+		Dir:                 s.dir,
+		LogNumber:           logNumber,
+		AppendToWorkerQueue: s.appendJobToWorkerQueue,
+		ExitCh:              s.exitCh,
+		WaitGroup:           s.waitGroup,
+	})
+	if err != nil {
+		diploma.Abort(diploma.CreateChangesWriterFailed, err)
+
+	}
+	go s.txlog.Run()
+
+	fileNames, err := s.searchREDOFiles()
+	if err != nil {
+		diploma.Abort(diploma.SearchREDOFilesFailed, err)
+	}
+
+	if len(fileNames) > 0 {
+		for _, fileName := range fileNames {
+			err = s.replayREDOFile(fileName)
+			if err != nil {
+				diploma.Abort(diploma.ReplayREDOFileFailed, err)
+			}
+		}
+
+		for _, fileName := range fileNames {
+			err = os.Remove(fileName)
+			if err != nil {
+				diploma.Abort(diploma.RemoveREDOFileFailed, err)
+			}
+		}
+	}
+
+	if recipe != nil {
+		if recipe.CompleteSnapshot {
+			err = s.dumpSnapshot(logNumber)
+			if err != nil {
+				diploma.Abort(diploma.DumpSnapshotFailed, err)
+			}
+		}
+
+		for _, fileName := range recipe.ToDelete {
+			err = os.Remove(fileName)
+			if err != nil {
+				diploma.Abort(diploma.RemoveRecipeFileFailed, err)
+			}
+		}
+	}
+}
+
+func (s *Database) searchREDOFiles() ([]string, error) {
+	var (
+		reREDO    = regexp.MustCompile(`a\d+\.redo`)
+		fileNames []string
+	)
+
+	entries, err := os.ReadDir(s.redoDir)
+	if err != nil {
+		return nil, err
+	}
+
+	for _, entry := range entries {
+		if entry.Type().IsRegular() {
+			baseName := entry.Name()
+			if reREDO.MatchString(baseName) {
+				fileNames = append(fileNames, filepath.Join(s.redoDir, baseName))
+			}
+		}
+	}
+	return fileNames, nil
+}
+
+func (s *Database) replayREDOFile(fileName string) error {
+	redoFile, err := redo.ReadREDOFile(redo.ReadREDOFileReq{
+		FileName:      fileName,
+		DataPageSize:  atree.DataPageSize,
+		IndexPageSize: atree.IndexPageSize,
+	})
+	if err != nil {
+		return fmt.Errorf("can't read REDO file %s: %s", fileName, err)
+	}
+
+	metric, ok := s.metrics[redoFile.MetricID]
+	if !ok {
+		return fmt.Errorf("has REDOFile, metric %d not found", redoFile.MetricID)
+	}
+
+	if metric.Until < redoFile.Timestamp {
+		waitCh := make(chan struct{})
+		s.atree.ApplyREDO(atree.WriteTask{
+			DataPage:   redoFile.DataPage,
+			IndexPages: redoFile.IndexPages,
+		})
+		<-waitCh
+
+		waitCh = s.txlog.WriteAppendedMeasureWithOverflow(
+			txlog.AppendedMeasureWithOverflow{
+				MetricID:         redoFile.MetricID,
+				Timestamp:        redoFile.Timestamp,
+				Value:            redoFile.Value,
+				IsDataPageReused: redoFile.IsDataPageReused,
+				DataPageNo:       redoFile.DataPage.PageNo,
+				IsRootChanged:    redoFile.IsRootChanged,
+				RootPageNo:       redoFile.RootPageNo,
+				ReusedIndexPages: redoFile.ReusedIndexPages,
+			},
+			fileName,
+			false,
+		)
+		<-waitCh
+	}
+	return nil
+}
+
+func (s *Database) verifySnapshot(fileName string) (_ bool, err error) {
+	file, err := os.Open(fileName)
+	if err != nil {
+		return
+	}
+	defer file.Close()
+
+	stat, err := file.Stat()
+	if err != nil {
+		return
+	}
+
+	if stat.Size() <= 4 {
+		return false, nil
+	}
+
+	var (
+		payloadSize = stat.Size() - 4
+		hash        = crc32.NewIEEE()
+	)
+
+	_, err = io.CopyN(hash, file, payloadSize)
+	if err != nil {
+		return
+	}
+	calculatedCRC := hash.Sum32()
+
+	storedCRC, err := bin.ReadUint32(file)
+	if err != nil {
+		return
+	}
+	if storedCRC != calculatedCRC {
+		return false, fmt.Errorf("strored CRC %d not equal calculated CRC %d",
+			storedCRC, calculatedCRC)
+	}
+	return true, nil
+}
+
+func (s *Database) replayChanges(fileName string) error {
+	walReader, err := txlog.NewReader(txlog.ReaderOptions{
+		FileName:   fileName,
+		BufferSize: 1024 * 1024,
+	})
+	if err != nil {
+		return err
+	}
+
+	for {
+		lsn, records, done, err := walReader.ReadPacket()
+		if err != nil {
+			return err
+		}
+		_ = lsn
+
+		if done {
+			return nil
+		}
+
+		for _, record := range records {
+			if err = s.replayChangesRecord(record); err != nil {
+				return err
+			}
+		}
+	}
+}
+
+func (s *Database) replayChangesRecord(untyped any) error {
+	switch rec := untyped.(type) {
+	case txlog.AddedMetric:
+		var (
+			values        diploma.ValueCompressor
+			timestampsBuf = conbuf.New(nil)
+			valuesBuf     = conbuf.New(nil)
+		)
+
+		if rec.MetricType == diploma.Cumulative {
+			values = chunkenc.NewReverseCumulativeDeltaCompressor(
+				valuesBuf, 0, byte(rec.FracDigits))
+		} else {
+			values = chunkenc.NewReverseInstantDeltaCompressor(
+				valuesBuf, 0, byte(rec.FracDigits))
+		}
+
+		s.metrics[rec.MetricID] = &_metric{
+			MetricType:    rec.MetricType,
+			FracDigits:    byte(rec.FracDigits),
+			TimestampsBuf: timestampsBuf,
+			ValuesBuf:     valuesBuf,
+			Timestamps:    chunkenc.NewReverseTimeDeltaOfDeltaCompressor(timestampsBuf, 0),
+			Values:        values,
+		}
+
+	case txlog.DeletedMetric:
+		delete(s.metrics, rec.MetricID)
+		if len(rec.FreeDataPages) > 0 {
+			s.dataFreeList.AddPages(rec.FreeDataPages)
+		}
+		if len(rec.FreeIndexPages) > 0 {
+			s.indexFreeList.AddPages(rec.FreeIndexPages)
+		}
+
+	case txlog.AppendedMeasure:
+		metric, ok := s.metrics[rec.MetricID]
+		if ok {
+			metric.Timestamps.Append(rec.Timestamp)
+			metric.Values.Append(rec.Value)
+
+			if metric.Since == 0 {
+				metric.Since = rec.Timestamp
+				metric.SinceValue = rec.Value
+			}
+
+			metric.Until = rec.Timestamp
+			metric.UntilValue = rec.Value
+		}
+
+	case txlog.AppendedMeasures:
+		metric, ok := s.metrics[rec.MetricID]
+		if ok {
+			for _, measure := range rec.Measures {
+				metric.Timestamps.Append(measure.Timestamp)
+				metric.Values.Append(measure.Value)
+
+				if metric.Since == 0 {
+					metric.Since = measure.Timestamp
+					metric.SinceValue = measure.Value
+				}
+
+				metric.Until = measure.Timestamp
+				metric.UntilValue = measure.Value
+			}
+		}
+
+	case txlog.AppendedMeasureWithOverflow:
+		metric, ok := s.metrics[rec.MetricID]
+		if ok {
+			metric.ReinitBy(rec.Timestamp, rec.Value)
+			if rec.IsRootChanged {
+				metric.RootPageNo = rec.RootPageNo
+			}
+			metric.LastPageNo = rec.DataPageNo
+			// delete free pages
+			if rec.IsDataPageReused {
+				s.dataFreeList.DeletePages([]uint32{
+					rec.DataPageNo,
+				})
+			}
+			if len(rec.ReusedIndexPages) > 0 {
+				s.indexFreeList.DeletePages(rec.ReusedIndexPages)
+			}
+		}
+
+	case txlog.DeletedMeasures:
+		metric, ok := s.metrics[rec.MetricID]
+		if ok {
+			metric.DeleteMeasures()
+			if len(rec.FreeDataPages) > 0 {
+				s.dataFreeList.AddPages(rec.FreeDataPages)
+			}
+			if len(rec.FreeDataPages) > 0 {
+				s.indexFreeList.AddPages(rec.FreeIndexPages)
+			}
+		}
+
+	default:
+		diploma.Abort(diploma.UnknownTxLogRecordTypeBug,
+			fmt.Errorf("bug: unknown record type %T in TransactionLog", rec))
+	}
+	return nil
+}

database/helpers.go

@@ -0,0 +1,74 @@
+package database
+
+import (
+	"errors"
+	"io/fs"
+	"os"
+	"time"
+
+	diploma "gordenko.dev/dima/qb"
+	"gordenko.dev/dima/qb/proto"
+)
+
+func timeBoundsOfAggregation(since, until proto.TimeBound, groupBy diploma.GroupBy, firstHourOfDay int) (s time.Time, u time.Time) {
+	switch groupBy {
+	case diploma.GroupByHour, diploma.GroupByDay:
+		s = time.Date(since.Year, since.Month, since.Day, 0, 0, 0, 0, time.Local)
+		u = time.Date(until.Year, until.Month, until.Day, 0, 0, 0, 0, time.Local)
+
+	case diploma.GroupByMonth:
+		s = time.Date(since.Year, since.Month, 1, 0, 0, 0, 0, time.Local)
+		u = time.Date(until.Year, until.Month, 1, 0, 0, 0, 0, time.Local)
+	}
+
+	if firstHourOfDay > 0 {
+		duration := time.Duration(firstHourOfDay) * time.Hour
+		s = s.Add(duration)
+		u = u.Add(duration)
+	}
+
+	u = u.Add(-1 * time.Second)
+	return
+}
+
+func isFileExist(fileName string) (bool, error) {
+	_, err := os.Stat(fileName)
+	if err != nil {
+		if errors.Is(err, fs.ErrNotExist) {
+			return false, nil
+		} else {
+			return false, err
+		}
+	} else {
+		return true, nil
+	}
+}
+
+func (s *Database) appendJobToWorkerQueue(job any) {
+	s.mutex.Lock()
+	s.workerQueue = append(s.workerQueue, job)
+	s.mutex.Unlock()
+
+	select {
+	case s.workerSignalCh <- struct{}{}:
+	default:
+	}
+}
+
+func (s *Database) metricRUnlock(metricID uint32) {
+	s.mutex.Lock()
+	s.rLocksToRelease = append(s.rLocksToRelease, metricID)
+	s.mutex.Unlock()
+
+	select {
+	case s.workerSignalCh <- struct{}{}:
+	default:
+	}
+}
+
+func correctToFHD(since, until uint32, firstHourOfDay int) (uint32, uint32) {
+	duration := time.Duration(firstHourOfDay) * time.Hour
+	since = uint32(time.Unix(int64(since), 0).Add(duration).Unix())
+	until = uint32(time.Unix(int64(until), 0).Add(duration).Unix())
+	return since, until
+}

database/metric.go

@@ -0,0 +1,71 @@
+package database
+
+import (
+	octopus "gordenko.dev/dima/qb"
+	"gordenko.dev/dima/qb/chunkenc"
+	"gordenko.dev/dima/qb/conbuf"
+)
+
+// METRIC
+
+type _metric struct {
+	MetricType    octopus.MetricType
+	FracDigits    byte
+	RootPageNo    uint32
+	LastPageNo    uint32
+	SinceValue    float64
+	Since         uint32
+	UntilValue    float64
+	Until         uint32
+	TimestampsBuf *conbuf.ContinuousBuffer
+	ValuesBuf     *conbuf.ContinuousBuffer
+	Timestamps    octopus.TimestampCompressor
+	Values        octopus.ValueCompressor
+}
+
+func (s *_metric) ReinitBy(timestamp uint32, value float64) {
+	s.TimestampsBuf = conbuf.New(nil)
+	s.ValuesBuf = conbuf.New(nil)
+	//
+	s.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor(
+		s.TimestampsBuf, 0)
+
+	if s.MetricType == octopus.Cumulative {
+		s.Values = chunkenc.NewReverseCumulativeDeltaCompressor(
+			s.ValuesBuf, 0, s.FracDigits)
+	} else {
+		s.Values = chunkenc.NewReverseInstantDeltaCompressor(
+			s.ValuesBuf, 0, s.FracDigits)
+	}
+
+	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.TimestampsBuf = conbuf.New(nil)
+	s.ValuesBuf = conbuf.New(nil)
+	//
+	s.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor(
+		s.TimestampsBuf, 0)
+
+	if s.MetricType == octopus.Cumulative {
+		s.Values = chunkenc.NewReverseCumulativeDeltaCompressor(
+			s.ValuesBuf, 0, s.FracDigits)
+	} else {
+		s.Values = chunkenc.NewReverseInstantDeltaCompressor(
+			s.ValuesBuf, 0, s.FracDigits)
+	}
+
+	s.RootPageNo = 0
+	s.LastPageNo = 0
+	s.Since = 0
+	s.SinceValue = 0
+	s.Until = 0
+	s.UntilValue = 0
+}

database/snapshot.go

@@ -0,0 +1,287 @@
+package database
+
+import (
+	"fmt"
+	"hash/crc32"
+	"io"
+	"os"
+	"path/filepath"
+
+	octopus "gordenko.dev/dima/qb"
+	"gordenko.dev/dima/qb/atree"
+	"gordenko.dev/dima/qb/bin"
+	"gordenko.dev/dima/qb/chunkenc"
+	"gordenko.dev/dima/qb/conbuf"
+	"gordenko.dev/dima/qb/freelist"
+)
+
+/*
+Формат:
+//lsn - varuint (останній LSN, що змінив дані у RAM)
+metricsQty - varuint
+[metric]*
+где metric - це:
+metricID - 4b
+metricType - 1b
+fracDigits - 1b
+rootPageNo - 4b
+lastPageNo - 4b
+since - 4b
+sinceValue - 8b
+until - 4b
+untilValue - 8b
+timestamps size - 2b
+values size - 2b
+timestams payload - Nb
+values payload - Nb
+dataFreeList size - varuint
+dataFreeList - Nb
+indexFreeList size - varuint
+indexFreeList - Nb
+CRC32 - 4b
+*/
+
+const metricHeaderSize = 42
+
+func (s *Database) dumpSnapshot(logNumber int) (err error) {
+	var (
+		fileName = filepath.Join(s.dir, fmt.Sprintf("%d.snapshot", logNumber))
+		hasher   = crc32.NewIEEE()
+		prefix   = make([]byte, metricHeaderSize)
+	)
+
+	file, err := os.OpenFile(fileName, os.O_CREATE|os.O_WRONLY, 0770)
+	if err != nil {
+		return
+	}
+
+	dst := io.MultiWriter(file, hasher)
+
+	_, err = bin.WriteVarUint64(dst, uint64(len(s.metrics)))
+	if err != nil {
+		return
+	}
+
+	for metricID, metric := range s.metrics {
+		tSize := metric.Timestamps.Size()
+		vSize := metric.Values.Size()
+
+		bin.PutUint32(prefix[0:], metricID)
+		prefix[4] = byte(metric.MetricType)
+		prefix[5] = metric.FracDigits
+		bin.PutUint32(prefix[6:], metric.RootPageNo)
+		bin.PutUint32(prefix[10:], metric.LastPageNo)
+		bin.PutUint32(prefix[14:], metric.Since)
+		bin.PutFloat64(prefix[18:], metric.SinceValue)
+		bin.PutUint32(prefix[26:], metric.Until)
+		bin.PutFloat64(prefix[30:], metric.UntilValue)
+		bin.PutUint16(prefix[38:], uint16(tSize))
+		bin.PutUint16(prefix[40:], uint16(vSize))
+
+		_, err = dst.Write(prefix)
+		if err != nil {
+			return
+		}
+		// copy timestamps
+		remaining := tSize
+		for _, buf := range metric.TimestampsBuf.Chunks() {
+			if remaining < len(buf) {
+				buf = buf[:remaining]
+			}
+			_, err = dst.Write(buf)
+			if err != nil {
+				return
+			}
+			remaining -= len(buf)
+			if remaining == 0 {
+				break
+			}
+		}
+		// copy values
+		remaining = vSize
+		for _, buf := range metric.ValuesBuf.Chunks() {
+			if remaining < len(buf) {
+				buf = buf[:remaining]
+			}
+			_, err = dst.Write(buf)
+			if err != nil {
+				return
+			}
+			remaining -= len(buf)
+			if remaining == 0 {
+				break
+			}
+		}
+	}
+	// free data pages
+	err = freeListWriteTo(s.dataFreeList, dst)
+	if err != nil {
+		return
+	}
+	// free index pages
+	err = freeListWriteTo(s.indexFreeList, dst)
+	if err != nil {
+		return
+	}
+
+	bin.WriteUint32(file, hasher.Sum32())
+
+	err = file.Sync()
+	if err != nil {
+		return
+	}
+
+	err = file.Close()
+	if err != nil {
+		return
+	}
+
+	prevLogNumber := logNumber - 1
+	prevChanges := filepath.Join(s.dir, fmt.Sprintf("%d.changes", prevLogNumber))
+	prevSnapshot := filepath.Join(s.dir, fmt.Sprintf("%d.snapshot", prevLogNumber))
+
+	isExist, err := isFileExist(prevChanges)
+	if err != nil {
+		return
+	}
+
+	if isExist {
+		err = os.Remove(prevChanges)
+		if err != nil {
+			octopus.Abort(octopus.DeletePrevChangesFileFailed, err)
+		}
+	}
+
+	isExist, err = isFileExist(prevSnapshot)
+	if err != nil {
+		return
+	}
+
+	if isExist {
+		err = os.Remove(prevSnapshot)
+		if err != nil {
+			octopus.Abort(octopus.DeletePrevSnapshotFileFailed, err)
+		}
+	}
+	return
+}
+
+func (s *Database) loadSnapshot(fileName string) (err error) {
+	var (
+		hasher     = crc32.NewIEEE()
+		metricsQty int
+		header     = make([]byte, metricHeaderSize)
+		body       = make([]byte, atree.DataPageSize)
+	)
+
+	file, err := os.Open(fileName)
+	if err != nil {
+		return
+	}
+
+	src := io.TeeReader(file, hasher)
+	u64, _, err := bin.ReadVarUint64(src)
+	if err != nil {
+		return
+	}
+	metricsQty = int(u64)
+
+	for range metricsQty {
+		var metric _metric
+		err = bin.ReadNInto(src, header)
+		if err != nil {
+			return
+		}
+
+		metricID := bin.GetUint32(header[0:])
+		metric.MetricType = octopus.MetricType(header[4])
+		metric.FracDigits = header[5]
+		metric.RootPageNo = bin.GetUint32(header[6:])
+		metric.LastPageNo = bin.GetUint32(header[10:])
+		metric.Since = bin.GetUint32(header[14:])
+		metric.SinceValue = bin.GetFloat64(header[18:])
+		metric.Until = bin.GetUint32(header[26:])
+		metric.UntilValue = bin.GetFloat64(header[30:])
+		tSize := bin.GetUint16(header[38:])
+		vSize := bin.GetUint16(header[40:])
+
+		buf := body[:tSize]
+		err = bin.ReadNInto(src, buf)
+		if err != nil {
+			return
+		}
+		metric.TimestampsBuf = conbuf.NewFromBuffer(buf)
+
+		buf = body[:vSize]
+		err = bin.ReadNInto(src, buf)
+		if err != nil {
+			return
+		}
+		metric.ValuesBuf = conbuf.NewFromBuffer(buf)
+
+		metric.Timestamps = chunkenc.NewReverseTimeDeltaOfDeltaCompressor(
+			metric.TimestampsBuf, int(tSize))
+
+		if metric.MetricType == octopus.Cumulative {
+			metric.Values = chunkenc.NewReverseCumulativeDeltaCompressor(
+				metric.ValuesBuf, int(vSize), metric.FracDigits)
+		} else {
+			metric.Values = chunkenc.NewReverseInstantDeltaCompressor(
+				metric.ValuesBuf, int(vSize), metric.FracDigits)
+		}
+		s.metrics[metricID] = &metric
+	}
+
+	err = restoreFreeList(s.dataFreeList, src)
+	if err != nil {
+		return fmt.Errorf("restore dataFreeList: %s", err)
+	}
+
+	err = restoreFreeList(s.indexFreeList, src)
+	if err != nil {
+		return fmt.Errorf("restore indexFreeList: %s", err)
+	}
+
+	calculatedChecksum := hasher.Sum32()
+
+	writtenChecksum, err := bin.ReadUint32(file)
+	if err != nil {
+		return
+	}
+
+	if calculatedChecksum != writtenChecksum {
+		return fmt.Errorf("calculated checksum %d not equal written checksum %d", calculatedChecksum, writtenChecksum)
+	}
+	return
+}
+
+// HELPERS
+
+func freeListWriteTo(freeList *freelist.FreeList, dst io.Writer) error {
+	serialized, err := freeList.Serialize()
+	if err != nil {
+		octopus.Abort(octopus.FailedFreeListSerialize, err)
+	}
+	_, err = bin.WriteVarUint64(dst, uint64(len(serialized)))
+	if err != nil {
+		return err
+	}
+	_, err = dst.Write(serialized)
+	if err != nil {
+		return err
+	}
+	return nil
+}
+
+func restoreFreeList(freeList *freelist.FreeList, src io.Reader) error {
+	size, _, err := bin.ReadVarUint64(src)
+	if err != nil {
+		return err
+	}
+	serialized, err := bin.ReadN(src, int(size))
+	if err != nil {
+		return err
+	}
+	freeList.Restore(serialized)
+	return nil
+}