storj.io/minio@v0.0.0-20230509071714-0cbc90f649b1/pkg/s3select/internal/parquet-go/schema/tree_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 schema
    18  
    19  import (
    20  	"testing"
    21  
    22  	"storj.io/minio/pkg/s3select/internal/parquet-go/gen-go/parquet"
    23  )
    24  
    25  func TestTreeSet(t *testing.T) {
    26  	a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
    27  	if err != nil {
    28  		t.Fatal(err)
    29  	}
    30  
    31  	b, err := NewElement("b", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
    32  	if err != nil {
    33  		t.Fatal(err)
    34  	}
    35  
    36  	c, err := NewElement("c", parquet.FieldRepetitionType_OPTIONAL,
    37  		parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_UTF8),
    38  		nil, nil, nil)
    39  	if err != nil {
    40  		t.Fatal(err)
    41  	}
    42  
    43  	testCases := []struct {
    44  		name      string
    45  		element   *Element
    46  		expectErr bool
    47  	}{
    48  		{"A", a, false},
    49  		{"A.B", b, false},
    50  		{"A.B.C", c, false},
    51  		{"B.C", nil, true},      // error: parent B does not exist
    52  		{"A.B.C.AA", nil, true}, // error: parent A.B.C is not group element
    53  	}
    54  
    55  	root := NewTree()
    56  	for i, testCase := range testCases {
    57  		err := root.Set(testCase.name, testCase.element)
    58  		expectErr := (err != nil)
    59  
    60  		if expectErr != testCase.expectErr {
    61  			if testCase.expectErr {
    62  				t.Fatalf("case %v: err: expected: <error>, got: <nil>", i+1)
    63  			} else {
    64  				t.Fatalf("case %v: err: expected: <nil>, got: %v", i+1, err)
    65  			}
    66  		}
    67  	}
    68  }
    69  
    70  func TestTreeGet(t *testing.T) {
    71  	a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
    72  	if err != nil {
    73  		t.Fatal(err)
    74  	}
    75  
    76  	b, err := NewElement("b", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
    77  	if err != nil {
    78  		t.Fatal(err)
    79  	}
    80  
    81  	c, err := NewElement("c", parquet.FieldRepetitionType_OPTIONAL,
    82  		parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_UTF8),
    83  		nil, nil, nil)
    84  	if err != nil {
    85  		t.Fatal(err)
    86  	}
    87  
    88  	root := NewTree()
    89  	if err := root.Set("A", a); err != nil {
    90  		t.Fatal(err)
    91  	}
    92  	if err := root.Set("A.B", b); err != nil {
    93  		t.Fatal(err)
    94  	}
    95  	if err := root.Set("A.B.C", c); err != nil {
    96  		t.Fatal(err)
    97  	}
    98  
    99  	testCases := []struct {
   100  		name            string
   101  		expectedElement *Element
   102  		expectedFound   bool
   103  	}{
   104  		{"A", a, true},
   105  		{"A.B", b, true},
   106  		{"A.B.C", c, true},
   107  		{"B", nil, false},
   108  		{"A.B.C.AA", nil, false},
   109  	}
   110  
   111  	for i, testCase := range testCases {
   112  		element, found := root.Get(testCase.name)
   113  
   114  		if element != testCase.expectedElement {
   115  			t.Fatalf("case %v: element: expected: %v, got: %v", i+1, testCase.expectedElement, element)
   116  		}
   117  
   118  		if found != testCase.expectedFound {
   119  			t.Fatalf("case %v: found: expected: %v, got: %v", i+1, testCase.expectedFound, found)
   120  		}
   121  	}
   122  }
   123  
   124  func TestTreeDelete(t *testing.T) {
   125  	testCases := []struct {
   126  		name          string
   127  		expectedFound bool
   128  	}{
   129  		{"A", false},
   130  		{"A.B", false},
   131  		{"A.B.C", false},
   132  	}
   133  
   134  	for i, testCase := range testCases {
   135  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
   136  		if err != nil {
   137  			t.Fatalf("case %v: %v", i+1, err)
   138  		}
   139  
   140  		b, err := NewElement("b", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
   141  		if err != nil {
   142  			t.Fatalf("case %v: %v", i+1, err)
   143  		}
   144  
   145  		c, err := NewElement("c", parquet.FieldRepetitionType_OPTIONAL,
   146  			parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_UTF8),
   147  			nil, nil, nil)
   148  		if err != nil {
   149  			t.Fatalf("case %v: %v", i+1, err)
   150  		}
   151  
   152  		root := NewTree()
   153  		if err := root.Set("A", a); err != nil {
   154  			t.Fatalf("case %v: %v", i+1, err)
   155  		}
   156  		if err := root.Set("A.B", b); err != nil {
   157  			t.Fatalf("case %v: %v", i+1, err)
   158  		}
   159  		if err := root.Set("A.B.C", c); err != nil {
   160  			t.Fatalf("case %v: %v", i+1, err)
   161  		}
   162  
   163  		root.Delete(testCase.name)
   164  		_, found := root.Get(testCase.name)
   165  
   166  		if found != testCase.expectedFound {
   167  			t.Fatalf("case %v: found: expected: %v, got: %v", i+1, testCase.expectedFound, found)
   168  		}
   169  	}
   170  }
   171  
   172  func TestTreeToParquetSchema(t *testing.T) {
   173  	case1Root := NewTree()
   174  	{
   175  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
   176  		if err != nil {
   177  			t.Fatal(err)
   178  		}
   179  
   180  		if err := case1Root.Set("A", a); err != nil {
   181  			t.Fatal(err)
   182  		}
   183  	}
   184  
   185  	case2Root := NewTree()
   186  	{
   187  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8), nil, nil, nil)
   188  		if err != nil {
   189  			t.Fatal(err)
   190  		}
   191  
   192  		if err := case2Root.Set("A", a); err != nil {
   193  			t.Fatal(err)
   194  		}
   195  	}
   196  
   197  	case3Root := NewTree()
   198  	{
   199  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP_KEY_VALUE), nil, nil, nil)
   200  		if err != nil {
   201  			t.Fatal(err)
   202  		}
   203  
   204  		if err := case3Root.Set("A", a); err != nil {
   205  			t.Fatal(err)
   206  		}
   207  	}
   208  
   209  	case4Root := NewTree()
   210  	{
   211  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL,
   212  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   213  			nil, nil, nil)
   214  		if err != nil {
   215  			t.Fatal(err)
   216  		}
   217  		if err := case4Root.Set("A", a); err != nil {
   218  			t.Fatal(err)
   219  		}
   220  	}
   221  
   222  	case5Root := NewTree()
   223  	{
   224  		a, err := NewElement("a", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
   225  		if err != nil {
   226  			t.Fatal(err)
   227  		}
   228  		b, err := NewElement("b", parquet.FieldRepetitionType_OPTIONAL, nil, nil, nil, nil, nil)
   229  		if err != nil {
   230  			t.Fatal(err)
   231  		}
   232  		c, err := NewElement("c", parquet.FieldRepetitionType_OPTIONAL,
   233  			parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_UTF8),
   234  			nil, nil, nil)
   235  		if err != nil {
   236  			t.Fatal(err)
   237  		}
   238  		if err := case5Root.Set("A", a); err != nil {
   239  			t.Fatal(err)
   240  		}
   241  		if err := case5Root.Set("A.B", b); err != nil {
   242  			t.Fatal(err)
   243  		}
   244  		if err := case5Root.Set("A.B.C", c); err != nil {
   245  			t.Fatal(err)
   246  		}
   247  	}
   248  
   249  	testCases := []struct {
   250  		tree      *Tree
   251  		expectErr bool
   252  	}{
   253  		{case1Root, true}, // err: A: group element must have children
   254  		{case2Root, true}, // err: A: ConvertedType INT_8 must have Type value
   255  		{case3Root, true}, // err: A: unsupported ConvertedType MAP_KEY_VALUE
   256  		{case4Root, false},
   257  		{case5Root, false},
   258  	}
   259  
   260  	for i, testCase := range testCases {
   261  		_, _, err := testCase.tree.ToParquetSchema()
   262  		expectErr := (err != nil)
   263  
   264  		if expectErr != testCase.expectErr {
   265  			if testCase.expectErr {
   266  				t.Fatalf("case %v: err: expected: <error>, got: <nil>", i+1)
   267  			} else {
   268  				t.Fatalf("case %v: err: expected: <nil>, got: %v", i+1, err)
   269  			}
   270  		}
   271  	}
   272  }
   273  
   274  func TestTreeToParquetSchemaOfList(t *testing.T) {
   275  	case1Root := NewTree()
   276  	{
   277  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   278  			parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   279  			nil, nil, nil)
   280  		if err != nil {
   281  			t.Fatal(err)
   282  		}
   283  
   284  		if err := case1Root.Set("Names", names); err != nil {
   285  			t.Fatal(err)
   286  		}
   287  	}
   288  
   289  	case2Root := NewTree()
   290  	{
   291  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   292  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   293  			nil, nil, nil)
   294  		if err != nil {
   295  			t.Fatal(err)
   296  		}
   297  
   298  		if err := case2Root.Set("Names", names); err != nil {
   299  			t.Fatal(err)
   300  		}
   301  	}
   302  
   303  	case3Root := NewTree()
   304  	{
   305  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   306  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   307  			nil, nil, nil)
   308  		if err != nil {
   309  			t.Fatal(err)
   310  		}
   311  
   312  		a, err := NewElement("a", parquet.FieldRepetitionType_REPEATED,
   313  			nil, nil,
   314  			nil, nil, nil)
   315  		if err != nil {
   316  			t.Fatal(err)
   317  		}
   318  
   319  		if err := case3Root.Set("Names", names); err != nil {
   320  			t.Fatal(err)
   321  		}
   322  
   323  		if err := case3Root.Set("Names.a", a); err != nil {
   324  			t.Fatal(err)
   325  		}
   326  	}
   327  
   328  	case4Root := NewTree()
   329  	{
   330  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   331  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   332  			nil, nil, nil)
   333  		if err != nil {
   334  			t.Fatal(err)
   335  		}
   336  
   337  		list, err := NewElement("LIST", parquet.FieldRepetitionType_REQUIRED,
   338  			nil, nil,
   339  			nil, nil, nil)
   340  		if err != nil {
   341  			t.Fatal(err)
   342  		}
   343  
   344  		if err := case4Root.Set("Names", names); err != nil {
   345  			t.Fatal(err)
   346  		}
   347  
   348  		if err := case4Root.Set("Names.list", list); err != nil {
   349  			t.Fatal(err)
   350  		}
   351  	}
   352  
   353  	case5Root := NewTree()
   354  	{
   355  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   356  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   357  			nil, nil, nil)
   358  		if err != nil {
   359  			t.Fatal(err)
   360  		}
   361  
   362  		list, err := NewElement("list", parquet.FieldRepetitionType_REQUIRED,
   363  			nil, nil,
   364  			nil, nil, nil)
   365  		if err != nil {
   366  			t.Fatal(err)
   367  		}
   368  
   369  		if err := case5Root.Set("Names", names); err != nil {
   370  			t.Fatal(err)
   371  		}
   372  
   373  		if err := case5Root.Set("Names.list", list); err != nil {
   374  			t.Fatal(err)
   375  		}
   376  	}
   377  
   378  	case6Root := NewTree()
   379  	{
   380  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   381  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   382  			nil, nil, nil)
   383  		if err != nil {
   384  			t.Fatal(err)
   385  		}
   386  
   387  		list, err := NewElement("list", parquet.FieldRepetitionType_REPEATED,
   388  			nil, nil,
   389  			nil, nil, nil)
   390  		if err != nil {
   391  			t.Fatal(err)
   392  		}
   393  
   394  		if err := case6Root.Set("Names", names); err != nil {
   395  			t.Fatal(err)
   396  		}
   397  
   398  		if err := case6Root.Set("Names.list", list); err != nil {
   399  			t.Fatal(err)
   400  		}
   401  	}
   402  
   403  	case7Root := NewTree()
   404  	{
   405  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   406  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   407  			nil, nil, nil)
   408  		if err != nil {
   409  			t.Fatal(err)
   410  		}
   411  
   412  		list, err := NewElement("list", parquet.FieldRepetitionType_REPEATED,
   413  			nil, nil,
   414  			nil, nil, nil)
   415  		if err != nil {
   416  			t.Fatal(err)
   417  		}
   418  
   419  		a, err := NewElement("a", parquet.FieldRepetitionType_REQUIRED,
   420  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   421  			nil, nil, nil)
   422  		if err != nil {
   423  			t.Fatal(err)
   424  		}
   425  
   426  		if err := case7Root.Set("Names", names); err != nil {
   427  			t.Fatal(err)
   428  		}
   429  
   430  		if err := case7Root.Set("Names.list", list); err != nil {
   431  			t.Fatal(err)
   432  		}
   433  
   434  		if err := case7Root.Set("Names.list.a", a); err != nil {
   435  			t.Fatal(err)
   436  		}
   437  	}
   438  
   439  	case8Root := NewTree()
   440  	{
   441  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   442  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   443  			nil, nil, nil)
   444  		if err != nil {
   445  			t.Fatal(err)
   446  		}
   447  
   448  		list, err := NewElement("list", parquet.FieldRepetitionType_REPEATED,
   449  			nil, nil,
   450  			nil, nil, nil)
   451  		if err != nil {
   452  			t.Fatal(err)
   453  		}
   454  
   455  		element, err := NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   456  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   457  			nil, nil, nil)
   458  		if err != nil {
   459  			t.Fatal(err)
   460  		}
   461  
   462  		a, err := NewElement("a", parquet.FieldRepetitionType_REQUIRED,
   463  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   464  			nil, nil, nil)
   465  		if err != nil {
   466  			t.Fatal(err)
   467  		}
   468  
   469  		if err := case8Root.Set("Names", names); err != nil {
   470  			t.Fatal(err)
   471  		}
   472  
   473  		if err := case8Root.Set("Names.list", list); err != nil {
   474  			t.Fatal(err)
   475  		}
   476  
   477  		if err := case8Root.Set("Names.list.element", element); err != nil {
   478  			t.Fatal(err)
   479  		}
   480  
   481  		if err := case8Root.Set("Names.list.a", a); err != nil {
   482  			t.Fatal(err)
   483  		}
   484  	}
   485  
   486  	case9Root := NewTree()
   487  	{
   488  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   489  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   490  			nil, nil, nil)
   491  		if err != nil {
   492  			t.Fatal(err)
   493  		}
   494  
   495  		list, err := NewElement("list", parquet.FieldRepetitionType_REPEATED,
   496  			nil, nil,
   497  			nil, nil, nil)
   498  		if err != nil {
   499  			t.Fatal(err)
   500  		}
   501  
   502  		element, err := NewElement("ELEMENT", parquet.FieldRepetitionType_REQUIRED,
   503  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   504  			nil, nil, nil)
   505  		if err != nil {
   506  			t.Fatal(err)
   507  		}
   508  
   509  		if err := case9Root.Set("Names", names); err != nil {
   510  			t.Fatal(err)
   511  		}
   512  
   513  		if err := case9Root.Set("Names.list", list); err != nil {
   514  			t.Fatal(err)
   515  		}
   516  
   517  		if err := case9Root.Set("Names.list.element", element); err != nil {
   518  			t.Fatal(err)
   519  		}
   520  	}
   521  
   522  	case10Root := NewTree()
   523  	{
   524  		names, err := NewElement("names", parquet.FieldRepetitionType_REQUIRED,
   525  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_LIST),
   526  			nil, nil, nil)
   527  		if err != nil {
   528  			t.Fatal(err)
   529  		}
   530  
   531  		list, err := NewElement("list", parquet.FieldRepetitionType_REPEATED,
   532  			nil, nil,
   533  			nil, nil, nil)
   534  		if err != nil {
   535  			t.Fatal(err)
   536  		}
   537  
   538  		element, err := NewElement("element", parquet.FieldRepetitionType_REQUIRED,
   539  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   540  			nil, nil, nil)
   541  		if err != nil {
   542  			t.Fatal(err)
   543  		}
   544  
   545  		if err := case10Root.Set("Names", names); err != nil {
   546  			t.Fatal(err)
   547  		}
   548  
   549  		if err := case10Root.Set("Names.list", list); err != nil {
   550  			t.Fatal(err)
   551  		}
   552  
   553  		if err := case10Root.Set("Names.list.element", element); err != nil {
   554  			t.Fatal(err)
   555  		}
   556  	}
   557  
   558  	testCases := []struct {
   559  		tree      *Tree
   560  		expectErr bool
   561  	}{
   562  		{case1Root, true}, // err: Names: type must be nil for LIST ConvertedType
   563  		{case2Root, true}, // err: Names: children must have one element only for LIST ConvertedType
   564  		{case3Root, true}, // err: Names: missing group element 'list' for LIST ConvertedType
   565  		{case4Root, true}, // err: Names.list: name must be 'list'
   566  		{case5Root, true}, // err: Names.list: repetition type must be REPEATED type
   567  		{case6Root, true}, // err: Names.list.element: not found
   568  		{case7Root, true}, // err: Names.list.element: not found
   569  		{case8Root, true}, // err: Names.list.element: not found
   570  		{case9Root, true}, // err: Names.list.element: name must be 'element'
   571  		{case10Root, false},
   572  	}
   573  
   574  	for i, testCase := range testCases {
   575  		_, _, err := testCase.tree.ToParquetSchema()
   576  		expectErr := (err != nil)
   577  
   578  		if expectErr != testCase.expectErr {
   579  			if testCase.expectErr {
   580  				t.Fatalf("case %v: err: expected: <error>, got: <nil>", i+1)
   581  			} else {
   582  				t.Fatalf("case %v: err: expected: <nil>, got: %v", i+1, err)
   583  			}
   584  		}
   585  	}
   586  }
   587  
   588  func TestTreeToParquetSchemaOfMap(t *testing.T) {
   589  	case1Root := NewTree()
   590  	{
   591  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   592  			parquet.TypePtr(parquet.Type_BYTE_ARRAY), parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   593  			nil, nil, nil)
   594  		if err != nil {
   595  			t.Fatal(err)
   596  		}
   597  
   598  		if err := case1Root.Set("NameMap", nameMap); err != nil {
   599  			t.Fatal(err)
   600  		}
   601  	}
   602  
   603  	case2Root := NewTree()
   604  	{
   605  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   606  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   607  			nil, nil, nil)
   608  		if err != nil {
   609  			t.Fatal(err)
   610  		}
   611  
   612  		if err := case2Root.Set("NameMap", nameMap); err != nil {
   613  			t.Fatal(err)
   614  		}
   615  	}
   616  
   617  	case3Root := NewTree()
   618  	{
   619  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   620  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   621  			nil, nil, nil)
   622  		if err != nil {
   623  			t.Fatal(err)
   624  		}
   625  
   626  		a, err := NewElement("a", parquet.FieldRepetitionType_REPEATED,
   627  			nil, nil,
   628  			nil, nil, nil)
   629  		if err != nil {
   630  			t.Fatal(err)
   631  		}
   632  
   633  		if err := case3Root.Set("NameMap", nameMap); err != nil {
   634  			t.Fatal(err)
   635  		}
   636  
   637  		if err := case3Root.Set("NameMap.a", a); err != nil {
   638  			t.Fatal(err)
   639  		}
   640  	}
   641  
   642  	case4Root := NewTree()
   643  	{
   644  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   645  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   646  			nil, nil, nil)
   647  		if err != nil {
   648  			t.Fatal(err)
   649  		}
   650  
   651  		keyValue, err := NewElement("keyValue", parquet.FieldRepetitionType_REQUIRED,
   652  			nil, nil,
   653  			nil, nil, nil)
   654  		if err != nil {
   655  			t.Fatal(err)
   656  		}
   657  
   658  		if err := case4Root.Set("NameMap", nameMap); err != nil {
   659  			t.Fatal(err)
   660  		}
   661  
   662  		if err := case4Root.Set("NameMap.key_value", keyValue); err != nil {
   663  			t.Fatal(err)
   664  		}
   665  	}
   666  
   667  	case5Root := NewTree()
   668  	{
   669  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   670  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   671  			nil, nil, nil)
   672  		if err != nil {
   673  			t.Fatal(err)
   674  		}
   675  
   676  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REQUIRED,
   677  			nil, nil,
   678  			nil, nil, nil)
   679  		if err != nil {
   680  			t.Fatal(err)
   681  		}
   682  
   683  		if err := case5Root.Set("NameMap", nameMap); err != nil {
   684  			t.Fatal(err)
   685  		}
   686  
   687  		if err := case5Root.Set("NameMap.key_value", keyValue); err != nil {
   688  			t.Fatal(err)
   689  		}
   690  	}
   691  
   692  	case6Root := NewTree()
   693  	{
   694  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   695  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   696  			nil, nil, nil)
   697  		if err != nil {
   698  			t.Fatal(err)
   699  		}
   700  
   701  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   702  			nil, nil,
   703  			nil, nil, nil)
   704  		if err != nil {
   705  			t.Fatal(err)
   706  		}
   707  
   708  		if err := case6Root.Set("NameMap", nameMap); err != nil {
   709  			t.Fatal(err)
   710  		}
   711  
   712  		if err := case6Root.Set("NameMap.key_value", keyValue); err != nil {
   713  			t.Fatal(err)
   714  		}
   715  	}
   716  
   717  	case7Root := NewTree()
   718  	{
   719  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   720  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   721  			nil, nil, nil)
   722  		if err != nil {
   723  			t.Fatal(err)
   724  		}
   725  
   726  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   727  			nil, nil,
   728  			nil, nil, nil)
   729  		if err != nil {
   730  			t.Fatal(err)
   731  		}
   732  
   733  		a, err := NewElement("a", parquet.FieldRepetitionType_REQUIRED,
   734  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   735  			nil, nil, nil)
   736  		if err != nil {
   737  			t.Fatal(err)
   738  		}
   739  
   740  		b, err := NewElement("b", parquet.FieldRepetitionType_REQUIRED,
   741  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   742  			nil, nil, nil)
   743  		if err != nil {
   744  			t.Fatal(err)
   745  		}
   746  
   747  		c, err := NewElement("c", parquet.FieldRepetitionType_REQUIRED,
   748  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   749  			nil, nil, nil)
   750  		if err != nil {
   751  			t.Fatal(err)
   752  		}
   753  
   754  		if err := case7Root.Set("NameMap", nameMap); err != nil {
   755  			t.Fatal(err)
   756  		}
   757  
   758  		if err := case7Root.Set("NameMap.key_value", keyValue); err != nil {
   759  			t.Fatal(err)
   760  		}
   761  
   762  		if err := case7Root.Set("NameMap.key_value.a", a); err != nil {
   763  			t.Fatal(err)
   764  		}
   765  
   766  		if err := case7Root.Set("NameMap.key_value.b", b); err != nil {
   767  			t.Fatal(err)
   768  		}
   769  
   770  		if err := case7Root.Set("NameMap.key_value.c", c); err != nil {
   771  			t.Fatal(err)
   772  		}
   773  	}
   774  
   775  	case8Root := NewTree()
   776  	{
   777  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   778  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   779  			nil, nil, nil)
   780  		if err != nil {
   781  			t.Fatal(err)
   782  		}
   783  
   784  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   785  			nil, nil,
   786  			nil, nil, nil)
   787  		if err != nil {
   788  			t.Fatal(err)
   789  		}
   790  
   791  		a, err := NewElement("a", parquet.FieldRepetitionType_REQUIRED,
   792  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   793  			nil, nil, nil)
   794  		if err != nil {
   795  			t.Fatal(err)
   796  		}
   797  
   798  		if err := case8Root.Set("NameMap", nameMap); err != nil {
   799  			t.Fatal(err)
   800  		}
   801  
   802  		if err := case8Root.Set("NameMap.key_value", keyValue); err != nil {
   803  			t.Fatal(err)
   804  		}
   805  
   806  		if err := case8Root.Set("NameMap.key_value.a", a); err != nil {
   807  			t.Fatal(err)
   808  		}
   809  	}
   810  
   811  	case9Root := NewTree()
   812  	{
   813  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   814  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   815  			nil, nil, nil)
   816  		if err != nil {
   817  			t.Fatal(err)
   818  		}
   819  
   820  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   821  			nil, nil,
   822  			nil, nil, nil)
   823  		if err != nil {
   824  			t.Fatal(err)
   825  		}
   826  
   827  		key, err := NewElement("KEY", parquet.FieldRepetitionType_OPTIONAL,
   828  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   829  			nil, nil, nil)
   830  		if err != nil {
   831  			t.Fatal(err)
   832  		}
   833  
   834  		if err := case9Root.Set("NameMap", nameMap); err != nil {
   835  			t.Fatal(err)
   836  		}
   837  
   838  		if err := case9Root.Set("NameMap.key_value", keyValue); err != nil {
   839  			t.Fatal(err)
   840  		}
   841  
   842  		if err := case9Root.Set("NameMap.key_value.key", key); err != nil {
   843  			t.Fatal(err)
   844  		}
   845  	}
   846  
   847  	case10Root := NewTree()
   848  	{
   849  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   850  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   851  			nil, nil, nil)
   852  		if err != nil {
   853  			t.Fatal(err)
   854  		}
   855  
   856  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   857  			nil, nil,
   858  			nil, nil, nil)
   859  		if err != nil {
   860  			t.Fatal(err)
   861  		}
   862  
   863  		key, err := NewElement("key", parquet.FieldRepetitionType_OPTIONAL,
   864  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   865  			nil, nil, nil)
   866  		if err != nil {
   867  			t.Fatal(err)
   868  		}
   869  
   870  		if err := case10Root.Set("NameMap", nameMap); err != nil {
   871  			t.Fatal(err)
   872  		}
   873  
   874  		if err := case10Root.Set("NameMap.key_value", keyValue); err != nil {
   875  			t.Fatal(err)
   876  		}
   877  
   878  		if err := case10Root.Set("NameMap.key_value.key", key); err != nil {
   879  			t.Fatal(err)
   880  		}
   881  	}
   882  
   883  	case11Root := NewTree()
   884  	{
   885  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   886  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   887  			nil, nil, nil)
   888  		if err != nil {
   889  			t.Fatal(err)
   890  		}
   891  
   892  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   893  			nil, nil,
   894  			nil, nil, nil)
   895  		if err != nil {
   896  			t.Fatal(err)
   897  		}
   898  
   899  		key, err := NewElement("key", parquet.FieldRepetitionType_REQUIRED,
   900  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   901  			nil, nil, nil)
   902  		if err != nil {
   903  			t.Fatal(err)
   904  		}
   905  
   906  		a, err := NewElement("a", parquet.FieldRepetitionType_REQUIRED,
   907  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   908  			nil, nil, nil)
   909  		if err != nil {
   910  			t.Fatal(err)
   911  		}
   912  
   913  		if err := case11Root.Set("NameMap", nameMap); err != nil {
   914  			t.Fatal(err)
   915  		}
   916  
   917  		if err := case11Root.Set("NameMap.key_value", keyValue); err != nil {
   918  			t.Fatal(err)
   919  		}
   920  
   921  		if err := case11Root.Set("NameMap.key_value.key", key); err != nil {
   922  			t.Fatal(err)
   923  		}
   924  
   925  		if err := case11Root.Set("NameMap.key_value.a", a); err != nil {
   926  			t.Fatal(err)
   927  		}
   928  	}
   929  
   930  	case12Root := NewTree()
   931  	{
   932  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   933  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   934  			nil, nil, nil)
   935  		if err != nil {
   936  			t.Fatal(err)
   937  		}
   938  
   939  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   940  			nil, nil,
   941  			nil, nil, nil)
   942  		if err != nil {
   943  			t.Fatal(err)
   944  		}
   945  
   946  		key, err := NewElement("key", parquet.FieldRepetitionType_REQUIRED,
   947  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   948  			nil, nil, nil)
   949  		if err != nil {
   950  			t.Fatal(err)
   951  		}
   952  
   953  		value, err := NewElement("VALUE", parquet.FieldRepetitionType_REQUIRED,
   954  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   955  			nil, nil, nil)
   956  		if err != nil {
   957  			t.Fatal(err)
   958  		}
   959  
   960  		if err := case12Root.Set("NameMap", nameMap); err != nil {
   961  			t.Fatal(err)
   962  		}
   963  
   964  		if err := case12Root.Set("NameMap.key_value", keyValue); err != nil {
   965  			t.Fatal(err)
   966  		}
   967  
   968  		if err := case12Root.Set("NameMap.key_value.key", key); err != nil {
   969  			t.Fatal(err)
   970  		}
   971  
   972  		if err := case12Root.Set("NameMap.key_value.value", value); err != nil {
   973  			t.Fatal(err)
   974  		}
   975  	}
   976  
   977  	case13Root := NewTree()
   978  	{
   979  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
   980  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
   981  			nil, nil, nil)
   982  		if err != nil {
   983  			t.Fatal(err)
   984  		}
   985  
   986  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
   987  			nil, nil,
   988  			nil, nil, nil)
   989  		if err != nil {
   990  			t.Fatal(err)
   991  		}
   992  
   993  		key, err := NewElement("key", parquet.FieldRepetitionType_REQUIRED,
   994  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
   995  			nil, nil, nil)
   996  		if err != nil {
   997  			t.Fatal(err)
   998  		}
   999  
  1000  		if err := case13Root.Set("NameMap", nameMap); err != nil {
  1001  			t.Fatal(err)
  1002  		}
  1003  
  1004  		if err := case13Root.Set("NameMap.key_value", keyValue); err != nil {
  1005  			t.Fatal(err)
  1006  		}
  1007  
  1008  		if err := case13Root.Set("NameMap.key_value.key", key); err != nil {
  1009  			t.Fatal(err)
  1010  		}
  1011  	}
  1012  
  1013  	case14Root := NewTree()
  1014  	{
  1015  		nameMap, err := NewElement("nameMap", parquet.FieldRepetitionType_REQUIRED,
  1016  			nil, parquet.ConvertedTypePtr(parquet.ConvertedType_MAP),
  1017  			nil, nil, nil)
  1018  		if err != nil {
  1019  			t.Fatal(err)
  1020  		}
  1021  
  1022  		keyValue, err := NewElement("key_value", parquet.FieldRepetitionType_REPEATED,
  1023  			nil, nil,
  1024  			nil, nil, nil)
  1025  		if err != nil {
  1026  			t.Fatal(err)
  1027  		}
  1028  
  1029  		key, err := NewElement("key", parquet.FieldRepetitionType_REQUIRED,
  1030  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
  1031  			nil, nil, nil)
  1032  		if err != nil {
  1033  			t.Fatal(err)
  1034  		}
  1035  
  1036  		value, err := NewElement("value", parquet.FieldRepetitionType_REQUIRED,
  1037  			parquet.TypePtr(parquet.Type_INT32), parquet.ConvertedTypePtr(parquet.ConvertedType_INT_8),
  1038  			nil, nil, nil)
  1039  		if err != nil {
  1040  			t.Fatal(err)
  1041  		}
  1042  
  1043  		if err := case14Root.Set("NameMap", nameMap); err != nil {
  1044  			t.Fatal(err)
  1045  		}
  1046  
  1047  		if err := case14Root.Set("NameMap.key_value", keyValue); err != nil {
  1048  			t.Fatal(err)
  1049  		}
  1050  
  1051  		if err := case14Root.Set("NameMap.key_value.key", key); err != nil {
  1052  			t.Fatal(err)
  1053  		}
  1054  
  1055  		if err := case13Root.Set("NameMap.key_value.value", value); err != nil {
  1056  			t.Fatal(err)
  1057  		}
  1058  	}
  1059  
  1060  	testCases := []struct {
  1061  		tree      *Tree
  1062  		expectErr bool
  1063  	}{
  1064  		{case1Root, true},  // err: NameMap: type must be nil for MAP ConvertedType
  1065  		{case2Root, true},  // err: NameMap: children must have one element only for MAP ConvertedType
  1066  		{case3Root, true},  // err: NameMap: missing group element 'key_value' for MAP ConvertedType
  1067  		{case4Root, true},  // err: NameMap.key_value: name must be 'key_value'
  1068  		{case5Root, true},  // err: NameMap.key_value: repetition type must be REPEATED type
  1069  		{case6Root, true},  // err: NameMap.key_value: children must have 'key' and optionally 'value' elements for MAP ConvertedType
  1070  		{case7Root, true},  // err: NameMap.key_value: children must have 'key' and optionally 'value' elements for MAP ConvertedType
  1071  		{case8Root, true},  // err: NameMap.key_value: missing 'key' element for MAP ConvertedType
  1072  		{case9Root, true},  // err: NameMap.key_value.key: name must be 'key'
  1073  		{case10Root, true}, // err: NameMap.key_value: repetition type must be REQUIRED type
  1074  		{case11Root, true}, // err: NameMap.key_value: second element must be 'value' element for MAP ConvertedType
  1075  		{case12Root, true}, // err: NameMap.key_value.value: name must be 'value'
  1076  		{case13Root, false},
  1077  		{case14Root, false},
  1078  	}
  1079  
  1080  	for i, testCase := range testCases {
  1081  		_, _, err := testCase.tree.ToParquetSchema()
  1082  		expectErr := (err != nil)
  1083  
  1084  		if expectErr != testCase.expectErr {
  1085  			if testCase.expectErr {
  1086  				t.Fatalf("case %v: err: expected: <error>, got: <nil>", i+1)
  1087  			} else {
  1088  				t.Fatalf("case %v: err: expected: <nil>, got: %v", i+1, err)
  1089  			}
  1090  		}
  1091  	}
  1092  }