This is an automated email from the ASF dual-hosted git repository.
zeroshade pushed a commit to branch main
in repository https://gitbox.apache.org/repos/asf/arrow-go.git
The following commit(s) were added to refs/heads/main by this push:
new d560d1f refactor: update linter and run it (#419)
d560d1f is described below
commit d560d1f1d811e1e47da04e53395913144cd9ae5a
Author: Matt Topol <zotthewiz...@gmail.com>
AuthorDate: Fri Jun 20 16:43:36 2025 -0400
refactor: update linter and run it (#419)
### Rationale for this change
Update golangci-lint to v2 and run it for cleanup.
---
.golangci.yaml | 30 ++++--
.pre-commit-config.yaml | 2 +-
arrow/array/binary.go | 52 +++++-----
arrow/array/binarybuilder.go | 22 ++--
arrow/array/boolean.go | 4 +-
arrow/array/booleanbuilder.go | 8 +-
arrow/array/bufferbuilder_byte.go | 2 +-
arrow/array/compare.go | 4 +-
arrow/array/concat_test.go | 10 +-
arrow/array/decimal.go | 12 +--
arrow/array/dictionary.go | 18 ++--
arrow/array/encoded.go | 2 +-
arrow/array/fixed_size_list.go | 12 +--
arrow/array/fixedsize_binary.go | 2 +-
arrow/array/fixedsize_binarybuilder.go | 12 +--
arrow/array/float16.go | 4 +-
arrow/array/float16_builder.go | 6 +-
arrow/array/interval.go | 30 +++---
arrow/array/list.go | 40 ++++----
arrow/array/null.go | 8 +-
arrow/array/numeric_generic.go | 4 +-
arrow/array/string.go | 60 +++++------
arrow/array/struct.go | 8 +-
arrow/array/timestamp.go | 10 +-
arrow/avro/reader_test.go | 2 +-
arrow/avro/reader_types.go | 8 +-
arrow/avro/schema.go | 4 +-
arrow/avro/schema_test.go | 2 +-
arrow/cdata/cdata.go | 11 +-
arrow/compute/exec.go | 2 +-
arrow/compute/exec_internals_test.go | 2 +-
arrow/compute/executor.go | 6 +-
arrow/compute/expression.go | 4 +-
arrow/compute/exprs/types.go | 12 +--
arrow/compute/functions.go | 2 +-
arrow/compute/scalar_compare_test.go | 2 +-
arrow/csv/reader.go | 4 +-
arrow/datatype_extension_test.go | 2 +-
arrow/decimal256/decimal256_test.go | 2 +-
arrow/extensions/json.go | 2 +-
arrow/extensions/variant.go | 7 +-
arrow/flight/client.go | 4 +-
arrow/float16/float16.go | 6 +-
arrow/internal/arrjson/arrjson.go | 8 +-
arrow/internal/testing/gen/random_array_gen.go | 137 +++++++------------------
arrow/ipc/compression.go | 2 +-
arrow/scalar/append_test.go | 18 ++--
arrow/scalar/scalar_test.go | 2 +-
arrow/util/protobuf_reflect.go | 10 +-
internal/bitutils/bit_block_counter_test.go | 4 +-
internal/bitutils/bitmap_generate.go | 8 +-
internal/bitutils/bitmap_generate_test.go | 6 +-
internal/types/extension_types.go | 4 +-
parquet/encryption_write_config_test.go | 6 +-
parquet/file/column_reader_test.go | 13 +--
parquet/file/file_reader_mmap.go | 4 +-
parquet/file/level_conversion.go | 6 +-
parquet/file/record_reader.go | 4 +-
parquet/internal/encoding/decoder.go | 2 +-
parquet/internal/testutils/random.go | 98 ++++++++++--------
parquet/internal/testutils/random_arrow.go | 28 ++---
parquet/internal/utils/bit_reader_test.go | 18 ++--
parquet/metadata/page_index.go | 10 +-
parquet/pqarrow/path_builder.go | 8 +-
parquet/pqarrow/reader_writer_test.go | 6 +-
parquet/schema/reflection.go | 12 ++-
66 files changed, 414 insertions(+), 446 deletions(-)
diff --git a/.golangci.yaml b/.golangci.yaml
index f850dc7..36ed5f0 100644
--- a/.golangci.yaml
+++ b/.golangci.yaml
@@ -15,15 +15,31 @@
# specific language governing permissions and limitations
# under the License.
+version: "2"
linters:
- # Disable all linters.
- # Default: false
- disable-all: true
- # Enable specific linter
- # https://golangci-lint.run/usage/linters/#enabled-by-default
+ default: none
enable:
- - gofmt
- - goimports
- staticcheck
+ exclusions:
+ generated: lax
+ presets:
+ - comments
+ - common-false-positives
+ - legacy
+ - std-error-handling
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
issues:
fix: true
+formatters:
+ enable:
+ - gofmt
+ - goimports
+ exclusions:
+ generated: lax
+ paths:
+ - third_party$
+ - builtin$
+ - examples$
diff --git a/.pre-commit-config.yaml b/.pre-commit-config.yaml
index 24ee353..b4df0ce 100644
--- a/.pre-commit-config.yaml
+++ b/.pre-commit-config.yaml
@@ -17,7 +17,7 @@
repos:
- repo: https://github.com/golangci/golangci-lint
- rev: v1.61.0
+ rev: v2.1.6
hooks:
# no built-in support for multiple go.mod
# https://github.com/golangci/golangci-lint/issues/828
diff --git a/arrow/array/binary.go b/arrow/array/binary.go
index 5fef60e..942fe30 100644
--- a/arrow/array/binary.go
+++ b/arrow/array/binary.go
@@ -52,10 +52,10 @@ func NewBinaryData(data arrow.ArrayData) *Binary {
// Value returns the slice at index i. This value should not be mutated.
func (a *Binary) Value(i int) []byte {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- idx := a.array.data.offset + i
+ idx := a.data.offset + i
return a.valueBytes[a.valueOffsets[idx]:a.valueOffsets[idx+1]]
}
@@ -75,10 +75,10 @@ func (a *Binary) ValueString(i int) string {
}
func (a *Binary) ValueOffset(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return int(a.valueOffsets[a.array.data.offset+i])
+ return int(a.valueOffsets[a.data.offset+i])
}
func (a *Binary) ValueOffset64(i int) int64 {
@@ -86,22 +86,22 @@ func (a *Binary) ValueOffset64(i int) int64 {
}
func (a *Binary) ValueLen(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- beg := a.array.data.offset + i
+ beg := a.data.offset + i
return int(a.valueOffsets[beg+1] - a.valueOffsets[beg])
}
func (a *Binary) ValueOffsets() []int32 {
- beg := a.array.data.offset
- end := beg + a.array.data.length + 1
+ beg := a.data.offset
+ end := beg + a.data.length + 1
return a.valueOffsets[beg:end]
}
func (a *Binary) ValueBytes() []byte {
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
return a.valueBytes[a.valueOffsets[beg]:a.valueOffsets[end]]
}
@@ -138,11 +138,11 @@ func (a *Binary) setData(data *Data) {
a.valueOffsets =
arrow.Int32Traits.CastFromBytes(valueOffsets.Bytes())
}
- if a.array.data.length < 1 {
+ if a.data.length < 1 {
return
}
- expNumOffsets := a.array.data.offset + a.array.data.length + 1
+ expNumOffsets := a.data.offset + a.data.length + 1
if len(a.valueOffsets) < expNumOffsets {
panic(fmt.Errorf("arrow/array: binary offset buffer must have
at least %d values", expNumOffsets))
}
@@ -195,10 +195,10 @@ func NewLargeBinaryData(data arrow.ArrayData)
*LargeBinary {
}
func (a *LargeBinary) Value(i int) []byte {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- idx := a.array.data.offset + i
+ idx := a.data.offset + i
return a.valueBytes[a.valueOffsets[idx]:a.valueOffsets[idx+1]]
}
@@ -215,10 +215,10 @@ func (a *LargeBinary) ValueString(i int) string {
}
func (a *LargeBinary) ValueOffset(i int) int64 {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return a.valueOffsets[a.array.data.offset+i]
+ return a.valueOffsets[a.data.offset+i]
}
func (a *LargeBinary) ValueOffset64(i int) int64 {
@@ -226,22 +226,22 @@ func (a *LargeBinary) ValueOffset64(i int) int64 {
}
func (a *LargeBinary) ValueLen(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- beg := a.array.data.offset + i
+ beg := a.data.offset + i
return int(a.valueOffsets[beg+1] - a.valueOffsets[beg])
}
func (a *LargeBinary) ValueOffsets() []int64 {
- beg := a.array.data.offset
- end := beg + a.array.data.length + 1
+ beg := a.data.offset
+ end := beg + a.data.length + 1
return a.valueOffsets[beg:end]
}
func (a *LargeBinary) ValueBytes() []byte {
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
return a.valueBytes[a.valueOffsets[beg]:a.valueOffsets[end]]
}
@@ -278,11 +278,11 @@ func (a *LargeBinary) setData(data *Data) {
a.valueOffsets =
arrow.Int64Traits.CastFromBytes(valueOffsets.Bytes())
}
- if a.array.data.length < 1 {
+ if a.data.length < 1 {
return
}
- expNumOffsets := a.array.data.offset + a.array.data.length + 1
+ expNumOffsets := a.data.offset + a.data.length + 1
if len(a.valueOffsets) < expNumOffsets {
panic(fmt.Errorf("arrow/array: large binary offset buffer must
have at least %d values", expNumOffsets))
}
@@ -353,10 +353,10 @@ func (a *BinaryView) setData(data *Data) {
}
func (a *BinaryView) ValueHeader(i int) *arrow.ViewHeader {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return &a.values[a.array.data.offset+i]
+ return &a.values[a.data.offset+i]
}
func (a *BinaryView) Value(i int) []byte {
diff --git a/arrow/array/binarybuilder.go b/arrow/array/binarybuilder.go
index b37a103..28188d7 100644
--- a/arrow/array/binarybuilder.go
+++ b/arrow/array/binarybuilder.go
@@ -81,7 +81,7 @@ func NewBinaryBuilder(mem memory.Allocator, dtype
arrow.BinaryDataType) *BinaryB
offsetByteWidth: offsetByteWidth,
getOffsetVal: getOffsetVal,
}
- bb.builder.refCount.Add(1)
+ bb.refCount.Add(1)
return bb
}
@@ -162,7 +162,7 @@ func (b *BinaryBuilder) AppendValues(v [][]byte, valid
[]bool) {
b.values.Append(vv)
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
// AppendStringValues will append the values in the v slice. The valid slice
determines which values
@@ -183,7 +183,7 @@ func (b *BinaryBuilder) AppendStringValues(v []string,
valid []bool) {
b.values.Append([]byte(vv))
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *BinaryBuilder) UnsafeAppend(v []byte) {
@@ -218,7 +218,7 @@ func (b *BinaryBuilder) DataCap() int { return
b.values.capacity }
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *BinaryBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// ReserveData ensures there is enough space for appending n bytes
@@ -236,7 +236,7 @@ func (b *BinaryBuilder) Resize(n int) {
if (n * b.offsetByteWidth) < b.offsets.Len() {
b.offsets.SetLength(n * b.offsetByteWidth)
}
- b.builder.resize(n, b.init)
+ b.resize(n, b.init)
}
func (b *BinaryBuilder) ResizeData(n int) {
@@ -291,7 +291,7 @@ func (b *BinaryBuilder) newData() (data *Data) {
values.Release()
}
- b.builder.reset()
+ b.reset()
return
}
@@ -397,7 +397,7 @@ func NewBinaryViewBuilder(mem memory.Allocator)
*BinaryViewBuilder {
mem: mem,
},
}
- bvb.builder.refCount.Add(1)
+ bvb.refCount.Add(1)
bvb.blockBuilder.refCount.Add(1)
return bvb
}
@@ -445,7 +445,7 @@ func (b *BinaryViewBuilder) Resize(n int) {
return
}
- b.builder.resize(nbuild, b.init)
+ b.resize(nbuild, b.init)
b.data.Resize(arrow.ViewHeaderTraits.BytesRequired(n))
b.rawData = arrow.ViewHeaderTraits.CastFromBytes(b.data.Bytes())
}
@@ -459,7 +459,7 @@ func (b *BinaryViewBuilder) ReserveData(length int) {
}
func (b *BinaryViewBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
func (b *BinaryViewBuilder) Append(v []byte) {
@@ -554,7 +554,7 @@ func (b *BinaryViewBuilder) AppendValues(v [][]byte, valid
[]bool) {
}
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *BinaryViewBuilder) AppendStringValues(v []string, valid []bool) {
@@ -587,7 +587,7 @@ func (b *BinaryViewBuilder) AppendStringValues(v []string,
valid []bool) {
}
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
// AppendValueFromString is paired with ValueStr for fulfilling the
diff --git a/arrow/array/boolean.go b/arrow/array/boolean.go
index 1b28a9f..d579fa0 100644
--- a/arrow/array/boolean.go
+++ b/arrow/array/boolean.go
@@ -50,10 +50,10 @@ func NewBooleanData(data arrow.ArrayData) *Boolean {
}
func (a *Boolean) Value(i int) bool {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return bitutil.BitIsSet(a.values, a.array.data.offset+i)
+ return bitutil.BitIsSet(a.values, a.data.offset+i)
}
func (a *Boolean) ValueStr(i int) string {
diff --git a/arrow/array/booleanbuilder.go b/arrow/array/booleanbuilder.go
index a277ffd..fddc51b 100644
--- a/arrow/array/booleanbuilder.go
+++ b/arrow/array/booleanbuilder.go
@@ -38,7 +38,7 @@ type BooleanBuilder struct {
func NewBooleanBuilder(mem memory.Allocator) *BooleanBuilder {
bb := &BooleanBuilder{builder: builder{mem: mem}}
- bb.builder.refCount.Add(1)
+ bb.refCount.Add(1)
return bb
}
@@ -131,7 +131,7 @@ func (b *BooleanBuilder) AppendValues(v []bool, valid
[]bool) {
for i, vv := range v {
bitutil.SetBitTo(b.rawData, b.length+i, vv)
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *BooleanBuilder) init(capacity int) {
@@ -146,7 +146,7 @@ func (b *BooleanBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *BooleanBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -159,7 +159,7 @@ func (b *BooleanBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(n, b.init)
+ b.resize(n, b.init)
b.data.Resize(arrow.BooleanTraits.BytesRequired(n))
b.rawData = b.data.Bytes()
}
diff --git a/arrow/array/bufferbuilder_byte.go
b/arrow/array/bufferbuilder_byte.go
index 61431b7..7502556 100644
--- a/arrow/array/bufferbuilder_byte.go
+++ b/arrow/array/bufferbuilder_byte.go
@@ -24,7 +24,7 @@ type byteBufferBuilder struct {
func newByteBufferBuilder(mem memory.Allocator) *byteBufferBuilder {
bbb := &byteBufferBuilder{bufferBuilder: bufferBuilder{mem: mem}}
- bbb.bufferBuilder.refCount.Add(1)
+ bbb.refCount.Add(1)
return bbb
}
diff --git a/arrow/array/compare.go b/arrow/array/compare.go
index fda15f5..0278b4c 100644
--- a/arrow/array/compare.go
+++ b/arrow/array/compare.go
@@ -72,7 +72,7 @@ func RecordApproxEqual(left, right arrow.Record, opts
...EqualOption) bool {
func chunkedBinaryApply(left, right *arrow.Chunked, fn func(left arrow.Array,
lbeg, lend int64, right arrow.Array, rbeg, rend int64) bool) {
var (
pos int64
- length int64 = int64(left.Len())
+ length = int64(left.Len())
leftIdx, rightIdx int
leftPos, rightPos int64
)
@@ -118,7 +118,7 @@ func ChunkedEqual(left, right *arrow.Chunked) bool {
return false
}
- var isequal bool = true
+ var isequal = true
chunkedBinaryApply(left, right, func(left arrow.Array, lbeg, lend
int64, right arrow.Array, rbeg, rend int64) bool {
isequal = SliceEqual(left, lbeg, lend, right, rbeg, rend)
return isequal
diff --git a/arrow/array/concat_test.go b/arrow/array/concat_test.go
index 4eb0c66..0a8d544 100644
--- a/arrow/array/concat_test.go
+++ b/arrow/array/concat_test.go
@@ -19,6 +19,7 @@ package array_test
import (
"fmt"
"math"
+ "math/rand/v2"
"sort"
"strings"
"testing"
@@ -31,7 +32,6 @@ import (
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
- "golang.org/x/exp/rand"
)
func TestConcatenateValueBuffersNull(t *testing.T) {
@@ -298,9 +298,9 @@ func (cts *ConcatTestSuite) checkTrailingBitsZeroed(bitmap
*memory.Buffer, lengt
func (cts *ConcatTestSuite) offsets(length, slicecount int32) []int32 {
offsets := make([]int32, slicecount+1)
- dist := rand.New(rand.NewSource(cts.seed))
+ dist := rand.New(rand.NewPCG(cts.seed, 0))
for i := range offsets {
- offsets[i] = dist.Int31n(length + 1)
+ offsets[i] = dist.Int32N(length + 1)
}
sort.Slice(offsets, func(i, j int) bool { return offsets[i] <
offsets[j] })
return offsets
@@ -308,9 +308,9 @@ func (cts *ConcatTestSuite) offsets(length, slicecount
int32) []int32 {
func (cts *ConcatTestSuite) largeoffsets(length int64, slicecount int32)
[]int64 {
offsets := make([]int64, slicecount+1)
- dist := rand.New(rand.NewSource(cts.seed))
+ dist := rand.New(rand.NewPCG(cts.seed, 0))
for i := range offsets {
- offsets[i] = dist.Int63n(length + 1)
+ offsets[i] = dist.Int64N(length + 1)
}
sort.Slice(offsets, func(i, j int) bool { return offsets[i] <
offsets[j] })
return offsets
diff --git a/arrow/array/decimal.go b/arrow/array/decimal.go
index dff0fea..993242b 100644
--- a/arrow/array/decimal.go
+++ b/arrow/array/decimal.go
@@ -83,8 +83,8 @@ func (a *baseDecimal[T]) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values = arrow.GetData[T](vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
@@ -187,7 +187,7 @@ func newDecimalBuilder[T interface {
builder: builder{mem: mem},
dtype: dtype,
}
- bdb.builder.refCount.Add(1)
+ bdb.refCount.Add(1)
return bdb
}
@@ -263,7 +263,7 @@ func (b *baseDecimalBuilder[T]) AppendValues(v []T, valid
[]bool) {
if len(v) > 0 {
copy(b.rawData[b.length:], v)
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *baseDecimalBuilder[T]) init(capacity int) {
@@ -276,7 +276,7 @@ func (b *baseDecimalBuilder[T]) init(capacity int) {
}
func (b *baseDecimalBuilder[T]) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
func (b *baseDecimalBuilder[T]) Resize(n int) {
@@ -288,7 +288,7 @@ func (b *baseDecimalBuilder[T]) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(b.traits.BytesRequired(n))
b.rawData = arrow.GetData[T](b.data.Bytes())
}
diff --git a/arrow/array/dictionary.go b/arrow/array/dictionary.go
index f71ca49..21dc962 100644
--- a/arrow/array/dictionary.go
+++ b/arrow/array/dictionary.go
@@ -63,7 +63,7 @@ type Dictionary struct {
// and dictionary using the given type.
func NewDictionaryArray(typ arrow.DataType, indices, dict arrow.Array)
*Dictionary {
a := &Dictionary{}
- a.array.refCount.Add(1)
+ a.refCount.Add(1)
dictdata := NewData(typ, indices.Len(), indices.Data().Buffers(),
indices.Data().Children(), indices.NullN(), indices.Data().Offset())
dictdata.dictionary = dict.Data().(*Data)
dict.Data().Retain()
@@ -432,7 +432,7 @@ func createDictBuilder[T arrow.ValueType](mem
memory.Allocator, idxbldr IndexBui
dt: dt,
},
}
- ret.builder.refCount.Add(1)
+ ret.refCount.Add(1)
if init != nil {
if err := ret.InsertDictValues(init.(arrValues[T])); err != nil
{
@@ -451,7 +451,7 @@ func createBinaryDictBuilder(mem memory.Allocator, idxbldr
IndexBuilder, memo ha
dt: dt,
},
}
- ret.builder.refCount.Add(1)
+ ret.refCount.Add(1)
if init != nil {
switch v := init.(type) {
@@ -479,7 +479,7 @@ func createFixedSizeDictBuilder[T fsbType](mem
memory.Allocator, idxbldr IndexBu
},
byteWidth: int(unsafe.Sizeof(z)),
}
- ret.builder.refCount.Add(1)
+ ret.refCount.Add(1)
if init != nil {
if err := ret.InsertDictValues(init.(arrValues[T])); err != nil
{
@@ -517,7 +517,7 @@ func NewDictionaryBuilderWithDict(mem memory.Allocator, dt
*arrow.DictionaryType
dt: dt,
},
}
- ret.builder.refCount.Add(1)
+ ret.refCount.Add(1)
debug.Assert(init == nil, "arrow/array: doesn't make sense to
init a null dictionary")
return ret
case arrow.UINT8:
@@ -554,7 +554,7 @@ func NewDictionaryBuilderWithDict(mem memory.Allocator, dt
*arrow.DictionaryType
},
byteWidth:
dt.ValueType.(*arrow.FixedSizeBinaryType).ByteWidth,
}
- ret.builder.refCount.Add(1)
+ ret.refCount.Add(1)
if init != nil {
if err = ret.InsertDictValues(init.(*FixedSizeBinary));
err != nil {
@@ -656,7 +656,7 @@ func (b *dictionaryBuilder) Resize(n int) {
}
func (b *dictionaryBuilder) ResetFull() {
- b.builder.reset()
+ b.reset()
b.idxBuilder.NewArray().Release()
b.memoTable.Reset()
}
@@ -1153,8 +1153,8 @@ func (b *FixedSizeBinaryDictionaryBuilder) Append(v
[]byte) error {
func (b *FixedSizeBinaryDictionaryBuilder) InsertDictValues(arr
*FixedSizeBinary) (err error) {
var (
- beg = arr.array.data.offset * b.byteWidth
- end = (arr.array.data.offset + arr.data.length) * b.byteWidth
+ beg = arr.data.offset * b.byteWidth
+ end = (arr.data.offset + arr.data.length) * b.byteWidth
)
data := arr.valueBytes[beg:end]
for len(data) > 0 {
diff --git a/arrow/array/encoded.go b/arrow/array/encoded.go
index 8e39090..2ce221f 100644
--- a/arrow/array/encoded.go
+++ b/arrow/array/encoded.go
@@ -312,7 +312,7 @@ func NewRunEndEncodedBuilder(mem memory.Allocator, runEnds,
encoded arrow.DataTy
maxRunEnd: maxEnd,
lastUnmarshalled: nil,
}
- reb.builder.refCount.Add(1)
+ reb.refCount.Add(1)
return reb
}
diff --git a/arrow/array/fixed_size_list.go b/arrow/array/fixed_size_list.go
index 4a0524e..69cb67b 100644
--- a/arrow/array/fixed_size_list.go
+++ b/arrow/array/fixed_size_list.go
@@ -108,7 +108,7 @@ func (a *FixedSizeList) Len() int { return a.array.Len() }
func (a *FixedSizeList) ValueOffsets(i int) (start, end int64) {
n := int64(a.n)
- off := int64(a.array.data.offset)
+ off := int64(a.data.offset)
start, end = (off+int64(i))*n, (off+int64(i+1))*n
return
}
@@ -177,7 +177,7 @@ func NewFixedSizeListBuilder(mem memory.Allocator, n int32,
etype arrow.DataType
},
n,
}
- fslb.baseListBuilder.builder.refCount.Add(1)
+ fslb.refCount.Add(1)
return fslb
}
@@ -194,7 +194,7 @@ func NewFixedSizeListBuilderWithField(mem memory.Allocator,
n int32, field arrow
n,
}
- fslb.baseListBuilder.builder.refCount.Add(1)
+ fslb.refCount.Add(1)
return fslb
}
@@ -254,7 +254,7 @@ func (b *FixedSizeListBuilder) AppendEmptyValues(n int) {
func (b *FixedSizeListBuilder) AppendValues(valid []bool) {
b.Reserve(len(valid))
- b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+ b.unsafeAppendBoolsToBitmap(valid, len(valid))
}
func (b *FixedSizeListBuilder) unsafeAppendBoolToBitmap(isValid bool) {
@@ -273,7 +273,7 @@ func (b *FixedSizeListBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *FixedSizeListBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -286,7 +286,7 @@ func (b *FixedSizeListBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(n, b.builder.init)
+ b.resize(n, b.builder.init)
}
}
diff --git a/arrow/array/fixedsize_binary.go b/arrow/array/fixedsize_binary.go
index a3b0380..31d507c 100644
--- a/arrow/array/fixedsize_binary.go
+++ b/arrow/array/fixedsize_binary.go
@@ -44,7 +44,7 @@ func NewFixedSizeBinaryData(data arrow.ArrayData)
*FixedSizeBinary {
// Value returns the fixed-size slice at index i. This value should not be
mutated.
func (a *FixedSizeBinary) Value(i int) []byte {
- i += a.array.data.offset
+ i += a.data.offset
var (
bw = int(a.bytewidth)
beg = i * bw
diff --git a/arrow/array/fixedsize_binarybuilder.go
b/arrow/array/fixedsize_binarybuilder.go
index ee7869f..ca5a10c 100644
--- a/arrow/array/fixedsize_binarybuilder.go
+++ b/arrow/array/fixedsize_binarybuilder.go
@@ -42,7 +42,7 @@ func NewFixedSizeBinaryBuilder(mem memory.Allocator, dtype
*arrow.FixedSizeBinar
dtype: dtype,
values: newByteBufferBuilder(mem),
}
- b.builder.refCount.Add(1)
+ b.refCount.Add(1)
return b
}
@@ -130,7 +130,7 @@ func (b *FixedSizeBinaryBuilder) AppendValues(v [][]byte,
valid []bool) {
}
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *FixedSizeBinaryBuilder) init(capacity int) {
@@ -141,13 +141,13 @@ func (b *FixedSizeBinaryBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *FixedSizeBinaryBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
// additional memory will be allocated. If n is smaller, the allocated memory
may reduced.
func (b *FixedSizeBinaryBuilder) Resize(n int) {
- b.builder.resize(n, b.init)
+ b.resize(n, b.init)
}
// NewArray creates a FixedSizeBinary array from the memory buffers used by the
@@ -173,7 +173,7 @@ func (b *FixedSizeBinaryBuilder) newData() (data *Data) {
values.Release()
}
- b.builder.reset()
+ b.reset()
return
}
@@ -223,7 +223,7 @@ func (b *FixedSizeBinaryBuilder) UnmarshalOne(dec
*json.Decoder) error {
if len(val) != b.dtype.ByteWidth {
return &json.UnmarshalTypeError{
- Value: fmt.Sprint(val),
+ Value: fmt.Sprint(string(val)),
Type: reflect.TypeOf([]byte{}),
Offset: dec.InputOffset(),
Struct: fmt.Sprintf("FixedSizeBinary[%d]",
b.dtype.ByteWidth),
diff --git a/arrow/array/float16.go b/arrow/array/float16.go
index 5f57f72..4127680 100644
--- a/arrow/array/float16.go
+++ b/arrow/array/float16.go
@@ -71,8 +71,8 @@ func (a *Float16) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values = arrow.Float16Traits.CastFromBytes(vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
diff --git a/arrow/array/float16_builder.go b/arrow/array/float16_builder.go
index d4acd7f..60cc91b 100644
--- a/arrow/array/float16_builder.go
+++ b/arrow/array/float16_builder.go
@@ -121,7 +121,7 @@ func (b *Float16Builder) AppendValues(v []float16.Num,
valid []bool) {
if len(v) > 0 {
arrow.Float16Traits.Copy(b.rawData[b.length:], v)
}
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *Float16Builder) init(capacity int) {
@@ -136,7 +136,7 @@ func (b *Float16Builder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *Float16Builder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -150,7 +150,7 @@ func (b *Float16Builder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(arrow.Float16Traits.BytesRequired(n))
b.rawData = arrow.Float16Traits.CastFromBytes(b.data.Bytes())
}
diff --git a/arrow/array/interval.go b/arrow/array/interval.go
index 54915cd..2900a59 100644
--- a/arrow/array/interval.go
+++ b/arrow/array/interval.go
@@ -88,8 +88,8 @@ func (a *MonthInterval) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values = arrow.MonthIntervalTraits.CastFromBytes(vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
@@ -220,7 +220,7 @@ func (b *MonthIntervalBuilder) AppendValues(v
[]arrow.MonthInterval, valid []boo
b.Reserve(len(v))
arrow.MonthIntervalTraits.Copy(b.rawData[b.length:], v)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *MonthIntervalBuilder) init(capacity int) {
@@ -235,7 +235,7 @@ func (b *MonthIntervalBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *MonthIntervalBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -249,7 +249,7 @@ func (b *MonthIntervalBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(arrow.MonthIntervalTraits.BytesRequired(n))
b.rawData =
arrow.MonthIntervalTraits.CastFromBytes(b.data.Bytes())
}
@@ -392,8 +392,8 @@ func (a *DayTimeInterval) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values =
arrow.DayTimeIntervalTraits.CastFromBytes(vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
@@ -522,7 +522,7 @@ func (b *DayTimeIntervalBuilder) AppendValues(v
[]arrow.DayTimeInterval, valid [
b.Reserve(len(v))
arrow.DayTimeIntervalTraits.Copy(b.rawData[b.length:], v)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *DayTimeIntervalBuilder) init(capacity int) {
@@ -537,7 +537,7 @@ func (b *DayTimeIntervalBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *DayTimeIntervalBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -551,7 +551,7 @@ func (b *DayTimeIntervalBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(arrow.DayTimeIntervalTraits.BytesRequired(n))
b.rawData =
arrow.DayTimeIntervalTraits.CastFromBytes(b.data.Bytes())
}
@@ -695,8 +695,8 @@ func (a *MonthDayNanoInterval) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values =
arrow.MonthDayNanoIntervalTraits.CastFromBytes(vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
@@ -827,7 +827,7 @@ func (b *MonthDayNanoIntervalBuilder) AppendValues(v
[]arrow.MonthDayNanoInterva
b.Reserve(len(v))
arrow.MonthDayNanoIntervalTraits.Copy(b.rawData[b.length:], v)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *MonthDayNanoIntervalBuilder) init(capacity int) {
@@ -842,7 +842,7 @@ func (b *MonthDayNanoIntervalBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *MonthDayNanoIntervalBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -856,7 +856,7 @@ func (b *MonthDayNanoIntervalBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(arrow.MonthDayNanoIntervalTraits.BytesRequired(n))
b.rawData =
arrow.MonthDayNanoIntervalTraits.CastFromBytes(b.data.Bytes())
}
diff --git a/arrow/array/list.go b/arrow/array/list.go
index 806b89c..d87cc26 100644
--- a/arrow/array/list.go
+++ b/arrow/array/list.go
@@ -164,8 +164,8 @@ func (a *List) Release() {
}
func (a *List) ValueOffsets(i int) (start, end int64) {
- debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
- j := i + a.array.data.offset
+ debug.Assert(i >= 0 && i < a.data.length, "index out of range")
+ j := i + a.data.offset
start, end = int64(a.offsets[j]), int64(a.offsets[j+1])
return
}
@@ -286,8 +286,8 @@ func (a *LargeList) Len() int { return a.array.Len() }
func (a *LargeList) Offsets() []int64 { return a.offsets }
func (a *LargeList) ValueOffsets(i int) (start, end int64) {
- debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
- j := i + a.array.data.offset
+ debug.Assert(i >= 0 && i < a.data.length, "index out of range")
+ j := i + a.data.offset
start, end = a.offsets[j], a.offsets[j+1]
return
}
@@ -468,13 +468,13 @@ func (b *baseListBuilder) AppendEmptyValues(n int) {
func (b *ListBuilder) AppendValues(offsets []int32, valid []bool) {
b.Reserve(len(valid))
b.offsets.(*Int32Builder).AppendValues(offsets, nil)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+ b.unsafeAppendBoolsToBitmap(valid, len(valid))
}
func (b *LargeListBuilder) AppendValues(offsets []int64, valid []bool) {
b.Reserve(len(valid))
b.offsets.(*Int64Builder).AppendValues(offsets, nil)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+ b.unsafeAppendBoolsToBitmap(valid, len(valid))
}
func (b *baseListBuilder) unsafeAppendBoolToBitmap(isValid bool) {
@@ -494,7 +494,7 @@ func (b *baseListBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *baseListBuilder) Reserve(n int) {
- b.builder.reserve(n, b.resizeHelper)
+ b.reserve(n, b.resizeHelper)
b.offsets.Reserve(n)
}
@@ -513,7 +513,7 @@ func (b *baseListBuilder) resizeHelper(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(n, b.builder.init)
+ b.resize(n, b.builder.init)
}
}
@@ -772,8 +772,8 @@ func (a *ListView) Release() {
}
func (a *ListView) ValueOffsets(i int) (start, end int64) {
- debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
- j := i + a.array.data.offset
+ debug.Assert(i >= 0 && i < a.data.length, "index out of range")
+ j := i + a.data.offset
size := int64(a.sizes[j])
// If size is 0, skip accessing offsets.
if size == 0 {
@@ -909,8 +909,8 @@ func (a *LargeListView) Offsets() []int64 { return
a.offsets }
func (a *LargeListView) Sizes() []int64 { return a.sizes }
func (a *LargeListView) ValueOffsets(i int) (start, end int64) {
- debug.Assert(i >= 0 && i < a.array.data.length, "index out of range")
- j := i + a.array.data.offset
+ debug.Assert(i >= 0 && i < a.data.length, "index out of range")
+ j := i + a.data.offset
size := a.sizes[j]
// If size is 0, skip accessing offsets.
if size == 0 {
@@ -1035,9 +1035,9 @@ func (a *array) validateOffsetsAndMaybeSizes(l
offsetsAndSizes, offsetByteWidth
}
func (a *ListView) validate(fullValidation bool) error {
- values := a.array.data.childData[0]
+ values := a.data.childData[0]
offsetLimit := values.Len()
- return a.array.validateOffsetsAndMaybeSizes(a, 4, true,
int64(offsetLimit), fullValidation)
+ return a.validateOffsetsAndMaybeSizes(a, 4, true, int64(offsetLimit),
fullValidation)
}
func (a *ListView) Validate() error {
@@ -1049,9 +1049,9 @@ func (a *ListView) ValidateFull() error {
}
func (a *LargeListView) validate(fullValidation bool) error {
- values := a.array.data.childData[0]
+ values := a.data.childData[0]
offsetLimit := values.Len()
- return a.array.validateOffsetsAndMaybeSizes(a, 8, true,
int64(offsetLimit), fullValidation)
+ return a.validateOffsetsAndMaybeSizes(a, 8, true, int64(offsetLimit),
fullValidation)
}
func (a *LargeListView) Validate() error {
@@ -1238,14 +1238,14 @@ func (b *ListViewBuilder) AppendValuesWithSizes(offsets
[]int32, sizes []int32,
b.Reserve(len(valid))
b.offsets.(*Int32Builder).AppendValues(offsets, nil)
b.sizes.(*Int32Builder).AppendValues(sizes, nil)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+ b.unsafeAppendBoolsToBitmap(valid, len(valid))
}
func (b *LargeListViewBuilder) AppendValuesWithSizes(offsets []int64, sizes
[]int64, valid []bool) {
b.Reserve(len(valid))
b.offsets.(*Int64Builder).AppendValues(offsets, nil)
b.sizes.(*Int64Builder).AppendValues(sizes, nil)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(valid))
+ b.unsafeAppendBoolsToBitmap(valid, len(valid))
}
func (b *baseListViewBuilder) unsafeAppendBoolToBitmap(isValid bool) {
@@ -1266,7 +1266,7 @@ func (b *baseListViewBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *baseListViewBuilder) Reserve(n int) {
- b.builder.reserve(n, b.resizeHelper)
+ b.reserve(n, b.resizeHelper)
b.offsets.Reserve(n)
b.sizes.Reserve(n)
}
@@ -1287,7 +1287,7 @@ func (b *baseListViewBuilder) resizeHelper(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(n, b.builder.init)
+ b.resize(n, b.builder.init)
}
}
diff --git a/arrow/array/null.go b/arrow/array/null.go
index 38b3b09..02ea12e 100644
--- a/arrow/array/null.go
+++ b/arrow/array/null.go
@@ -76,8 +76,8 @@ func (a *Null) String() string {
func (a *Null) setData(data *Data) {
a.array.setData(data)
- a.array.nullBitmapBytes = nil
- a.array.data.nulls = a.array.data.length
+ a.nullBitmapBytes = nil
+ a.data.nulls = a.data.length
}
func (a *Null) GetOneForMarshal(i int) interface{} {
@@ -115,8 +115,8 @@ func (b *NullBuilder) Release() {
}
func (b *NullBuilder) AppendNull() {
- b.builder.length++
- b.builder.nulls++
+ b.length++
+ b.nulls++
}
func (b *NullBuilder) AppendNulls(n int) {
diff --git a/arrow/array/numeric_generic.go b/arrow/array/numeric_generic.go
index 016dc37..874e86d 100644
--- a/arrow/array/numeric_generic.go
+++ b/arrow/array/numeric_generic.go
@@ -68,8 +68,8 @@ func (a *numericArray[T]) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values = arrow.GetData[T](vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
diff --git a/arrow/array/string.go b/arrow/array/string.go
index d42492d..dd2e2d2 100644
--- a/arrow/array/string.go
+++ b/arrow/array/string.go
@@ -56,7 +56,7 @@ func (a *String) Reset(data arrow.ArrayData) {
// Value returns the slice at index i. This value should not be mutated.
func (a *String) Value(i int) string {
- i = i + a.array.data.offset
+ i = i + a.data.offset
return a.values[a.offsets[i]:a.offsets[i+1]]
}
@@ -69,10 +69,10 @@ func (a *String) ValueStr(i int) string {
// ValueOffset returns the offset of the value at index i.
func (a *String) ValueOffset(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return int(a.offsets[i+a.array.data.offset])
+ return int(a.offsets[i+a.data.offset])
}
func (a *String) ValueOffset64(i int) int64 {
@@ -80,23 +80,23 @@ func (a *String) ValueOffset64(i int) int64 {
}
func (a *String) ValueLen(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- beg := a.array.data.offset + i
+ beg := a.data.offset + i
return int(a.offsets[beg+1] - a.offsets[beg])
}
func (a *String) ValueOffsets() []int32 {
- beg := a.array.data.offset
- end := beg + a.array.data.length + 1
+ beg := a.data.offset
+ end := beg + a.data.length + 1
return a.offsets[beg:end]
}
func (a *String) ValueBytes() []byte {
- beg := a.array.data.offset
- end := beg + a.array.data.length
- if a.array.data.buffers[2] != nil {
+ beg := a.data.offset
+ end := beg + a.data.length
+ if a.data.buffers[2] != nil {
return
a.array.data.buffers[2].Bytes()[a.offsets[beg]:a.offsets[end]]
}
return nil
@@ -136,11 +136,11 @@ func (a *String) setData(data *Data) {
a.offsets = arrow.Int32Traits.CastFromBytes(offsets.Bytes())
}
- if a.array.data.length < 1 {
+ if a.data.length < 1 {
return
}
- expNumOffsets := a.array.data.offset + a.array.data.length + 1
+ expNumOffsets := a.data.offset + a.data.length + 1
if len(a.offsets) < expNumOffsets {
panic(fmt.Errorf("arrow/array: string offset buffer must have
at least %d values", expNumOffsets))
}
@@ -203,7 +203,7 @@ func (a *LargeString) Reset(data arrow.ArrayData) {
// Value returns the slice at index i. This value should not be mutated.
func (a *LargeString) Value(i int) string {
- i = i + a.array.data.offset
+ i = i + a.data.offset
return a.values[a.offsets[i]:a.offsets[i+1]]
}
@@ -216,10 +216,10 @@ func (a *LargeString) ValueStr(i int) string {
// ValueOffset returns the offset of the value at index i.
func (a *LargeString) ValueOffset(i int) int64 {
- if i < 0 || i > a.array.data.length {
+ if i < 0 || i > a.data.length {
panic("arrow/array: index out of range")
}
- return a.offsets[i+a.array.data.offset]
+ return a.offsets[i+a.data.offset]
}
func (a *LargeString) ValueOffset64(i int) int64 {
@@ -227,23 +227,23 @@ func (a *LargeString) ValueOffset64(i int) int64 {
}
func (a *LargeString) ValueLen(i int) int {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- beg := a.array.data.offset + i
+ beg := a.data.offset + i
return int(a.offsets[beg+1] - a.offsets[beg])
}
func (a *LargeString) ValueOffsets() []int64 {
- beg := a.array.data.offset
- end := beg + a.array.data.length + 1
+ beg := a.data.offset
+ end := beg + a.data.length + 1
return a.offsets[beg:end]
}
func (a *LargeString) ValueBytes() []byte {
- beg := a.array.data.offset
- end := beg + a.array.data.length
- if a.array.data.buffers[2] != nil {
+ beg := a.data.offset
+ end := beg + a.data.length
+ if a.data.buffers[2] != nil {
return
a.array.data.buffers[2].Bytes()[a.offsets[beg]:a.offsets[end]]
}
return nil
@@ -283,11 +283,11 @@ func (a *LargeString) setData(data *Data) {
a.offsets = arrow.Int64Traits.CastFromBytes(offsets.Bytes())
}
- if a.array.data.length < 1 {
+ if a.data.length < 1 {
return
}
- expNumOffsets := a.array.data.offset + a.array.data.length + 1
+ expNumOffsets := a.data.offset + a.data.length + 1
if len(a.offsets) < expNumOffsets {
panic(fmt.Errorf("arrow/array: string offset buffer must have
at least %d values", expNumOffsets))
}
@@ -356,10 +356,10 @@ func (a *StringView) setData(data *Data) {
}
func (a *StringView) ValueHeader(i int) *arrow.ViewHeader {
- if i < 0 || i >= a.array.data.length {
+ if i < 0 || i >= a.data.length {
panic("arrow/array: index out of range")
}
- return &a.values[a.array.data.offset+i]
+ return &a.values[a.data.offset+i]
}
func (a *StringView) Value(i int) string {
@@ -457,7 +457,7 @@ func (b *StringBuilder) Append(v string) {
// in v are valid (not null). The valid slice must either be empty or be equal
in length to v. If empty,
// all values in v are appended and considered valid.
func (b *StringBuilder) AppendValues(v []string, valid []bool) {
- b.BinaryBuilder.AppendStringValues(v, valid)
+ b.AppendStringValues(v, valid)
}
// Value returns the string at index i.
@@ -550,7 +550,7 @@ func (b *LargeStringBuilder) Append(v string) {
// in v are valid (not null). The valid slice must either be empty or be equal
in length to v. If empty,
// all values in v are appended and considered valid.
func (b *LargeStringBuilder) AppendValues(v []string, valid []bool) {
- b.BinaryBuilder.AppendStringValues(v, valid)
+ b.AppendStringValues(v, valid)
}
// Value returns the string at index i.
@@ -630,11 +630,11 @@ func NewStringViewBuilder(mem memory.Allocator)
*StringViewBuilder {
}
func (b *StringViewBuilder) Append(v string) {
- b.BinaryViewBuilder.AppendString(v)
+ b.AppendString(v)
}
func (b *StringViewBuilder) AppendValues(v []string, valid []bool) {
- b.BinaryViewBuilder.AppendStringValues(v, valid)
+ b.AppendStringValues(v, valid)
}
func (b *StringViewBuilder) UnmarshalOne(dec *json.Decoder) error {
diff --git a/arrow/array/struct.go b/arrow/array/struct.go
index 957947b..e0902ee 100644
--- a/arrow/array/struct.go
+++ b/arrow/array/struct.go
@@ -312,7 +312,7 @@ func (b *StructBuilder) Append(v bool) {
// the underlying children they already ensure they have enough space
// reserved. The only thing we must do is ensure we have enough space in
// the validity bitmap of the struct builder itself.
- b.builder.reserve(1, b.resizeHelper)
+ b.reserve(1, b.resizeHelper)
b.unsafeAppendBoolToBitmap(v)
if !v {
for _, f := range b.fields {
@@ -323,7 +323,7 @@ func (b *StructBuilder) Append(v bool) {
func (b *StructBuilder) AppendValues(valids []bool) {
b.Reserve(len(valids))
- b.builder.unsafeAppendBoolsToBitmap(valids, len(valids))
+ b.unsafeAppendBoolsToBitmap(valids, len(valids))
}
func (b *StructBuilder) AppendNull() { b.Append(false) }
@@ -363,7 +363,7 @@ func (b *StructBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *StructBuilder) Reserve(n int) {
- b.builder.reserve(n, b.resizeHelper)
+ b.reserve(n, b.resizeHelper)
for _, f := range b.fields {
f.Reserve(n)
}
@@ -386,7 +386,7 @@ func (b *StructBuilder) resizeHelper(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(n, b.builder.init)
+ b.resize(n, b.builder.init)
}
}
diff --git a/arrow/array/timestamp.go b/arrow/array/timestamp.go
index 9f8ca47..ff9ff4b 100644
--- a/arrow/array/timestamp.go
+++ b/arrow/array/timestamp.go
@@ -81,8 +81,8 @@ func (a *Timestamp) setData(data *Data) {
vals := data.buffers[1]
if vals != nil {
a.values = arrow.TimestampTraits.CastFromBytes(vals.Bytes())
- beg := a.array.data.offset
- end := beg + a.array.data.length
+ beg := a.data.offset
+ end := beg + a.data.length
a.values = a.values[beg:end]
}
}
@@ -221,7 +221,7 @@ func (b *TimestampBuilder) AppendValues(v
[]arrow.Timestamp, valid []bool) {
b.Reserve(len(v))
arrow.TimestampTraits.Copy(b.rawData[b.length:], v)
- b.builder.unsafeAppendBoolsToBitmap(valid, len(v))
+ b.unsafeAppendBoolsToBitmap(valid, len(v))
}
func (b *TimestampBuilder) init(capacity int) {
@@ -236,7 +236,7 @@ func (b *TimestampBuilder) init(capacity int) {
// Reserve ensures there is enough space for appending n elements
// by checking the capacity and calling Resize if necessary.
func (b *TimestampBuilder) Reserve(n int) {
- b.builder.reserve(n, b.Resize)
+ b.reserve(n, b.Resize)
}
// Resize adjusts the space allocated by b to n elements. If n is greater than
b.Cap(),
@@ -250,7 +250,7 @@ func (b *TimestampBuilder) Resize(n int) {
if b.capacity == 0 {
b.init(n)
} else {
- b.builder.resize(nBuilder, b.init)
+ b.resize(nBuilder, b.init)
b.data.Resize(arrow.TimestampTraits.BytesRequired(n))
b.rawData = arrow.TimestampTraits.CastFromBytes(b.data.Bytes())
}
diff --git a/arrow/avro/reader_test.go b/arrow/avro/reader_test.go
index 6dad0fd..1b07fbb 100644
--- a/arrow/avro/reader_test.go
+++ b/arrow/avro/reader_test.go
@@ -354,7 +354,7 @@ func TestEditSchemaStringEqual(t *testing.T) {
if err != nil {
t.Fatalf("%v", err)
}
- if !(fmt.Sprintf("%+v", want.String()) ==
fmt.Sprintf("%+v", got.String())) {
+ if fmt.Sprintf("%+v", want.String()) !=
fmt.Sprintf("%+v", got.String()) {
t.Fatalf("got=%v,\n want=%v", got.String(),
want.String())
} else {
t.Logf("schema.String() comparison passed")
diff --git a/arrow/avro/reader_types.go b/arrow/avro/reader_types.go
index d5c5127..50f0b18 100644
--- a/arrow/avro/reader_types.go
+++ b/arrow/avro/reader_types.go
@@ -249,7 +249,7 @@ func (d *dataLoader) loadDatum(data any) error {
}
func (d *dataLoader) newChild() *dataLoader {
- var child *dataLoader = &dataLoader{
+ var child = &dataLoader{
depth: d.depth + 1,
}
d.children = append(d.children, child)
@@ -257,7 +257,7 @@ func (d *dataLoader) newChild() *dataLoader {
}
func (d *dataLoader) newListChild(list *fieldPos) *dataLoader {
- var child *dataLoader = &dataLoader{
+ var child = &dataLoader{
list: list,
item: list.childrens[0],
depth: d.depth + 1,
@@ -267,7 +267,7 @@ func (d *dataLoader) newListChild(list *fieldPos)
*dataLoader {
}
func (d *dataLoader) newMapChild(mapField *fieldPos) *dataLoader {
- var child *dataLoader = &dataLoader{
+ var child = &dataLoader{
mapField: mapField,
depth: d.depth + 1,
}
@@ -296,7 +296,7 @@ func newFieldPos() *fieldPos { return &fieldPos{index: -1} }
func (f *fieldPos) children() []*fieldPos { return f.childrens }
func (f *fieldPos) newChild(childName string, childBuilder array.Builder, meta
arrow.Metadata) *fieldPos {
- var child fieldPos = fieldPos{
+ var child = fieldPos{
parent: f,
fieldName: childName,
builder: childBuilder,
diff --git a/arrow/avro/schema.go b/arrow/avro/schema.go
index 26e373d..91b1729 100644
--- a/arrow/avro/schema.go
+++ b/arrow/avro/schema.go
@@ -106,7 +106,7 @@ func arrowSchemafromAvro(n *schemaNode) {
k := strconv.FormatInt(int64(index), 10)
symbols[k] = symbol
}
- var dt arrow.DictionaryType = arrow.DictionaryType{IndexType:
arrow.PrimitiveTypes.Uint64, ValueType: arrow.BinaryTypes.String, Ordered:
false}
+ var dt = arrow.DictionaryType{IndexType:
arrow.PrimitiveTypes.Uint64, ValueType: arrow.BinaryTypes.String, Ordered:
false}
sl := int64(len(symbols))
switch {
case sl <= math.MaxUint8:
@@ -204,7 +204,7 @@ func iterateFields(n *schemaNode) {
k := strconv.FormatInt(int64(index), 10)
symbols[k] = symbol
}
- var dt arrow.DictionaryType =
arrow.DictionaryType{IndexType: arrow.PrimitiveTypes.Uint64, ValueType:
arrow.BinaryTypes.String, Ordered: false}
+ var dt = arrow.DictionaryType{IndexType:
arrow.PrimitiveTypes.Uint64, ValueType: arrow.BinaryTypes.String, Ordered:
false}
sl := len(symbols)
switch {
case sl <= math.MaxUint8:
diff --git a/arrow/avro/schema_test.go b/arrow/avro/schema_test.go
index 8edea40..385bd4b 100644
--- a/arrow/avro/schema_test.go
+++ b/arrow/avro/schema_test.go
@@ -352,7 +352,7 @@ func TestSchemaStringEqual(t *testing.T) {
if err != nil {
t.Fatalf("%v", err)
}
- if !(fmt.Sprintf("%+v", want.String()) ==
fmt.Sprintf("%+v", got.String())) {
+ if fmt.Sprintf("%+v", want.String()) !=
fmt.Sprintf("%+v", got.String()) {
t.Fatalf("got=%v,\n want=%v", got.String(),
want.String())
} else {
t.Logf("schema.String() comparison passed")
diff --git a/arrow/cdata/cdata.go b/arrow/cdata/cdata.go
index 2e15edf..3ed0ca8 100644
--- a/arrow/cdata/cdata.go
+++ b/arrow/cdata/cdata.go
@@ -281,9 +281,10 @@ func importSchema(schema *CArrowSchema) (ret arrow.Field,
err error) {
case 'L': // large list
dt = arrow.LargeListOfField(childFields[0])
case 'v': // list view/large list view
- if f[2] == 'l' {
+ switch f[2] {
+ case 'l':
dt = arrow.ListViewOfField(childFields[0])
- } else if f[2] == 'L' {
+ case 'L':
dt = arrow.LargeListViewOfField(childFields[0])
}
case 'w': // fixed size list is w:# where # is the list size.
@@ -963,10 +964,10 @@ func (n *nativeCRecordBatchReader) Record() arrow.Record
{ return n.cur }
func (n *nativeCRecordBatchReader) Next() bool {
err := n.next()
- switch {
- case err == nil:
+ switch err {
+ case nil:
return true
- case err == io.EOF:
+ case io.EOF:
return false
}
n.err = err
diff --git a/arrow/compute/exec.go b/arrow/compute/exec.go
index d37d95a..0afb3b1 100644
--- a/arrow/compute/exec.go
+++ b/arrow/compute/exec.go
@@ -150,7 +150,7 @@ func execInternal(ctx context.Context, fn Function, opts
FunctionOptions, passed
}
case FuncVector:
vkernel := k.(*exec.VectorKernel)
- if !(allSame || !vkernel.CanExecuteChunkWise) {
+ if !allSame && vkernel.CanExecuteChunkWise {
return nil, fmt.Errorf("%w: vector kernel
arguments must all be the same length", arrow.ErrInvalid)
}
}
diff --git a/arrow/compute/exec_internals_test.go
b/arrow/compute/exec_internals_test.go
index bbe4913..f813fb1 100644
--- a/arrow/compute/exec_internals_test.go
+++ b/arrow/compute/exec_internals_test.go
@@ -46,7 +46,7 @@ type ComputeInternalsTestSuite struct {
func (c *ComputeInternalsTestSuite) SetupTest() {
c.mem = memory.NewCheckedAllocator(memory.DefaultAllocator)
- c.rng = gen.NewRandomArrayGenerator(0, c.mem)
+ c.rng = gen.NewRandomArrayGenerator(1337, c.mem)
c.resetCtx()
}
diff --git a/arrow/compute/executor.go b/arrow/compute/executor.go
index bf41036..59f1c4e 100644
--- a/arrow/compute/executor.go
+++ b/arrow/compute/executor.go
@@ -249,7 +249,7 @@ func propagateNulls(ctx *exec.KernelCtx, batch
*exec.ExecSpan, out *exec.ArraySp
var (
arrsWithNulls = make([]*exec.ArraySpan, 0, len(batch.Values))
isAllNull bool
- prealloc bool = out.Buffers[0].Buf != nil
+ prealloc = out.Buffers[0].Buf != nil
)
for i := range batch.Values {
@@ -440,7 +440,7 @@ func (e *nonAggExecImpl) Init(ctx *exec.KernelCtx, args
exec.KernelInitArgs) (er
}
func (e *nonAggExecImpl) prepareOutput(length int) *exec.ExecResult {
- var nullCount int = array.UnknownNullCount
+ var nullCount = array.UnknownNullCount
if e.kernel.GetNullHandling() == exec.NullNoOutput {
nullCount = 0
@@ -761,7 +761,7 @@ func iterateExecSpans(batch *ExecBatch, maxChunkSize int64,
promoteIfAllScalar b
}
var (
- args []Datum = batch.Values
+ args = batch.Values
haveChunked bool
chunkIdxes = make([]int, len(args))
valuePositions = make([]int64, len(args))
diff --git a/arrow/compute/expression.go b/arrow/compute/expression.go
index 4e60d38..0de425f 100644
--- a/arrow/compute/expression.go
+++ b/arrow/compute/expression.go
@@ -822,8 +822,8 @@ func DeserializeExpr(mem memory.Allocator, buf
*memory.Buffer) (Expression, erro
var (
getone func() (Expression, error)
- index int = 0
- metadata = batch.Schema().Metadata()
+ index = 0
+ metadata = batch.Schema().Metadata()
)
getscalar := func(i string) (scalar.Scalar, error) {
diff --git a/arrow/compute/exprs/types.go b/arrow/compute/exprs/types.go
index 0c468f3..314df6f 100644
--- a/arrow/compute/exprs/types.go
+++ b/arrow/compute/exprs/types.go
@@ -320,9 +320,9 @@ func (e *extensionSet) GetArrowRegistry()
*ExtensionIDRegistry { return e.
func (e *extensionSet) GetSubstraitRegistry() expr.ExtensionRegistry { return
e.ExtensionRegistry }
func (e *extensionSet) DecodeTypeArrow(anchor uint32) (extensions.ID,
arrow.DataType, bool) {
- id, ok := e.Set.DecodeType(anchor)
+ id, ok := e.DecodeType(anchor)
if !ok {
- if id, ok = e.Set.DecodeTypeVariation(anchor); !ok {
+ if id, ok = e.DecodeTypeVariation(anchor); !ok {
return id, nil, false
}
}
@@ -332,7 +332,7 @@ func (e *extensionSet) DecodeTypeArrow(anchor uint32)
(extensions.ID, arrow.Data
}
func (e *extensionSet) DecodeFunction(ref uint32) (extensions.ID,
substraitToArrow, bool) {
- id, ok := e.Set.DecodeFunc(ref)
+ id, ok := e.DecodeFunc(ref)
if !ok {
return id, nil, false
}
@@ -353,7 +353,7 @@ func (e *extensionSet) EncodeTypeVariation(dt
arrow.DataType) (extensions.ID, ui
return extensions.ID{}, 0, false
}
- return id, e.Set.GetTypeVariationAnchor(id), true
+ return id, e.GetTypeVariationAnchor(id), true
}
func (e *extensionSet) EncodeType(dt arrow.DataType) (extensions.ID, uint32,
bool) {
@@ -362,11 +362,11 @@ func (e *extensionSet) EncodeType(dt arrow.DataType)
(extensions.ID, uint32, boo
return extensions.ID{}, 0, false
}
- return id, e.Set.GetTypeAnchor(id), true
+ return id, e.GetTypeAnchor(id), true
}
func (e *extensionSet) EncodeFunction(id extensions.ID) uint32 {
- return e.Set.GetFuncAnchor(id)
+ return e.GetFuncAnchor(id)
}
// ExtensionIDRegistry manages a set of mappings between Arrow types
diff --git a/arrow/compute/functions.go b/arrow/compute/functions.go
index 11d8e68..84f9bbc 100644
--- a/arrow/compute/functions.go
+++ b/arrow/compute/functions.go
@@ -150,7 +150,7 @@ func (b *baseFunction) Validate() error {
}
argCount := len(b.doc.ArgNames)
- if argCount != b.arity.NArgs && !(b.arity.IsVarArgs && argCount ==
b.arity.NArgs+1) {
+ if argCount != b.arity.NArgs && (!b.arity.IsVarArgs || argCount !=
b.arity.NArgs+1) {
return fmt.Errorf("in function '%s': number of argument names
for function doc != function arity", b.name)
}
diff --git a/arrow/compute/scalar_compare_test.go
b/arrow/compute/scalar_compare_test.go
index e45b3af..4b4d78b 100644
--- a/arrow/compute/scalar_compare_test.go
+++ b/arrow/compute/scalar_compare_test.go
@@ -1195,7 +1195,7 @@ func (c *CompareStringSuite) validateCompareComputed(op
kernels.CompareOperator,
}
defer expected.Release()
- c.CompareSuite.validateCompareDatum(op, lhs, rhs, expected)
+ c.validateCompareDatum(op, lhs, rhs, expected)
}
func (c *CompareStringSuite) TestRandomCompareArrayArray() {
diff --git a/arrow/csv/reader.go b/arrow/csv/reader.go
index 284964a..3d919a9 100644
--- a/arrow/csv/reader.go
+++ b/arrow/csv/reader.go
@@ -802,7 +802,7 @@ func (r *Reader) parseListLike(field array.ListLikeBuilder,
str string) {
field.AppendNull()
return
}
- if !(strings.HasPrefix(str, "{") && strings.HasSuffix(str, "}")) {
+ if !strings.HasPrefix(str, "{") || !strings.HasSuffix(str, "}") {
r.err = errors.New("invalid list format. should start with '{'
and end with '}'")
return
}
@@ -830,7 +830,7 @@ func (r *Reader) parseFixedSizeList(field
*array.FixedSizeListBuilder, str strin
field.AppendNull()
return
}
- if !(strings.HasPrefix(str, "{") && strings.HasSuffix(str, "}")) {
+ if !strings.HasPrefix(str, "{") || !strings.HasSuffix(str, "}") {
r.err = errors.New("invalid list format. should start with '{'
and end with '}'")
return
}
diff --git a/arrow/datatype_extension_test.go b/arrow/datatype_extension_test.go
index ae246e0..9a3361c 100644
--- a/arrow/datatype_extension_test.go
+++ b/arrow/datatype_extension_test.go
@@ -42,7 +42,7 @@ func (BadExtensionType) Deserialize(_ arrow.DataType, _
string) (arrow.Extension
func TestMustEmbedBase(t *testing.T) {
var ext interface{} = &BadExtensionType{}
assert.Panics(t, func() {
- var _ arrow.ExtensionType = ext.(arrow.ExtensionType)
+ var _ = ext.(arrow.ExtensionType)
})
}
diff --git a/arrow/decimal256/decimal256_test.go
b/arrow/decimal256/decimal256_test.go
index 421b598..a93cdfe 100644
--- a/arrow/decimal256/decimal256_test.go
+++ b/arrow/decimal256/decimal256_test.go
@@ -601,7 +601,7 @@ func TestHexFromString(t *testing.T) {
t.Errorf("expected: %s, actual: %s\n", decStr, num.ToString(38))
actualCoeff := num.BigInt()
- expectedCoeff, _ :=
(&big.Int{}).SetString(strings.Replace(decStr, ".", "", -1), 10)
+ expectedCoeff, _ :=
(&big.Int{}).SetString(strings.ReplaceAll(decStr, ".", ""), 10)
t.Errorf("expected(hex): %X, actual(hex): %X\n",
expectedCoeff.Bytes(), actualCoeff.Bytes())
}
}
diff --git a/arrow/extensions/json.go b/arrow/extensions/json.go
index 2324009..3f46b50 100644
--- a/arrow/extensions/json.go
+++ b/arrow/extensions/json.go
@@ -55,7 +55,7 @@ func NewJSONType(storageType arrow.DataType) (*JSONType,
error) {
func (b *JSONType) ArrayType() reflect.Type { return
reflect.TypeOf(JSONArray{}) }
func (b *JSONType) Deserialize(storageType arrow.DataType, data string)
(arrow.ExtensionType, error) {
- if !(data == "" || data == "{}") {
+ if data != "" && data != "{}" {
return nil, fmt.Errorf("serialized metadata for JSON extension
type must be '' or '{}', found: %s", data)
}
return NewJSONType(storageType)
diff --git a/arrow/extensions/variant.go b/arrow/extensions/variant.go
index ff8aa1d..53de4ff 100644
--- a/arrow/extensions/variant.go
+++ b/arrow/extensions/variant.go
@@ -395,7 +395,7 @@ func (v *VariantArray) String() string {
val, err := v.Value(i)
if err != nil {
- o.WriteString(fmt.Sprintf("error: %v", err))
+ fmt.Fprintf(o, "error: %v", err)
continue
}
@@ -1002,12 +1002,13 @@ func variantTypeFromArrow(dt arrow.DataType)
variant.Type {
case arrow.TIMESTAMP:
dt := dt.(*arrow.TimestampType)
isUTC := dt.TimeZone == "" || dt.TimeZone == "UTC"
- if dt.Unit == arrow.Microsecond {
+ switch dt.Unit {
+ case arrow.Microsecond:
if isUTC {
return variant.TimestampMicros
}
return variant.TimestampMicrosNTZ
- } else if dt.Unit == arrow.Nanosecond {
+ case arrow.Nanosecond:
if isUTC {
return variant.TimestampNanos
}
diff --git a/arrow/flight/client.go b/arrow/flight/client.go
index e1860a1..9e5da87 100644
--- a/arrow/flight/client.go
+++ b/arrow/flight/client.go
@@ -310,7 +310,7 @@ func NewClientFromConn(cc grpc.ClientConnInterface, auth
ClientAuthHandler) Clie
func (c *client) AuthenticateBasicToken(ctx context.Context, username,
password string, opts ...grpc.CallOption) (context.Context, error) {
authCtx := metadata.AppendToOutgoingContext(ctx, "Authorization",
"Basic
"+base64.RawStdEncoding.EncodeToString([]byte(strings.Join([]string{username,
password}, ":"))))
- stream, err := c.FlightServiceClient.Handshake(authCtx, opts...)
+ stream, err := c.Handshake(authCtx, opts...)
if err != nil {
return ctx, err
}
@@ -346,7 +346,7 @@ func (c *client) Authenticate(ctx context.Context, opts
...grpc.CallOption) erro
return status.Error(codes.NotFound, "cannot authenticate
without an auth-handler")
}
- stream, err := c.FlightServiceClient.Handshake(ctx, opts...)
+ stream, err := c.Handshake(ctx, opts...)
if err != nil {
return err
}
diff --git a/arrow/float16/float16.go b/arrow/float16/float16.go
index f61db40..0aa4df8 100644
--- a/arrow/float16/float16.go
+++ b/arrow/float16/float16.go
@@ -63,10 +63,10 @@ func (f Num) Float32() float32 {
exp := (f.bits >> 10) & 0x1f
res := uint32(exp) + 127 - 15
fc := uint32(f.bits & 0x3ff)
- switch {
- case exp == 0:
+ switch exp {
+ case 0:
res = 0
- case exp == 0x1f:
+ case 0x1f:
res = 0xff
}
return math.Float32frombits((sn << 31) | (res << 23) | (fc << 13))
diff --git a/arrow/internal/arrjson/arrjson.go
b/arrow/internal/arrjson/arrjson.go
index 2181ebd..a2c86ff 100644
--- a/arrow/internal/arrjson/arrjson.go
+++ b/arrow/internal/arrjson/arrjson.go
@@ -568,10 +568,10 @@ func (f *FieldWrapper) UnmarshalJSON(data []byte) error {
if len(f.Metadata) > 0 { // unmarshal the key/value metadata pairs
var (
- mdkeys = make([]string, 0, len(f.Metadata))
- mdvals = make([]string, 0, len(f.Metadata))
- extKeyIdx int = -1
- extDataIdx int = -1
+ mdkeys = make([]string, 0, len(f.Metadata))
+ mdvals = make([]string, 0, len(f.Metadata))
+ extKeyIdx = -1
+ extDataIdx = -1
)
for i, kv := range f.Metadata {
diff --git a/arrow/internal/testing/gen/random_array_gen.go
b/arrow/internal/testing/gen/random_array_gen.go
index 7350454..aadc24a 100644
--- a/arrow/internal/testing/gen/random_array_gen.go
+++ b/arrow/internal/testing/gen/random_array_gen.go
@@ -18,13 +18,14 @@ package gen
import (
"math"
+ "math/rand/v2"
+ "unsafe"
"github.com/apache/arrow-go/v18/arrow"
"github.com/apache/arrow-go/v18/arrow/array"
"github.com/apache/arrow-go/v18/arrow/bitutil"
"github.com/apache/arrow-go/v18/arrow/internal/debug"
"github.com/apache/arrow-go/v18/arrow/memory"
- "golang.org/x/exp/rand"
"gonum.org/v1/gonum/stat/distuv"
)
@@ -40,7 +41,7 @@ type RandomArrayGenerator struct {
// NewRandomArrayGenerator constructs a new generator with the requested Seed
func NewRandomArrayGenerator(seed uint64, mem memory.Allocator)
RandomArrayGenerator {
- src := rand.NewSource(seed)
+ src := rand.NewPCG(seed, 0)
return RandomArrayGenerator{seed, 0, src, rand.New(src), mem}
}
@@ -54,7 +55,7 @@ func (r *RandomArrayGenerator) GenerateBitmap(buffer []byte,
n int64, prob float
// bernoulli distribution uses P to determine the probability of a 0 or
a 1,
// which we'll use to generate the bitmap.
- dist := distuv.Bernoulli{P: 1 - prob, Src: rand.NewSource(r.seed +
r.extra)}
+ dist := distuv.Bernoulli{P: 1 - prob, Src: rand.NewPCG(r.seed, r.extra)}
for i := 0; int64(i) < n; i++ {
if dist.Rand() != float64(0.0) {
bitutil.SetBit(buffer, i)
@@ -99,112 +100,46 @@ func (r *RandomArrayGenerator) baseGenPrimitive(size
int64, prob float64, byteWi
return buffers, nullCount
}
-func (r *RandomArrayGenerator) Int8(size int64, min, max int8, prob float64)
arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Int8SizeBytes)
+func genArray[T arrow.IntType | arrow.UintType](r *RandomArrayGenerator, size
int64, min, max T, prob float64) arrow.Array {
+ buffers, nullcount := r.baseGenPrimitive(size, prob,
int(unsafe.Sizeof(T(0))))
for _, b := range buffers {
defer b.Release()
}
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Int8Traits.CastFromBytes(buffers[1].Bytes())
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
+ out := arrow.GetData[T](buffers[1].Bytes())
for i := int64(0); i < size; i++ {
- out[i] = int8(dist.Intn(int(max)-int(min+1))) + min
+ out[i] = T(dist.IntN(int(max)-int(min+1))) + min
}
- data := array.NewData(arrow.PrimitiveTypes.Int8, int(size), buffers,
nil, int(nullcount), 0)
+ data := array.NewData(arrow.GetDataType[T](), int(size), buffers, nil,
int(nullcount), 0)
defer data.Release()
- return array.NewInt8Data(data)
+ return array.MakeFromData(data)
}
-func (r *RandomArrayGenerator) Uint8(size int64, min, max uint8, prob float64)
arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Uint8SizeBytes)
- for _, b := range buffers {
- defer b.Release()
- }
-
- r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Uint8Traits.CastFromBytes(buffers[1].Bytes())
- for i := int64(0); i < size; i++ {
- out[i] = uint8(dist.Intn(int(max)-int(min)+1)) + min
- }
+func (r *RandomArrayGenerator) Int8(size int64, min, max int8, prob float64)
arrow.Array {
+ return genArray(r, size, min, max, prob)
+}
- data := array.NewData(arrow.PrimitiveTypes.Uint8, int(size), buffers,
nil, int(nullcount), 0)
- defer data.Release()
- return array.NewUint8Data(data)
+func (r *RandomArrayGenerator) Uint8(size int64, min, max uint8, prob float64)
arrow.Array {
+ return genArray(r, size, min, max, prob)
}
func (r *RandomArrayGenerator) Int16(size int64, min, max int16, prob float64)
arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Int16SizeBytes)
- for _, b := range buffers {
- defer b.Release()
- }
-
- r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Int16Traits.CastFromBytes(buffers[1].Bytes())
- for i := int64(0); i < size; i++ {
- out[i] = int16(dist.Intn(int(max)-int(min)+1)) + min
- }
-
- data := array.NewData(arrow.PrimitiveTypes.Int16, int(size), buffers,
nil, int(nullcount), 0)
- defer data.Release()
- return array.NewInt16Data(data)
+ return genArray(r, size, min, max, prob)
}
func (r *RandomArrayGenerator) Uint16(size int64, min, max uint16, prob
float64) arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Uint16SizeBytes)
- for _, b := range buffers {
- defer b.Release()
- }
-
- r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Uint16Traits.CastFromBytes(buffers[1].Bytes())
- for i := int64(0); i < size; i++ {
- out[i] = uint16(dist.Intn(int(max)-int(min)+1)) + min
- }
-
- data := array.NewData(arrow.PrimitiveTypes.Uint16, int(size), buffers,
nil, int(nullcount), 0)
- defer data.Release()
- return array.NewUint16Data(data)
+ return genArray(r, size, min, max, prob)
}
func (r *RandomArrayGenerator) Int32(size int64, min, max int32, prob float64)
arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Int32SizeBytes)
- for _, b := range buffers {
- defer b.Release()
- }
-
- r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Int32Traits.CastFromBytes(buffers[1].Bytes())
- for i := int64(0); i < size; i++ {
- out[i] = int32(dist.Intn(int(max)-int(min)+1)) + min
- }
-
- data := array.NewData(arrow.PrimitiveTypes.Int32, int(size), buffers,
nil, int(nullcount), 0)
- defer data.Release()
- return array.NewInt32Data(data)
+ return genArray(r, size, min, max, prob)
}
func (r *RandomArrayGenerator) Uint32(size int64, min, max uint32, prob
float64) arrow.Array {
- buffers, nullcount := r.baseGenPrimitive(size, prob,
arrow.Uint32SizeBytes)
- for _, b := range buffers {
- defer b.Release()
- }
-
- r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
- out := arrow.Uint32Traits.CastFromBytes(buffers[1].Bytes())
- for i := int64(0); i < size; i++ {
- out[i] = uint32(dist.Uint64n(uint64(max)-uint64(min)+1)) + min
- }
-
- data := array.NewData(arrow.PrimitiveTypes.Uint32, int(size), buffers,
nil, int(nullcount), 0)
- defer data.Release()
- return array.NewUint32Data(data)
+ return genArray(r, size, min, max, prob)
}
func (r *RandomArrayGenerator) Int64(size int64, min, max int64, prob float64)
arrow.Array {
@@ -214,7 +149,7 @@ func (r *RandomArrayGenerator) Int64(size int64, min, max
int64, prob float64) a
}
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Int64Traits.CastFromBytes(buffers[1].Bytes())
if max == math.MaxInt64 && min == math.MinInt64 {
for i := int64(0); i < size; i++ {
@@ -222,7 +157,7 @@ func (r *RandomArrayGenerator) Int64(size int64, min, max
int64, prob float64) a
}
} else {
for i := int64(0); i < size; i++ {
- out[i] = dist.Int63n(max-min+1) + min
+ out[i] = dist.Int64N(max-min+1) + min
}
}
@@ -238,7 +173,7 @@ func (r *RandomArrayGenerator) Uint64(size int64, min, max
uint64, prob float64)
}
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Uint64Traits.CastFromBytes(buffers[1].Bytes())
if max == math.MaxUint64 {
for i := int64(0); i < size; i++ {
@@ -246,7 +181,7 @@ func (r *RandomArrayGenerator) Uint64(size int64, min, max
uint64, prob float64)
}
} else {
for i := int64(0); i < size; i++ {
- out[i] = dist.Uint64n(max-min+1) + min
+ out[i] = dist.Uint64N(max-min+1) + min
}
}
@@ -262,7 +197,7 @@ func (r *RandomArrayGenerator) Float32(size int64, min, max
float32, prob float6
}
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Float32Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
out[i] = min + dist.Float32()*(max+1-min)
@@ -280,7 +215,7 @@ func (r *RandomArrayGenerator) Float64(size int64, min, max
float64, prob float6
}
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Float64Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
out[i] = dist.NormFloat64() + (max - min)
@@ -299,13 +234,13 @@ func (r *RandomArrayGenerator) String(size int64,
minLength, maxLength int, null
defer bldr.Release()
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
buf := make([]byte, 0, maxLength)
gen := func(n int32) string {
out := buf[:n]
for i := range out {
- out[i] = uint8(dist.Int31n(int32('z')-int32('A')+1) +
int32('A'))
+ out[i] = uint8(dist.Int32N(int32('z')-int32('A')+1) +
int32('A'))
}
return string(out)
}
@@ -329,13 +264,13 @@ func (r *RandomArrayGenerator) LargeString(size int64,
minLength, maxLength int6
defer bldr.Release()
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
buf := make([]byte, 0, maxLength)
gen := func(n int64) string {
out := buf[:n]
for i := range out {
- out[i] = uint8(dist.Int63n(int64('z')-int64('A')+1) +
int64('A'))
+ out[i] = uint8(dist.Int64N(int64('z')-int64('A')+1) +
int64('A'))
}
return string(out)
}
@@ -363,13 +298,13 @@ func (r *RandomArrayGenerator) generateBinaryView(dt
arrow.DataType, size int64,
defer bldr.Release()
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
buf := make([]byte, 0, maxLength)
gen := func(n int32) string {
out := buf[:n]
for i := range out {
- out[i] = uint8(dist.Int31n(int32('z')-int32('A')+1) +
int32('A'))
+ out[i] = uint8(dist.Int32N(int32('z')-int32('A')+1) +
int32('A'))
}
return string(out)
}
@@ -422,9 +357,9 @@ func viewOffsetsFromLengthsArray32(
sizes := sizesArray.Int32Values()
offsets := make([]int32, sizesArray.Len())
- offsetDeltaRand := rand.New(rand.NewSource(seed))
+ offsetDeltaRand := rand.New(rand.NewPCG(seed, 0))
sampleOffset := func(offsetBase int32) int32 {
- delta := int32(offsetDeltaRand.Int63n(2*int64(avgLength)) -
int64(avgLength))
+ delta := int32(offsetDeltaRand.Int64N(2*int64(avgLength)) -
int64(avgLength))
offset := offsetBase + delta
if offset < 0 {
return 0
@@ -463,9 +398,9 @@ func viewOffsetsFromLengthsArray64(
sizes := sizesArray.Int64Values()
offsets := make([]int64, sizesArray.Len())
- offsetDeltaRand := rand.New(rand.NewSource(seed))
+ offsetDeltaRand := rand.New(rand.NewPCG(seed, 0))
sampleOffset := func(offsetBase int64) int64 {
- delta := int64(offsetDeltaRand.Int63n(2*avgLength) - avgLength)
+ delta := int64(offsetDeltaRand.Int64N(2*avgLength) - avgLength)
offset := offsetBase + delta
if offset < 0 {
return 0
diff --git a/arrow/ipc/compression.go b/arrow/ipc/compression.go
index f74510a..abdf631 100644
--- a/arrow/ipc/compression.go
+++ b/arrow/ipc/compression.go
@@ -105,7 +105,7 @@ type lz4Decompressor struct {
}
func (z *lz4Decompressor) Close() {
- z.Reader.Reset(nil)
+ z.Reset(nil)
}
func getDecompressor(codec flatbuf.CompressionType) decompressor {
diff --git a/arrow/scalar/append_test.go b/arrow/scalar/append_test.go
index 03ef7fa..b61013d 100644
--- a/arrow/scalar/append_test.go
+++ b/arrow/scalar/append_test.go
@@ -14,12 +14,11 @@
// See the License for the specific language governing permissions and
// limitations under the License.
-//go:build go1.18
-
package scalar_test
import (
"math"
+ "math/rand/v2"
"strings"
"testing"
@@ -32,7 +31,6 @@ import (
"github.com/stretchr/testify/require"
"github.com/stretchr/testify/suite"
"golang.org/x/exp/constraints"
- "golang.org/x/exp/rand"
"gonum.org/v1/gonum/stat/distuv"
)
@@ -42,14 +40,14 @@ type primitiveTypes interface {
func draw[T constraints.Integer](n int64, min, max T) []T {
const seed = 1337
- gen := rand.New(rand.NewSource(seed))
+ gen := rand.New(rand.NewPCG(seed, 0))
normalizedMin := uint64(math.Abs(float64(min)))
normalizedMax := uint64(max) + normalizedMin
out := make([]T, n)
for i := range out {
- out[i] = T(gen.Uint64n(normalizedMax) - normalizedMin)
+ out[i] = T(gen.Uint64N(normalizedMax) - normalizedMin)
}
return out
}
@@ -58,7 +56,7 @@ func drawFloat[T float32 | float64](n int64) []T {
const seed = 0xdeadbeef
d := distuv.Uniform{
Min: -1000.0, Max: 1000.0,
- Src: rand.NewSource(seed),
+ Src: rand.New(rand.NewPCG(seed, 0)),
}
out := make([]T, n)
@@ -70,14 +68,14 @@ func drawFloat[T float32 | float64](n int64) []T {
func drawBytes[T string | []byte](n int64, minLen, maxLen int) []T {
const seed = 1337
- gen := rand.New(rand.NewSource(seed))
+ gen := rand.New(rand.NewPCG(seed, 0))
out := make([]T, n)
for i := range out {
- l := gen.Intn(maxLen-minLen+1) + minLen
+ l := gen.IntN(maxLen-minLen+1) + minLen
buf := make([]byte, l)
for j := range buf {
- buf[j] = uint8(gen.Intn(int('z')-int('A')+1) + int('A'))
+ buf[j] = uint8(gen.IntN(int('z')-int('A')+1) + int('A'))
}
out[i] = T(buf)
}
@@ -88,7 +86,7 @@ func randomBools(n int64, pctFalse float64) []bool {
const seed = 0
d := distuv.Uniform{
Min: 0.0, Max: 1.0,
- Src: rand.NewSource(seed),
+ Src: rand.NewPCG(seed, 0),
}
out := make([]bool, n)
diff --git a/arrow/scalar/scalar_test.go b/arrow/scalar/scalar_test.go
index 01f9668..a3a9766 100644
--- a/arrow/scalar/scalar_test.go
+++ b/arrow/scalar/scalar_test.go
@@ -882,7 +882,7 @@ func getScalars(mem memory.Allocator) []scalar.Scalar {
scalar.NewDecimal256Scalar(decimal256.FromI64(10),
&arrow.Decimal256Type{Precision: 16, Scale: 4}),
scalar.NewStringScalarFromBuffer(hello),
scalar.NewListScalar(int8Arr),
- scalar.NewMapScalar(mapArr.List.ListValues()),
+ scalar.NewMapScalar(mapArr.ListValues()),
scalar.NewFixedSizeListScalar(int8Arr),
scalar.NewStructScalar([]scalar.Scalar{scalar.NewInt32Scalar(2),
scalar.NewInt32Scalar(6)},
arrow.StructOf([]arrow.Field{{Name: "min", Type:
arrow.PrimitiveTypes.Int32}, {Name: "max", Type:
arrow.PrimitiveTypes.Int32}}...)),
diff --git a/arrow/util/protobuf_reflect.go b/arrow/util/protobuf_reflect.go
index c7f03ea..6950745 100644
--- a/arrow/util/protobuf_reflect.go
+++ b/arrow/util/protobuf_reflect.go
@@ -98,14 +98,14 @@ func (pfr *ProtobufFieldReflection) GetDescriptor()
protoreflect.FieldDescriptor
}
func (pfr *ProtobufFieldReflection) name() string {
- if pfr.isOneOf() && pfr.schemaOptions.oneOfHandler != OneOfNull {
+ if pfr.isOneOf() && pfr.oneOfHandler != OneOfNull {
return
pfr.fieldNameFormatter(string(pfr.descriptor.ContainingOneof().Name()))
}
return pfr.fieldNameFormatter(string(pfr.descriptor.Name()))
}
func (pfr *ProtobufFieldReflection) arrowType() arrow.Type {
- if pfr.isOneOf() && pfr.schemaOptions.oneOfHandler == OneOfDenseUnion {
+ if pfr.isOneOf() && pfr.oneOfHandler == OneOfDenseUnion {
return arrow.DENSE_UNION
}
if pfr.isEnum() {
@@ -643,7 +643,7 @@ func (msg ProtobufMessageReflection) Record(mem
memory.Allocator) arrow.Record {
var fieldNames []string
for i, f := range msg.fields {
f.AppendValueOrNull(recordBuilder.Field(i), mem)
- fieldNames = append(fieldNames, f.protobufReflection.name())
+ fieldNames = append(fieldNames, f.name())
}
var arrays []arrow.Array
@@ -752,7 +752,7 @@ func (f ProtobufMessageFieldReflection) AppendValueOrNull(b
array.Builder, mem m
switch b.Type().ID() {
case arrow.STRING:
- if f.protobufReflection.isEnum() {
+ if f.isEnum() {
b.(*array.StringBuilder).Append(string(fd.Enum().Values().ByNumber(pv.Enum()).Name()))
} else {
b.(*array.StringBuilder).Append(pv.String())
@@ -760,7 +760,7 @@ func (f ProtobufMessageFieldReflection) AppendValueOrNull(b
array.Builder, mem m
case arrow.BINARY:
b.(*array.BinaryBuilder).Append(pv.Bytes())
case arrow.INT32:
- if f.protobufReflection.isEnum() {
+ if f.isEnum() {
b.(*array.Int32Builder).Append(int32(f.reflectValue().Int()))
} else {
b.(*array.Int32Builder).Append(int32(pv.Int()))
diff --git a/internal/bitutils/bit_block_counter_test.go
b/internal/bitutils/bit_block_counter_test.go
index 58ac7f8..8ebbbe8 100644
--- a/internal/bitutils/bit_block_counter_test.go
+++ b/internal/bitutils/bit_block_counter_test.go
@@ -17,13 +17,13 @@
package bitutils_test
import (
+ "math/rand/v2"
"testing"
"github.com/apache/arrow-go/v18/arrow/bitutil"
"github.com/apache/arrow-go/v18/arrow/memory"
"github.com/apache/arrow-go/v18/internal/bitutils"
"github.com/stretchr/testify/assert"
- "golang.org/x/exp/rand"
)
const kWordSize = 64
@@ -184,7 +184,7 @@ func TestFourWordsRandomData(t *testing.T) {
)
buf := make([]byte, nbytes)
- r := rand.New(rand.NewSource(0))
+ r := &rand.ChaCha8{}
r.Read(buf)
checkWithOffset := func(offset int64) {
diff --git a/internal/bitutils/bitmap_generate.go
b/internal/bitutils/bitmap_generate.go
index 178751d..19ddb96 100644
--- a/internal/bitutils/bitmap_generate.go
+++ b/internal/bitutils/bitmap_generate.go
@@ -60,10 +60,10 @@ func GenerateBitsUnrolled(bitmap []byte, start, length
int64, g func() bool) {
var (
curbyte byte
- cur = bitmap[start/8:]
- startBitOffset uint64 = uint64(start % 8)
- mask = bitutil.BitMask[startBitOffset]
- remaining = length
+ cur = bitmap[start/8:]
+ startBitOffset = uint64(start % 8)
+ mask = bitutil.BitMask[startBitOffset]
+ remaining = length
)
if mask != 0x01 {
diff --git a/internal/bitutils/bitmap_generate_test.go
b/internal/bitutils/bitmap_generate_test.go
index 3f3f8b7..b8510a0 100644
--- a/internal/bitutils/bitmap_generate_test.go
+++ b/internal/bitutils/bitmap_generate_test.go
@@ -17,10 +17,10 @@
package bitutils_test
import (
+ "math/rand/v2"
"testing"
"github.com/apache/arrow-go/v18/internal/bitutils"
- "golang.org/x/exp/rand"
)
const kBufferSize int64 = 1024 * 8
@@ -46,7 +46,7 @@ func runBench(b *testing.B, bitmap []byte, nbits int64, fn
func([]byte, int64, i
func BenchmarkGenerateBits(b *testing.B) {
nbits := kBufferSize * 8
// random bytes
- r := rand.New(rand.NewSource(0))
+ r := &rand.ChaCha8{}
bitmap := make([]byte, kBufferSize)
r.Read(bitmap)
@@ -58,7 +58,7 @@ func BenchmarkGenerateBits(b *testing.B) {
func BenchmarkGenerateBitsUnrolled(b *testing.B) {
nbits := kBufferSize * 8
// random bytes
- r := rand.New(rand.NewSource(0))
+ r := &rand.ChaCha8{}
bitmap := make([]byte, kBufferSize)
r.Read(bitmap)
diff --git a/internal/types/extension_types.go
b/internal/types/extension_types.go
index 73c92a5..8257059 100644
--- a/internal/types/extension_types.go
+++ b/internal/types/extension_types.go
@@ -65,7 +65,7 @@ type Parametric1Type struct {
func NewParametric1Type(p int32) *Parametric1Type {
ret := &Parametric1Type{param: p}
- ret.ExtensionBase.Storage = arrow.PrimitiveTypes.Int32
+ ret.Storage = arrow.PrimitiveTypes.Int32
return ret
}
@@ -116,7 +116,7 @@ type Parametric2Type struct {
func NewParametric2Type(p int32) *Parametric2Type {
ret := &Parametric2Type{param: p}
- ret.ExtensionBase.Storage = arrow.PrimitiveTypes.Int32
+ ret.Storage = arrow.PrimitiveTypes.Int32
return ret
}
diff --git a/parquet/encryption_write_config_test.go
b/parquet/encryption_write_config_test.go
index ff0154a..b2c10e5 100644
--- a/parquet/encryption_write_config_test.go
+++ b/parquet/encryption_write_config_test.go
@@ -137,9 +137,9 @@ func (en *EncryptionConfigTestSuite) encryptFile(configs
*parquet.FileEncryption
int64Writer := nextColumn().(*file.Int64ColumnChunkWriter)
for i := 0; i < 2*en.rowsPerRG; i++ {
var (
- defLevel = [1]int16{1}
- repLevel = [1]int16{0}
- value int64 = int64(i) * 1000 * 1000 * 1000
* 1000
+ defLevel = [1]int16{1}
+ repLevel = [1]int16{0}
+ value = int64(i) * 1000 * 1000 * 1000 * 1000
)
if i%2 == 0 {
repLevel[0] = 0
diff --git a/parquet/file/column_reader_test.go
b/parquet/file/column_reader_test.go
index f96156a..575bda4 100644
--- a/parquet/file/column_reader_test.go
+++ b/parquet/file/column_reader_test.go
@@ -122,10 +122,11 @@ func makePages(version parquet.DataPageVersion, d
*schema.Column, npages, lvlsPe
}
values := reflect.MakeSlice(reflect.SliceOf(typ), nvalues, nvalues)
- if enc == parquet.Encodings.Plain {
+ switch enc {
+ case parquet.Encodings.Plain:
initValues(values)
return testutils.PaginatePlain(version, d, values, defLevels,
repLevels, maxDef, maxRep, lvlsPerPage, valuesPerPage,
parquet.Encodings.Plain), nvalues, values, defLevels, repLevels
- } else if enc == parquet.Encodings.PlainDict || enc ==
parquet.Encodings.RLEDict {
+ case parquet.Encodings.PlainDict, parquet.Encodings.RLEDict:
initDictValues(values, lvlsPerPage)
return testutils.PaginateDict(version, d, values, defLevels,
repLevels, maxDef, maxRep, lvlsPerPage, valuesPerPage,
parquet.Encodings.RLEDict), nvalues, values, defLevels, repLevels
}
@@ -218,10 +219,10 @@ func (p *PrimitiveReaderSuite) checkResults(typ
reflect.Type) {
var (
read int64 = 0
- totalRead int = 0
- batchActual int = 0
+ totalRead = 0
+ batchActual = 0
batchSize int32 = 8
- batch int = 0
+ batch = 0
)
p.Require().NotNil(p.reader)
@@ -251,7 +252,7 @@ func (p *PrimitiveReaderSuite) checkResults(typ
reflect.Type) {
totalRead += batch
batchActual += int(read)
batchSize = int32(utils.Min(1<<24, utils.Max(int(batchSize*2),
4096)))
- if batch <= 0 {
+ if read <= 0 {
break
}
}
diff --git a/parquet/file/file_reader_mmap.go b/parquet/file/file_reader_mmap.go
index f2c06ea..44e48e9 100644
--- a/parquet/file/file_reader_mmap.go
+++ b/parquet/file/file_reader_mmap.go
@@ -64,12 +64,12 @@ func (m *mmapAdapter) Seek(offset int64, whence int)
(int64, error) {
case io.SeekCurrent:
newPos = m.pos + offs
case io.SeekEnd:
- newPos = int64(m.ReaderAt.Len()) + offs
+ newPos = int64(m.Len()) + offs
}
if newPos < 0 {
return 0, xerrors.New("negative result pos")
}
- if newPos > int64(m.ReaderAt.Len()) {
+ if newPos > int64(m.Len()) {
return 0, xerrors.New("new position exceeds size of file")
}
m.pos = newPos
diff --git a/parquet/file/level_conversion.go b/parquet/file/level_conversion.go
index b0db789..7661288 100644
--- a/parquet/file/level_conversion.go
+++ b/parquet/file/level_conversion.go
@@ -179,10 +179,8 @@ func defLevelsToBitmapInternal(defLevels []int16, info
LevelInfo, out *ValidityB
// DefLevelsToBitmap creates a validitybitmap out of the passed in definition
levels and info object.
func DefLevelsToBitmap(defLevels []int16, info LevelInfo, out
*ValidityBitmapInputOutput) {
- hasRepeatedParent := false
- if info.RepLevel > 0 {
- hasRepeatedParent = true
- }
+ hasRepeatedParent := info.RepLevel > 0
+
defLevelsToBitmapInternal(defLevels, info, out, hasRepeatedParent)
}
diff --git a/parquet/file/record_reader.go b/parquet/file/record_reader.go
index e2fdcc8..81ec0af 100644
--- a/parquet/file/record_reader.go
+++ b/parquet/file/record_reader.go
@@ -169,7 +169,7 @@ func (pr *primitiveRecordReader) Release() {
}
func (pr *primitiveRecordReader) SetPageReader(rdr PageReader) {
- pr.ColumnChunkReader.setPageReader(rdr)
+ pr.setPageReader(rdr)
}
func (pr *primitiveRecordReader) ReleaseValidBits() *memory.Buffer {
@@ -444,7 +444,7 @@ func (rr *recordReader) reserveLevels(extra int64) error {
}
func (rr *recordReader) reserveValues(extra int64) error {
- return rr.recordReaderImpl.ReserveValues(extra,
rr.leafInfo.HasNullableValues())
+ return rr.ReserveValues(extra, rr.leafInfo.HasNullableValues())
}
func (rr *recordReader) ResetValues() {
diff --git a/parquet/internal/encoding/decoder.go
b/parquet/internal/encoding/decoder.go
index 64455d1..b2a012e 100644
--- a/parquet/internal/encoding/decoder.go
+++ b/parquet/internal/encoding/decoder.go
@@ -214,7 +214,7 @@ func spacedExpand(buffer interface{}, nullCount int,
validBits []byte, validBits
}
var (
- numValues int = bufferRef.Len()
+ numValues = bufferRef.Len()
)
idxDecode := int64(numValues - nullCount)
diff --git a/parquet/internal/testutils/random.go
b/parquet/internal/testutils/random.go
index 5044b74..a0fc949 100644
--- a/parquet/internal/testutils/random.go
+++ b/parquet/internal/testutils/random.go
@@ -21,6 +21,7 @@ package testutils
import (
"encoding/binary"
"math"
+ "math/rand/v2"
"time"
"unsafe"
@@ -33,7 +34,6 @@ import (
"github.com/apache/arrow-go/v18/parquet"
"github.com/apache/arrow-go/v18/parquet/pqarrow"
- "golang.org/x/exp/rand"
"gonum.org/v1/gonum/stat/distuv"
)
@@ -48,7 +48,7 @@ type RandomArrayGenerator struct {
// NewRandomArrayGenerator constructs a new generator with the requested Seed
func NewRandomArrayGenerator(seed uint64) RandomArrayGenerator {
- src := rand.NewSource(seed)
+ src := rand.NewPCG(seed, 0)
return RandomArrayGenerator{seed, 0, src, rand.New(src)}
}
@@ -62,7 +62,7 @@ func (r *RandomArrayGenerator) GenerateBitmap(buffer []byte,
n int64, prob float
// bernoulli distribution uses P to determine the probability of a 0 or
a 1,
// which we'll use to generate the bitmap.
- dist := distuv.Bernoulli{P: prob, Src: rand.NewSource(r.seed + r.extra)}
+ dist := distuv.Bernoulli{P: prob, Src: rand.NewPCG(r.seed, r.extra)}
for i := 0; int64(i) < n; i++ {
if dist.Rand() != float64(0.0) {
bitutil.SetBit(buffer, i)
@@ -88,7 +88,7 @@ func (r *RandomArrayGenerator) ByteArray(size int64, minLen,
maxLen int32, nullP
defer lengths.Release()
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
bldr := array.NewStringBuilder(memory.DefaultAllocator)
defer bldr.Release()
@@ -98,7 +98,7 @@ func (r *RandomArrayGenerator) ByteArray(size int64, minLen,
maxLen int32, nullP
if lengths.IsValid(i) {
l := lengths.Value(i)
for j := int32(0); j < l; j++ {
- strbuf[j] =
byte(dist.Int31n(int32('z')-int32('A')+1) + int32('A'))
+ strbuf[j] =
byte(dist.Int32N(int32('z')-int32('A')+1) + int32('A'))
}
val := strbuf[:l]
bldr.Append(*(*string)(unsafe.Pointer(&val)))
@@ -124,10 +124,10 @@ func (r *RandomArrayGenerator) Uint8(size int64, min, max
uint8, prob float64) a
buffers[1].Resize(int(size * int64(arrow.Uint8SizeBytes)))
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Uint8Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
- out[i] = uint8(dist.Intn(int(max-min+1))) + min
+ out[i] = uint8(dist.IntN(int(max-min+1))) + min
}
return array.NewUint8Data(array.NewData(arrow.PrimitiveTypes.Uint8,
int(size), buffers, nil, int(nullCount), 0))
@@ -147,10 +147,10 @@ func (r *RandomArrayGenerator) Int32(size int64, min, max
int32, pctNull float64
buffers[1].Resize(arrow.Int32Traits.BytesRequired(int(size)))
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Int32Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
- out[i] = dist.Int31n(max-min+1) + min
+ out[i] = dist.Int32N(max-min+1) + min
}
return array.NewInt32Data(array.NewData(arrow.PrimitiveTypes.Int32,
int(size), buffers, nil, int(nullCount), 0))
}
@@ -169,10 +169,10 @@ func (r *RandomArrayGenerator) Int64(size int64, min, max
int64, pctNull float64
buffers[1].Resize(arrow.Int64Traits.BytesRequired(int(size)))
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Int64Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
- out[i] = dist.Int63n(max-min+1) + min
+ out[i] = dist.Int64N(max-min+1) + min
}
return array.NewInt64Data(array.NewData(arrow.PrimitiveTypes.Int64,
int(size), buffers, nil, int(nullCount), 0))
}
@@ -191,7 +191,7 @@ func (r *RandomArrayGenerator) Float64(size int64, pctNull
float64) *array.Float
buffers[1].Resize(arrow.Float64Traits.BytesRequired(int(size)))
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Float64Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
out[i] = dist.NormFloat64()
@@ -231,43 +231,43 @@ func (r *RandomArrayGenerator) StringWithRepeats(mem
memory.Allocator, sz, uniqu
// FillRandomInt8 populates the slice out with random int8 values between min
and max using
// seed as the random see for generation to allow consistency for testing.
func FillRandomInt8(seed uint64, min, max int8, out []int8) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = int8(r.Intn(int(max-min+1))) + min
+ out[idx] = int8(r.IntN(int(max-min+1))) + min
}
}
// FillRandomUint8 populates the slice out with random uint8 values between
min and max using
// seed as the random see for generation to allow consistency for testing.
func FillRandomUint8(seed uint64, min, max uint8, out []uint8) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = uint8(r.Intn(int(max-min+1))) + min
+ out[idx] = uint8(r.IntN(int(max-min+1))) + min
}
}
// FillRandomInt16 populates the slice out with random int16 values between
min and max using
// seed as the random see for generation to allow consistency for testing.
func FillRandomInt16(seed uint64, min, max int16, out []int16) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = int16(r.Intn(int(max-min+1))) + min
+ out[idx] = int16(r.IntN(int(max-min+1))) + min
}
}
// FillRandomUint16 populates the slice out with random uint16 values between
min and max using
// seed as the random see for generation to allow consistency for testing.
func FillRandomUint16(seed uint64, min, max uint16, out []uint16) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = uint16(r.Intn(int(max-min+1))) + min
+ out[idx] = uint16(r.IntN(int(max-min+1))) + min
}
}
// FillRandomInt32 populates out with random int32 values using seed as the
random
// seed for the generator to allow consistency for testing.
func FillRandomInt32(seed uint64, out []int32) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = int32(r.Uint32())
}
@@ -276,34 +276,34 @@ func FillRandomInt32(seed uint64, out []int32) {
// FillRandomInt32Max populates out with random int32 values between 0 and max
using seed as the random
// seed for the generator to allow consistency for testing.
func FillRandomInt32Max(seed uint64, max int32, out []int32) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = r.Int31n(max)
+ out[idx] = r.Int32N(max)
}
}
// FillRandomUint32Max populates out with random uint32 values between 0 and
max using seed as the random
// seed for the generator to allow consistency for testing.
func FillRandomUint32Max(seed uint64, max uint32, out []uint32) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = uint32(r.Uint64n(uint64(max)))
+ out[idx] = uint32(r.Uint64N(uint64(max)))
}
}
// FillRandomInt64Max populates out with random int64 values between 0 and max
using seed as the random
// seed for the generator to allow consistency for testing.
func FillRandomInt64Max(seed uint64, max int64, out []int64) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = r.Int63n(max)
+ out[idx] = r.Int64N(max)
}
}
// FillRandomUint32 populates out with random uint32 values using seed as the
random
// seed for the generator to allow consistency for testing.
func FillRandomUint32(seed uint64, out []uint32) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = r.Uint32()
}
@@ -312,7 +312,7 @@ func FillRandomUint32(seed uint64, out []uint32) {
// FillRandomUint64 populates out with random uint64 values using seed as the
random
// seed for the generator to allow consistency for testing.
func FillRandomUint64(seed uint64, out []uint64) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = r.Uint64()
}
@@ -321,16 +321,16 @@ func FillRandomUint64(seed uint64, out []uint64) {
// FillRandomUint64Max populates out with random uint64 values between 0 and
max using seed as the random
// seed for the generator to allow consistency for testing.
func FillRandomUint64Max(seed uint64, max uint64, out []uint64) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
- out[idx] = r.Uint64n(max)
+ out[idx] = r.Uint64N(max)
}
}
// FillRandomInt64 populates out with random int64 values using seed as the
random
// seed for the generator to allow consistency for testing.
func FillRandomInt64(seed uint64, out []int64) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = int64(r.Uint64())
}
@@ -340,7 +340,7 @@ func FillRandomInt64(seed uint64, out []int64) {
// seed for the generator to allow consistency for testing. It does this by
generating
// three random uint32 values for each int96 value.
func FillRandomInt96(seed uint64, out []parquet.Int96) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
*(*int32)(unsafe.Pointer(&out[idx][0])) = int32(r.Uint32())
*(*int32)(unsafe.Pointer(&out[idx][4])) = int32(r.Uint32())
@@ -374,7 +374,7 @@ func randFloat64(r *rand.Rand) float64 {
// to better spread the values out and ensure we do not return any NaN or Inf
values.
func randFloat16(r *rand.Rand) float16.Num {
for {
- f := float16.FromBits(uint16(r.Uint64n(math.MaxUint16 + 1)))
+ f := float16.FromBits(uint16(r.Uint64N(math.MaxUint16 + 1)))
if !f.IsNaN() {
return f
}
@@ -384,7 +384,7 @@ func randFloat16(r *rand.Rand) float16.Num {
// FillRandomFloat32 populates out with random float32 values using seed as
the random
// seed for the generator to allow consistency for testing.
func FillRandomFloat32(seed uint64, out []float32) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = randFloat32(r)
}
@@ -393,7 +393,7 @@ func FillRandomFloat32(seed uint64, out []float32) {
// FillRandomFloat64 populates out with random float64 values using seed as
the random
// seed for the generator to allow consistency for testing.
func FillRandomFloat64(seed uint64, out []float64) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = randFloat64(r)
}
@@ -402,7 +402,7 @@ func FillRandomFloat64(seed uint64, out []float64) {
// FillRandomFloat16 populates out with random float64 values using seed as
the random
// seed for the generator to allow consistency for testing.
func FillRandomFloat16(seed uint64, out []float16.Num) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = randFloat16(r)
}
@@ -425,8 +425,11 @@ func FillRandomByteArray(seed uint64, out
[]parquet.ByteArray, heap *memory.Buff
func FillRandomFixedByteArray(seed uint64, out []parquet.FixedLenByteArray,
heap *memory.Buffer, size int) {
heap.Resize(len(out) * size)
+ var seedBytes [32]byte
+ binary.LittleEndian.PutUint64(seedBytes[:8], seed)
+
buf := heap.Bytes()
- r := rand.New(rand.NewSource(seed))
+ r := rand.NewChaCha8(seedBytes)
for idx := range out {
r.Read(buf[:size])
out[idx] = buf[:size]
@@ -438,7 +441,7 @@ func FillRandomFixedByteArray(seed uint64, out
[]parquet.FixedLenByteArray, heap
// seed as the random seed to the generator in order to allow consistency for
testing. This uses
// a Bernoulli distribution of values.
func FillRandomBooleans(p float64, seed uint64, out []bool) {
- dist := distuv.Bernoulli{P: p, Src: rand.NewSource(seed)}
+ dist := distuv.Bernoulli{P: p, Src: rand.NewPCG(seed, 0)}
for idx := range out {
out[idx] = dist.Rand() != float64(0.0)
}
@@ -449,7 +452,7 @@ func FillRandomBooleans(p float64, seed uint64, out []bool)
{
// the default Golang random generator distribution of float64 values between
0 and 1 comparing against
// pctNull. If the random value is > pctNull, it is true.
func fillRandomIsValid(seed uint64, pctNull float64, out []bool) {
- r := rand.New(rand.NewSource(seed))
+ r := rand.New(rand.NewPCG(seed, 0))
for idx := range out {
out[idx] = r.Float64() > pctNull
}
@@ -494,11 +497,15 @@ func InitValues(values interface{}, heap *memory.Buffer) {
func RandomByteArray(seed uint64, out []parquet.ByteArray, heap
*memory.Buffer, minlen, maxlen int) {
heap.Resize(len(out) * (maxlen + arrow.Uint32SizeBytes))
+ var seedBytes [32]byte
+ binary.LittleEndian.PutUint64(seedBytes[:8], seed)
+
buf := heap.Bytes()
- r := rand.New(rand.NewSource(seed))
+ src := rand.NewChaCha8(seedBytes)
+ r := rand.New(src)
for idx := range out {
- length := r.Intn(maxlen-minlen+1) + minlen
- r.Read(buf[:length])
+ length := r.IntN(maxlen-minlen+1) + minlen
+ src.Read(buf[:length])
out[idx] = buf[:length]
buf = buf[length:]
@@ -509,7 +516,10 @@ func RandomByteArray(seed uint64, out []parquet.ByteArray,
heap *memory.Buffer,
// for the values and seed as the random generator seed to allow consistency
for testing. The
// resulting values will be either 32 bytes or 16 bytes each depending on the
precision.
func RandomDecimals(n int64, seed uint64, precision int32) []byte {
- r := rand.New(rand.NewSource(seed))
+ var seedBytes [32]byte
+ binary.LittleEndian.PutUint64(seedBytes[:8], seed)
+
+ r := rand.NewChaCha8(seedBytes)
nreqBytes := pqarrow.DecimalSize(precision)
byteWidth := 32
if precision <= 38 {
diff --git a/parquet/internal/testutils/random_arrow.go
b/parquet/internal/testutils/random_arrow.go
index 6fa10d3..01ea08b 100644
--- a/parquet/internal/testutils/random_arrow.go
+++ b/parquet/internal/testutils/random_arrow.go
@@ -17,11 +17,12 @@
package testutils
import (
+ "math/rand/v2"
+
"github.com/apache/arrow-go/v18/arrow"
"github.com/apache/arrow-go/v18/arrow/array"
"github.com/apache/arrow-go/v18/arrow/float16"
"github.com/apache/arrow-go/v18/arrow/memory"
- "golang.org/x/exp/rand"
)
// RandomNonNull generates a random arrow array of the requested type with
length size with no nulls.
@@ -156,10 +157,11 @@ func RandomNonNull(mem memory.Allocator, dt
arrow.DataType, size int) arrow.Arra
defer bldr.Release()
buf := make([]byte, 12)
- r := rand.New(rand.NewSource(0))
+ src := &rand.ChaCha8{}
+ r := rand.New(src)
for i := 0; i < size; i++ {
- length := r.Intn(12-2+1) + 2
- r.Read(buf[:length])
+ length := r.IntN(12-2+1) + 2
+ src.Read(buf[:length])
bldr.Append(buf[:length])
}
return bldr.NewArray()
@@ -168,7 +170,7 @@ func RandomNonNull(mem memory.Allocator, dt arrow.DataType,
size int) arrow.Arra
defer bldr.Release()
buf := make([]byte, 10)
- r := rand.New(rand.NewSource(0))
+ r := &rand.ChaCha8{}
for i := 0; i < size; i++ {
r.Read(buf)
bldr.Append(buf)
@@ -416,15 +418,16 @@ func RandomNullable(dt arrow.DataType, size int, numNulls
int) arrow.Array {
}
buf := make([]byte, 12)
- r := rand.New(rand.NewSource(0))
+ src := &rand.ChaCha8{}
+ r := rand.New(src)
for i := 0; i < size; i++ {
if !valid[i] {
bldr.AppendNull()
continue
}
- length := r.Intn(12-2+1) + 2
- r.Read(buf[:length])
+ length := r.IntN(12-2+1) + 2
+ src.Read(buf[:length])
bldr.Append(buf[:length])
}
return bldr.NewArray()
@@ -441,15 +444,16 @@ func RandomNullable(dt arrow.DataType, size int, numNulls
int) arrow.Array {
}
buf := make([]byte, 12)
- r := rand.New(rand.NewSource(0))
+ src := &rand.ChaCha8{}
+ r := rand.New(src)
for i := 0; i < size; i++ {
if !valid[i] {
bldr.AppendNull()
continue
}
- length := r.Intn(12-2+1) + 2
- r.Read(buf[:length])
+ length := r.IntN(12-2+1) + 2
+ src.Read(buf[:length])
// trivially force data to be valid UTF8 by making it
all ASCII
for idx := range buf[:length] {
buf[idx] &= 0x7f
@@ -470,7 +474,7 @@ func RandomNullable(dt arrow.DataType, size int, numNulls
int) arrow.Array {
}
buf := make([]byte, 10)
- r := rand.New(rand.NewSource(0))
+ r := &rand.ChaCha8{}
for i := 0; i < size; i++ {
if !valid[i] {
bldr.AppendNull()
diff --git a/parquet/internal/utils/bit_reader_test.go
b/parquet/internal/utils/bit_reader_test.go
index 3987cd5..366ae40 100644
--- a/parquet/internal/utils/bit_reader_test.go
+++ b/parquet/internal/utils/bit_reader_test.go
@@ -22,6 +22,7 @@ import (
"fmt"
"math"
"math/bits"
+ "math/rand/v2"
"strconv"
"testing"
@@ -32,7 +33,6 @@ import (
"github.com/apache/arrow-go/v18/parquet/internal/utils"
"github.com/stretchr/testify/assert"
"github.com/stretchr/testify/suite"
- "golang.org/x/exp/rand"
"gonum.org/v1/gonum/stat/distuv"
)
@@ -550,15 +550,15 @@ func (r *RLERandomSuite) TestRandomSequences() {
const maxgroup = 16
values := make([]uint64, ngroups+maxgroup)
- seed := rand.Uint64() ^ (rand.Uint64() << 32)
- gen := rand.New(rand.NewSource(seed))
+ seed1, seed2 := rand.Uint64(), rand.Uint64()<<32
+ gen := rand.New(rand.NewPCG(seed1, seed2))
for itr := 0; itr < niters; itr++ {
parity := false
values = values[:0]
for i := 0; i < ngroups; i++ {
- groupsize := gen.Intn(19) + 1
+ groupsize := gen.IntN(19) + 1
if groupsize > maxgroup {
groupsize = 1
}
@@ -572,7 +572,7 @@ func (r *RLERandomSuite) TestRandomSequences() {
}
parity = !parity
}
- r.Require().Truef(r.checkRoundTrip(values,
bits.Len(uint(len(values)))), "failing seed: %d", seed)
+ r.Require().Truef(r.checkRoundTrip(values,
bits.Len(uint(len(values)))), "failing seed: %d,%d", seed1, seed2)
}
}
@@ -584,7 +584,7 @@ type RandomArrayGenerator struct {
}
func NewRandomArrayGenerator(seed uint64) RandomArrayGenerator {
- src := rand.NewSource(seed)
+ src := rand.NewPCG(seed, 0)
return RandomArrayGenerator{seed, 0, src, rand.New(src)}
}
@@ -592,7 +592,7 @@ func (r *RandomArrayGenerator) generateBitmap(buffer
[]byte, n int64, prob float
count := int64(0)
r.extra++
- dist := distuv.Bernoulli{P: prob, Src: rand.NewSource(r.seed + r.extra)}
+ dist := distuv.Bernoulli{P: prob, Src: rand.NewPCG(r.seed, r.extra)}
for i := int(0); int64(i) < n; i++ {
if dist.Rand() != float64(0.0) {
bitutil.SetBit(buffer, i)
@@ -616,10 +616,10 @@ func (r *RandomArrayGenerator) Int32(size int64, min, max
int32, prob float64) a
buffers[1].Resize(int(size * int64(arrow.Int32SizeBytes)))
r.extra++
- dist := rand.New(rand.NewSource(r.seed + r.extra))
+ dist := rand.New(rand.NewPCG(r.seed, r.extra))
out := arrow.Int32Traits.CastFromBytes(buffers[1].Bytes())
for i := int64(0); i < size; i++ {
- out[i] = int32(dist.Int31n(max-min+1)) + min
+ out[i] = int32(dist.Int32N(max-min+1)) + min
}
return array.NewInt32Data(array.NewData(arrow.PrimitiveTypes.Int32,
int(size), buffers, nil, int(nullCount), 0))
diff --git a/parquet/metadata/page_index.go b/parquet/metadata/page_index.go
index 020ab4c..7e0b3e4 100644
--- a/parquet/metadata/page_index.go
+++ b/parquet/metadata/page_index.go
@@ -611,9 +611,10 @@ func newColumnIndexBuilder[T parquet.ColumnTypes](descr
*schema.Column) *columnI
}
func (b *columnIndexBuilder[T]) AddPage(stats *EncodedStatistics) error {
- if b.state == stateFinished {
+ switch b.state {
+ case stateFinished:
return fmt.Errorf("%w: cannot add page to finished
ColumnIndexBuilder", arrow.ErrInvalid)
- } else if b.state == stateDiscarded {
+ case stateDiscarded:
return nil
}
@@ -750,9 +751,10 @@ func (o *OffsetIndexBuilder) AddPageLoc(pgloc
PageLocation) error {
}
func (o *OffsetIndexBuilder) AddPage(offset, firstRowIdx int64,
compressedPgSize int32) error {
- if o.state == stateFinished {
+ switch o.state {
+ case stateFinished:
return fmt.Errorf("%w: cannot add page to finished
OffsetIndexBuilder", arrow.ErrInvalid)
- } else if o.state == stateDiscarded {
+ case stateDiscarded:
// offset index is discarded, do nothing
return nil
}
diff --git a/parquet/pqarrow/path_builder.go b/parquet/pqarrow/path_builder.go
index 7abd0f5..784a2c2 100644
--- a/parquet/pqarrow/path_builder.go
+++ b/parquet/pqarrow/path_builder.go
@@ -251,7 +251,7 @@ type nullableNode struct {
}
func (n *nullableNode) clone() pathNode {
- var ret nullableNode = *n
+ var ret = *n
return &ret
}
@@ -632,7 +632,7 @@ type int16BufferBuilder struct {
}
func (b *int16BufferBuilder) Values() []int16 {
- return arrow.Int16Traits.CastFromBytes(b.PooledBufferWriter.Bytes())
+ return arrow.Int16Traits.CastFromBytes(b.Bytes())
}
func (b *int16BufferBuilder) Value(i int) int16 {
@@ -651,12 +651,12 @@ func (b *int16BufferBuilder) AppendCopies(count int, val
int16) {
}
func (b *int16BufferBuilder) UnsafeAppend(v int16) {
- b.PooledBufferWriter.UnsafeWrite((*(*[2]byte)(unsafe.Pointer(&v)))[:])
+ b.UnsafeWrite((*(*[2]byte)(unsafe.Pointer(&v)))[:])
}
func (b *int16BufferBuilder) Append(v int16) {
b.PooledBufferWriter.Reserve(arrow.Int16SizeBytes)
- b.PooledBufferWriter.Write((*(*[2]byte)(unsafe.Pointer(&v)))[:])
+ b.Write((*(*[2]byte)(unsafe.Pointer(&v)))[:])
}
func fillRepLevels(count int, repLvl int16, ctx *pathWriteCtx) {
diff --git a/parquet/pqarrow/reader_writer_test.go
b/parquet/pqarrow/reader_writer_test.go
index d00b5d2..f346876 100644
--- a/parquet/pqarrow/reader_writer_test.go
+++ b/parquet/pqarrow/reader_writer_test.go
@@ -21,6 +21,7 @@ import (
"context"
"fmt"
"math"
+ "math/rand/v2"
"testing"
"unsafe"
@@ -32,7 +33,6 @@ import (
"github.com/apache/arrow-go/v18/parquet/file"
"github.com/apache/arrow-go/v18/parquet/pqarrow"
"github.com/stretchr/testify/require"
- "golang.org/x/exp/rand"
"gonum.org/v1/gonum/stat/distuv"
)
@@ -50,7 +50,7 @@ func randomUint8(size, truePct int, sampleVals [2]uint8, seed
uint64) []uint8 {
dist := distuv.Bernoulli{
P: float64(truePct) / 100.0,
- Src: rand.NewSource(seed),
+ Src: rand.NewPCG(seed, 0),
}
for idx := range ret {
@@ -70,7 +70,7 @@ func randomInt32(size, truePct int, sampleVals [2]int32, seed
uint64) []int32 {
dist := distuv.Bernoulli{
P: float64(truePct) / 100.0,
- Src: rand.NewSource(seed),
+ Src: rand.NewPCG(seed, 0),
}
for idx := range ret {
diff --git a/parquet/schema/reflection.go b/parquet/schema/reflection.go
index c5e21b0..6082c29 100644
--- a/parquet/schema/reflection.go
+++ b/parquet/schema/reflection.go
@@ -242,7 +242,7 @@ func infoFromTags(f reflect.StructTag) *taggedInfo {
info.Exclude = true
return &info
}
- for _, tag := range strings.Split(strings.Replace(ptags, "\t",
"", -1), ",") {
+ for _, tag := range strings.Split(strings.ReplaceAll(ptags,
"\t", ""), ",") {
tag = strings.TrimSpace(tag)
kv := strings.SplitN(tag, "=", 2)
key := strings.TrimSpace(strings.ToLower(kv[0]))
@@ -488,9 +488,10 @@ func typeToNode(name string, typ reflect.Type, repType
parquet.Repetition, info
bitwidth := int8(typ.Bits())
if physical != parquet.Types.Undefined {
- if ptyp == parquet.Types.Int32 {
+ switch ptyp {
+ case parquet.Types.Int32:
bitwidth = 32
- } else if ptyp == parquet.Types.Int64 {
+ case parquet.Types.Int64:
bitwidth = 64
}
}
@@ -517,9 +518,10 @@ func typeToNode(name string, typ reflect.Type, repType
parquet.Repetition, info
bitwidth := int8(typ.Bits())
if physical != parquet.Types.Undefined {
- if ptyp == parquet.Types.Int32 {
+ switch ptyp {
+ case parquet.Types.Int32:
bitwidth = 32
- } else if ptyp == parquet.Types.Int64 {
+ case parquet.Types.Int64:
bitwidth = 64
}
}
