rubydb 0.1.4 → 0.1.6

data/accelerator/internal/execution/operators.go

@@ -0,0 +1,167 @@
+package execution
+
+import (
+	"context"
+	"fmt"
+	"sort"
+)
+
+func ProjectRows(rows []map[string]interface{}, columns []string) []map[string]interface{} {
+	result := make([]map[string]interface{}, 0, len(rows))
+	for _, row := range rows {
+		projected := make(map[string]interface{}, len(columns))
+		for _, column := range columns {
+			projected[column] = row[column]
+		}
+		result = append(result, projected)
+	}
+	return result
+}
+
+func SortRowsContext(ctx context.Context, rows []map[string]interface{}, orderBy []Order) error {
+	cancelled := false
+	sort.SliceStable(rows, func(left, right int) bool {
+		select {
+		case <-ctx.Done():
+			cancelled = true
+			return false
+		default:
+		}
+		for _, item := range orderBy {
+			comparison := Compare(rows[left][item.Column], rows[right][item.Column])
+			if comparison == 0 {
+				continue
+			}
+			if equalFold(item.Direction, "desc") {
+				return comparison > 0
+			}
+			return comparison < 0
+		}
+		return false
+	})
+	if cancelled {
+		return ctx.Err()
+	}
+	return nil
+}
+
+func ApplyWindowsContext(ctx context.Context, rows []map[string]interface{}, windows []Window) ([]map[string]interface{}, error) {
+	for _, definition := range windows {
+		if err := applyWindowContext(ctx, rows, definition); err != nil {
+			return nil, err
+		}
+	}
+	return rows, nil
+}
+
+func applyWindowContext(ctx context.Context, rows []map[string]interface{}, definition Window) error {
+	partitions := map[string][]map[string]interface{}{}
+	for _, row := range rows {
+		select {
+		case <-ctx.Done():
+			return ctx.Err()
+		default:
+		}
+		values := make([]interface{}, len(definition.PartitionBy))
+		for index, column := range definition.PartitionBy {
+			values[index] = row[column]
+		}
+		key := JoinKey(values)
+		partitions[key] = append(partitions[key], row)
+	}
+	for _, partition := range partitions {
+		if err := SortRowsContext(ctx, partition, definition.OrderBy); err != nil {
+			return err
+		}
+		for index, row := range partition {
+			select {
+			case <-ctx.Done():
+				return ctx.Err()
+			default:
+			}
+			value, err := windowValue(definition, partition, index)
+			if err != nil {
+				return err
+			}
+			alias := definition.Alias
+			if alias == "" {
+				alias = definition.Function
+			}
+			row[alias] = value
+		}
+	}
+	return nil
+}
+
+func windowValue(definition Window, partition []map[string]interface{}, index int) (interface{}, error) {
+	switch normalizeFunction(definition.Function) {
+	case "ROW_NUMBER":
+		return int64(index + 1), nil
+	case "RANK":
+		if index == 0 || len(definition.OrderBy) == 0 {
+			return int64(index + 1), nil
+		}
+		rank := 1
+		for previous := 1; previous <= index; previous++ {
+			if compareOrderRow(partition[previous-1], partition[previous], definition.OrderBy) != 0 {
+				rank = previous + 1
+			}
+		}
+		return int64(rank), nil
+	case "DENSE_RANK":
+		rank := 1
+		for previous := 1; previous <= index; previous++ {
+			if compareOrderRow(partition[previous-1], partition[previous], definition.OrderBy) != 0 {
+				rank++
+			}
+		}
+		return int64(rank), nil
+	case "LAG", "LEAD":
+		delta := -1
+		if normalizeFunction(definition.Function) == "LEAD" {
+			delta = 1
+		}
+		position := index + delta
+		if position < 0 || position >= len(partition) {
+			return nil, nil
+		}
+		return partition[position][definition.Column], nil
+	case "COUNT":
+		count := int64(0)
+		for _, row := range partition {
+			if definition.Column == "*" || row[definition.Column] != nil {
+				count++
+			}
+		}
+		return count, nil
+	case "SUM", "AVG", "MIN", "MAX":
+		return AggregateValue(partition, Aggregate{Function: definition.Function, Column: definition.Column}), nil
+	default:
+		return nil, fmt.Errorf("unsupported window function %q", definition.Function)
+	}
+}
+
+func compareOrderRow(left, right map[string]interface{}, orderBy []Order) int {
+	for _, order := range orderBy {
+		comparison := Compare(left[order.Column], right[order.Column])
+		if comparison == 0 {
+			continue
+		}
+		if equalFold(order.Direction, "desc") {
+			return -comparison
+		}
+		return comparison
+	}
+	return 0
+}
+
+func normalizeFunction(value string) string {
+	result := make([]byte, 0, len(value))
+	for _, character := range value {
+		if character >= 'a' && character <= 'z' {
+			character -= 'a' - 'A'
+		}
+		result = append(result, byte(character))
+	}
+	return string(result)
+}

