github.com/apache/arrow/go/v7@v7.0.1/parquet/pqarrow/path_builder_test.go (about)

     1  // Licensed to the Apache Software Foundation (ASF) under one
     2  // or more contributor license agreements.  See the NOTICE file
     3  // distributed with this work for additional information
     4  // regarding copyright ownership.  The ASF licenses this file
     5  // to you under the Apache License, Version 2.0 (the
     6  // "License"); you may not use this file except in compliance
     7  // with the License.  You may obtain a copy of the License at
     8  //
     9  // http://www.apache.org/licenses/LICENSE-2.0
    10  //
    11  // Unless required by applicable law or agreed to in writing, software
    12  // distributed under the License is distributed on an "AS IS" BASIS,
    13  // WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    14  // See the License for the specific language governing permissions and
    15  // limitations under the License.
    16  
    17  package pqarrow
    18  
    19  import (
    20  	"context"
    21  	"testing"
    22  
    23  	"github.com/apache/arrow/go/v7/arrow"
    24  	"github.com/apache/arrow/go/v7/arrow/array"
    25  	"github.com/apache/arrow/go/v7/arrow/memory"
    26  	"github.com/stretchr/testify/assert"
    27  	"github.com/stretchr/testify/require"
    28  )
    29  
    30  func TestNonNullableSingleList(t *testing.T) {
    31  	// translates to the following parquet schema:
    32  	// required group bag {
    33  	//   repeated group [unseen] (List) {
    34  	//		 required int64 Entires;
    35  	//	 }
    36  	// }
    37  	// So:
    38  	// def level 0: a null entry
    39  	// def level 1: a non-null entry
    40  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
    41  	defer bldr.Release()
    42  
    43  	vb := bldr.ValueBuilder().(*array.Int64Builder)
    44  
    45  	bldr.Append(true)
    46  	vb.Append(1)
    47  
    48  	bldr.Append(true)
    49  	vb.Append(2)
    50  	vb.Append(3)
    51  
    52  	bldr.Append(true)
    53  	vb.Append(4)
    54  	vb.Append(5)
    55  	vb.Append(6)
    56  
    57  	arr := bldr.NewListArray()
    58  	defer arr.Release()
    59  
    60  	mp, err := newMultipathLevelBuilder(arr, false)
    61  	require.NoError(t, err)
    62  	defer mp.Release()
    63  
    64  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
    65  	result, err := mp.write(0, ctx)
    66  	require.NoError(t, err)
    67  
    68  	assert.Equal(t, []int16{2, 2, 2, 2, 2, 2}, result.defLevels)
    69  	assert.Equal(t, []int16{0, 0, 1, 0, 1, 1}, result.repLevels)
    70  	assert.Len(t, result.postListVisitedElems, 1)
    71  	assert.EqualValues(t, 0, result.postListVisitedElems[0].start)
    72  	assert.EqualValues(t, 6, result.postListVisitedElems[0].end)
    73  }
    74  
    75  // next group of tests translates to the following parquet schema:
    76  // optional group bag {
    77  //   repeated group [unseen] (List) {
    78  //		 optional int64 Entires;
    79  //	 }
    80  // }
    81  // So:
    82  // def level 0: a null list
    83  // def level 1: an empty list
    84  // def level 2: a null entry
    85  // def level 3: a non-null entry
    86  
    87  func TestNullableSingleListAllNulls(t *testing.T) {
    88  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
    89  	defer bldr.Release()
    90  
    91  	bldr.AppendNull()
    92  	bldr.AppendNull()
    93  	bldr.AppendNull()
    94  	bldr.AppendNull()
    95  
    96  	arr := bldr.NewListArray()
    97  	defer arr.Release()
    98  
    99  	mp, err := newMultipathLevelBuilder(arr, true)
   100  	require.NoError(t, err)
   101  	defer mp.Release()
   102  
   103  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   104  	result, err := mp.write(0, ctx)
   105  	require.NoError(t, err)
   106  
   107  	assert.Equal(t, []int16{0, 0, 0, 0}, result.defLevels)
   108  	assert.Equal(t, []int16{0, 0, 0, 0}, result.repLevels)
   109  }
   110  
   111  func TestNullableSingleListAllEmpty(t *testing.T) {
   112  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
   113  	defer bldr.Release()
   114  
   115  	bldr.Append(true)
   116  	bldr.Append(true)
   117  	bldr.Append(true)
   118  	bldr.Append(true)
   119  
   120  	arr := bldr.NewListArray()
   121  	defer arr.Release()
   122  
   123  	mp, err := newMultipathLevelBuilder(arr, true)
   124  	require.NoError(t, err)
   125  	defer mp.Release()
   126  
   127  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   128  	result, err := mp.write(0, ctx)
   129  	require.NoError(t, err)
   130  
   131  	assert.Equal(t, []int16{1, 1, 1, 1}, result.defLevels)
   132  	assert.Equal(t, []int16{0, 0, 0, 0}, result.repLevels)
   133  }
   134  
   135  func TestNullableSingleListAllNullEntries(t *testing.T) {
   136  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
   137  	defer bldr.Release()
   138  
   139  	vb := bldr.ValueBuilder().(*array.Int64Builder)
   140  
   141  	bldr.Append(true)
   142  	vb.AppendNull()
   143  	bldr.Append(true)
   144  	vb.AppendNull()
   145  	bldr.Append(true)
   146  	vb.AppendNull()
   147  	bldr.Append(true)
   148  	vb.AppendNull()
   149  
   150  	arr := bldr.NewListArray()
   151  	defer arr.Release()
   152  
   153  	mp, err := newMultipathLevelBuilder(arr, true)
   154  	require.NoError(t, err)
   155  	defer mp.Release()
   156  
   157  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   158  	result, err := mp.write(0, ctx)
   159  	require.NoError(t, err)
   160  
   161  	assert.Equal(t, []int16{2, 2, 2, 2}, result.defLevels)
   162  	assert.Equal(t, []int16{0, 0, 0, 0}, result.repLevels)
   163  	assert.Len(t, result.postListVisitedElems, 1)
   164  	assert.EqualValues(t, 0, result.postListVisitedElems[0].start)
   165  	assert.EqualValues(t, 4, result.postListVisitedElems[0].end)
   166  }
   167  
   168  func TestNullableSingleListAllPresentEntries(t *testing.T) {
   169  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
   170  	defer bldr.Release()
   171  
   172  	vb := bldr.ValueBuilder().(*array.Int64Builder)
   173  
   174  	bldr.Append(true)
   175  	bldr.Append(true)
   176  	bldr.Append(true)
   177  	vb.Append(1)
   178  	bldr.Append(true)
   179  	bldr.Append(true)
   180  	vb.Append(2)
   181  	vb.Append(3)
   182  
   183  	arr := bldr.NewListArray()
   184  	defer arr.Release()
   185  
   186  	mp, err := newMultipathLevelBuilder(arr, true)
   187  	require.NoError(t, err)
   188  	defer mp.Release()
   189  
   190  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   191  	result, err := mp.write(0, ctx)
   192  	require.NoError(t, err)
   193  
   194  	assert.Equal(t, []int16{1, 1, 3, 1, 3, 3}, result.defLevels)
   195  	assert.Equal(t, []int16{0, 0, 0, 0, 0, 1}, result.repLevels)
   196  	assert.Len(t, result.postListVisitedElems, 1)
   197  	assert.EqualValues(t, 0, result.postListVisitedElems[0].start)
   198  	assert.EqualValues(t, 3, result.postListVisitedElems[0].end)
   199  }
   200  
   201  func TestNullableSingleListSomeNullEntriesSomeNullLists(t *testing.T) {
   202  	bldr := array.NewListBuilder(memory.DefaultAllocator, arrow.PrimitiveTypes.Int64)
   203  	defer bldr.Release()
   204  
   205  	vb := bldr.ValueBuilder().(*array.Int64Builder)
   206  
   207  	bldr.Append(false)
   208  	bldr.Append(true)
   209  	vb.AppendValues([]int64{1, 2, 3}, nil)
   210  	bldr.Append(true)
   211  	bldr.Append(true)
   212  	bldr.AppendNull()
   213  	bldr.AppendNull()
   214  	bldr.Append(true)
   215  	vb.AppendValues([]int64{4, 5}, nil)
   216  	bldr.Append(true)
   217  	vb.AppendNull()
   218  
   219  	arr := bldr.NewListArray()
   220  	defer arr.Release()
   221  
   222  	mp, err := newMultipathLevelBuilder(arr, true)
   223  	require.NoError(t, err)
   224  	defer mp.Release()
   225  
   226  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   227  	result, err := mp.write(0, ctx)
   228  	require.NoError(t, err)
   229  
   230  	assert.Equal(t, []int16{0, 3, 3, 3, 1, 1, 0, 0, 3, 3, 2}, result.defLevels)
   231  	assert.Equal(t, []int16{0, 0, 1, 1, 0, 0, 0, 0, 0, 1, 0}, result.repLevels)
   232  }
   233  
   234  // next group of tests translate to the following parquet schema:
   235  //
   236  // optional group bag {
   237  //   repeated group outer_list (List) {
   238  //     optional group nullable {
   239  //       repeated group inner_list (List) {
   240  //         optional int64 Entries;
   241  //       }
   242  //     }
   243  //   }
   244  // }
   245  // So:
   246  // def level 0: null outer list
   247  // def level 1: empty outer list
   248  // def level 2: null inner list
   249  // def level 3: empty inner list
   250  // def level 4: null entry
   251  // def level 5: non-null entry
   252  
   253  func TestNestedListsWithSomeEntries(t *testing.T) {
   254  	listType := arrow.ListOf(arrow.PrimitiveTypes.Int64)
   255  	bldr := array.NewListBuilder(memory.DefaultAllocator, listType)
   256  	defer bldr.Release()
   257  
   258  	nestedBldr := bldr.ValueBuilder().(*array.ListBuilder)
   259  	vb := nestedBldr.ValueBuilder().(*array.Int64Builder)
   260  
   261  	// produce: [null, [[1, 2, 3], [4, 5]], [[], [], []], []]
   262  
   263  	bldr.AppendNull()
   264  	bldr.Append(true)
   265  	nestedBldr.Append(true)
   266  	vb.AppendValues([]int64{1, 2, 3}, nil)
   267  	nestedBldr.Append(true)
   268  	vb.AppendValues([]int64{4, 5}, nil)
   269  
   270  	bldr.Append(true)
   271  	nestedBldr.Append(true)
   272  	nestedBldr.Append(true)
   273  	nestedBldr.Append(true)
   274  	bldr.Append(true)
   275  
   276  	arr := bldr.NewListArray()
   277  	defer arr.Release()
   278  
   279  	mp, err := newMultipathLevelBuilder(arr, true)
   280  	require.NoError(t, err)
   281  	defer mp.Release()
   282  
   283  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   284  	result, err := mp.write(0, ctx)
   285  	require.NoError(t, err)
   286  
   287  	assert.Equal(t, []int16{0, 5, 5, 5, 5, 5, 3, 3, 3, 1}, result.defLevels)
   288  	assert.Equal(t, []int16{0, 0, 2, 2, 1, 2, 0, 1, 1, 0}, result.repLevels)
   289  }
   290  
   291  func TestNestedListsWithSomeNulls(t *testing.T) {
   292  	listType := arrow.ListOf(arrow.PrimitiveTypes.Int64)
   293  	bldr := array.NewListBuilder(memory.DefaultAllocator, listType)
   294  	defer bldr.Release()
   295  
   296  	nestedBldr := bldr.ValueBuilder().(*array.ListBuilder)
   297  	vb := nestedBldr.ValueBuilder().(*array.Int64Builder)
   298  
   299  	// produce: [null, [[1, null, 3], null, null], [[4, 5]]]
   300  
   301  	bldr.AppendNull()
   302  	bldr.Append(true)
   303  	nestedBldr.Append(true)
   304  	vb.AppendValues([]int64{1, 0, 3}, []bool{true, false, true})
   305  	nestedBldr.AppendNull()
   306  	nestedBldr.AppendNull()
   307  	bldr.Append(true)
   308  	nestedBldr.Append(true)
   309  	vb.AppendValues([]int64{4, 5}, nil)
   310  
   311  	arr := bldr.NewListArray()
   312  	defer arr.Release()
   313  
   314  	mp, err := newMultipathLevelBuilder(arr, true)
   315  	require.NoError(t, err)
   316  	defer mp.Release()
   317  
   318  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   319  	result, err := mp.write(0, ctx)
   320  	require.NoError(t, err)
   321  
   322  	assert.Equal(t, []int16{0, 5, 4, 5, 2, 2, 5, 5}, result.defLevels)
   323  	assert.Equal(t, []int16{0, 0, 2, 2, 1, 1, 0, 2}, result.repLevels)
   324  }
   325  
   326  func TestNestedListsSomeNullsSomeEmpty(t *testing.T) {
   327  	listType := arrow.ListOf(arrow.PrimitiveTypes.Int64)
   328  	bldr := array.NewListBuilder(memory.DefaultAllocator, listType)
   329  	defer bldr.Release()
   330  
   331  	nestedBldr := bldr.ValueBuilder().(*array.ListBuilder)
   332  	vb := nestedBldr.ValueBuilder().(*array.Int64Builder)
   333  
   334  	// produce: [null, [[1, null, 3], [], []], [[4, 5]]]
   335  
   336  	bldr.AppendNull()
   337  	bldr.Append(true)
   338  	nestedBldr.Append(true)
   339  	vb.AppendValues([]int64{1, 0, 3}, []bool{true, false, true})
   340  	nestedBldr.Append(true)
   341  	nestedBldr.Append(true)
   342  	bldr.Append(true)
   343  	nestedBldr.Append(true)
   344  	vb.AppendValues([]int64{4, 5}, nil)
   345  
   346  	arr := bldr.NewListArray()
   347  	defer arr.Release()
   348  
   349  	mp, err := newMultipathLevelBuilder(arr, true)
   350  	require.NoError(t, err)
   351  	defer mp.Release()
   352  
   353  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   354  	result, err := mp.write(0, ctx)
   355  	require.NoError(t, err)
   356  
   357  	assert.Equal(t, []int16{0, 5, 4, 5, 3, 3, 5, 5}, result.defLevels)
   358  	assert.Equal(t, []int16{0, 0, 2, 2, 1, 1, 0, 2}, result.repLevels)
   359  }
   360  
   361  // triplenested translates to parquet:
   362  //
   363  // optional group bag {
   364  //   repeated group outer_list (List) {
   365  //     option group nullable {
   366  //       repeated group middle_list (List) {
   367  //         option group nullable {
   368  //           repeated group inner_list (List) {
   369  //              optional int64 Entries;
   370  //           }
   371  //         }
   372  //       }
   373  //     }
   374  //   }
   375  // }
   376  // So:
   377  // def level 0: a outer list
   378  // def level 1: an empty outer list
   379  // def level 2: a null middle list
   380  // def level 3: an empty middle list
   381  // def level 4: an null inner list
   382  // def level 5: an empty inner list
   383  // def level 6: a null entry
   384  // def level 7: a non-null entry
   385  
   386  func TestTripleNestedAllPresent(t *testing.T) {
   387  	listType := arrow.ListOf(arrow.PrimitiveTypes.Int64)
   388  	nestedListType := arrow.ListOf(listType)
   389  	bldr := array.NewListBuilder(memory.DefaultAllocator, nestedListType)
   390  	defer bldr.Release()
   391  
   392  	dblNestedBldr := bldr.ValueBuilder().(*array.ListBuilder)
   393  	nestedBldr := dblNestedBldr.ValueBuilder().(*array.ListBuilder)
   394  	vb := nestedBldr.ValueBuilder().(*array.Int64Builder)
   395  
   396  	// produce: [ [[[1, 2, 3], [4, 5, 6]], [[7, 8, 9]]] ]
   397  	bldr.Append(true)
   398  	dblNestedBldr.Append(true)
   399  	nestedBldr.Append(true)
   400  	vb.AppendValues([]int64{1, 2, 3}, nil)
   401  	nestedBldr.Append(true)
   402  	vb.AppendValues([]int64{4, 5, 6}, nil)
   403  
   404  	dblNestedBldr.Append(true)
   405  	nestedBldr.Append(true)
   406  	vb.AppendValues([]int64{7, 8, 9}, nil)
   407  
   408  	arr := bldr.NewListArray()
   409  	defer arr.Release()
   410  
   411  	mp, err := newMultipathLevelBuilder(arr, true)
   412  	require.NoError(t, err)
   413  	defer mp.Release()
   414  
   415  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   416  	result, err := mp.write(0, ctx)
   417  	require.NoError(t, err)
   418  
   419  	assert.Equal(t, []int16{7, 7, 7, 7, 7, 7, 7, 7, 7}, result.defLevels)
   420  	assert.Equal(t, []int16{0, 3, 3, 2, 3, 3, 1, 3, 3}, result.repLevels)
   421  }
   422  
   423  func TestTripleNestedSomeNullsSomeEmpty(t *testing.T) {
   424  	listType := arrow.ListOf(arrow.PrimitiveTypes.Int64)
   425  	nestedListType := arrow.ListOf(listType)
   426  	bldr := array.NewListBuilder(memory.DefaultAllocator, nestedListType)
   427  	defer bldr.Release()
   428  
   429  	dblNestedBldr := bldr.ValueBuilder().(*array.ListBuilder)
   430  	nestedBldr := dblNestedBldr.ValueBuilder().(*array.ListBuilder)
   431  	vb := nestedBldr.ValueBuilder().(*array.Int64Builder)
   432  
   433  	// produce: [
   434  	//	  [null, [[1, null, 3], []], []],     first row
   435  	//    [[[]], [[], [1, 2]], null, [[3]]],  second row
   436  	//    null,                               third row
   437  	//    []                                  fourth row
   438  	//  ]
   439  
   440  	// first row
   441  	bldr.Append(true)
   442  	dblNestedBldr.AppendNull()
   443  	dblNestedBldr.Append(true)
   444  	nestedBldr.Append(true)
   445  	vb.AppendValues([]int64{1, 0, 3}, []bool{true, false, true})
   446  	nestedBldr.Append(true)
   447  	dblNestedBldr.Append(true)
   448  
   449  	// second row
   450  	bldr.Append(true)
   451  	dblNestedBldr.Append(true)
   452  	nestedBldr.Append(true)
   453  	dblNestedBldr.Append(true)
   454  	nestedBldr.Append(true)
   455  	nestedBldr.Append(true)
   456  	vb.AppendValues([]int64{1, 2}, nil)
   457  	dblNestedBldr.AppendNull()
   458  	dblNestedBldr.Append(true)
   459  	nestedBldr.Append(true)
   460  	vb.Append(3)
   461  
   462  	// third row
   463  	bldr.AppendNull()
   464  
   465  	// fourth row
   466  	bldr.Append(true)
   467  
   468  	arr := bldr.NewListArray()
   469  	defer arr.Release()
   470  
   471  	mp, err := newMultipathLevelBuilder(arr, true)
   472  	require.NoError(t, err)
   473  	defer mp.Release()
   474  
   475  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   476  	result, err := mp.write(0, ctx)
   477  	require.NoError(t, err)
   478  
   479  	assert.Equal(t, []int16{
   480  		2, 7, 6, 7, 5, 3, // first row
   481  		5, 5, 7, 7, 2, 7, // second row
   482  		0, // third row
   483  		1,
   484  	}, result.defLevels)
   485  	assert.Equal(t, []int16{
   486  		0, 1, 3, 3, 2, 1, // first row
   487  		0, 1, 2, 3, 1, 1, // second row
   488  		0, 0,
   489  	}, result.repLevels)
   490  }
   491  
   492  func TestStruct(t *testing.T) {
   493  	structType := arrow.StructOf(arrow.Field{Name: "list", Type: arrow.ListOf(arrow.PrimitiveTypes.Int64), Nullable: true},
   494  		arrow.Field{Name: "Entries", Type: arrow.PrimitiveTypes.Int64, Nullable: true})
   495  
   496  	bldr := array.NewStructBuilder(memory.DefaultAllocator, structType)
   497  	defer bldr.Release()
   498  
   499  	entryBldr := bldr.FieldBuilder(1).(*array.Int64Builder)
   500  	listBldr := bldr.FieldBuilder(0).(*array.ListBuilder)
   501  	vb := listBldr.ValueBuilder().(*array.Int64Builder)
   502  
   503  	// produce: [ {"Entries": 1, "list": [2, 3]}, {"Entries": 4, "list": [5, 6]}, null]
   504  
   505  	bldr.Append(true)
   506  	entryBldr.Append(1)
   507  	listBldr.Append(true)
   508  	vb.AppendValues([]int64{2, 3}, nil)
   509  
   510  	bldr.Append(true)
   511  	entryBldr.Append(4)
   512  	listBldr.Append(true)
   513  	vb.AppendValues([]int64{5, 6}, nil)
   514  
   515  	bldr.AppendNull()
   516  
   517  	arr := bldr.NewArray()
   518  	defer arr.Release()
   519  
   520  	mp, err := newMultipathLevelBuilder(arr, true)
   521  	require.NoError(t, err)
   522  	defer mp.Release()
   523  
   524  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   525  	result, err := mp.writeAll(ctx)
   526  	require.NoError(t, err)
   527  
   528  	assert.Len(t, result, 2)
   529  	assert.Equal(t, []int16{4, 4, 4, 4, 0}, result[0].defLevels)
   530  	assert.Equal(t, []int16{0, 1, 0, 1, 0}, result[0].repLevels)
   531  
   532  	assert.Equal(t, []int16{2, 2, 0}, result[1].defLevels)
   533  	assert.Nil(t, result[1].repLevels)
   534  }
   535  
   536  func TestFixedSizeListNullableElems(t *testing.T) {
   537  	bldr := array.NewFixedSizeListBuilder(memory.DefaultAllocator, 2, arrow.PrimitiveTypes.Int64)
   538  	defer bldr.Release()
   539  
   540  	vb := bldr.ValueBuilder().(*array.Int64Builder)
   541  	bldr.AppendValues([]bool{false, true, true, false})
   542  	vb.AppendValues([]int64{2, 3, 4, 5}, nil)
   543  
   544  	// produce: [null, [2, 3], [4, 5], null]
   545  
   546  	arr := bldr.NewArray()
   547  	defer arr.Release()
   548  
   549  	mp, err := newMultipathLevelBuilder(arr, true)
   550  	require.NoError(t, err)
   551  	defer mp.Release()
   552  
   553  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   554  	result, err := mp.writeAll(ctx)
   555  	require.NoError(t, err)
   556  
   557  	assert.Len(t, result, 1)
   558  	assert.Equal(t, []int16{0, 3, 3, 3, 3, 0}, result[0].defLevels)
   559  	assert.Equal(t, []int16{0, 0, 1, 0, 1, 0}, result[0].repLevels)
   560  
   561  	// null slots take up space in a fixed size list (they can in variable
   562  	// size lists as well) but the actual written values are only the middle
   563  	// elements
   564  	assert.Len(t, result[0].postListVisitedElems, 1)
   565  	assert.EqualValues(t, 2, result[0].postListVisitedElems[0].start)
   566  	assert.EqualValues(t, 6, result[0].postListVisitedElems[0].end)
   567  }
   568  
   569  func TestFixedSizeListMissingMiddleTwoVisitedRanges(t *testing.T) {
   570  	bldr := array.NewFixedSizeListBuilder(memory.DefaultAllocator, 2, arrow.PrimitiveTypes.Int64)
   571  	defer bldr.Release()
   572  
   573  	vb := bldr.ValueBuilder().(*array.Int64Builder)
   574  	bldr.AppendValues([]bool{true, false, true})
   575  	vb.AppendValues([]int64{0, 1, 2, 3}, nil)
   576  
   577  	// produce: [[0, 1], null, [2, 3]]
   578  
   579  	arr := bldr.NewArray()
   580  	defer arr.Release()
   581  
   582  	mp, err := newMultipathLevelBuilder(arr, true)
   583  	require.NoError(t, err)
   584  	defer mp.Release()
   585  
   586  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   587  	result, err := mp.writeAll(ctx)
   588  	require.NoError(t, err)
   589  
   590  	assert.Len(t, result, 1)
   591  	assert.Equal(t, []int16{3, 3, 0, 3, 3}, result[0].defLevels)
   592  	assert.Equal(t, []int16{0, 1, 0, 0, 1}, result[0].repLevels)
   593  
   594  	// null slots take up space in a fixed size list (they can in variable
   595  	// size lists as well) but the actual written values are only the middle
   596  	// elements
   597  	assert.Len(t, result[0].postListVisitedElems, 2)
   598  	assert.EqualValues(t, 0, result[0].postListVisitedElems[0].start)
   599  	assert.EqualValues(t, 2, result[0].postListVisitedElems[0].end)
   600  
   601  	assert.EqualValues(t, 4, result[0].postListVisitedElems[1].start)
   602  	assert.EqualValues(t, 6, result[0].postListVisitedElems[1].end)
   603  }
   604  
   605  func TestPrimitiveNonNullable(t *testing.T) {
   606  	bldr := array.NewInt64Builder(memory.DefaultAllocator)
   607  	defer bldr.Release()
   608  
   609  	bldr.AppendValues([]int64{1, 2, 3, 4}, nil)
   610  
   611  	arr := bldr.NewArray()
   612  	defer arr.Release()
   613  
   614  	mp, err := newMultipathLevelBuilder(arr, false)
   615  	require.NoError(t, err)
   616  	defer mp.Release()
   617  
   618  	ctx := arrowCtxFromContext(NewArrowWriteContext(context.Background(), nil))
   619  	result, err := mp.write(0, ctx)
   620  	require.NoError(t, err)
   621  
   622  	assert.Nil(t, result.defLevels)
   623  	assert.Nil(t, result.repLevels)
   624  
   625  	assert.Len(t, result.postListVisitedElems, 1)
   626  	assert.EqualValues(t, 0, result.postListVisitedElems[0].start)
   627  	assert.EqualValues(t, 4, result.postListVisitedElems[0].end)
   628  }