Use parquet tag for column names

internal/dremel/dremel_test.go

@@ -112,22 +112,22 @@ func TestDremel(t *testing.T) {
 }
 
 type Link struct {
-	Backward []int64
-	Forward  []int64
+	Backward []int64 `parquet:"backward"`
+	Forward  []int64 `parquet:"forward"`
 }
 
 type Language struct {
-	Code    string
-	Country *string
+	Code    string  `parquet:"code"`
+	Country *string `parquet:"country"`
 }
 
 type Name struct {
-	Languages []Language
-	URL       *string
+	Languages []Language `parquet:"languages"`
+	URL       *string    `parquet:"url"`
 }
 
 type Document struct {
-	DocID int64
-	Link  *Link
-	Names []Name
+	DocID int64  `parquet:"docid"`
+	Link  *Link  `parquet:"link"`
+	Names []Name `parquet:"names"`
 }

internal/dremel/write_test.go

@@ -516,7 +516,7 @@ func TestWrite(t *testing.T) {
 		{
 			name: "writeFriendsID",
 			fields: []fields.Field{
-				{Type: "Person", FieldNames: []string{"Friends", "ID"}, FieldTypes: []string{"Being", "int32"}, TypeName: "int32", FieldType: "Int32OptionalField", ParquetType: "Int32Type", ColumnName: "id", Category: "numericOptional", RepetitionTypes: []fields.RepetitionType{2, 0}},
+				{Type: "Person", FieldNames: []string{"Friends", "ID"}, FieldTypes: []string{"Being", "int32"}, TypeName: "int32", FieldType: "Int32OptionalField", ParquetType: "Int32Type", Category: "numericOptional", RepetitionTypes: []fields.RepetitionType{2, 0}},
 			},
 			result: `func writeFriendsID(x *Person, vals []int32, defs, reps []uint8) (int, int) {
 	var nVals, nLevels int

internal/fields/fields.go

@@ -11,12 +11,12 @@ type Field struct {
 	Type            string
 	RepetitionTypes RepetitionTypes
 	FieldNames      []string
+	ColumnNames     []string
 	FieldTypes      []string
 	Seen            RepetitionTypes
 	TypeName        string
 	FieldType       string
 	ParquetType     string
-	ColumnName      string
 	Category        string
 }
 
@@ -249,9 +249,9 @@ func (f Field) parent(start int) string {
 }
 
 func (f Field) Path() string {
-	out := make([]string, len(f.FieldNames))
-	for i, n := range f.FieldNames {
-		out[i] = fmt.Sprintf(`"%s"`, strings.ToLower(n))
+	out := make([]string, len(f.ColumnNames))
+	for i, n := range f.ColumnNames {
+		out[i] = fmt.Sprintf(`"%s"`, n)
 	}
 	return strings.Join(out, ", ")
 }

internal/gen/funcs.go

@@ -74,7 +74,7 @@ var (
 			}
 			return out
 		},
-		"columnName":    func(f fields.Field) string { return strings.ToLower(strings.Join(f.FieldNames, ".")) },
+		"columnName":    func(f fields.Field) string { return strings.Join(f.ColumnNames, ".") },
 		"writeFunc":     dremel.Write,
 		"readFunc":      dremel.Read,
 		"writeFuncName": func(f fields.Field) string { return fmt.Sprintf("write%s", strings.Join(f.FieldNames, "")) },

internal/parse/parse.go

@@ -17,7 +17,7 @@ const letters = "abcdefghijklmnopqrstuvwxyz"
 
 type field struct {
 	Field     fields.Field
-	tagName   string
+	tagNames  []string
 	fieldName string
 	fieldType string
 	omit      bool
@@ -96,6 +96,7 @@ func getOut(i int, f field, fields map[string][]field, errs []error, out []field
 					fld.Field.RepetitionTypes = append(append(f.Field.RepetitionTypes[:0:0], f.Field.RepetitionTypes...), o) //make a copy
 					fld.Field.FieldNames = append(f.Field.FieldNames, fld.Field.FieldNames...)
 					fld.Field.FieldTypes = append(f.Field.FieldTypes, fld.Field.FieldTypes...)
+					fld.Field.ColumnNames = append(f.Field.ColumnNames, fld.Field.ColumnNames...)
 				}
 				i, out, errs = getOut(i, fld, fields, errs, out)
 			}
@@ -142,11 +143,6 @@ func getFields(fullTyp string, fields []field, m map[string][]field) []flds.Fiel
 		}
 
 		f.Field.Type = fullTyp
-		if f.tagName != "" {
-			f.Field.ColumnName = f.tagName
-		} else {
-			f.Field.ColumnName = strings.Join(f.Field.FieldNames, ".")
-		}
 		out = append(out, f.Field)
 	}
 	return out
@@ -215,18 +211,22 @@ func getField(name string, x ast.Node) field {
 		return true
 	})
 
+	if tag == "" {
+		tag = name
+	}
+
 	fn, cat, pt := lookupTypeAndCategory(typ, optional, repeated)
 	return field{
 		Field: flds.Field{
 			FieldNames:  []string{name},
 			FieldTypes:  []string{typ},
+			ColumnNames: []string{tag},
 			TypeName:    getTypeName(typ, optional),
 			FieldType:   fn,
 			ParquetType: pt,
 			Category:    cat},
 		fieldName: name,
 		fieldType: typ,
-		tagName:   tag,
 		omit:      tag == "-",
 		optional:  optional,
 		repeated:  repeated,

internal/parse/parse_test.go

@@ -120,21 +120,21 @@ type Slice4 struct {
 }
 
 type Hobby2 struct {
-	Names []string
+	Names []string `parquet:"names"`
 }
 
 type Slice5 struct {
-	ID    int32 `parquet:"id"`
-	Hobby Hobby2
+	ID    int32  `parquet:"id"`
+	Hobby Hobby2 `parquet:"hobby"`
 }
 
 type Slice6 struct {
-	ID      int32
-	Hobbies []Hobby2
+	ID      int32    `parquet:"id"`
+	Hobbies []Hobby2 `parquet:"hobbies"`
 }
 
 type Slice7 struct {
-	Thing *Slice6
+	Thing *Slice6 `parquet:"thing"`
 }
 
 type Link struct {

parquet.go

@@ -230,7 +230,7 @@ func (m *Metadata) Footer(w io.Writer) error {
 		}
 
 		for _, col := range mrg.fields.fields {
-			ch, ok := mrg.columns[strings.ToLower(strings.Join(col.Path, "."))]
+			ch, ok := mrg.columns[strings.Join(col.Path, ".")]
 			if !ok {
 				continue
 			}
@@ -307,7 +307,7 @@ func schemaElements(fields []Field) schema {
 	for _, f := range fields {
 		var z int32
 		se := sch.SchemaElement{
-			Name:       strings.ToLower(f.Name),
+			Name:       f.Name,
 			TypeLength: &z,
 			Scale:      &z,
 			Precision:  &z,
@@ -316,7 +316,7 @@ func schemaElements(fields []Field) schema {
 
 		f.Type(&se)
 		f.RepetitionType(&se)
-		m[strings.ToLower(strings.Join(f.Path, "."))] = se
+		m[strings.Join(f.Path, ".")] = se
 	}
 
 	return schema{lookup: m, fields: fields}
@@ -331,7 +331,7 @@ func (m *Metadata) Pages() (map[string][]Page, error) {
 	for _, rg := range m.metadata.RowGroups {
 		for _, ch := range rg.Columns {
 			pth := ch.MetaData.PathInSchema
-			_, ok := m.schema.lookup[strings.ToLower(strings.Join(pth, "."))]
+			_, ok := m.schema.lookup[strings.Join(pth, ".")]
 			if !ok {
 				return nil, fmt.Errorf("could not find schema for %v", pth)
 			}
@@ -342,7 +342,7 @@ func (m *Metadata) Pages() (map[string][]Page, error) {
 				Size:   int(ch.MetaData.TotalCompressedSize),
 				Codec:  ch.MetaData.Codec,
 			}
-			k := strings.ToLower(strings.Join(pth, "."))
+			k := strings.Join(pth, ".")
 			out[k] = append(out[k], pg)
 		}
 	}