data/accelerator/internal/execution/scan.go

@@ -0,0 +1,20 @@
+package execution
+
+import "context"
+
+// FilterRowsContext is the cancellation-aware form used by server workers.
+// The non-context API remains intentionally small for the stdio protocol.
+func FilterRowsContext(ctx context.Context, rows []map[string]interface{}, condition Filter) ([]map[string]interface{}, error) {
+	filtered := make([]map[string]interface{}, 0, len(rows))
+	for _, row := range rows {
+		select {
+		case <-ctx.Done():
+			return nil, ctx.Err()
+		default:
+		}
+		if Matches(row[condition.Column], condition.Operator, condition.Value) {
+			filtered = append(filtered, row)
+		}
+	}
+	return filtered, nil
+}

data/accelerator/internal/execution/sort.go

@@ -0,0 +1,62 @@
+package execution
+
+import "sort"
+
+func SortRows(rows []map[string]interface{}, orderBy []Order) {
+	sort.SliceStable(rows, func(i, j int) bool {
+		for _, item := range orderBy {
+			comparison := Compare(rows[i][item.Column], rows[j][item.Column])
+			if comparison == 0 {
+				continue
+			}
+			if equalFold(item.Direction, "desc") {
+				return comparison > 0
+			}
+			return comparison < 0
+		}
+		return false
+	})
+}
+
+func ApplyWindow(rows []map[string]interface{}, offset int, limit *int) ([]map[string]interface{}, error) {
+	if offset < 0 {
+		return nil, ErrInvalidWindow("offset cannot be negative")
+	}
+	if limit != nil && *limit < 0 {
+		return nil, ErrInvalidWindow("limit cannot be negative")
+	}
+	if offset >= len(rows) {
+		return []map[string]interface{}{}, nil
+	}
+	if offset > 0 {
+		rows = rows[offset:]
+	}
+	if limit != nil && *limit < len(rows) {
+		rows = rows[:*limit]
+	}
+	return rows, nil
+}
+
+type invalidWindowError string
+
+func (err invalidWindowError) Error() string { return string(err) }
+func ErrInvalidWindow(message string) error  { return invalidWindowError(message) }
+
+func equalFold(left, right string) bool {
+	if len(left) != len(right) {
+		return false
+	}
+	for index := range left {
+		l, r := left[index], right[index]
+		if l >= 'A' && l <= 'Z' {
+			l += 'a' - 'A'
+		}
+		if r >= 'A' && r <= 'Z' {
+			r += 'a' - 'A'
+		}
+		if l != r {
+			return false
+		}
+	}
+	return true
+}

data/accelerator/internal/execution/types.go

