rubydb 0.1.5 → 0.1.6

data/accelerator/cmd/rubydb-accelerator/main.go

@@ -0,0 +1,11 @@
+package main
+
+import (
+	"os"
+
+	acceleratorRuntime "github.com/aldanedev-create/rubydb/accelerator/internal/runtime"
+)
+
+func main() {
+	acceleratorRuntime.Run(os.Stdin, os.Stdout)
+}

data/accelerator/go.mod

@@ -0,0 +1,3 @@
+module github.com/aldanedev-create/rubydb/accelerator
+
+go 1.23

data/accelerator/internal/execution/aggregate.go

@@ -0,0 +1,94 @@
+package execution
+
+import (
+	"encoding/json"
+	"strings"
+)
+
+func AggregateRows(rows []map[string]interface{}, groupBy []string, definitions []Aggregate) []map[string]interface{} {
+	groups := map[string][]map[string]interface{}{}
+	keys := map[string][]interface{}{}
+	order := make([]string, 0)
+	if len(groupBy) == 0 {
+		groups["_"] = rows
+		order = append(order, "_")
+	} else {
+		for _, row := range rows {
+			values := make([]interface{}, len(groupBy))
+			for i, column := range groupBy {
+				values[i] = row[column]
+			}
+			keyBytes, _ := json.Marshal(values)
+			key := string(keyBytes)
+			if _, exists := groups[key]; !exists {
+				order = append(order, key)
+			}
+			groups[key] = append(groups[key], row)
+			keys[key] = values
+		}
+	}
+	result := make([]map[string]interface{}, 0, len(groups))
+	for _, key := range order {
+		group := groups[key]
+		row := map[string]interface{}{}
+		for i, column := range groupBy {
+			row[column] = keys[key][i]
+		}
+		for _, definition := range definitions {
+			name := definition.Alias
+			if name == "" {
+				name = strings.ToLower(definition.Function) + "(" + definition.Column + ")"
+			}
+			row[name] = AggregateValue(group, definition)
+		}
+		result = append(result, row)
+	}
+	return result
+}
+
+func AggregateValue(rows []map[string]interface{}, definition Aggregate) interface{} {
+	values := make([]interface{}, 0, len(rows))
+	for _, row := range rows {
+		value := row[definition.Column]
+		if value != nil {
+			values = append(values, value)
+		}
+	}
+	switch strings.ToUpper(definition.Function) {
+	case "COUNT":
+		if definition.Column == "*" {
+			return len(rows)
+		}
+		return len(values)
+	case "SUM", "AVG":
+		var sum float64
+		for _, value := range values {
+			number, ok := NumberValue(value)
+			if !ok {
+				return nil
+			}
+			sum += number
+		}
+		if strings.EqualFold(definition.Function, "AVG") {
+			if len(values) == 0 {
+				return nil
+			}
+			return sum / float64(len(values))
+		}
+		return sum
+	case "MIN", "MAX":
+		if len(values) == 0 {
+			return nil
+		}
+		best := values[0]
+		for _, value := range values[1:] {
+			comparison := Compare(value, best)
+			if (strings.EqualFold(definition.Function, "MIN") && comparison < 0) || (strings.EqualFold(definition.Function, "MAX") && comparison > 0) {
+				best = value
+			}
+		}
+		return best
+	default:
+		return nil
+	}
+}

data/accelerator/internal/execution/distinct.go

@@ -0,0 +1,22 @@
+package execution
+
+import "encoding/json"
+
+func DistinctRows(rows []map[string]interface{}, columns []string) []map[string]interface{} {
+	seen := make(map[string]struct{}, len(rows))
+	result := make([]map[string]interface{}, 0, len(rows))
+	for _, row := range rows {
+		values := make([]interface{}, len(columns))
+		for index, column := range columns {
+			values[index] = row[column]
+		}
+		keyBytes, _ := json.Marshal(values)
+		key := string(keyBytes)
+		if _, exists := seen[key]; exists {
+			continue
+		}
+		seen[key] = struct{}{}
+		result = append(result, row)
+	}
+	return result
+}

data/accelerator/internal/execution/filter.go

