538 lines
15 KiB
Go
538 lines
15 KiB
Go
package main
|
||
|
||
import (
|
||
"encoding/json"
|
||
"fmt"
|
||
"log"
|
||
"os"
|
||
"sort"
|
||
"strconv"
|
||
"strings"
|
||
"time"
|
||
|
||
"linedb/pkg/linedb"
|
||
)
|
||
|
||
// User представляет пользователя
|
||
type User struct {
|
||
ID int `json:"id"`
|
||
Username string `json:"username"`
|
||
Email string `json:"email"`
|
||
IsActive bool `json:"isActive"`
|
||
Role string `json:"role"`
|
||
CreatedAt int64 `json:"createdAt"`
|
||
}
|
||
|
||
// Product представляет продукт
|
||
type Product struct {
|
||
ID int `json:"id"`
|
||
Name string `json:"name"`
|
||
Price float64 `json:"price"`
|
||
Category string `json:"category"`
|
||
InStock bool `json:"inStock"`
|
||
SellerID int `json:"sellerId"`
|
||
CreatedAt int64 `json:"createdAt"`
|
||
}
|
||
|
||
func main() {
|
||
// Очищаем тестовые данные
|
||
os.RemoveAll("./data/test-linedb-custom-json")
|
||
|
||
fmt.Println("=== LineDb Custom JSON Serialization Demo ===")
|
||
|
||
// Получаем номера тестов из аргументов командной строки
|
||
testNumbers := parseTestNumbers()
|
||
|
||
// Выполняем тесты
|
||
if len(testNumbers) == 0 {
|
||
// Если номера не указаны, выполняем все тесты
|
||
runAllTests()
|
||
} else {
|
||
// Выполняем только указанные тесты
|
||
runSelectedTests(testNumbers)
|
||
}
|
||
|
||
fmt.Println("\n=== Все тесты завершены ===")
|
||
}
|
||
|
||
// parseTestNumbers парсит номера тестов из аргументов командной строки
|
||
func parseTestNumbers() []int {
|
||
if len(os.Args) < 2 {
|
||
return []int{}
|
||
}
|
||
|
||
// Получаем аргумент после имени программы
|
||
arg := os.Args[1]
|
||
|
||
// Проверяем, что это не флаг помощи
|
||
if arg == "-h" || arg == "--help" || arg == "help" {
|
||
printUsage()
|
||
return []int{}
|
||
}
|
||
|
||
// Разбиваем по запятой
|
||
parts := strings.Split(arg, ",")
|
||
var numbers []int
|
||
|
||
for _, part := range parts {
|
||
part = strings.TrimSpace(part)
|
||
if part == "" {
|
||
continue
|
||
}
|
||
|
||
num, err := strconv.Atoi(part)
|
||
if err != nil {
|
||
fmt.Printf("Ошибка: '%s' не является числом\n", part)
|
||
printUsage()
|
||
return []int{}
|
||
}
|
||
|
||
// Проверяем диапазон
|
||
if num < 1 || num > 4 {
|
||
fmt.Printf("Ошибка: номер теста %d должен быть от 1 до 4\n", num)
|
||
printUsage()
|
||
return []int{}
|
||
}
|
||
|
||
numbers = append(numbers, num)
|
||
}
|
||
|
||
return numbers
|
||
}
|
||
|
||
// printUsage выводит справку по использованию
|
||
func printUsage() {
|
||
fmt.Println("\nИспользование:")
|
||
fmt.Println(" go run main.go # Запустить все тесты")
|
||
fmt.Println(" go run main.go 1 # Запустить только тест 1")
|
||
fmt.Println(" go run main.go 1,3 # Запустить тесты 1 и 3")
|
||
fmt.Println(" go run main.go 2,3,4 # Запустить тесты 2, 3 и 4")
|
||
fmt.Println(" go run main.go help # Показать эту справку")
|
||
fmt.Println("\nДоступные тесты:")
|
||
fmt.Println(" 1 - Использование go-json (по умолчанию)")
|
||
fmt.Println(" 2 - Использование стандартного encoding/json")
|
||
fmt.Println(" 3 - Использование кастомной функции сериализации")
|
||
fmt.Println(" 4 - ID всегда первое поле")
|
||
os.Exit(0)
|
||
}
|
||
|
||
// runAllTests запускает все тесты
|
||
func runAllTests() {
|
||
testDefaultJSON()
|
||
testStandardJSON()
|
||
testCustomJSON()
|
||
testIDFirstField()
|
||
}
|
||
|
||
// runSelectedTests запускает только выбранные тесты
|
||
func runSelectedTests(numbers []int) {
|
||
for _, num := range numbers {
|
||
switch num {
|
||
case 1:
|
||
fmt.Println("1. Использование go-json (по умолчанию)")
|
||
testDefaultJSON()
|
||
case 2:
|
||
fmt.Println("2. Использование стандартного encoding/json")
|
||
testStandardJSON()
|
||
case 3:
|
||
fmt.Println("3. Использование кастомной функции сериализации")
|
||
testCustomJSON()
|
||
case 4:
|
||
fmt.Println("4. ID всегда первое поле")
|
||
testIDFirstField()
|
||
}
|
||
}
|
||
}
|
||
|
||
func testDefaultJSON() {
|
||
// Создаем опции инициализации с go-json (по умолчанию)
|
||
initOptions := &linedb.LineDbInitOptions{
|
||
CacheSize: 1000,
|
||
CacheTTL: 10 * time.Second,
|
||
DBFolder: "./data/test-linedb-custom-json/default",
|
||
Collections: []linedb.JSONLFileOptions{
|
||
{
|
||
CollectionName: "users",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "username"},
|
||
},
|
||
},
|
||
}
|
||
|
||
// Создаем базу данных
|
||
db := linedb.NewLineDb(nil)
|
||
|
||
// Инициализируем базу данных
|
||
if err := db.Init(true, initOptions); err != nil {
|
||
log.Printf("Failed to init database: %v", err)
|
||
return
|
||
}
|
||
defer db.Close()
|
||
|
||
// Создаем пользователя
|
||
user := map[string]any{
|
||
"id": 1,
|
||
"username": "default_user",
|
||
"email": "default@example.com",
|
||
"isActive": true,
|
||
"role": "user",
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Вставляем данные
|
||
if err := db.Insert(user, "users", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert user: %v", err)
|
||
return
|
||
}
|
||
|
||
// Читаем данные
|
||
result, err := db.Read("users", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read users: %v", err)
|
||
return
|
||
}
|
||
|
||
fmt.Printf(" Пользователей в базе: %d\n", len(result))
|
||
if len(result) > 0 {
|
||
if record, ok := result[0].(map[string]any); ok {
|
||
fmt.Printf(" ID: %v, Username: %s\n", record["id"], record["username"])
|
||
}
|
||
}
|
||
}
|
||
|
||
func testStandardJSON() {
|
||
// Создаем функции сериализации с использованием стандартного encoding/json
|
||
standardJSONMarshal := func(v any) ([]byte, error) {
|
||
return json.Marshal(v)
|
||
}
|
||
|
||
standardJSONUnmarshal := func(data []byte, v any) error {
|
||
return json.Unmarshal(data, v)
|
||
}
|
||
|
||
// Создаем опции инициализации со стандартным JSON
|
||
initOptions := &linedb.LineDbInitOptions{
|
||
CacheSize: 1000,
|
||
CacheTTL: 10 * time.Second,
|
||
DBFolder: "./data/test-linedb-custom-json/standard",
|
||
Collections: []linedb.JSONLFileOptions{
|
||
{
|
||
CollectionName: "users",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "username"},
|
||
JSONMarshal: standardJSONMarshal,
|
||
JSONUnmarshal: standardJSONUnmarshal,
|
||
},
|
||
},
|
||
}
|
||
|
||
// Создаем базу данных
|
||
db := linedb.NewLineDb(nil)
|
||
|
||
// Инициализируем базу данных
|
||
if err := db.Init(true, initOptions); err != nil {
|
||
log.Printf("Failed to init database: %v", err)
|
||
return
|
||
}
|
||
defer db.Close()
|
||
|
||
// Создаем пользователя
|
||
user := map[string]any{
|
||
"id": 2,
|
||
"username": "standard_user",
|
||
"email": "standard@example.com",
|
||
"isActive": true,
|
||
"role": "admin",
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Вставляем данные
|
||
if err := db.Insert(user, "users", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert user: %v", err)
|
||
return
|
||
}
|
||
|
||
// Читаем данные
|
||
result, err := db.Read("users", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read users: %v", err)
|
||
return
|
||
}
|
||
|
||
fmt.Printf(" Пользователей в базе: %d\n", len(result))
|
||
if len(result) > 0 {
|
||
if record, ok := result[0].(map[string]any); ok {
|
||
fmt.Printf(" ID: %v, Username: %s\n", record["id"], record["username"])
|
||
}
|
||
}
|
||
}
|
||
|
||
func testCustomJSON() {
|
||
// Создаем кастомные функции сериализации с дополнительной логикой
|
||
customJSONMarshal := func(v any) ([]byte, error) {
|
||
// Добавляем метаданные к сериализации
|
||
data := map[string]any{
|
||
"data": v,
|
||
"timestamp": time.Now().Unix(),
|
||
"version": "1.0",
|
||
}
|
||
return json.Marshal(data)
|
||
}
|
||
|
||
customJSONUnmarshal := func(data []byte, v any) error {
|
||
// Извлекаем данные из кастомного формата
|
||
var wrapper map[string]any
|
||
if err := json.Unmarshal(data, &wrapper); err != nil {
|
||
return err
|
||
}
|
||
|
||
// Извлекаем основную часть данных
|
||
if dataField, exists := wrapper["data"]; exists {
|
||
// Сериализуем обратно в JSON и десериализуем в целевой тип
|
||
dataBytes, err := json.Marshal(dataField)
|
||
if err != nil {
|
||
return err
|
||
}
|
||
return json.Unmarshal(dataBytes, v)
|
||
}
|
||
|
||
// Если нет поля data, пытаемся десериализовать как обычный JSON
|
||
return json.Unmarshal(data, v)
|
||
}
|
||
|
||
// Создаем опции инициализации с кастомными функциями
|
||
initOptions := &linedb.LineDbInitOptions{
|
||
CacheSize: 1000,
|
||
CacheTTL: 10 * time.Second,
|
||
DBFolder: "./data/test-linedb-custom-json/custom",
|
||
Collections: []linedb.JSONLFileOptions{
|
||
{
|
||
CollectionName: "users",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "username"},
|
||
JSONMarshal: customJSONMarshal,
|
||
JSONUnmarshal: customJSONUnmarshal,
|
||
},
|
||
{
|
||
CollectionName: "products",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "name"},
|
||
JSONMarshal: customJSONMarshal,
|
||
JSONUnmarshal: customJSONUnmarshal,
|
||
},
|
||
},
|
||
}
|
||
|
||
// Создаем базу данных
|
||
db := linedb.NewLineDb(nil)
|
||
|
||
// Инициализируем базу данных
|
||
if err := db.Init(true, initOptions); err != nil {
|
||
log.Printf("Failed to init database: %v", err)
|
||
return
|
||
}
|
||
defer db.Close()
|
||
|
||
// Создаем пользователя
|
||
user := map[string]any{
|
||
"id": 3,
|
||
"username": "custom_user",
|
||
"email": "custom@example.com",
|
||
"isActive": true,
|
||
"role": "moderator",
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Создаем продукт
|
||
product := map[string]any{
|
||
"id": 1,
|
||
"name": "Custom Product",
|
||
"price": 99.99,
|
||
"category": "Electronics",
|
||
"inStock": true,
|
||
"sellerId": 1,
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Вставляем данные
|
||
if err := db.Insert(user, "users", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert user: %v", err)
|
||
return
|
||
}
|
||
|
||
if err := db.Insert(product, "products", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert product: %v", err)
|
||
return
|
||
}
|
||
|
||
// Читаем данные
|
||
users, err := db.Read("users", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read users: %v", err)
|
||
return
|
||
}
|
||
|
||
products, err := db.Read("products", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read products: %v", err)
|
||
return
|
||
}
|
||
|
||
fmt.Printf(" Пользователей в базе: %d\n", len(users))
|
||
fmt.Printf(" Продуктов в базе: %d\n", len(products))
|
||
|
||
if len(users) > 0 {
|
||
if record, ok := users[0].(map[string]any); ok {
|
||
fmt.Printf(" Пользователь ID: %v, Username: %s\n", record["id"], record["username"])
|
||
}
|
||
}
|
||
|
||
if len(products) > 0 {
|
||
if record, ok := products[0].(map[string]any); ok {
|
||
fmt.Printf(" Продукт ID: %v, Name: %s, Price: %v\n", record["id"], record["name"], record["price"])
|
||
}
|
||
}
|
||
}
|
||
|
||
func testIDFirstField() {
|
||
// Создаем функции сериализации где id всегда первое поле
|
||
idFirstJSONMarshal := func(v any) ([]byte, error) {
|
||
if data, ok := v.(map[string]any); ok {
|
||
var parts []string
|
||
|
||
// Сначала добавляем id если он есть
|
||
if id, exists := data["id"]; exists {
|
||
idBytes, err := json.Marshal(id)
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
parts = append(parts, fmt.Sprintf(`"id":%s`, string(idBytes)))
|
||
}
|
||
|
||
// Затем добавляем все остальные поля в алфавитном порядке
|
||
var keys []string
|
||
for key := range data {
|
||
if key != "id" {
|
||
keys = append(keys, key)
|
||
}
|
||
}
|
||
sort.Strings(keys)
|
||
|
||
for _, key := range keys {
|
||
valueBytes, err := json.Marshal(data[key])
|
||
if err != nil {
|
||
return nil, err
|
||
}
|
||
parts = append(parts, fmt.Sprintf(`"%s":%s`, key, string(valueBytes)))
|
||
}
|
||
|
||
jsonStr := "{" + strings.Join(parts, ",") + "}"
|
||
return []byte(jsonStr), nil
|
||
}
|
||
|
||
// Если это не map, используем стандартную сериализацию
|
||
return json.Marshal(v)
|
||
}
|
||
|
||
idFirstJSONUnmarshal := func(data []byte, v any) error {
|
||
return json.Unmarshal(data, v)
|
||
}
|
||
|
||
// Создаем опции инициализации с функциями id-first
|
||
initOptions := &linedb.LineDbInitOptions{
|
||
CacheSize: 1000,
|
||
CacheTTL: 10 * time.Second,
|
||
DBFolder: "./data/test-linedb-custom-json/id-first",
|
||
Collections: []linedb.JSONLFileOptions{
|
||
{
|
||
CollectionName: "users",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "username"},
|
||
JSONMarshal: idFirstJSONMarshal,
|
||
JSONUnmarshal: idFirstJSONUnmarshal,
|
||
},
|
||
{
|
||
CollectionName: "products",
|
||
AllocSize: 256,
|
||
IndexedFields: []string{"id", "name"},
|
||
JSONMarshal: idFirstJSONMarshal,
|
||
JSONUnmarshal: idFirstJSONUnmarshal,
|
||
},
|
||
},
|
||
}
|
||
|
||
// Создаем базу данных
|
||
db := linedb.NewLineDb(nil)
|
||
|
||
// Инициализируем базу данных
|
||
if err := db.Init(true, initOptions); err != nil {
|
||
log.Printf("Failed to init database: %v", err)
|
||
return
|
||
}
|
||
defer db.Close()
|
||
|
||
// Создаем пользователя (id не первое поле в исходных данных)
|
||
user := map[string]any{
|
||
"username": "id_first_user",
|
||
"email": "id_first@example.com",
|
||
"id": 1,
|
||
"isActive": true,
|
||
"role": "user",
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Создаем продукт (id не первое поле в исходных данных)
|
||
product := map[string]any{
|
||
"name": "ID First Product",
|
||
"price": 123.45,
|
||
"id": 2,
|
||
"category": "Books",
|
||
"inStock": false,
|
||
"sellerId": 1,
|
||
"createdAt": time.Now().Unix(),
|
||
}
|
||
|
||
// Вставляем данные
|
||
if err := db.Insert(user, "users", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert user: %v", err)
|
||
return
|
||
}
|
||
|
||
if err := db.Insert(product, "products", linedb.LineDbAdapterOptions{}); err != nil {
|
||
log.Printf("Failed to insert product: %v", err)
|
||
return
|
||
}
|
||
|
||
// Читаем данные
|
||
users, err := db.Read("users", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read users: %v", err)
|
||
return
|
||
}
|
||
|
||
products, err := db.Read("products", linedb.LineDbAdapterOptions{})
|
||
if err != nil {
|
||
log.Printf("Failed to read products: %v", err)
|
||
return
|
||
}
|
||
|
||
fmt.Printf(" Пользователей в базе: %d\n", len(users))
|
||
fmt.Printf(" Продуктов в базе: %d\n", len(products))
|
||
|
||
if len(users) > 0 {
|
||
if record, ok := users[0].(map[string]any); ok {
|
||
fmt.Printf(" Пользователь ID: %v, Username: %s\n", record["id"], record["username"])
|
||
}
|
||
}
|
||
|
||
if len(products) > 0 {
|
||
if record, ok := products[0].(map[string]any); ok {
|
||
fmt.Printf(" Продукт ID: %v, Name: %s, Price: %v\n", record["id"], record["name"], record["price"])
|
||
}
|
||
}
|
||
|
||
// Показываем содержимое файла для демонстрации
|
||
fmt.Println(" Проверьте файл ./data/test-linedb-custom-json/id-first/users.jsonl")
|
||
fmt.Println(" Поле 'id' должно быть первым в JSON строке")
|
||
}
|