params_test.go

package gospice

import (
	"context"
	"testing"

	"github.com/apache/arrow-go/v18/arrow"
)

func TestParamType(t *testing.T) {
	tests := []struct {
		name          string
		param         Param
		expectedType  arrow.DataType
		expectedValue interface{}
	}{
		{
			name:          "NewParam with int",
			param:         NewParam(int32(42)),
			expectedType:  nil, // Type should be inferred
			expectedValue: int32(42),
		},
		{
			name:          "Int32Param",
			param:         Int32Param(42),
			expectedType:  arrow.PrimitiveTypes.Int32,
			expectedValue: int32(42),
		},
		{
			name:          "StringParam",
			param:         StringParam("test"),
			expectedType:  arrow.BinaryTypes.String,
			expectedValue: "test",
		},
		{
			name:          "Float64Param",
			param:         Float64Param(3.14),
			expectedType:  arrow.PrimitiveTypes.Float64,
			expectedValue: float64(3.14),
		},
		{
			name:          "BoolParam",
			param:         BoolParam(true),
			expectedType:  arrow.FixedWidthTypes.Boolean,
			expectedValue: true,
		},
		{
			name:          "Date32Param",
			param:         Date32Param(arrow.Date32(18628)),
			expectedType:  arrow.PrimitiveTypes.Date32,
			expectedValue: arrow.Date32(18628),
		},
		{
			name:          "TimestampParam with microseconds",
			param:         TimestampParam(arrow.Timestamp(1609459200000000), arrow.Microsecond, "UTC"),
			expectedType:  &arrow.TimestampType{Unit: arrow.Microsecond, TimeZone: "UTC"},
			expectedValue: arrow.Timestamp(1609459200000000),
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			if tt.expectedType != nil {
				// Compare type IDs instead of exact equality since some types like Timestamp are pointers
				if tt.param.Type.ID() != tt.expectedType.ID() {
					t.Errorf("expected type %v, got %v", tt.expectedType, tt.param.Type)
				}
			}
			if tt.param.Value != tt.expectedValue {
				t.Errorf("expected value %v, got %v", tt.expectedValue, tt.param.Value)
			}
		})
	}
}

func TestTypedParamInference(t *testing.T) {
	tests := []struct {
		name     string
		param    interface{}
		wantType arrow.DataType
	}{
		{
			name:     "Inferred int32",
			param:    int32(42),
			wantType: arrow.PrimitiveTypes.Int32,
		},
		{
			name:     "Explicit LargeString",
			param:    LargeStringParam("test"),
			wantType: arrow.BinaryTypes.LargeString,
		},
		{
			name:     "Explicit Time32 with seconds",
			param:    Time32Param(arrow.Time32(43200), arrow.Second),
			wantType: &arrow.Time32Type{Unit: arrow.Second},
		},
		{
			name:     "Explicit MonthInterval",
			param:    MonthIntervalParam(arrow.MonthInterval(12)),
			wantType: arrow.FixedWidthTypes.MonthInterval,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			// Extract value and type
			var val interface{}
			var dataType arrow.DataType

			if p, ok := tt.param.(Param); ok {
				val = p.Value
				if p.Type != nil {
					dataType = p.Type
				} else {
					var err error
					dataType, err = inferArrowType(p.Value)
					if err != nil {
						t.Fatalf("error inferring type: %v", err)
					}
				}
			} else {
				val = tt.param
				var err error
				dataType, err = inferArrowType(tt.param)
				if err != nil {
					t.Fatalf("error inferring type: %v", err)
				}
			}

			// Verify we got a type
			if dataType == nil {
				t.Error("expected non-nil data type")
			}

			// Verify type matches expected
			if dataType.ID() != tt.wantType.ID() {
				t.Errorf("expected type ID %v, got %v", tt.wantType.ID(), dataType.ID())
			}

			// Verify value is not nil (except for explicit null)
			if val == nil && tt.name != "Explicit null" {
				t.Error("expected non-nil value")
			}
		})
	}
}

