main.go

package main

import (
	"context"
	"fmt"
	"log"
	"time"

	"github.com/mew-sh/qdb"
)

func main() {
	// Example usage of QDB library
	ctx := context.Background()

	// Create a new QDB instance with default config
	config := qdb.DefaultConfig()
	// config.UseMemory = true // Use in-memory storage for testing
	
	db, err := qdb.New(config)
	if err != nil {
		log.Fatal("Failed to create QDB:", err)
	}
	defer db.Close()

	// Basic key-value operations
	fmt.Println("=== Basic Key-Value Operations ===")
	
	// Set values
	if err := db.Set(ctx, "name", "Alice"); err != nil {
		log.Fatal("Failed to set name:", err)
	}
	
	if err := db.Set(ctx, "age", 30); err != nil {
		log.Fatal("Failed to set age:", err)
	}
	
	if err := db.Set(ctx, "score", 95.5); err != nil {
		log.Fatal("Failed to set score:", err)
	}

	// Get values
	name, err := db.Get(ctx, "name").String()
	if err != nil {
		log.Fatal("Failed to get name:", err)
	}
	fmt.Printf("Name: %s\n", name)

	age, err := db.Get(ctx, "age").Int()
	if err != nil {
		log.Fatal("Failed to get age:", err)
	}
	fmt.Printf("Age: %d\n", age)

	score, err := db.Get(ctx, "score").Float()
	if err != nil {
		log.Fatal("Failed to get score:", err)
	}
	fmt.Printf("Score: %.1f\n", score)

	// Check existence
	exists, err := db.Exists(ctx, "name")
	if err != nil {
		log.Fatal("Failed to check existence:", err)
	}
	fmt.Printf("Name exists: %t\n", exists)

	// Vector operations
	fmt.Println("\n=== Vector Operations ===")

	// Set vectors with metadata
	vector1 := []float64{1.0, 2.0, 3.0, 4.0}
	metadata1 := map[string]interface{}{
		"category": "A",
		"priority": 1,
		"tags":     []string{"important", "vector"},
	}
	
	if err := db.SetVector(ctx, "vec1", vector1, metadata1); err != nil {
		log.Fatal("Failed to set vector1:", err)
	}

	vector2 := []float64{2.0, 3.0, 4.0, 5.0}
	metadata2 := map[string]interface{}{
		"category": "B",
		"priority": 2,
		"tags":     []string{"normal", "vector"},
	}
	
	if err := db.SetVector(ctx, "vec2", vector2, metadata2); err != nil {
		log.Fatal("Failed to set vector2:", err)
	}

	vector3 := []float64{1.5, 2.5, 3.5, 4.5}
	metadata3 := map[string]interface{}{
		"category": "A",
		"priority": 3,
		"tags":     []string{"important", "test"},
	}
	
	if err := db.SetVector(ctx, "vec3", vector3, metadata3); err != nil {
		log.Fatal("Failed to set vector3:", err)
	}

	// Perform ANN search
	query := []float64{1.1, 2.1, 3.1, 4.1}
	
	fmt.Println("ANN Search Results:")
	results, err := db.SearchVector(ctx, query, 3)
	if err != nil {
		log.Fatal("Failed to perform ANN search:", err)
	}
	
	for i, result := range results {
		fmt.Printf("  %d. Key: %s, Score: %.3f, Vector: %v\n", 
			i+1, result.Key, result.Score, result.Vector)
		if metadata, ok := result.Metadata.(map[string]interface{}); ok {
			fmt.Printf("     Metadata: category=%s, priority=%.0f\n", 
				metadata["category"], metadata["priority"])
		}
	}

	// Perform exact K-NN search
	fmt.Println("\nExact K-NN Search Results:")
	exactResults, err := db.SearchVectorExact(ctx, query, 3)
	if err != nil {
		log.Fatal("Failed to perform exact search:", err)
	}
	
	for i, result := range exactResults {
		fmt.Printf("  %d. Key: %s, Score: %.3f, Vector: %v\n", 
			i+1, result.Key, result.Score, result.Vector)
	}

	// Search with filters
	fmt.Println("\nFiltered Search Results (category = 'A'):")
	filter := &qdb.FilterCondition{
		Field:    "category",
		Operator: "eq",
		Value:    "A",
	}
	
	filteredResults, err := db.SearchVectorExact(ctx, query, 3, filter)
	if err != nil {
		log.Fatal("Failed to perform filtered search:", err)
	}
	
	for i, result := range filteredResults {
		fmt.Printf("  %d. Key: %s, Score: %.3f\n", 
			i+1, result.Key, result.Score)
		if metadata, ok := result.Metadata.(map[string]interface{}); ok {
			fmt.Printf("     Category: %s\n", metadata["category"])
		}
	}

	// Demonstrate different data types
	fmt.Println("\n=== Different Data Types ===")
	
	// Store complex data
	complexData := map[string]interface{}{
		"user_id": 12345,
		"profile": map[string]string{
			"email": "alice@example.com",
			"role":  "admin",
		},
		"settings": []bool{true, false, true},
	}
	
	if err := db.Set(ctx, "user:12345", complexData); err != nil {
		log.Fatal("Failed to set complex data:", err)
	}

	// Retrieve complex data
	val, err := db.Get(ctx, "user:12345").Result()
	if err == nil && val != nil {
		fmt.Printf("Complex data: %+v\n", val)
	}

	// Store binary data
	binaryData := []byte{0x48, 0x65, 0x6C, 0x6C, 0x6F} // "Hello" in bytes
	if err := db.Set(ctx, "binary", binaryData); err != nil {
		log.Fatal("Failed to set binary data:", err)
	}

	retrievedBytes, err := db.Get(ctx, "binary").Bytes()
	if err != nil {
		log.Fatal("Failed to get binary data:", err)
	}
	fmt.Printf("Binary data: %v (as string: %s)\n", retrievedBytes, string(retrievedBytes))

	// Store slice data
	fmt.Println("\n=== Slice Data Types ===")
	
	intSlice := []int{10, 20, 30, 40, 50}
	stringSlice := []string{"apple", "banana", "cherry"}
	floatSlice := []float64{1.1, 2.2, 3.3}
	boolSlice := []bool{true, false, true}

	if err := db.Set(ctx, "int_slice", intSlice); err != nil {
		log.Fatal("Failed to set int slice:", err)
	}
	
	if err := db.Set(ctx, "string_slice", stringSlice); err != nil {
		log.Fatal("Failed to set string slice:", err)
	}
	
	if err := db.Set(ctx, "float_slice", floatSlice); err != nil {
		log.Fatal("Failed to set float slice:", err)
	}
	
	if err := db.Set(ctx, "bool_slice", boolSlice); err != nil {
		log.Fatal("Failed to set bool slice:", err)
	}

	// Retrieve slices
	intResult, err := db.Get(ctx, "int_slice").Result()
	if err != nil {
		log.Fatal("Failed to get int slice:", err)
	}
	fmt.Printf("Int slice: %v (type: %T)\n", intResult, intResult)

	stringResult, err := db.Get(ctx, "string_slice").Result()
	if err != nil {
		log.Fatal("Failed to get string slice:", err)
	}
	fmt.Printf("String slice: %v (type: %T)\n", stringResult, stringResult)

	floatResult, err := db.Get(ctx, "float_slice").Result()
	if err != nil {
		log.Fatal("Failed to get float slice:", err)
	}
	fmt.Printf("Float slice: %v (type: %T)\n", floatResult, floatResult)

	// Delete operations
	fmt.Println("\n=== Delete Operations ===")
	
	if err := db.Delete(ctx, "age"); err != nil {
		log.Fatal("Failed to delete age:", err)
	}

	exists, err = db.Exists(ctx, "age")
	if err != nil {
		log.Fatal("Failed to check existence after delete:", err)
	}
	fmt.Printf("Age exists after delete: %t\n", exists)

	fmt.Println("\n=== Performance Test ===")
	
	// Simple performance test
	start := time.Now()
	for i := 0; i < 1000; i++ {
		key := fmt.Sprintf("perf:key:%d", i)
		if err := db.Set(ctx, key, i); err != nil {
			log.Fatal("Failed to set performance key:", err)
		}
	}
	
	setDuration := time.Since(start)
	fmt.Printf("Set 1000 keys in: %v (%.0f ops/sec)\n", 
		setDuration, 1000.0/setDuration.Seconds())

	start = time.Now()
	for i := 0; i < 1000; i++ {
		key := fmt.Sprintf("perf:key:%d", i)
		_, err := db.Get(ctx, key).Int()
		if err != nil {
			log.Fatal("Failed to get performance key:", err)
		}
	}
	
	getDuration := time.Since(start)
	fmt.Printf("Get 1000 keys in: %v (%.0f ops/sec)\n", 
		getDuration, 1000.0/getDuration.Seconds())

	fmt.Println("\nQDB demo completed successfully!")
}