gotidb/examples/file_engine_example.go

package main

import (
	"context"
	"fmt"
	"os"
	"time"

	"git.pyer.club/kingecg/gotidb/pkg/engine"
	_ "git.pyer.club/kingecg/gotidb/pkg/engine/file" // 导入文件引擎以注册
)

func main() {
	// 创建临时目录
	tempDir, err := os.MkdirTemp("", "gotidb_example")
	if err != nil {
		fmt.Printf("Failed to create temp dir: %v\n", err)
		return
	}
	defer os.RemoveAll(tempDir)

	// 创建引擎配置
	config := &engine.FileEngineConfig{
		DataDir:          tempDir,
		SegmentSize:      1024 * 1024, // 1MB
		MaxSegments:      10,
		WriteBufferSize:  1000,
		IndexCacheSize:   1024 * 1024, // 1MB
		UseCompression:   false,
		CompressionLevel: 0,
		CompactThreshold: 0.7,
		MaxOpenFiles:     100,
		SyncWrites:       true,
		RetentionPeriod:  24 * time.Hour,
	}

	// 创建引擎
	e, err := engine.NewEngine(engine.EngineConfig{
		Type:       "file",
		FileConfig: config,
	})
	if err != nil {
		fmt.Printf("Failed to create file engine: %v\n", err)
		return
	}

	// 打开引擎
	if err := e.Open(); err != nil {
		fmt.Printf("Failed to open engine: %v\n", err)
		return
	}
	defer e.Close()

	// 创建上下文
	ctx := context.Background()

	// 写入测试数据
	fmt.Println("Writing data points...")
	points := []engine.DataPoint{
		{
			Timestamp: time.Now().UnixNano(),
			Value:     1.0,
			Labels: map[string]string{
				"host":   "server1",
				"region": "us-west",
				"app":    "web",
			},
		},
		{
			Timestamp: time.Now().Add(time.Second).UnixNano(),
			Value:     2.0,
			Labels: map[string]string{
				"host":   "server1",
				"region": "us-west",
				"app":    "web",
			},
		},
		{
			Timestamp: time.Now().Add(2 * time.Second).UnixNano(),
			Value:     3.0,
			Labels: map[string]string{
				"host":   "server2",
				"region": "us-east",
				"app":    "api",
			},
		},
		{
			Timestamp: time.Now().Add(3 * time.Second).UnixNano(),
			Value:     4.0,
			Labels: map[string]string{
				"host":   "server2",
				"region": "us-east",
				"app":    "api",
			},
		},
	}

	// 写入数据
	if err := e.Write(ctx, points); err != nil {
		fmt.Printf("Failed to write points: %v\n", err)
		return
	}

	// 查询原始数据
	fmt.Println("\nQuerying raw data for server1...")
	rawQuery := engine.Query{
		Type:      engine.QueryTypeRaw,
		StartTime: time.Now().Add(-time.Minute).UnixNano(),
		EndTime:   time.Now().Add(time.Minute).UnixNano(),
		Tags: map[string]string{
			"host": "server1",
		},
		Limit: 10,
	}

	rawResult, err := e.Query(ctx, rawQuery)
	if err != nil {
		fmt.Printf("Failed to query raw data: %v\n", err)
		return
	}

	// 打印原始查询结果
	fmt.Printf("Raw query returned %d series\n", len(rawResult))
	for i, series := range rawResult {
		fmt.Printf("Series %d (ID: %s):\n", i+1, series.SeriesID)
		fmt.Printf("  Labels: %v\n", series.Points[0].Labels)
		fmt.Printf("  Points: %d\n", len(series.Points))
		for j, point := range series.Points {
			fmt.Printf("    Point %d: timestamp=%s, value=%f\n",
				j+1,
				time.Unix(0, point.Timestamp).Format(time.RFC3339Nano),
				point.Value)
		}
	}

	// 查询最新数据
	fmt.Println("\nQuerying latest data for each host...")
	latestQuery := engine.Query{
		Type:      engine.QueryTypeLatest,
		StartTime: time.Now().Add(-time.Minute).UnixNano(),
		EndTime:   time.Now().Add(time.Minute).UnixNano(),
		Tags:      map[string]string{}, // 空标签查询所有序列
	}

	latestResult, err := e.Query(ctx, latestQuery)
	if err != nil {
		fmt.Printf("Failed to query latest data: %v\n", err)
		return
	}

	// 打印最新查询结果
	fmt.Printf("Latest query returned %d series\n", len(latestResult))
	for i, series := range latestResult {
		fmt.Printf("Series %d (ID: %s):\n", i+1, series.SeriesID)
		fmt.Printf("  Labels: %v\n", series.Points[0].Labels)
		for _, point := range series.Points {
			fmt.Printf("  Latest point: timestamp=%s, value=%f\n",
				time.Unix(0, point.Timestamp).Format(time.RFC3339Nano),
				point.Value)
		}
	}

	// 查询聚合数据
	fmt.Println("\nQuerying aggregate data (average) for each region...")
	aggQuery := engine.Query{
		Type:          engine.QueryTypeAggregate,
		StartTime:     time.Now().Add(-time.Minute).UnixNano(),
		EndTime:       time.Now().Add(time.Minute).UnixNano(),
		AggregateType: engine.AggregateTypeAvg,
		Tags:          map[string]string{}, // 空标签查询所有序列
	}

	aggResult, err := e.Query(ctx, aggQuery)
	if err != nil {
		fmt.Printf("Failed to query aggregate data: %v\n", err)
		return
	}

	// 打印聚合查询结果
	fmt.Printf("Aggregate query returned %d series\n", len(aggResult))
	for i, series := range aggResult {
		fmt.Printf("Series %d (ID: %s):\n", i+1, series.SeriesID)
		fmt.Printf("  Labels: %v\n", series.Points[0].Labels)
		for _, point := range series.Points {
			fmt.Printf("  Average value: %f\n", point.Value)
		}
	}

	// 获取引擎统计信息
	stats := e.Stats()
	fmt.Println("\nEngine statistics:")
	fmt.Printf("  Points count: %d\n", stats.PointsCount)
	fmt.Printf("  Segments count: %d\n", stats.SegmentsCount)
	fmt.Printf("  Last write time: %s\n", stats.LastWriteTime.Format(time.RFC3339))
	if !stats.LastCompactionTime.IsZero() {
		fmt.Printf("  Last compaction time: %s\n", stats.LastCompactionTime.Format(time.RFC3339))
	} else {
		fmt.Printf("  Last compaction time: Never\n")
	}
}