func TestExtendedArrowTypes(t *testing.T) {
	tests := []struct {
		name          string
		value         interface{}
		expectedType  arrow.DataType
		shouldSucceed bool
	}{
		// Interval types
		{
			name:          "MonthInterval",
			value:         arrow.MonthInterval(12),
			expectedType:  arrow.FixedWidthTypes.MonthInterval,
			shouldSucceed: true,
		},
		{
			name:          "DayTimeInterval",
			value:         arrow.DayTimeInterval{Days: 1, Milliseconds: 1000},
			expectedType:  arrow.FixedWidthTypes.DayTimeInterval,
			shouldSucceed: true,
		},
		{
			name:          "MonthDayNanoInterval",
			value:         arrow.MonthDayNanoInterval{Months: 1, Days: 2, Nanoseconds: 3000},
			expectedType:  arrow.FixedWidthTypes.MonthDayNanoInterval,
			shouldSucceed: true,
		},
		// Decimal types (as byte arrays)
		{
			name:          "Decimal128 bytes",
			value:         [16]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15},
			expectedType:  &arrow.Decimal128Type{Precision: 38, Scale: 10},
			shouldSucceed: true,
		},
		{
			name:          "Decimal256 bytes",
			value:         [32]byte{0, 1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15, 16, 17, 18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29, 30, 31},
			expectedType:  &arrow.Decimal256Type{Precision: 76, Scale: 10},
			shouldSucceed: true,
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			dataType, err := inferArrowType(tt.value)
			if tt.shouldSucceed && err != nil {
				t.Errorf("expected success, got error: %v", err)
			}
			if !tt.shouldSucceed && err == nil {
				t.Errorf("expected error, got success")
			}
			if tt.shouldSucceed && dataType.ID() != tt.expectedType.ID() {
				t.Errorf("expected type %v, got %v", tt.expectedType, dataType)
			}
		})
	}
}

func TestSqlWithParamsUsingTypedParams(t *testing.T) {
	spice := NewSpiceClient()
	defer func() {
		if err := spice.Close(); err != nil {
			t.Errorf("error closing SpiceClient: %v", err)
		}
	}()

	if err := spice.Init(); err != nil {
		t.Skipf("Skipping - cannot initialize SpiceClient: %v", err)
	}

	ctx := context.Background()

	tests := []struct {
		name   string
		sql    string
		params []interface{}
	}{
		{
			name:   "Simple query with explicit Int32",
			sql:    "SELECT $1 as value",
			params: []interface{}{Int32Param(42)},
		},
		{
			name:   "Query with mixed inferred and explicit params",
			sql:    "SELECT $1 as num, $2 as str",
			params: []interface{}{42, StringParam("test")},
		},
		{
			name:   "Query with temporal param",
			sql:    "SELECT $1 as ts",
			params: []interface{}{TimestampParam(arrow.Timestamp(1609459200000000), arrow.Microsecond, "UTC")},
		},
	}

	for _, tt := range tests {
		t.Run(tt.name, func(t *testing.T) {
			reader, err := spice.SqlWithParams(ctx, tt.sql, tt.params...)
			if err != nil {
				t.Logf("Query failed (may be expected): %v", err)
				return
			}
			defer reader.Release()

			// Verify we can read results
			if reader.Next() {
				rec := reader.RecordBatch()
				defer rec.Release()
				if rec.NumRows() == 0 {
					t.Error("expected at least one row")
				}
			}
		})
	}
}

func TestSqlWithParamsAlias(t *testing.T) {
	spice := NewSpiceClient()
	defer func() {
		if err := spice.Close(); err != nil {
			t.Errorf("error closing SpiceClient: %v", err)
		}
	}()

	if err := spice.Init(); err != nil {
		t.Skipf("Skipping - cannot initialize SpiceClient: %v", err)
	}

	ctx := context.Background()

	// Test that SqlWithParams works with simple parameterized query
	reader, err := spice.SqlWithParams(ctx, "SELECT $1 as value", 42)
	if err != nil {
		// Local instances may not support parameterized queries properly
		// Skip the test gracefully instead of failing
		t.Skipf("Skipping - parameterized queries may not be supported on local instance: %v", err)
	}
	defer reader.Release()

	if reader.Next() {
		rec := reader.RecordBatch()
		defer rec.Release()
		if rec.NumRows() == 0 {
			t.Error("expected at least one row")
		}
	}
}