@@ -0,0 +1,73 @@
+package execution
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/aldanedev-create/rubydb/accelerator/internal/parallel"
+)
+
+func FilterRows(rows []map[string]interface{}, condition Filter) []map[string]interface{} {
+	if len(rows) < 4096 {
+		filtered := make([]map[string]interface{}, 0, len(rows))
+		for _, row := range rows {
+			if Matches(row[condition.Column], condition.Operator, condition.Value) {
+				filtered = append(filtered, row)
+			}
+		}
+		return filtered
+	}
+
+	chunks := make([][]map[string]interface{}, parallel.ChunkCount(len(rows)))
+	parallel.ForEachChunk(len(rows), func(index, start, end int) {
+		filtered := make([]map[string]interface{}, 0, end-start)
+		for _, row := range rows[start:end] {
+			if Matches(row[condition.Column], condition.Operator, condition.Value) {
+				filtered = append(filtered, row)
+			}
+		}
+		chunks[index] = filtered
+	})
+	filtered := make([]map[string]interface{}, 0, len(rows))
+	for _, chunk := range chunks {
+		filtered = append(filtered, chunk...)
+	}
+	return filtered
+}
+
+func Matches(actual interface{}, operator string, expected interface{}) bool {
+	if strings.EqualFold(operator, "is_null") {
+		return actual == nil
+	}
+	if strings.EqualFold(operator, "is_not_null") {
+		return actual != nil
+	}
+	if actual == nil || expected == nil {
+		return false
+	}
+	if strings.EqualFold(operator, "like") {
+		pattern := regexp.QuoteMeta(fmt.Sprint(expected))
+		pattern = strings.ReplaceAll(pattern, "%", ".*")
+		pattern = strings.ReplaceAll(pattern, "_", ".")
+		matched, _ := regexp.MatchString("(?i)^"+pattern+"$", fmt.Sprint(actual))
+		return matched
+	}
+	comparison := Compare(actual, expected)
+	switch strings.ToLower(operator) {
+	case "eq":
+		return comparison == 0
+	case "ne":
+		return comparison != 0
+	case "lt":
+		return comparison < 0
+	case "lte":
+		return comparison <= 0
+	case "gt":
+		return comparison > 0
+	case "gte":
+		return comparison >= 0
+	default:
+		return false
+	}
+}

data/accelerator/internal/execution/join.go

@@ -0,0 +1,79 @@
+package execution
+
+import (
+	"encoding/json"
+	"sort"
+)
+
+func HashJoinRows(leftRows, rightRows []map[string]interface{}, leftKey, rightKey string) []map[string]interface{} {
+	index := make(map[string][]map[string]interface{}, len(rightRows))
+	for _, row := range rightRows {
+		key := JoinKey(row[rightKey])
+		index[key] = append(index[key], row)
+	}
+	rows := make([]map[string]interface{}, 0)
+	for _, left := range leftRows {
+		for _, right := range index[JoinKey(left[leftKey])] {
+			merged := make(map[string]interface{}, len(left)+len(right))
+			for key, value := range right {
+				merged[key] = value
+			}
+			for key, value := range left {
+				merged[key] = value
+			}
+			rows = append(rows, merged)
+		}
+	}
+	return rows
+}
+
+// MergeJoinRows is used when both inputs are already ordered by their join
+// keys. It avoids allocating a hash table for large, sorted relations.
+func MergeJoinRows(leftRows, rightRows []map[string]interface{}, leftKey, rightKey string) []map[string]interface{} {
+	left := append([]map[string]interface{}(nil), leftRows...)
+	right := append([]map[string]interface{}(nil), rightRows...)
+	sort.SliceStable(left, func(i, j int) bool { return Compare(left[i][leftKey], left[j][leftKey]) < 0 })
+	sort.SliceStable(right, func(i, j int) bool { return Compare(right[i][rightKey], right[j][rightKey]) < 0 })
+	result := make([]map[string]interface{}, 0)
+	for i, j := 0, 0; i < len(left) && j < len(right); {
+		comparison := Compare(left[i][leftKey], right[j][rightKey])
+		if comparison < 0 {
+			i++
+			continue
+		}
+		if comparison > 0 {
+			j++
+			continue
+		}
+		leftEnd, rightEnd := i, j
+		for leftEnd < len(left) && Compare(left[leftEnd][leftKey], left[i][leftKey]) == 0 {
+			leftEnd++
+		}
+		for rightEnd < len(right) && Compare(right[rightEnd][rightKey], right[j][rightKey]) == 0 {
+			rightEnd++
+		}
+		for leftIndex := i; leftIndex < leftEnd; leftIndex++ {
+			for rightIndex := j; rightIndex < rightEnd; rightIndex++ {
+				result = append(result, mergeRows(left[leftIndex], right[rightIndex]))
+			}
+		}
+		i, j = leftEnd, rightEnd
+	}
+	return result
+}
+
+func mergeRows(left, right map[string]interface{}) map[string]interface{} {
+	merged := make(map[string]interface{}, len(left)+len(right))
+	for key, value := range right {
+		merged[key] = value
+	}
+	for key, value := range left {
+		merged[key] = value
+	}
+	return merged
+}
+
+func JoinKey(value interface{}) string {
+	encoded, _ := json.Marshal(value)
+	return string(encoded)
+}

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