Skip to content

Commit 30cad48

Browse files
zeroshadezeroshade
committed
refactor(arreflect): third-pass consolidation — eliminate appendPrimitiveValue, collapse decimal builder, assertArray[T]
reflect_go_to_arrow.go: - Delete appendPrimitiveValue (~43 lines); buildPrimitiveArray now delegates to appendValue directly - Collapse buildDecimalArray from 4 inline iterSlice blocks to single switch (builder creation) + shared iterSlice delegating to appendDecimalValue (~50 lines saved) - Hoist nil-check in appendListElement before type switch, eliminating 4 duplicate isNil guards (~8 lines saved) reflect_arrow_to_go.go: - Add assertArray[T] generic helper replacing 13 identical 3-line type-assertion guards across setValue, setTemporalValue, setDecimalValue Net: -90 lines
1 parent 39ccd63 commit 30cad48

2 files changed

Lines changed: 80 additions & 170 deletions

File tree

‎arrow/array/arreflect/reflect_arrow_to_go.go‎

Lines changed: 57 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -25,6 +25,15 @@ import (
2525
"github.com/apache/arrow-go/v18/arrow/array"
2626
)
2727

28+
func assertArray[T any](arr arrow.Array) (*T, error) {
29+
a, ok := any(arr).(*T)
30+
if !ok {
31+
var zero T
32+
return nil, fmt.Errorf("expected *%T, got %T: %w", zero, arr, ErrTypeMismatch)
33+
}
34+
return a, nil
35+
}
36+
2837
func isIntKind(k reflect.Kind) bool {
2938
return k == reflect.Int || k == reflect.Int8 || k == reflect.Int16 ||
3039
k == reflect.Int32 || k == reflect.Int64
@@ -49,9 +58,9 @@ func setValue(v reflect.Value, arr arrow.Array, i int) error {
4958

5059
switch arr.DataType().ID() {
5160
case arrow.BOOL:
52-
a, ok := arr.(*array.Boolean)
53-
if !ok {
54-
return fmt.Errorf("expected *Boolean, got %T: %w", arr, ErrTypeMismatch)
61+
a, err := assertArray[array.Boolean](arr)
62+
if err != nil {
63+
return err
5564
}
5665
if v.Kind() != reflect.Bool {
5766
return fmt.Errorf("cannot set bool into %s: %w", v.Type(), ErrTypeMismatch)
@@ -93,9 +102,9 @@ func setValue(v reflect.Value, arr arrow.Array, i int) error {
93102
return setDecimalValue(v, arr, i)
94103

95104
case arrow.STRUCT:
96-
a, ok := arr.(*array.Struct)
97-
if !ok {
98-
return fmt.Errorf("expected *Struct, got %T: %w", arr, ErrTypeMismatch)
105+
a, err := assertArray[array.Struct](arr)
106+
if err != nil {
107+
return err
99108
}
100109
return setStructValue(v, a, i)
101110

@@ -107,30 +116,30 @@ func setValue(v reflect.Value, arr arrow.Array, i int) error {
107116
return setListValue(v, a, i)
108117

109118
case arrow.MAP:
110-
a, ok := arr.(*array.Map)
111-
if !ok {
112-
return fmt.Errorf("expected *Map, got %T: %w", arr, ErrTypeMismatch)
119+
a, err := assertArray[array.Map](arr)
120+
if err != nil {
121+
return err
113122
}
114123
return setMapValue(v, a, i)
115124

116125
case arrow.FIXED_SIZE_LIST:
117-
a, ok := arr.(*array.FixedSizeList)
118-
if !ok {
119-
return fmt.Errorf("expected *FixedSizeList, got %T: %w", arr, ErrTypeMismatch)
126+
a, err := assertArray[array.FixedSizeList](arr)
127+
if err != nil {
128+
return err
120129
}
121130
return setFixedSizeListValue(v, a, i)
122131

123132
case arrow.DICTIONARY:
124-
a, ok := arr.(*array.Dictionary)
125-
if !ok {
126-
return fmt.Errorf("expected *Dictionary, got %T: %w", arr, ErrTypeMismatch)
133+
a, err := assertArray[array.Dictionary](arr)
134+
if err != nil {
135+
return err
127136
}
128137
return setDictionaryValue(v, a, i)
129138

130139
case arrow.RUN_END_ENCODED:
131-
a, ok := arr.(*array.RunEndEncoded)
132-
if !ok {
133-
return fmt.Errorf("expected *RunEndEncoded, got %T: %w", arr, ErrTypeMismatch)
140+
a, err := assertArray[array.RunEndEncoded](arr)
141+
if err != nil {
142+
return err
134143
}
135144
return setRunEndEncodedValue(v, a, i)
136145

@@ -209,47 +218,47 @@ func setTime(v reflect.Value, t time.Time) error {
209218
func setTemporalValue(v reflect.Value, arr arrow.Array, i int) error {
210219
switch arr.DataType().ID() {
211220
case arrow.TIMESTAMP:
212-
a, ok := arr.(*array.Timestamp)
213-
if !ok {
214-
return fmt.Errorf("expected *Timestamp, got %T: %w", arr, ErrTypeMismatch)
221+
a, err := assertArray[array.Timestamp](arr)
222+
if err != nil {
223+
return err
215224
}
216225
unit := arr.DataType().(*arrow.TimestampType).Unit
217226
return setTime(v, a.Value(i).ToTime(unit))
218227

219228
case arrow.DATE32:
220-
a, ok := arr.(*array.Date32)
221-
if !ok {
222-
return fmt.Errorf("expected *Date32, got %T: %w", arr, ErrTypeMismatch)
229+
a, err := assertArray[array.Date32](arr)
230+
if err != nil {
231+
return err
223232
}
224233
return setTime(v, a.Value(i).ToTime())
225234

226235
case arrow.DATE64:
227-
a, ok := arr.(*array.Date64)
228-
if !ok {
229-
return fmt.Errorf("expected *Date64, got %T: %w", arr, ErrTypeMismatch)
236+
a, err := assertArray[array.Date64](arr)
237+
if err != nil {
238+
return err
230239
}
231240
return setTime(v, a.Value(i).ToTime())
232241

233242
case arrow.TIME32:
234-
a, ok := arr.(*array.Time32)
235-
if !ok {
236-
return fmt.Errorf("expected *Time32, got %T: %w", arr, ErrTypeMismatch)
243+
a, err := assertArray[array.Time32](arr)
244+
if err != nil {
245+
return err
237246
}
238247
unit := arr.DataType().(*arrow.Time32Type).Unit
239248
return setTime(v, a.Value(i).ToTime(unit))
240249

241250
case arrow.TIME64:
242-
a, ok := arr.(*array.Time64)
243-
if !ok {
244-
return fmt.Errorf("expected *Time64, got %T: %w", arr, ErrTypeMismatch)
251+
a, err := assertArray[array.Time64](arr)
252+
if err != nil {
253+
return err
245254
}
246255
unit := arr.DataType().(*arrow.Time64Type).Unit
247256
return setTime(v, a.Value(i).ToTime(unit))
248257

249258
case arrow.DURATION:
250-
a, ok := arr.(*array.Duration)
251-
if !ok {
252-
return fmt.Errorf("expected *Duration, got %T: %w", arr, ErrTypeMismatch)
259+
a, err := assertArray[array.Duration](arr)
260+
if err != nil {
261+
return err
253262
}
254263
if v.Type() != typeOfDuration {
255264
return fmt.Errorf("cannot set time.Duration into %s: %w", v.Type(), ErrTypeMismatch)
@@ -267,9 +276,9 @@ func setTemporalValue(v reflect.Value, arr arrow.Array, i int) error {
267276
func setDecimalValue(v reflect.Value, arr arrow.Array, i int) error {
268277
switch arr.DataType().ID() {
269278
case arrow.DECIMAL128:
270-
a, ok := arr.(*array.Decimal128)
271-
if !ok {
272-
return fmt.Errorf("expected *Decimal128, got %T: %w", arr, ErrTypeMismatch)
279+
a, err := assertArray[array.Decimal128](arr)
280+
if err != nil {
281+
return err
273282
}
274283
if v.Type() != typeOfDec128 {
275284
return fmt.Errorf("cannot set decimal128.Num into %s: %w", v.Type(), ErrTypeMismatch)
@@ -278,9 +287,9 @@ func setDecimalValue(v reflect.Value, arr arrow.Array, i int) error {
278287
v.Set(reflect.ValueOf(num))
279288

280289
case arrow.DECIMAL256:
281-
a, ok := arr.(*array.Decimal256)
282-
if !ok {
283-
return fmt.Errorf("expected *Decimal256, got %T: %w", arr, ErrTypeMismatch)
290+
a, err := assertArray[array.Decimal256](arr)
291+
if err != nil {
292+
return err
284293
}
285294
if v.Type() != typeOfDec256 {
286295
return fmt.Errorf("cannot set decimal256.Num into %s: %w", v.Type(), ErrTypeMismatch)
@@ -289,19 +298,19 @@ func setDecimalValue(v reflect.Value, arr arrow.Array, i int) error {
289298
v.Set(reflect.ValueOf(num))
290299

291300
case arrow.DECIMAL32:
292-
a, ok := arr.(*array.Decimal32)
293-
if !ok {
294-
return fmt.Errorf("expected *Decimal32, got %T: %w", arr, ErrTypeMismatch)
301+
a, err := assertArray[array.Decimal32](arr)
302+
if err != nil {
303+
return err
295304
}
296305
if v.Type() != typeOfDec32 {
297306
return fmt.Errorf("cannot set decimal.Decimal32 into %s: %w", v.Type(), ErrTypeMismatch)
298307
}
299308
v.Set(reflect.ValueOf(a.Value(i)))
300309

301310
case arrow.DECIMAL64:
302-
a, ok := arr.(*array.Decimal64)
303-
if !ok {
304-
return fmt.Errorf("expected *Decimal64, got %T: %w", arr, ErrTypeMismatch)
311+
a, err := assertArray[array.Decimal64](arr)
312+
if err != nil {
313+
return err
305314
}
306315
if v.Type() != typeOfDec64 {
307316
return fmt.Errorf("cannot set decimal.Decimal64 into %s: %w", v.Type(), ErrTypeMismatch)

‎arrow/array/arreflect/reflect_go_to_arrow.go‎

Lines changed: 23 additions & 122 deletions
Original file line numberDiff line numberDiff line change
@@ -96,57 +96,13 @@ func buildPrimitiveArray(vals reflect.Value, mem memory.Allocator) (arrow.Array,
9696
b.Reserve(vals.Len())
9797

9898
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
99-
return appendPrimitiveValue(b, v, dt)
99+
return appendValue(b, v, tagOpts{})
100100
}); err != nil {
101101
return nil, err
102102
}
103103
return b.NewArray(), nil
104104
}
105105

106-
func appendPrimitiveValue(b array.Builder, v reflect.Value, dt arrow.DataType) error {
107-
switch dt.ID() {
108-
case arrow.INT8:
109-
b.(*array.Int8Builder).Append(int8(v.Int()))
110-
case arrow.INT16:
111-
b.(*array.Int16Builder).Append(int16(v.Int()))
112-
case arrow.INT32:
113-
b.(*array.Int32Builder).Append(int32(v.Int()))
114-
case arrow.INT64:
115-
b.(*array.Int64Builder).Append(int64(v.Int()))
116-
case arrow.UINT8:
117-
b.(*array.Uint8Builder).Append(uint8(v.Uint()))
118-
case arrow.UINT16:
119-
b.(*array.Uint16Builder).Append(uint16(v.Uint()))
120-
case arrow.UINT32:
121-
b.(*array.Uint32Builder).Append(uint32(v.Uint()))
122-
case arrow.UINT64:
123-
b.(*array.Uint64Builder).Append(uint64(v.Uint()))
124-
case arrow.FLOAT32:
125-
b.(*array.Float32Builder).Append(float32(v.Float()))
126-
case arrow.FLOAT64:
127-
b.(*array.Float64Builder).Append(float64(v.Float()))
128-
case arrow.BOOL:
129-
b.(*array.BooleanBuilder).Append(v.Bool())
130-
case arrow.STRING:
131-
b.(*array.StringBuilder).Append(v.String())
132-
case arrow.BINARY:
133-
if v.IsNil() {
134-
b.(*array.BinaryBuilder).AppendNull()
135-
} else {
136-
b.(*array.BinaryBuilder).Append(v.Bytes())
137-
}
138-
case arrow.DURATION:
139-
d, err := asDuration(v)
140-
if err != nil {
141-
return err
142-
}
143-
b.(*array.DurationBuilder).Append(arrow.Duration(d.Nanoseconds()))
144-
default:
145-
return fmt.Errorf("unsupported Arrow type %v: %w", dt, ErrUnsupportedType)
146-
}
147-
return nil
148-
}
149-
150106
func timeOfDayNanos(t time.Time) int64 {
151107
t = t.UTC()
152108
midnight := time.Date(t.Year(), t.Month(), t.Day(), 0, 0, 0, 0, time.UTC)
@@ -253,74 +209,31 @@ func decimalPrecisionScale(opts tagOpts, defaultPrec int32) (precision, scale in
253209
func buildDecimalArray(vals reflect.Value, opts tagOpts, mem memory.Allocator) (arrow.Array, error) {
254210
elemType, isPtr := derefSliceElem(vals)
255211

212+
var b array.Builder
256213
switch elemType {
257214
case typeOfDec128:
258-
precision, scale := decimalPrecisionScale(opts, dec128DefaultPrecision)
259-
dt := &arrow.Decimal128Type{Precision: precision, Scale: scale}
260-
b := array.NewDecimal128Builder(mem, dt)
261-
defer b.Release()
262-
b.Reserve(vals.Len())
263-
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
264-
n, ok := reflect.TypeAssert[decimal128.Num](v)
265-
if !ok {
266-
return fmt.Errorf("expected decimal128.Num, got %s: %w", v.Type(), ErrTypeMismatch)
267-
}
268-
b.Append(n)
269-
return nil
270-
}); err != nil {
271-
return nil, err
272-
}
273-
return b.NewArray(), nil
274-
215+
p, s := decimalPrecisionScale(opts, dec128DefaultPrecision)
216+
b = array.NewDecimal128Builder(mem, &arrow.Decimal128Type{Precision: p, Scale: s})
275217
case typeOfDec256:
276-
precision, scale := decimalPrecisionScale(opts, dec256DefaultPrecision)
277-
dt := &arrow.Decimal256Type{Precision: precision, Scale: scale}
278-
b := array.NewDecimal256Builder(mem, dt)
279-
defer b.Release()
280-
b.Reserve(vals.Len())
281-
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
282-
n, ok := reflect.TypeAssert[decimal256.Num](v)
283-
if !ok {
284-
return fmt.Errorf("expected decimal256.Num, got %s: %w", v.Type(), ErrTypeMismatch)
285-
}
286-
b.Append(n)
287-
return nil
288-
}); err != nil {
289-
return nil, err
290-
}
291-
return b.NewArray(), nil
292-
218+
p, s := decimalPrecisionScale(opts, dec256DefaultPrecision)
219+
b = array.NewDecimal256Builder(mem, &arrow.Decimal256Type{Precision: p, Scale: s})
293220
case typeOfDec32:
294-
precision, scale := decimalPrecisionScale(opts, dec32DefaultPrecision)
295-
dt := &arrow.Decimal32Type{Precision: precision, Scale: scale}
296-
b := array.NewDecimal32Builder(mem, dt)
297-
defer b.Release()
298-
b.Reserve(vals.Len())
299-
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
300-
b.Append(decimal.Decimal32(v.Int()))
301-
return nil
302-
}); err != nil {
303-
return nil, err
304-
}
305-
return b.NewArray(), nil
306-
221+
p, s := decimalPrecisionScale(opts, dec32DefaultPrecision)
222+
b = array.NewDecimal32Builder(mem, &arrow.Decimal32Type{Precision: p, Scale: s})
307223
case typeOfDec64:
308-
precision, scale := decimalPrecisionScale(opts, dec64DefaultPrecision)
309-
dt := &arrow.Decimal64Type{Precision: precision, Scale: scale}
310-
b := array.NewDecimal64Builder(mem, dt)
311-
defer b.Release()
312-
b.Reserve(vals.Len())
313-
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
314-
b.Append(decimal.Decimal64(v.Int()))
315-
return nil
316-
}); err != nil {
317-
return nil, err
318-
}
319-
return b.NewArray(), nil
320-
224+
p, s := decimalPrecisionScale(opts, dec64DefaultPrecision)
225+
b = array.NewDecimal64Builder(mem, &arrow.Decimal64Type{Precision: p, Scale: s})
321226
default:
322227
return nil, fmt.Errorf("unsupported decimal type %v: %w", elemType, ErrUnsupportedType)
323228
}
229+
defer b.Release()
230+
b.Reserve(vals.Len())
231+
if err := iterSlice(vals, isPtr, b.AppendNull, func(v reflect.Value) error {
232+
return appendDecimalValue(b, v)
233+
}); err != nil {
234+
return nil, err
235+
}
236+
return b.NewArray(), nil
324237
}
325238

326239
func appendStructFields(sb *array.StructBuilder, v reflect.Value, fields []fieldMeta) error {
@@ -568,35 +481,23 @@ type listBuilderLike interface {
568481
}
569482

570483
func appendListElement(b array.Builder, v reflect.Value) error {
571-
isNil := v.Kind() == reflect.Slice && v.IsNil()
484+
if v.Kind() == reflect.Slice && v.IsNil() {
485+
b.AppendNull()
486+
return nil
487+
}
488+
572489
var vb array.Builder
573490
switch lb := b.(type) {
574491
case *array.ListBuilder:
575-
if isNil {
576-
lb.AppendNull()
577-
return nil
578-
}
579492
lb.Append(true)
580493
vb = lb.ValueBuilder()
581494
case *array.LargeListBuilder:
582-
if isNil {
583-
lb.AppendNull()
584-
return nil
585-
}
586495
lb.Append(true)
587496
vb = lb.ValueBuilder()
588497
case *array.ListViewBuilder:
589-
if isNil {
590-
lb.AppendNull()
591-
return nil
592-
}
593498
lb.AppendWithSize(true, v.Len())
594499
vb = lb.ValueBuilder()
595500
case *array.LargeListViewBuilder:
596-
if isNil {
597-
lb.AppendNull()
598-
return nil
599-
}
600501
lb.AppendWithSize(true, v.Len())
601502
vb = lb.ValueBuilder()
602503
default:

0 commit comments

Comments
 (0)
⚡