rubydb 0.1.5 → 0.1.6

data/accelerator/internal/execution/value.go

@@ -0,0 +1,67 @@
+package execution
+
+import (
+	"encoding/json"
+	"fmt"
+	"math"
+	"strings"
+)
+
+func Compare(left, right interface{}) int {
+	if left == nil && right == nil {
+		return 0
+	}
+	if left == nil {
+		return -1
+	}
+	if right == nil {
+		return 1
+	}
+	if leftNumber, ok := NumberValue(left); ok {
+		if rightNumber, rightOK := NumberValue(right); rightOK {
+			switch {
+			case leftNumber < rightNumber:
+				return -1
+			case leftNumber > rightNumber:
+				return 1
+			default:
+				return 0
+			}
+		}
+	}
+	return strings.Compare(fmt.Sprint(left), fmt.Sprint(right))
+}
+
+func NumberValue(value interface{}) (float64, bool) {
+	switch number := value.(type) {
+	case json.Number:
+		parsed, err := number.Float64()
+		return parsed, err == nil
+	case float32:
+		return float64(number), !math.IsNaN(float64(number))
+	case float64:
+		return number, !math.IsNaN(number)
+	case int:
+		return float64(number), true
+	case int8:
+		return float64(number), true
+	case int16:
+		return float64(number), true
+	case int32:
+		return float64(number), true
+	case int64:
+		return float64(number), true
+	case uint:
+		return float64(number), true
+	case uint8:
+		return float64(number), true
+	case uint16:
+		return float64(number), true
+	case uint32:
+		return float64(number), true
+	case uint64:
+		return float64(number), true
+	default:
+		return 0, false
+	}
+}

data/accelerator/internal/memory/arena.go

@@ -0,0 +1,47 @@
+package memory
+
+type Arena struct {
+	blocks [][]byte
+	used   int
+}
+
+func NewArena(capacity int) *Arena {
+	if capacity < 1024 {
+		capacity = 1024
+	}
+	return &Arena{blocks: [][]byte{make([]byte, capacity)}}
+}
+
+func (arena *Arena) Bytes(size int) []byte {
+	if size < 0 {
+		size = 0
+	}
+	block := arena.blocks[len(arena.blocks)-1]
+	if arena.used+size > len(block) {
+		capacity := len(block) * 2
+		if capacity < size {
+			capacity = size
+		}
+		block = make([]byte, capacity)
+		arena.blocks = append(arena.blocks, block)
+		arena.used = 0
+	}
+	start := arena.used
+	arena.used += size
+	return block[start:arena.used]
+}
+
+func (arena *Arena) Reset() {
+	if len(arena.blocks) > 1 {
+		arena.blocks = arena.blocks[:1]
+	}
+	arena.used = 0
+}
+
+func (arena *Arena) Capacity() int {
+	total := 0
+	for _, block := range arena.blocks {
+		total += len(block)
+	}
+	return total
+}

data/accelerator/internal/memory/reuse.go

@@ -0,0 +1,22 @@
+package memory
+
+type BytesPool struct {
+	pool [][]byte
+}
+
+func (pool *BytesPool) Get(size int) []byte {
+	for index, candidate := range pool.pool {
+		if cap(candidate) >= size {
+			pool.pool = append(pool.pool[:index], pool.pool[index+1:]...)
+			return candidate[:size]
+		}
+	}
+	return make([]byte, size)
+}
+
+func (pool *BytesPool) Put(buffer []byte) {
+	if buffer == nil {
+		return
+	}
+	pool.pool = append(pool.pool, buffer[:0])
+}

data/accelerator/internal/metrics/registry.go

