@loaders.gl/parquet 4.0.0-alpha.5 → 4.0.0-alpha.7

package/dist/esm/lib/wip/convert-schema-deep.java.disabled

@@ -0,0 +1,910 @@
+
+/*
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.parquet.arrow.schema;
+
+import static java.util.Arrays.asList;
+import static java.util.Optional.empty;
+import static java.util.Optional.of;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.TimeUnit.MICROS;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.TimeUnit.MILLIS;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.TimeUnit.NANOS;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.dateType;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.decimalType;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.intType;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.stringType;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.timeType;
+import static org.apache.parquet.schema.LogicalTypeAnnotation.timestampType;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.BINARY;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.BOOLEAN;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.DOUBLE;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.FIXED_LEN_BYTE_ARRAY;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.FLOAT;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT32;
+import static org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName.INT64;
+import static org.apache.parquet.schema.Type.Repetition.OPTIONAL;
+import static org.apache.parquet.schema.Type.Repetition.REPEATED;
+import static org.apache.parquet.schema.Type.Repetition.REQUIRED;
+
+import java.util.ArrayList;
+import java.util.List;
+import java.util.Optional;
+
+import org.apache.arrow.vector.types.DateUnit;
+import org.apache.arrow.vector.types.FloatingPointPrecision;
+import org.apache.arrow.vector.types.TimeUnit;
+import org.apache.arrow.vector.types.pojo.ArrowType;
+import org.apache.arrow.vector.types.pojo.ArrowType.ArrowTypeVisitor;
+import org.apache.arrow.vector.types.pojo.ArrowType.Binary;
+import org.apache.arrow.vector.types.pojo.ArrowType.Bool;
+import org.apache.arrow.vector.types.pojo.ArrowType.Date;
+import org.apache.arrow.vector.types.pojo.ArrowType.Decimal;
+import org.apache.arrow.vector.types.pojo.ArrowType.FloatingPoint;
+import org.apache.arrow.vector.types.pojo.ArrowType.Int;
+import org.apache.arrow.vector.types.pojo.ArrowType.Interval;
+import org.apache.arrow.vector.types.pojo.ArrowType.Null;
+import org.apache.arrow.vector.types.pojo.ArrowType.Struct;
+import org.apache.arrow.vector.types.pojo.ArrowType.Time;
+import org.apache.arrow.vector.types.pojo.ArrowType.Timestamp;
+import org.apache.arrow.vector.types.pojo.ArrowType.Union;
+import org.apache.arrow.vector.types.pojo.ArrowType.Utf8;
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.parquet.arrow.schema.SchemaMapping.ListTypeMapping;
+import org.apache.parquet.arrow.schema.SchemaMapping.PrimitiveTypeMapping;
+import org.apache.parquet.arrow.schema.SchemaMapping.RepeatedTypeMapping;
+import org.apache.parquet.arrow.schema.SchemaMapping.StructTypeMapping;
+import org.apache.parquet.arrow.schema.SchemaMapping.TypeMapping;
+import org.apache.parquet.arrow.schema.SchemaMapping.UnionTypeMapping;
+import org.apache.parquet.schema.GroupType;
+import org.apache.parquet.schema.LogicalTypeAnnotation;
+import org.apache.parquet.schema.MessageType;
+import org.apache.parquet.schema.PrimitiveType;
+import org.apache.parquet.schema.PrimitiveType.PrimitiveTypeName;
+import org.apache.parquet.schema.Type;
+import org.apache.parquet.schema.Type.Repetition;
+import org.apache.parquet.schema.Types;
+import org.apache.parquet.schema.Types.GroupBuilder;
+
+/**
+ * Logic to convert Parquet and Arrow Schemas back and forth and maintain the mapping
+ */
+public class SchemaConverter {
+
+  // Indicates if Int96 should be converted to Arrow Timestamp
+  private final boolean convertInt96ToArrowTimestamp;
+
+  /**
+   * For when we'll need this to be configurable
+   */
+  public SchemaConverter() {
+    this(false);
+  }
+
+  // TODO(PARQUET-1511): pass the parameters in a configuration object
+  public SchemaConverter(final boolean convertInt96ToArrowTimestamp) {
+    this.convertInt96ToArrowTimestamp = convertInt96ToArrowTimestamp;
+  }
+
+  /**
+   * Creates a Parquet Schema from an Arrow one and returns the mapping
+   * @param arrowSchema the provided Arrow Schema
+   * @return the mapping between the 2
+   */
+  public SchemaMapping fromArrow(Schema arrowSchema) {
+    List<Field> fields = arrowSchema.getFields();
+    List<TypeMapping> parquetFields = fromArrow(fields);
+    MessageType parquetType = addToBuilder(parquetFields, Types.buildMessage()).named("root");
+    return new SchemaMapping(arrowSchema, parquetType, parquetFields);
+  }
+
+  private <T> GroupBuilder<T> addToBuilder(List<TypeMapping> parquetFields, GroupBuilder<T> builder) {
+    for (TypeMapping type : parquetFields) {
+      builder = builder.addField(type.getParquetType());
+    }
+    return builder;
+  }
+
+  private List<TypeMapping> fromArrow(List<Field> fields) {
+    List<TypeMapping> result = new ArrayList<>(fields.size());
+    for (Field field : fields) {
+      result.add(fromArrow(field));
+    }
+    return result;
+  }
+
+  private TypeMapping fromArrow(final Field field) {
+    return fromArrow(field, field.getName());
+  }
+
+  /**
+   * @param field arrow field
+   * @param fieldName overrides field.getName()
+   * @return mapping
+   */
+  private TypeMapping fromArrow(final Field field, final String fieldName) {
+    final List<Field> children = field.getChildren();
+    return field.getType().accept(new ArrowTypeVisitor<TypeMapping>() {
+
+      @Override
+      public TypeMapping visit(Null type) {
+        // TODO(PARQUET-757): null original type
+        return primitive(BINARY);
+      }
+
+      @Override
+      public TypeMapping visit(Struct type) {
+        List<TypeMapping> parquetTypes = fromArrow(children);
+        return new StructTypeMapping(field, addToBuilder(parquetTypes, Types.buildGroup(OPTIONAL)).named(fieldName), parquetTypes);
+      }
+
+      @Override
+      public TypeMapping visit(org.apache.arrow.vector.types.pojo.ArrowType.List type) {
+        return createListTypeMapping();
+      }
+
+      @Override
+      public TypeMapping visit(org.apache.arrow.vector.types.pojo.ArrowType.FixedSizeList type) {
+        return createListTypeMapping();
+      }
+
+      private ListTypeMapping createListTypeMapping() {
+        if (children.size() != 1) {
+          throw new IllegalArgumentException("list fields must have exactly one child: " + field);
+        }
+        TypeMapping parquetChild = fromArrow(children.get(0), "element");
+        GroupType list = Types.optionalList().element(parquetChild.getParquetType()).named(fieldName);
+        return new ListTypeMapping(field, new List3Levels(list), parquetChild);
+      }
+
+      @Override
+      public TypeMapping visit(Union type) {
+        // TODO(PARQUET-756): add Union OriginalType
+        List<TypeMapping> parquetTypes = fromArrow(children);
+        return new UnionTypeMapping(field, addToBuilder(parquetTypes, Types.buildGroup(OPTIONAL)).named(fieldName), parquetTypes);
+      }
+
+      @Override
+      public TypeMapping visit(Int type) {
+        boolean signed = type.getIsSigned();
+        switch (type.getBitWidth()) {
+          case 8:
+          case 16:
+          case 32:
+            return primitive(INT32, intType(type.getBitWidth(), signed));
+          case 64:
+            return primitive(INT64, intType(64, signed));
+          default:
+            throw new IllegalArgumentException("Illegal int type: " + field);
+        }
+      }
+
+      @Override
+      public TypeMapping visit(FloatingPoint type) {
+        switch (type.getPrecision()) {
+          case HALF:
+            // TODO(PARQUET-757): original type HalfFloat
+            return primitive(FLOAT);
+          case SINGLE:
+            return primitive(FLOAT);
+          case DOUBLE:
+            return primitive(DOUBLE);
+          default:
+            throw new IllegalArgumentException("Illegal float type: " + field);
+        }
+      }
+
+      @Override
+      public TypeMapping visit(Utf8 type) {
+        return primitive(BINARY, stringType());
+      }
+
+      @Override
+      public TypeMapping visit(Binary type) {
+        return primitive(BINARY);
+      }
+
+      @Override
+      public TypeMapping visit(Bool type) {
+        return primitive(BOOLEAN);
+      }
+
+      /**
+       * See https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#decimal
+       * @param type an arrow decimal type
+       * @return a mapping from the arrow decimal to the Parquet type
+       */
+      @Override
+      public TypeMapping visit(Decimal type) {
+        int precision = type.getPrecision();
+        int scale = type.getScale();
+        if (1 <= precision && precision <= 9) {
+          return decimal(INT32, precision, scale);
+        } else if (1 <= precision && precision <= 18) {
+          return decimal(INT64, precision, scale);
+        } else {
+          // Better: FIXED_LENGTH_BYTE_ARRAY with length
+          return decimal(BINARY, precision, scale);
+        }
+      }
+
+      @Override
+      public TypeMapping visit(Date type) {
+        return primitive(INT32, dateType());
+      }
+
+      @Override
+      public TypeMapping visit(Time type) {
+        int bitWidth = type.getBitWidth();
+        TimeUnit timeUnit = type.getUnit();
+        if (bitWidth == 32 && timeUnit == TimeUnit.MILLISECOND) {
+          return primitive(INT32, timeType(false, MILLIS));
+        } else if (bitWidth == 64 && timeUnit == TimeUnit.MICROSECOND) {
+          return primitive(INT64, timeType(false, MICROS));
+        } else if (bitWidth == 64 && timeUnit == TimeUnit.NANOSECOND) {
+          return primitive(INT64, timeType(false, NANOS));
+        }
+        throw new UnsupportedOperationException("Unsupported type " + type);
+      }
+
+      @Override
+      public TypeMapping visit(Timestamp type) {
+        TimeUnit timeUnit = type.getUnit();
+        if (timeUnit == TimeUnit.MILLISECOND) {
+          return primitive(INT64, timestampType(isUtcNormalized(type), MILLIS));
+        } else if (timeUnit == TimeUnit.MICROSECOND) {
+          return primitive(INT64, timestampType(isUtcNormalized(type), MICROS));
+        } else if (timeUnit == TimeUnit.NANOSECOND) {
+          return primitive(INT64, timestampType(isUtcNormalized(type), NANOS));
+        }
+        throw new UnsupportedOperationException("Unsupported type " + type);
+      }
+
+      private boolean isUtcNormalized(Timestamp timestamp) {
+        String timeZone = timestamp.getTimezone();
+        return timeZone != null && !timeZone.isEmpty();
+      }
+
+      /**
+       * See https://github.com/apache/parquet-format/blob/master/LogicalTypes.md#interval
+       */
+      @Override
+      public TypeMapping visit(Interval type) {
+        // TODO(PARQUET-675): fix interval original types
+        return primitiveFLBA(12, LogicalTypeAnnotation.IntervalLogicalTypeAnnotation.getInstance());
+      }
+
+      @Override
+      public TypeMapping visit(ArrowType.FixedSizeBinary fixedSizeBinary) {
+        return primitive(BINARY);
+      }
+
+      private TypeMapping mapping(PrimitiveType parquetType) {
+        return new PrimitiveTypeMapping(field, parquetType);
+      }
+
+      private TypeMapping decimal(PrimitiveTypeName type, int precision, int scale) {
+        return mapping(Types.optional(type).as(decimalType(scale, precision)).named(fieldName));
+      }
+
+      private TypeMapping primitive(PrimitiveTypeName type) {
+        return mapping(Types.optional(type).named(fieldName));
+      }
+
+      private TypeMapping primitive(PrimitiveTypeName type, LogicalTypeAnnotation otype) {
+        return mapping(Types.optional(type).as(otype).named(fieldName));
+      }
+
+      private TypeMapping primitiveFLBA(int length, LogicalTypeAnnotation otype) {
+        return mapping(Types.optional(FIXED_LEN_BYTE_ARRAY).length(length).as(otype).named(fieldName));
+      }
+    });
+  }
+
+  /**
+   * Creates an Arrow Schema from an Parquet one and returns the mapping
+   * @param parquetSchema the provided Parquet Schema
+   * @return the mapping between the 2
+   */
+  public SchemaMapping fromParquet(MessageType parquetSchema) {
+    List<Type> fields = parquetSchema.getFields();
+    List<TypeMapping> mappings = fromParquet(fields);
+    List<Field> arrowFields = fields(mappings);
+    return new SchemaMapping(new Schema(arrowFields), parquetSchema, mappings);
+  }
+
+  private List<Field> fields(List<TypeMapping> mappings) {
+    List<Field> result = new ArrayList<>(mappings.size());
+    for (TypeMapping typeMapping : mappings) {
+      result.add(typeMapping.getArrowField());
+    }
+    return result;
+  }
+
+  private List<TypeMapping> fromParquet(List<Type> fields) {
+    List<TypeMapping> result = new ArrayList<>(fields.size());
+    for (Type type : fields) {
+      result.add(fromParquet(type));
+    }
+    return result;
+  }
+
+  private TypeMapping fromParquet(Type type) {
+    return fromParquet(type, type.getName(), type.getRepetition());
+  }
+
+  /**
+   * @param type parquet type
+   * @param name overrides parquet.getName)
+   * @param repetition overrides parquet.getRepetition()
+   * @return a type mapping from the Parquet type to an Arrow type
+   */
+  private TypeMapping fromParquet(Type type, String name, Repetition repetition) {
+    if (repetition == REPEATED) {
+      // case where we have a repeated field that is not in a List/Map
+      TypeMapping child = fromParquet(type, null, REQUIRED);
+      Field arrowField = new Field(name, false, new ArrowType.List(), asList(child.getArrowField()));
+      return new RepeatedTypeMapping(arrowField, type, child);
+    }
+    if (type.isPrimitive()) {
+      return fromParquetPrimitive(type.asPrimitiveType(), name);
+    } else {
+      return fromParquetGroup(type.asGroupType(), name);
+    }
+  }
+
+  /**
+   * @param type parquet types
+   * @param name overrides parquet.getName()
+   * @return the mapping
+   */
+  private TypeMapping fromParquetGroup(GroupType type, String name) {
+    LogicalTypeAnnotation logicalType = type.getLogicalTypeAnnotation();
+    if (logicalType == null) {
+      List<TypeMapping> typeMappings = fromParquet(type.getFields());
+      Field arrowField = new Field(name, type.isRepetition(OPTIONAL), new Struct(), fields(typeMappings));
+      return new StructTypeMapping(arrowField, type, typeMappings);
+    } else {
+      return logicalType.accept(new LogicalTypeAnnotation.LogicalTypeAnnotationVisitor<TypeMapping>() {
+        @Override
+        public Optional<TypeMapping> visit(LogicalTypeAnnotation.ListLogicalTypeAnnotation listLogicalType) {
+          List3Levels list3Levels = new List3Levels(type);
+          TypeMapping child = fromParquet(list3Levels.getElement(), null, list3Levels.getElement().getRepetition());
+          Field arrowField = new Field(name, type.isRepetition(OPTIONAL), new ArrowType.List(), asList(child.getArrowField()));
+          return of(new ListTypeMapping(arrowField, list3Levels, child));
+        }
+      }).orElseThrow(() -> new UnsupportedOperationException("Unsupported type " + type));
+    }
+  }
+
+  /**
+   * @param type parquet types
+   * @param name overrides parquet.getName()
+   * @return the mapping
+   */
+  private TypeMapping fromParquetPrimitive(final PrimitiveType type, final String name) {
+    return type.getPrimitiveTypeName().convert(new PrimitiveType.PrimitiveTypeNameConverter<TypeMapping, RuntimeException>() {
+
+      private TypeMapping field(ArrowType arrowType) {
+        Field field = new Field(name, type.isRepetition(OPTIONAL), arrowType, null);
+        return new PrimitiveTypeMapping(field, type);
+      }
+
+      @Override
+      public TypeMapping convertFLOAT(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        return field(new ArrowType.FloatingPoint(FloatingPointPrecision.SINGLE));
+      }
+
+      @Override
+      public TypeMapping convertDOUBLE(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        return field(new ArrowType.FloatingPoint(FloatingPointPrecision.DOUBLE));
+      }
+
+      @Override
+      public TypeMapping convertINT32(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        LogicalTypeAnnotation logicalTypeAnnotation = type.getLogicalTypeAnnotation();
+        if (logicalTypeAnnotation == null) {
+          return integer(32, true);
+        }
+        return logicalTypeAnnotation.accept(new LogicalTypeAnnotation.LogicalTypeAnnotationVisitor<TypeMapping>() {
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalLogicalType) {
+            return of(decimal(decimalLogicalType.getPrecision(), decimalLogicalType.getScale()));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DateLogicalTypeAnnotation dateLogicalType) {
+            return of(field(new ArrowType.Date(DateUnit.DAY)));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.TimeLogicalTypeAnnotation timeLogicalType) {
+            return timeLogicalType.getUnit() == MILLIS ? of(field(new ArrowType.Time(TimeUnit.MILLISECOND, 32))) : empty();
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.IntLogicalTypeAnnotation intLogicalType) {
+            if (intLogicalType.getBitWidth() == 64) {
+              return empty();
+            }
+            return of(integer(intLogicalType.getBitWidth(), intLogicalType.isSigned()));
+          }
+        }).orElseThrow(() -> new IllegalArgumentException("illegal type " + type));
+      }
+
+      @Override
+      public TypeMapping convertINT64(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        LogicalTypeAnnotation logicalTypeAnnotation = type.getLogicalTypeAnnotation();
+        if (logicalTypeAnnotation == null) {
+          return integer(64, true);
+        }
+
+        return logicalTypeAnnotation.accept(new LogicalTypeAnnotation.LogicalTypeAnnotationVisitor<TypeMapping>() {
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DateLogicalTypeAnnotation dateLogicalType) {
+            return of(field(new ArrowType.Date(DateUnit.DAY)));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalLogicalType) {
+            return of(decimal(decimalLogicalType.getPrecision(), decimalLogicalType.getScale()));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.IntLogicalTypeAnnotation intLogicalType) {
+            return of(integer(intLogicalType.getBitWidth(), intLogicalType.isSigned()));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.TimeLogicalTypeAnnotation timeLogicalType) {
+            if (timeLogicalType.getUnit() == MICROS) {
+              return of(field(new ArrowType.Time(TimeUnit.MICROSECOND, 64)));
+            }  else if (timeLogicalType.getUnit() == NANOS) {
+              return of(field(new ArrowType.Time(TimeUnit.NANOSECOND, 64)));
+            }
+            return empty();
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.TimestampLogicalTypeAnnotation timestampLogicalType) {
+            switch (timestampLogicalType.getUnit()) {
+              case MICROS:
+                return of(field(new ArrowType.Timestamp(TimeUnit.MICROSECOND, getTimeZone(timestampLogicalType))));
+              case MILLIS:
+                return of(field(new ArrowType.Timestamp(TimeUnit.MILLISECOND, getTimeZone(timestampLogicalType))));
+              case NANOS:
+                return of(field(new ArrowType.Timestamp(TimeUnit.NANOSECOND, getTimeZone(timestampLogicalType))));
+            }
+            return empty();
+          }
+
+          private String getTimeZone(LogicalTypeAnnotation.TimestampLogicalTypeAnnotation timestampLogicalType) {
+            return timestampLogicalType.isAdjustedToUTC() ? "UTC" : null;
+          }
+        }).orElseThrow(() -> new IllegalArgumentException("illegal type " + type));
+      }
+
+      @Override
+      public TypeMapping convertINT96(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        if (convertInt96ToArrowTimestamp) {
+          return field(new ArrowType.Timestamp(TimeUnit.NANOSECOND, null));
+        } else {
+          return field(new ArrowType.Binary());
+        }
+      }
+
+      @Override
+      public TypeMapping convertFIXED_LEN_BYTE_ARRAY(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        LogicalTypeAnnotation logicalTypeAnnotation = type.getLogicalTypeAnnotation();
+        if (logicalTypeAnnotation == null) {
+          return field(new ArrowType.Binary());
+        }
+
+        return logicalTypeAnnotation.accept(new LogicalTypeAnnotation.LogicalTypeAnnotationVisitor<TypeMapping>() {
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalLogicalType) {
+            return of(decimal(decimalLogicalType.getPrecision(), decimalLogicalType.getScale()));
+          }
+        }).orElseThrow(() -> new IllegalArgumentException("illegal type " + type));
+      }
+
+      @Override
+      public TypeMapping convertBOOLEAN(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        return field(new ArrowType.Bool());
+      }
+
+      @Override
+      public TypeMapping convertBINARY(PrimitiveTypeName primitiveTypeName) throws RuntimeException {
+        LogicalTypeAnnotation logicalTypeAnnotation = type.getLogicalTypeAnnotation();
+        if (logicalTypeAnnotation == null) {
+          return field(new ArrowType.Binary());
+        }
+        return logicalTypeAnnotation.accept(new LogicalTypeAnnotation.LogicalTypeAnnotationVisitor<TypeMapping>() {
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.StringLogicalTypeAnnotation stringLogicalType) {
+            return of(field(new ArrowType.Utf8()));
+          }
+
+          @Override
+          public Optional<TypeMapping> visit(LogicalTypeAnnotation.DecimalLogicalTypeAnnotation decimalLogicalType) {
+            return of(decimal(decimalLogicalType.getPrecision(), decimalLogicalType.getScale()));
+          }
+        }).orElseThrow(() -> new IllegalArgumentException("illegal type " + type));
+      }
+
+      private TypeMapping decimal(int precision, int scale) {
+        return field(new ArrowType.Decimal(precision, scale));
+      }
+
+      private TypeMapping integer(int width, boolean signed) {
+        return field(new ArrowType.Int(width, signed));
+      }
+    });
+  }
+
+  /**
+   * Maps a Parquet and Arrow Schema
+   * For now does not validate primitive type compatibility
+   * @param arrowSchema an Arrow schema
+   * @param parquetSchema a Parquet message type
+   * @return the mapping between the 2
+   */
+  public SchemaMapping map(Schema arrowSchema, MessageType parquetSchema) {
+    List<TypeMapping> children = map(arrowSchema.getFields(), parquetSchema.getFields());
+    return new SchemaMapping(arrowSchema, parquetSchema, children);
+  }
+
+  private List<TypeMapping> map(List<Field> arrowFields, List<Type> parquetFields) {
+    if (arrowFields.size() != parquetFields.size()) {
+      throw new IllegalArgumentException("Can not map schemas as sizes differ: " + arrowFields + " != " + parquetFields);
+    }
+    List<TypeMapping> result = new ArrayList<>(arrowFields.size());
+    for (int i = 0; i < arrowFields.size(); i++) {
+      Field arrowField = arrowFields.get(i);
+      Type parquetField = parquetFields.get(i);
+      result.add(map(arrowField, parquetField));
+    }
+    return result;
+  }
+
+  private TypeMapping map(final Field arrowField, final Type parquetField) {
+    return arrowField.getType().accept(new ArrowTypeVisitor<TypeMapping>() {
+
+      @Override
+      public TypeMapping visit(Null type) {
+        if (!parquetField.isRepetition(OPTIONAL)) {
+          throw new IllegalArgumentException("Parquet type can't be null: " + parquetField);
+        }
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Struct type) {
+        if (parquetField.isPrimitive()) {
+          throw new IllegalArgumentException("Parquet type not a group: " + parquetField);
+        }
+        GroupType groupType = parquetField.asGroupType();
+        return new StructTypeMapping(arrowField, groupType, map(arrowField.getChildren(), groupType.getFields()));
+      }
+
+      @Override
+      public TypeMapping visit(org.apache.arrow.vector.types.pojo.ArrowType.List type) {
+        return createListTypeMapping(type);
+      }
+
+      @Override
+      public TypeMapping visit(org.apache.arrow.vector.types.pojo.ArrowType.FixedSizeList type) {
+        return createListTypeMapping(type);
+      }
+
+      private TypeMapping createListTypeMapping(ArrowType.ComplexType type) {
+        if (arrowField.getChildren().size() != 1) {
+          throw new IllegalArgumentException("Invalid list type: " + type);
+        }
+        Field arrowChild = arrowField.getChildren().get(0);
+        if (parquetField.isRepetition(REPEATED)) {
+          return new RepeatedTypeMapping(arrowField, parquetField, map(arrowChild, parquetField));
+        }
+        if (parquetField.isPrimitive()) {
+          throw new IllegalArgumentException("Parquet type not a group: " + parquetField);
+        }
+        List3Levels list3Levels = new List3Levels(parquetField.asGroupType());
+        if (arrowField.getChildren().size() != 1) {
+          throw new IllegalArgumentException("invalid arrow list: " + arrowField);
+        }
+        return new ListTypeMapping(arrowField, list3Levels, map(arrowChild, list3Levels.getElement()));
+      }
+
+      @Override
+      public TypeMapping visit(Union type) {
+        if (parquetField.isPrimitive()) {
+          throw new IllegalArgumentException("Parquet type not a group: " + parquetField);
+        }
+        GroupType groupType = parquetField.asGroupType();
+        return new UnionTypeMapping(arrowField, groupType, map(arrowField.getChildren(), groupType.getFields()));
+      }
+
+      @Override
+      public TypeMapping visit(Int type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(FloatingPoint type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Utf8 type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Binary type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Bool type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Decimal type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Date type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Time type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Timestamp type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(Interval type) {
+        return primitive();
+      }
+
+      @Override
+      public TypeMapping visit(ArrowType.FixedSizeBinary fixedSizeBinary) {
+        return primitive();
+      }
+
+      private TypeMapping primitive() {
+        if (!parquetField.isPrimitive()) {
+          throw new IllegalArgumentException("Can not map schemas as one is primitive and the other is not: " + arrowField + " != " + parquetField);
+        }
+        return new PrimitiveTypeMapping(arrowField, parquetField.asPrimitiveType());
+      }
+    });
+  }
+}
+
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one
+ * or more contributor license agreements.  See the NOTICE file
+ * distributed with this work for additional information
+ * regarding copyright ownership.  The ASF licenses this file
+ * to you under the Apache License, Version 2.0 (the
+ * "License"); you may not use this file except in compliance
+ * with the License.  You may obtain a copy of the License at
+ *
+ *   http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing,
+ * software distributed under the License is distributed on an
+ * "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+ * KIND, either express or implied.  See the License for the
+ * specific language governing permissions and limitations
+ * under the License.
+ */
+package org.apache.parquet.arrow.schema;
+
+import static java.util.Arrays.asList;
+
+import java.util.Collections;
+import java.util.List;
+
+import org.apache.arrow.vector.types.pojo.Field;
+import org.apache.arrow.vector.types.pojo.Schema;
+import org.apache.parquet.schema.GroupType;
+import org.apache.parquet.schema.MessageType;
+import org.apache.parquet.schema.PrimitiveType;
+import org.apache.parquet.schema.Type;
+
+/**
+ * The mapping between an Arrow and a Parquet schema
+ * @see SchemaConverter
+ */
+public class SchemaMapping {
+
+  private final Schema arrowSchema;
+  private final MessageType parquetSchema;
+  private final List<TypeMapping> children;
+
+  SchemaMapping(Schema arrowSchema, MessageType parquetSchema, List<TypeMapping> children) {
+    super();
+    this.arrowSchema = arrowSchema;
+    this.parquetSchema = parquetSchema;
+    this.children = Collections.unmodifiableList(children);
+  }
+
+  public Schema getArrowSchema() {
+    return arrowSchema;
+  }
+
+  public MessageType getParquetSchema() {
+    return parquetSchema;
+  }
+
+  /**
+   * @return mapping between individual fields of each of the 2 schemas (should be the same width)
+   */
+  public List<TypeMapping> getChildren() {
+    return children;
+  }
+
+  /**
+   * To traverse a schema mapping
+   * @param <T> the Java return type of the visitor
+   */
+  public interface TypeMappingVisitor<T> {
+    T visit(PrimitiveTypeMapping primitiveTypeMapping);
+    T visit(StructTypeMapping structTypeMapping);
+    T visit(UnionTypeMapping unionTypeMapping);
+    T visit(ListTypeMapping listTypeMapping);
+    T visit(RepeatedTypeMapping repeatedTypeMapping);
+  }
+
+  /**
+   * Mapping between an Arrow and a Parquet types
+   */
+  public abstract static class TypeMapping {
+
+    private final Field arrowField;
+    private final Type parquetType;
+    private List<TypeMapping> children;
+
+    TypeMapping(Field arrowField, Type parquetType, List<TypeMapping> children) {
+      super();
+      this.arrowField = arrowField;
+      this.parquetType = parquetType;
+      this.children = children;
+    }
+
+    public Field getArrowField() {
+      return arrowField;
+    }
+
+    public Type getParquetType() {
+      return parquetType;
+    }
+
+    public List<TypeMapping> getChildren() {
+      return children;
+    }
+
+    public abstract <T> T accept(TypeMappingVisitor<T> visitor);
+
+  }
+
+  /**
+   * mapping between two primitive types
+   */
+  public static class PrimitiveTypeMapping extends TypeMapping {
+    public PrimitiveTypeMapping(Field arrowField, PrimitiveType parquetType) {
+      super(arrowField, parquetType, Collections.<TypeMapping>emptyList());
+    }
+
+    @Override
+    public <T> T accept(TypeMappingVisitor<T> visitor) {
+      return visitor.visit(this);
+    }
+  }
+
+  /**
+   * mapping of a struct type
+   */
+  public static class StructTypeMapping extends TypeMapping {
+    public StructTypeMapping(Field arrowField, GroupType parquetType, List<TypeMapping> children) {
+      super(arrowField, parquetType, children);
+    }
+
+    @Override
+    public <T> T accept(TypeMappingVisitor<T> visitor) {
+      return visitor.visit(this);
+    }
+  }
+
+  /**
+   * mapping of a union type
+   */
+  public static class UnionTypeMapping extends TypeMapping {
+    public UnionTypeMapping(Field arrowField, GroupType parquetType, List<TypeMapping> children) {
+      super(arrowField, parquetType, children);
+    }
+
+    @Override
+    public <T> T accept(TypeMappingVisitor<T> visitor) {
+      return visitor.visit(this);
+    }
+  }
+
+  /**
+   * mapping of a List type and standard 3-level List annotated Parquet type
+   */
+  public static class ListTypeMapping extends TypeMapping {
+    private final List3Levels list3Levels;
+    private final TypeMapping child;
+
+    public ListTypeMapping(Field arrowField, List3Levels list3Levels, TypeMapping child) {
+      super(arrowField, list3Levels.getList(), asList(child));
+      this.list3Levels = list3Levels;
+      this.child = child;
+      if (list3Levels.getElement() != child.getParquetType()) {
+        throw new IllegalArgumentException(list3Levels + " <=> " + child);
+      }
+    }
+
+    public List3Levels getList3Levels() {
+      return list3Levels;
+    }
+
+    public TypeMapping getChild() {
+      return child;
+    }
+
+    @Override
+    public <T> T accept(TypeMappingVisitor<T> visitor) {
+      return visitor.visit(this);
+    }
+  }
+
+  /**
+   * mapping of a List type and repeated Parquet field (non-list annotated)
+   */
+  public static class RepeatedTypeMapping extends TypeMapping {
+    private final TypeMapping child;
+
+    public RepeatedTypeMapping(Field arrowField, Type parquetType, TypeMapping child) {
+      super(arrowField, parquetType, asList(child));
+      this.child = child;
+    }
+
+    public TypeMapping getChild() {
+      return child;
+    }
+
+    @Override
+    public <T> T accept(TypeMappingVisitor<T> visitor) {
+      return visitor.visit(this);
+    }
+  }
+}
+*/