@@ -0,0 +1,136 @@
+package execution
+
+import (
+	"context"
+	"encoding/json"
+)
+
+type RowsRequest struct {
+	Rows            []map[string]interface{} `json:"rows"`
+	Filters         []Filter                 `json:"filters,omitempty"`
+	OrderBy         []Order                  `json:"order_by,omitempty"`
+	GroupBy         []string                 `json:"group_by,omitempty"`
+	Aggregate       []Aggregate              `json:"aggregates,omitempty"`
+	Having          []Filter                 `json:"having,omitempty"`
+	Projection      []string                 `json:"projection,omitempty"`
+	Distinct        bool                     `json:"distinct,omitempty"`
+	DistinctColumns []string                 `json:"distinct_columns,omitempty"`
+	Windows         []Window                 `json:"windows,omitempty"`
+	BatchSize       int                      `json:"batch_size,omitempty"`
+	Limit           *int                     `json:"limit,omitempty"`
+	Offset          int                      `json:"offset,omitempty"`
+}
+
+type Filter struct {
+	Column   string      `json:"column"`
+	Operator string      `json:"operator"`
+	Value    interface{} `json:"value,omitempty"`
+}
+
+type Order struct {
+	Column    string `json:"column"`
+	Direction string `json:"direction,omitempty"`
+}
+
+type Aggregate struct {
+	Function string `json:"function"`
+	Column   string `json:"column,omitempty"`
+	Alias    string `json:"alias,omitempty"`
+}
+
+// Window describes the portable window subset used by the accelerator. Ruby
+// remains the authority for parsing and deciding whether this representation
+// is semantically safe to delegate.
+type Window struct {
+	Function    string   `json:"function"`
+	Column      string   `json:"column,omitempty"`
+	Alias       string   `json:"alias,omitempty"`
+	PartitionBy []string `json:"partition_by,omitempty"`
+	OrderBy     []Order  `json:"order_by,omitempty"`
+}
+
+type RowsResult struct {
+	Rows       []map[string]interface{}
+	Aggregates []map[string]interface{}
+}
+
+func (result RowsResult) AsMap() map[string]interface{} {
+	payload := map[string]interface{}{
+		"rows":      result.Rows,
+		"row_count": len(result.Rows),
+	}
+	if len(result.Aggregates) > 0 {
+		payload["aggregates"] = result.Aggregates
+	}
+	return payload
+}
+
+func ExecuteRowsPipeline(payload RowsRequest) (RowsResult, error) {
+	return ExecuteRowsPipelineContext(context.Background(), payload)
+}
+
+func ExecuteRowsPipelineContext(ctx context.Context, payload RowsRequest) (RowsResult, error) {
+	rows := payload.Rows
+	for _, condition := range payload.Filters {
+		filtered, err := FilterRowsContext(ctx, rows, condition)
+		if err != nil {
+			return RowsResult{}, err
+		}
+		rows = filtered
+	}
+	if len(payload.OrderBy) > 0 {
+		if err := SortRowsContext(ctx, rows, payload.OrderBy); err != nil {
+			return RowsResult{}, err
+		}
+	}
+	result := RowsResult{}
+	var aggregateRows []map[string]interface{}
+	if len(payload.Aggregate) > 0 {
+		aggregateRows = AggregateRows(rows, payload.GroupBy, payload.Aggregate)
+		for _, condition := range payload.Having {
+			filtered, err := FilterRowsContext(ctx, aggregateRows, condition)
+			if err != nil {
+				return RowsResult{}, err
+			}
+			aggregateRows = filtered
+		}
+		if len(payload.Projection) > 0 {
+			rows = aggregateRows
+		}
+	}
+	if payload.Distinct {
+		columns := payload.DistinctColumns
+		if len(columns) == 0 {
+			columns = payload.Projection
+		}
+		if len(columns) == 0 && len(rows) > 0 {
+			for column := range rows[0] {
+				columns = append(columns, column)
+			}
+		}
+		rows = DistinctRows(rows, columns)
+	}
+	if len(payload.Projection) > 0 {
+		rows = ProjectRows(rows, payload.Projection)
+	}
+	if len(payload.Windows) > 0 {
+		var err error
+		rows, err = ApplyWindowsContext(ctx, rows, payload.Windows)
+		if err != nil {
+			return RowsResult{}, err
+		}
+	}
+	rows, err := ApplyWindow(rows, payload.Offset, payload.Limit)
+	if err != nil {
+		return RowsResult{}, err
+	}
+	result.Rows = rows
+	if len(payload.Aggregate) > 0 {
+		result.Aggregates = aggregateRows
+	}
+	return result, nil
+}
+
+func MarshalRowsResult(result RowsResult) ([]byte, error) {
+	return json.Marshal(result.AsMap())
+}

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()
+}