@@ -0,0 +1,67 @@
+package metrics
+
+import (
+	"sync"
+	"time"
+)
+
+type Sample struct {
+	Count int64   `json:"count"`
+	Total float64 `json:"total_ms"`
+	P50   float64 `json:"p50_ms"`
+	P95   float64 `json:"p95_ms"`
+	P99   float64 `json:"p99_ms"`
+}
+
+type Registry struct {
+	mu      sync.Mutex
+	counts  map[string]int64
+	totals  map[string]float64
+	samples map[string][]float64
+}
+
+func NewRegistry() *Registry {
+	return &Registry{counts: map[string]int64{}, totals: map[string]float64{}, samples: map[string][]float64{}}
+}
+
+func (registry *Registry) Observe(operation string, duration time.Duration) {
+	registry.mu.Lock()
+	defer registry.mu.Unlock()
+	ms := float64(duration) / float64(time.Millisecond)
+	registry.counts[operation]++
+	registry.totals[operation] += ms
+	values := registry.samples[operation]
+	if len(values) >= 1024 {
+		copy(values, values[1:])
+		values = values[:1023]
+	}
+	registry.samples[operation] = append(values, ms)
+}
+
+func (registry *Registry) Snapshot() map[string]Sample {
+	registry.mu.Lock()
+	defer registry.mu.Unlock()
+	result := make(map[string]Sample, len(registry.counts))
+	for operation, count := range registry.counts {
+		values := append([]float64(nil), registry.samples[operation]...)
+		for index := 1; index < len(values); index++ {
+			value := values[index]
+			position := index - 1
+			for position >= 0 && values[position] > value {
+				values[position+1] = values[position]
+				position--
+			}
+			values[position+1] = value
+		}
+		p50, p95, p99 := float64(0), float64(0), float64(0)
+		if len(values) > 0 {
+			p50 = values[int(float64(len(values)-1)*0.50)]
+			position := int(float64(len(values)-1) * 0.95)
+			p95 = values[position]
+			position = int(float64(len(values)-1) * 0.99)
+			p99 = values[position]
+		}
+		result[operation] = Sample{Count: count, Total: registry.totals[operation], P50: p50, P95: p95, P99: p99}
+	}
+	return result
+}

data/accelerator/internal/parallel/bounded_queue.go

@@ -0,0 +1,56 @@
+package parallel
+
+import (
+	"context"
+	"errors"
+)
+
+var ErrQueueClosed = errors.New("bounded queue is closed")
+
+type BoundedQueue[T any] struct {
+	items  chan T
+	closed chan struct{}
+}
+
+func NewBoundedQueue[T any](capacity int) *BoundedQueue[T] {
+	if capacity < 1 {
+		capacity = 1
+	}
+	return &BoundedQueue[T]{items: make(chan T, capacity), closed: make(chan struct{})}
+}
+
+func (queue *BoundedQueue[T]) Push(ctx context.Context, item T) error {
+	select {
+	case <-queue.closed:
+		return ErrQueueClosed
+	case <-ctx.Done():
+		return ctx.Err()
+	case queue.items <- item:
+		return nil
+	}
+}
+
+func (queue *BoundedQueue[T]) Pop(ctx context.Context) (T, error) {
+	var zero T
+	select {
+	case item := <-queue.items:
+		return item, nil
+	case <-queue.closed:
+		select {
+		case item := <-queue.items:
+			return item, nil
+		default:
+			return zero, ErrQueueClosed
+		}
+	case <-ctx.Done():
+		return zero, ctx.Err()
+	}
+}
+
+func (queue *BoundedQueue[T]) Close() {
+	select {
+	case <-queue.closed:
+	default:
+		close(queue.closed)
+	}
+}

data/accelerator/internal/parallel/scheduler.go

@@ -0,0 +1,47 @@
+package parallel
+
+import (
+	"runtime"
+	"sync"
+)
+
+func ChunkCount(items int) int {
+	if items <= 0 {
+		return 0
+	}
+	workers := runtime.GOMAXPROCS(0)
+	if workers < 2 {
+		workers = 2
+	}
+	if workers > items {
+		workers = items
+	}
+	return workers
+}
+
+// ForEachChunk preserves result order by giving each callback a stable index.
+// The caller owns result storage; callbacks must only write their own index.
+func ForEachChunk(items int, callback func(index, start, end int)) {
+	workers := ChunkCount(items)
+	if workers == 0 {
+		return
+	}
+	chunkSize := (items + workers - 1) / workers
+	var wait sync.WaitGroup
+	for index := 0; index < workers; index++ {
+		start := index * chunkSize
+		end := start + chunkSize
+		if end > items {
+			end = items
+		}
+		if start >= end {
+			continue
+		}
+		wait.Add(1)
+		go func(index, start, end int) {
+			defer wait.Done()
+			callback(index, start, end)
+		}(index, start, end)
+	}
+	wait.Wait()
+}

data/accelerator/internal/parallel/worker_pool.go

@@ -0,0 +1,53 @@
+package parallel
+
+import (
+	"context"
+	"sync"
+)
+
+type WorkerPool struct {
+	queue  *BoundedQueue[func()]
+	wait   sync.WaitGroup
+	closed chan struct{}
+}
+
+func NewWorkerPool(workers, queueSize int) *WorkerPool {
+	if workers < 1 {
+		workers = 1
+	}
+	pool := &WorkerPool{queue: NewBoundedQueue[func()](queueSize), closed: make(chan struct{})}
+	for index := 0; index < workers; index++ {
+		pool.wait.Add(1)
+		go func() {
+			defer pool.wait.Done()
+			for {
+				job, err := pool.queue.Pop(context.Background())
+				if err != nil {
+					return
+				}
+				job()
+			}
+		}()
+	}
+	return pool
+}
+
+func (pool *WorkerPool) Submit(ctx context.Context, job func()) error {
+	select {
+	case <-pool.closed:
+		return ErrQueueClosed
+	default:
+	}
+	return pool.queue.Push(ctx, job)
+}
+
+func (pool *WorkerPool) Close() {
+	select {
+	case <-pool.closed:
+		return
+	default:
+		close(pool.closed)
+		pool.queue.Close()
+		pool.wait.Wait()
+	}
+}

