storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/s3select/internal/parquet-go/data/column-listoflist_test.go (about)

     1  /*
     2   * Minio Cloud Storage, (C) 2019 Minio, Inc.
     3   *
     4   * Licensed under the Apache License, Version 2.0 (the "License");
     5   * you may not use this file except in compliance with the License.
     6   * You may obtain a copy of the License at
     7   *
     8   *     http://www.apache.org/licenses/LICENSE-2.0
     9   *
    10   * Unless required by applicable law or agreed to in writing, software
    11   * distributed under the License is distributed on an "AS IS" BASIS,
    12   * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
    13   * See the License for the specific language governing permissions and
    14   * limitations under the License.
    15   */
    16  
    17  package data
    18  
    19  import (
    20  	"reflect"
    21  	"testing"
    22  
    23  	"storj.io/minio/pkg/s3select/internal/parquet-go/gen-go/parquet"
    24  	"storj.io/minio/pkg/s3select/internal/parquet-go/schema"
    25  )
    26  
    27  func TestPopulateListOfList(t *testing.T) {
    28  	requiredList1 := schema.NewTree()
    29  	{
    30  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_REQUIRED,
    31  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
    32  			nil, nil, nil)
    33  		if err != nil {
    34  			t.Fatal(err)
    35  		}
    36  
    37  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
    38  			nil, nil,
    39  			nil, nil, nil)
    40  		if err != nil {
    41  			t.Fatal(err)
    42  		}
    43  
    44  		requiredElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
    45  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
    46  			nil, nil, nil)
    47  		if err != nil {
    48  			t.Fatal(err)
    49  		}
    50  
    51  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
    52  			nil, nil,
    53  			nil, nil, nil)
    54  		if err != nil {
    55  			t.Fatal(err)
    56  		}
    57  
    58  		requiredSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
    59  			parquet.TypePtr(parquet.Type_INT32), nil,
    60  			nil, nil, nil)
    61  		if err != nil {
    62  			t.Fatal(err)
    63  		}
    64  
    65  		if err = requiredList1.Set("col", requiredCol); err != nil {
    66  			t.Fatal(err)
    67  		}
    68  		if err = requiredList1.Set("col.list", list); err != nil {
    69  			t.Fatal(err)
    70  		}
    71  		if err = requiredList1.Set("col.list.element", requiredElement); err != nil {
    72  			t.Fatal(err)
    73  		}
    74  		if err = requiredList1.Set("col.list.element.list", subList); err != nil {
    75  			t.Fatal(err)
    76  		}
    77  		if err = requiredList1.Set("col.list.element.list.element", requiredSubElement); err != nil {
    78  			t.Fatal(err)
    79  		}
    80  
    81  		if _, _, err = requiredList1.ToParquetSchema(); err != nil {
    82  			t.Fatal(err)
    83  		}
    84  	}
    85  
    86  	requiredList2 := schema.NewTree()
    87  	{
    88  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_REQUIRED,
    89  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
    90  			nil, nil, nil)
    91  		if err != nil {
    92  			t.Fatal(err)
    93  		}
    94  
    95  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
    96  			nil, nil,
    97  			nil, nil, nil)
    98  		if err != nil {
    99  			t.Fatal(err)
   100  		}
   101  
   102  		requiredElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   103  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   104  			nil, nil, nil)
   105  		if err != nil {
   106  			t.Fatal(err)
   107  		}
   108  
   109  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   110  			nil, nil,
   111  			nil, nil, nil)
   112  		if err != nil {
   113  			t.Fatal(err)
   114  		}
   115  
   116  		optionalSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   117  			parquet.TypePtr(parquet.Type_INT32), nil,
   118  			nil, nil, nil)
   119  		if err != nil {
   120  			t.Fatal(err)
   121  		}
   122  
   123  		if err = requiredList2.Set("col", requiredCol); err != nil {
   124  			t.Fatal(err)
   125  		}
   126  		if err = requiredList2.Set("col.list", list); err != nil {
   127  			t.Fatal(err)
   128  		}
   129  		if err = requiredList2.Set("col.list.element", requiredElement); err != nil {
   130  			t.Fatal(err)
   131  		}
   132  		if err = requiredList2.Set("col.list.element.list", subList); err != nil {
   133  			t.Fatal(err)
   134  		}
   135  		if err = requiredList2.Set("col.list.element.list.element", optionalSubElement); err != nil {
   136  			t.Fatal(err)
   137  		}
   138  
   139  		if _, _, err = requiredList2.ToParquetSchema(); err != nil {
   140  			t.Fatal(err)
   141  		}
   142  	}
   143  
   144  	requiredList3 := schema.NewTree()
   145  	{
   146  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_REQUIRED,
   147  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   148  			nil, nil, nil)
   149  		if err != nil {
   150  			t.Fatal(err)
   151  		}
   152  
   153  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   154  			nil, nil,
   155  			nil, nil, nil)
   156  		if err != nil {
   157  			t.Fatal(err)
   158  		}
   159  
   160  		optioonalElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   161  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   162  			nil, nil, nil)
   163  		if err != nil {
   164  			t.Fatal(err)
   165  		}
   166  
   167  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   168  			nil, nil,
   169  			nil, nil, nil)
   170  		if err != nil {
   171  			t.Fatal(err)
   172  		}
   173  
   174  		requiredSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   175  			parquet.TypePtr(parquet.Type_INT32), nil,
   176  			nil, nil, nil)
   177  		if err != nil {
   178  			t.Fatal(err)
   179  		}
   180  
   181  		if err = requiredList3.Set("col", requiredCol); err != nil {
   182  			t.Fatal(err)
   183  		}
   184  		if err = requiredList3.Set("col.list", list); err != nil {
   185  			t.Fatal(err)
   186  		}
   187  		if err = requiredList3.Set("col.list.element", optioonalElement); err != nil {
   188  			t.Fatal(err)
   189  		}
   190  		if err = requiredList3.Set("col.list.element.list", subList); err != nil {
   191  			t.Fatal(err)
   192  		}
   193  		if err = requiredList3.Set("col.list.element.list.element", requiredSubElement); err != nil {
   194  			t.Fatal(err)
   195  		}
   196  
   197  		if _, _, err = requiredList3.ToParquetSchema(); err != nil {
   198  			t.Fatal(err)
   199  		}
   200  	}
   201  
   202  	requiredList4 := schema.NewTree()
   203  	{
   204  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_REQUIRED,
   205  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   206  			nil, nil, nil)
   207  		if err != nil {
   208  			t.Fatal(err)
   209  		}
   210  
   211  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   212  			nil, nil,
   213  			nil, nil, nil)
   214  		if err != nil {
   215  			t.Fatal(err)
   216  		}
   217  
   218  		optioonalElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   219  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   220  			nil, nil, nil)
   221  		if err != nil {
   222  			t.Fatal(err)
   223  		}
   224  
   225  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   226  			nil, nil,
   227  			nil, nil, nil)
   228  		if err != nil {
   229  			t.Fatal(err)
   230  		}
   231  
   232  		optionalSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   233  			parquet.TypePtr(parquet.Type_INT32), nil,
   234  			nil, nil, nil)
   235  		if err != nil {
   236  			t.Fatal(err)
   237  		}
   238  
   239  		if err = requiredList4.Set("col", requiredCol); err != nil {
   240  			t.Fatal(err)
   241  		}
   242  		if err = requiredList4.Set("col.list", list); err != nil {
   243  			t.Fatal(err)
   244  		}
   245  		if err = requiredList4.Set("col.list.element", optioonalElement); err != nil {
   246  			t.Fatal(err)
   247  		}
   248  		if err = requiredList4.Set("col.list.element.list", subList); err != nil {
   249  			t.Fatal(err)
   250  		}
   251  		if err = requiredList4.Set("col.list.element.list.element", optionalSubElement); err != nil {
   252  			t.Fatal(err)
   253  		}
   254  
   255  		if _, _, err = requiredList4.ToParquetSchema(); err != nil {
   256  			t.Fatal(err)
   257  		}
   258  	}
   259  
   260  	optionalList1 := schema.NewTree()
   261  	{
   262  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_OPTIONAL,
   263  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   264  			nil, nil, nil)
   265  		if err != nil {
   266  			t.Fatal(err)
   267  		}
   268  
   269  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   270  			nil, nil,
   271  			nil, nil, nil)
   272  		if err != nil {
   273  			t.Fatal(err)
   274  		}
   275  
   276  		requiredElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   277  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   278  			nil, nil, nil)
   279  		if err != nil {
   280  			t.Fatal(err)
   281  		}
   282  
   283  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   284  			nil, nil,
   285  			nil, nil, nil)
   286  		if err != nil {
   287  			t.Fatal(err)
   288  		}
   289  
   290  		requiredSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   291  			parquet.TypePtr(parquet.Type_INT32), nil,
   292  			nil, nil, nil)
   293  		if err != nil {
   294  			t.Fatal(err)
   295  		}
   296  
   297  		if err = optionalList1.Set("col", requiredCol); err != nil {
   298  			t.Fatal(err)
   299  		}
   300  		if err = optionalList1.Set("col.list", list); err != nil {
   301  			t.Fatal(err)
   302  		}
   303  		if err = optionalList1.Set("col.list.element", requiredElement); err != nil {
   304  			t.Fatal(err)
   305  		}
   306  		if err = optionalList1.Set("col.list.element.list", subList); err != nil {
   307  			t.Fatal(err)
   308  		}
   309  		if err = optionalList1.Set("col.list.element.list.element", requiredSubElement); err != nil {
   310  			t.Fatal(err)
   311  		}
   312  
   313  		if _, _, err = optionalList1.ToParquetSchema(); err != nil {
   314  			t.Fatal(err)
   315  		}
   316  	}
   317  
   318  	optionalList2 := schema.NewTree()
   319  	{
   320  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_OPTIONAL,
   321  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   322  			nil, nil, nil)
   323  		if err != nil {
   324  			t.Fatal(err)
   325  		}
   326  
   327  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   328  			nil, nil,
   329  			nil, nil, nil)
   330  		if err != nil {
   331  			t.Fatal(err)
   332  		}
   333  
   334  		requiredElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   335  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   336  			nil, nil, nil)
   337  		if err != nil {
   338  			t.Fatal(err)
   339  		}
   340  
   341  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   342  			nil, nil,
   343  			nil, nil, nil)
   344  		if err != nil {
   345  			t.Fatal(err)
   346  		}
   347  
   348  		optionalSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   349  			parquet.TypePtr(parquet.Type_INT32), nil,
   350  			nil, nil, nil)
   351  		if err != nil {
   352  			t.Fatal(err)
   353  		}
   354  
   355  		if err = optionalList2.Set("col", requiredCol); err != nil {
   356  			t.Fatal(err)
   357  		}
   358  		if err = optionalList2.Set("col.list", list); err != nil {
   359  			t.Fatal(err)
   360  		}
   361  		if err = optionalList2.Set("col.list.element", requiredElement); err != nil {
   362  			t.Fatal(err)
   363  		}
   364  		if err = optionalList2.Set("col.list.element.list", subList); err != nil {
   365  			t.Fatal(err)
   366  		}
   367  		if err = optionalList2.Set("col.list.element.list.element", optionalSubElement); err != nil {
   368  			t.Fatal(err)
   369  		}
   370  
   371  		if _, _, err = optionalList2.ToParquetSchema(); err != nil {
   372  			t.Fatal(err)
   373  		}
   374  	}
   375  
   376  	optionalList3 := schema.NewTree()
   377  	{
   378  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_OPTIONAL,
   379  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   380  			nil, nil, nil)
   381  		if err != nil {
   382  			t.Fatal(err)
   383  		}
   384  
   385  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   386  			nil, nil,
   387  			nil, nil, nil)
   388  		if err != nil {
   389  			t.Fatal(err)
   390  		}
   391  
   392  		optioonalElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   393  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   394  			nil, nil, nil)
   395  		if err != nil {
   396  			t.Fatal(err)
   397  		}
   398  
   399  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   400  			nil, nil,
   401  			nil, nil, nil)
   402  		if err != nil {
   403  			t.Fatal(err)
   404  		}
   405  
   406  		requiredSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   407  			parquet.TypePtr(parquet.Type_INT32), nil,
   408  			nil, nil, nil)
   409  		if err != nil {
   410  			t.Fatal(err)
   411  		}
   412  
   413  		if err = optionalList3.Set("col", requiredCol); err != nil {
   414  			t.Fatal(err)
   415  		}
   416  		if err = optionalList3.Set("col.list", list); err != nil {
   417  			t.Fatal(err)
   418  		}
   419  		if err = optionalList3.Set("col.list.element", optioonalElement); err != nil {
   420  			t.Fatal(err)
   421  		}
   422  		if err = optionalList3.Set("col.list.element.list", subList); err != nil {
   423  			t.Fatal(err)
   424  		}
   425  		if err = optionalList3.Set("col.list.element.list.element", requiredSubElement); err != nil {
   426  			t.Fatal(err)
   427  		}
   428  
   429  		if _, _, err = optionalList3.ToParquetSchema(); err != nil {
   430  			t.Fatal(err)
   431  		}
   432  	}
   433  
   434  	optionalList4 := schema.NewTree()
   435  	{
   436  		requiredCol, err := schema.NewElement("col", parquet.FieldRepetitionType_OPTIONAL,
   437  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   438  			nil, nil, nil)
   439  		if err != nil {
   440  			t.Fatal(err)
   441  		}
   442  
   443  		list, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   444  			nil, nil,
   445  			nil, nil, nil)
   446  		if err != nil {
   447  			t.Fatal(err)
   448  		}
   449  
   450  		optioonalElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   451  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   452  			nil, nil, nil)
   453  		if err != nil {
   454  			t.Fatal(err)
   455  		}
   456  
   457  		subList, err := schema.NewElement("list", parquet.FieldRepetitionType_REPEATED,
   458  			nil, nil,
   459  			nil, nil, nil)
   460  		if err != nil {
   461  			t.Fatal(err)
   462  		}
   463  
   464  		optionalSubElement, err := schema.NewElement("element", parquet.FieldRepetitionType_OPTIONAL,
   465  			parquet.TypePtr(parquet.Type_INT32), nil,
   466  			nil, nil, nil)
   467  		if err != nil {
   468  			t.Fatal(err)
   469  		}
   470  
   471  		if err = optionalList4.Set("col", requiredCol); err != nil {
   472  			t.Fatal(err)
   473  		}
   474  		if err = optionalList4.Set("col.list", list); err != nil {
   475  			t.Fatal(err)
   476  		}
   477  		if err = optionalList4.Set("col.list.element", optioonalElement); err != nil {
   478  			t.Fatal(err)
   479  		}
   480  		if err = optionalList4.Set("col.list.element.list", subList); err != nil {
   481  			t.Fatal(err)
   482  		}
   483  		if err = optionalList4.Set("col.list.element.list.element", optionalSubElement); err != nil {
   484  			t.Fatal(err)
   485  		}
   486  
   487  		if _, _, err = optionalList4.ToParquetSchema(); err != nil {
   488  			t.Fatal(err)
   489  		}
   490  	}
   491  
   492  	result1 := map[string]*Column{
   493  		"col.list.element.list.element": {
   494  			parquetType:      parquet.Type_INT32,
   495  			values:           []interface{}{v10},
   496  			definitionLevels: []int64{2},
   497  			repetitionLevels: []int64{0},
   498  			rowCount:         1,
   499  			maxBitWidth:      4,
   500  			minValue:         v10,
   501  			maxValue:         v10,
   502  		},
   503  	}
   504  
   505  	result2 := map[string]*Column{
   506  		"col.list.element.list.element": {
   507  			parquetType:      parquet.Type_INT32,
   508  			values:           []interface{}{v10, v20, v30, v10, v20, v10, v30},
   509  			definitionLevels: []int64{2, 2, 2, 2, 2, 2, 2},
   510  			repetitionLevels: []int64{0, 2, 1, 2, 1, 2, 2},
   511  			rowCount:         1,
   512  			maxBitWidth:      5,
   513  			minValue:         v10,
   514  			maxValue:         v30,
   515  		},
   516  	}
   517  
   518  	result3 := map[string]*Column{
   519  		"col.list.element.list.element": {
   520  			parquetType:      parquet.Type_INT32,
   521  			values:           []interface{}{nil},
   522  			definitionLevels: []int64{2},
   523  			repetitionLevels: []int64{0},
   524  			rowCount:         1,
   525  		},
   526  	}
   527  
   528  	result4 := map[string]*Column{
   529  		"col.list.element.list.element": {
   530  			parquetType:      parquet.Type_INT32,
   531  			values:           []interface{}{v10},
   532  			definitionLevels: []int64{3},
   533  			repetitionLevels: []int64{0},
   534  			rowCount:         1,
   535  			maxBitWidth:      4,
   536  			minValue:         v10,
   537  			maxValue:         v10,
   538  		},
   539  	}
   540  
   541  	result5 := map[string]*Column{
   542  		"col.list.element.list.element": {
   543  			parquetType:      parquet.Type_INT32,
   544  			values:           []interface{}{v10, v20, v30, v10, v20, v10, v30},
   545  			definitionLevels: []int64{3, 3, 3, 3, 3, 3, 3},
   546  			repetitionLevels: []int64{0, 2, 1, 2, 1, 2, 2},
   547  			rowCount:         1,
   548  			maxBitWidth:      5,
   549  			minValue:         v10,
   550  			maxValue:         v30,
   551  		},
   552  	}
   553  
   554  	result6 := map[string]*Column{
   555  		"col.list.element.list.element": {
   556  			parquetType:      parquet.Type_INT32,
   557  			values:           []interface{}{nil},
   558  			definitionLevels: []int64{3},
   559  			repetitionLevels: []int64{0},
   560  			rowCount:         1,
   561  		},
   562  	}
   563  
   564  	result7 := map[string]*Column{
   565  		"col.list.element.list.element": {
   566  			parquetType:      parquet.Type_INT32,
   567  			values:           []interface{}{v10},
   568  			definitionLevels: []int64{4},
   569  			repetitionLevels: []int64{0},
   570  			rowCount:         1,
   571  			maxBitWidth:      4,
   572  			minValue:         v10,
   573  			maxValue:         v10,
   574  		},
   575  	}
   576  
   577  	result8 := map[string]*Column{
   578  		"col.list.element.list.element": {
   579  			parquetType:      parquet.Type_INT32,
   580  			values:           []interface{}{v10, v20, v30, v10, v20, v10, v30},
   581  			definitionLevels: []int64{4, 4, 4, 4, 4, 4, 4},
   582  			repetitionLevels: []int64{0, 2, 1, 2, 1, 2, 2},
   583  			rowCount:         1,
   584  			maxBitWidth:      5,
   585  			minValue:         v10,
   586  			maxValue:         v30,
   587  		},
   588  	}
   589  
   590  	result9 := map[string]*Column{
   591  		"col.list.element.list.element": {
   592  			parquetType:      parquet.Type_INT32,
   593  			values:           []interface{}{nil},
   594  			definitionLevels: []int64{0},
   595  			repetitionLevels: []int64{0},
   596  			rowCount:         1,
   597  		},
   598  	}
   599  
   600  	result10 := map[string]*Column{
   601  		"col.list.element.list.element": {
   602  			parquetType:      parquet.Type_INT32,
   603  			values:           []interface{}{nil},
   604  			definitionLevels: []int64{4},
   605  			repetitionLevels: []int64{0},
   606  			rowCount:         1,
   607  		},
   608  	}
   609  
   610  	result11 := map[string]*Column{
   611  		"col.list.element.list.element": {
   612  			parquetType:      parquet.Type_INT32,
   613  			values:           []interface{}{v10},
   614  			definitionLevels: []int64{5},
   615  			repetitionLevels: []int64{0},
   616  			rowCount:         1,
   617  			maxBitWidth:      4,
   618  			minValue:         v10,
   619  			maxValue:         v10,
   620  		},
   621  	}
   622  
   623  	result12 := map[string]*Column{
   624  		"col.list.element.list.element": {
   625  			parquetType:      parquet.Type_INT32,
   626  			values:           []interface{}{v10, v20, v30, v10, v20, v10, v30},
   627  			definitionLevels: []int64{5, 5, 5, 5, 5, 5, 5},
   628  			repetitionLevels: []int64{0, 2, 1, 2, 1, 2, 2},
   629  			rowCount:         1,
   630  			maxBitWidth:      5,
   631  			minValue:         v10,
   632  			maxValue:         v30,
   633  		},
   634  	}
   635  
   636  	testCases := []struct {
   637  		schemaTree     *schema.Tree
   638  		data           string
   639  		expectedResult map[string]*Column
   640  		expectErr      bool
   641  	}{
   642  		{requiredList1, `{}`, nil, true},                // err: col: nil value for required field
   643  		{requiredList1, `{"col": null}`, nil, true},     // err: col: nil value for required field
   644  		{requiredList1, `{"col": [[null]]}`, nil, true}, // err: col.list.element.list.element: nil value for required field
   645  		{requiredList1, `{"col": [[10]]}`, result1, false},
   646  		{requiredList1, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result2, false},
   647  		{requiredList2, `{}`, nil, true},            // err: col: nil value for required field
   648  		{requiredList2, `{"col": null}`, nil, true}, // err: col: nil value for required field
   649  		{requiredList2, `{"col": [[null]]}`, result3, false},
   650  		{requiredList2, `{"col": [[10]]}`, result4, false},
   651  		{requiredList2, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result5, false},
   652  		{requiredList3, `{}`, nil, true},                // err: col: nil value for required field
   653  		{requiredList3, `{"col": null}`, nil, true},     // err: col: nil value for required field
   654  		{requiredList3, `{"col": [[null]]}`, nil, true}, // err: col.list.element.list.element: nil value for required field
   655  		{requiredList3, `{"col": [[10]]}`, result4, false},
   656  		{requiredList3, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result5, false},
   657  		{requiredList4, `{}`, nil, true},            // err: col: nil value for required field
   658  		{requiredList4, `{"col": null}`, nil, true}, // err: col: nil value for required field
   659  		{requiredList4, `{"col": [[null]]}`, result6, false},
   660  		{requiredList4, `{"col": [[10]]}`, result7, false},
   661  		{requiredList4, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result8, false},
   662  		{optionalList1, `{}`, result9, false},
   663  		{optionalList1, `{"col": null}`, result9, false},
   664  		{optionalList1, `{"col": [[null]]}`, nil, true}, // err: col.list.element.list.element: nil value for required field
   665  		{optionalList1, `{"col": [[10]]}`, result4, false},
   666  		{optionalList1, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result5, false},
   667  		{optionalList2, `{}`, result9, false},
   668  		{optionalList2, `{"col": null}`, result9, false},
   669  		{optionalList2, `{"col": [[null]]}`, result6, false},
   670  		{optionalList2, `{"col": [[10]]}`, result7, false},
   671  		{optionalList2, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result8, false},
   672  		{optionalList3, `{}`, result9, false},
   673  		{optionalList3, `{"col": null}`, result9, false},
   674  		{optionalList3, `{"col": [[null]]}`, nil, true}, // err: col.list.element.list.element: nil value for required field
   675  		{optionalList3, `{"col": [[10]]}`, result7, false},
   676  		{optionalList3, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result8, false},
   677  		{optionalList4, `{}`, result9, false},
   678  		{optionalList4, `{"col": null}`, result9, false},
   679  		{optionalList4, `{"col": [[null]]}`, result10, false},
   680  		{optionalList4, `{"col": [[10]]}`, result11, false},
   681  		{optionalList4, `{"col": [[10, 20], [30, 10], [20, 10, 30]]}`, result12, false},
   682  	}
   683  
   684  	for i, testCase := range testCases {
   685  		result, err := UnmarshalJSON([]byte(testCase.data), testCase.schemaTree)
   686  		expectErr := (err != nil)
   687  
   688  		if testCase.expectErr != expectErr {
   689  			t.Fatalf("case %v: error: expected: %v, got: %v", i+1, testCase.expectErr, expectErr)
   690  		}
   691  
   692  		if !testCase.expectErr {
   693  			if !reflect.DeepEqual(result, testCase.expectedResult) {
   694  				t.Fatalf("case %v: result: expected: %v, got: %v", i+1, testCase.expectedResult, result)
   695  			}
   696  		}
   697  	}
   698  }