data/accelerator/internal/protocol/cancellation.go

@@ -0,0 +1,48 @@
+package protocol
+
+import (
+	"context"
+	"sync"
+)
+
+// CancellationRegistry gives the runtime a bounded, request-scoped context
+// registry. A future multiplexed transport can cancel a running request by
+// ID without changing the physical execution APIs.
+type CancellationRegistry struct {
+	mu      sync.Mutex
+	entries map[string]context.CancelFunc
+}
+
+func NewCancellationRegistry() *CancellationRegistry {
+	return &CancellationRegistry{entries: make(map[string]context.CancelFunc)}
+}
+
+func (registry *CancellationRegistry) Begin(parent context.Context, id string) context.Context {
+	ctx, cancel := context.WithCancel(parent)
+	registry.mu.Lock()
+	if previous, exists := registry.entries[id]; exists {
+		previous()
+	}
+	registry.entries[id] = cancel
+	registry.mu.Unlock()
+	return ctx
+}
+
+func (registry *CancellationRegistry) Cancel(id string) bool {
+	registry.mu.Lock()
+	cancel, exists := registry.entries[id]
+	if exists {
+		delete(registry.entries, id)
+	}
+	registry.mu.Unlock()
+	if exists {
+		cancel()
+	}
+	return exists
+}
+
+func (registry *CancellationRegistry) Finish(id string) {
+	registry.mu.Lock()
+	delete(registry.entries, id)
+	registry.mu.Unlock()
+}

data/accelerator/internal/protocol/columnar.go

@@ -0,0 +1,263 @@
+package protocol
+
+import (
+	"bytes"
+	"encoding/binary"
+	"encoding/json"
+	"errors"
+	"math"
+)
+
+func EncodeRows(rows []map[string]interface{}) ([]byte, error) {
+	columns := make([]string, 0)
+	known := make(map[string]bool)
+	for _, row := range rows {
+		for key := range row {
+			if !known[key] {
+				known[key] = true
+				columns = append(columns, key)
+			}
+		}
+	}
+	if len(columns) > math.MaxUint16 || uint64(len(rows)) > math.MaxUint32 {
+		return nil, errors.New("binary rows batch is too large")
+	}
+	output := bytes.NewBuffer(make([]byte, 0, 6+len(columns)*16))
+	writeUint16(output, uint16(len(columns)))
+	writeUint32(output, uint32(len(rows)))
+	for _, column := range columns {
+		if len(column) > math.MaxUint16 {
+			return nil, errors.New("binary row column name is too long")
+		}
+		writeUint16(output, uint16(len(column)))
+		output.WriteString(column)
+	}
+	for _, column := range columns {
+		for _, row := range rows {
+			if err := encodeValue(output, row[column]); err != nil {
+				return nil, err
+			}
+		}
+	}
+	return output.Bytes(), nil
+}
+
+func DecodeRows(data []byte) ([]map[string]interface{}, error) {
+	reader := newValueReader(data)
+	columnCount, err := reader.uint16()
+	if err != nil {
+		return nil, errors.New("binary rows batch is truncated")
+	}
+	rowCount, err := reader.uint32()
+	if err != nil {
+		return nil, errors.New("binary rows batch is truncated")
+	}
+	columns := make([]string, columnCount)
+	for index := range columns {
+		name, err := reader.string16()
+		if err != nil {
+			return nil, errors.New("binary row column metadata is invalid")
+		}
+		columns[index] = name
+	}
+	rows := make([]map[string]interface{}, rowCount)
+	for index := range rows {
+		rows[index] = make(map[string]interface{}, columnCount)
+	}
+	for _, column := range columns {
+		for rowIndex := range rows {
+			value, err := reader.value()
+			if err != nil {
+				return nil, errors.New("binary row value is invalid")
+			}
+			rows[rowIndex][column] = value
+		}
+	}
+	if reader.remaining() != 0 {
+		return nil, errors.New("binary rows batch has trailing bytes")
+	}
+	return rows, nil
+}
+
+func encodeValue(output *bytes.Buffer, value interface{}) error {
+	switch typed := value.(type) {
+	case nil:
+		output.WriteByte(0)
+	case bool:
+		output.WriteByte(1)
+		if typed {
+			output.WriteByte(1)
+		} else {
+			output.WriteByte(0)
+		}
+	case json.Number:
+		if integer, err := typed.Int64(); err == nil {
+			output.WriteByte(2)
+			writeInt64(output, integer)
+		} else if number, err := typed.Float64(); err == nil {
+			output.WriteByte(3)
+			writeFloat64(output, number)
+		} else {
+			return errors.New("invalid numeric value")
+		}
+	case int:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case int8:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case int16:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case int32:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case int64:
+		output.WriteByte(2)
+		writeInt64(output, typed)
+	case uint:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case uint8:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case uint16:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case uint32:
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case uint64:
+		if typed > math.MaxInt64 {
+			return errors.New("unsigned numeric value is too large")
+		}
+		output.WriteByte(2)
+		writeInt64(output, int64(typed))
+	case float32:
+		output.WriteByte(3)
+		writeFloat64(output, float64(typed))
+	case float64:
+		output.WriteByte(3)
+		writeFloat64(output, typed)
+	case []byte:
+		output.WriteByte(5)
+		writeBytes(output, typed)
+	case string:
+		output.WriteByte(4)
+		writeBytes(output, []byte(typed))
+	default:
+		encoded, err := json.Marshal(value)
+		if err != nil {
+			return errors.New("value is not serializable")
+		}
+		output.WriteByte(6)
+		writeBytes(output, encoded)
+	}
+	return nil
+}
+
+type valueReader struct {
+	data   []byte
+	offset int
+}
+
+func newValueReader(data []byte) *valueReader { return &valueReader{data: data} }
+func (reader *valueReader) remaining() int    { return len(reader.data) - reader.offset }
+
+func (reader *valueReader) take(length int) ([]byte, error) {
+	if length < 0 || reader.remaining() < length {
+		return nil, errors.New("binary value is truncated")
+	}
+	value := reader.data[reader.offset : reader.offset+length]
+	reader.offset += length
+	return value, nil
+}
+
+func (reader *valueReader) uint16() (uint16, error) {
+	value, err := reader.take(2)
+	if err != nil {
+		return 0, err
+	}
+	return binary.LittleEndian.Uint16(value), nil
+}
+
+func (reader *valueReader) uint32() (uint32, error) {
+	value, err := reader.take(4)
+	if err != nil {
+		return 0, err
+	}
+	return binary.LittleEndian.Uint32(value), nil
+}
+
+func (reader *valueReader) string16() (string, error) {
+	length, err := reader.uint16()
+	if err != nil {
+		return "", err
+	}
+	value, err := reader.take(int(length))
+	return string(value), err
+}
+
+func (reader *valueReader) value() (interface{}, error) {
+	tag, err := reader.take(1)
+	if err != nil {
+		return nil, err
+	}
+	switch tag[0] {
+	case 0:
+		return nil, nil
+	case 1:
+		value, err := reader.take(1)
+		return value[0] == 1, err
+	case 2:
+		value, err := reader.take(8)
+		if err != nil {
+			return nil, err
+		}
+		return int64(binary.LittleEndian.Uint64(value)), nil
+	case 3:
+		value, err := reader.take(8)
+		if err != nil {
+			return nil, err
+		}
+		return math.Float64frombits(binary.LittleEndian.Uint64(value)), nil
+	case 4, 5, 6:
+		length, err := reader.uint32()
+		if err != nil {
+			return nil, err
+		}
+		value, err := reader.take(int(length))
+		if err != nil {
+			return nil, err
+		}
+		if tag[0] == 4 {
+			return string(value), nil
+		}
+		if tag[0] == 5 {
+			return append([]byte(nil), value...), nil
+		}
+		var decoded interface{}
+		if err := json.Unmarshal(value, &decoded); err != nil {
+			return nil, err
+		}
+		return decoded, nil
+	default:
+		return nil, errors.New("unknown binary value tag")
+	}
+}
+
+func writeUint16(output *bytes.Buffer, value uint16) {
+	_ = binary.Write(output, binary.LittleEndian, value)
+}
+func writeUint32(output *bytes.Buffer, value uint32) {
+	_ = binary.Write(output, binary.LittleEndian, value)
+}
+func writeBytes(output *bytes.Buffer, value []byte) {
+	writeUint32(output, uint32(len(value)))
+	output.Write(value)
+}
+func writeInt64(output *bytes.Buffer, value int64)     { writeUint64(output, uint64(value)) }
+func writeFloat64(output *bytes.Buffer, value float64) { writeUint64(output, math.Float64bits(value)) }
+func writeUint64(output *bytes.Buffer, value uint64) {
+	_ = binary.Write(output, binary.LittleEndian, value)
+}