xmax,
+ List ymax
+ ) {}
+
+ public record Covering(
+ CoveringBbox bbox
+ ) {}
+
+
+ public static GeoParquetMetadata parse(FileMetaData metadata) throws IOException {
+ String string = metadata.getKeyValueMetaData().get("geo");
+ if (string != null) {
+ try {
+ return mapper.readValue(string, GeoParquetMetadata.class);
+ } catch (JsonProcessingException e) {
+ LOGGER.warn("Invalid geoparquet metadata", e);
+ }
+ }
+ // fallback
+ for (var field : metadata.getSchema().asGroupType().getFields()) {
+ if (field.isPrimitive() &&
+ field.asPrimitiveType().getPrimitiveTypeName() == PrimitiveType.PrimitiveTypeName.BINARY) {
+ switch (field.getName()) {
+ case "geometry", "wkb_geometry" -> {
+ return new GeoParquetMetadata("1.0.0", field.getName(), Map.of(
+ field.getName(), new ColumnMetadata("WKB")));
+ }
+ case "wkt_geometry" -> {
+ return new GeoParquetMetadata("1.0.0", field.getName(), Map.of(
+ field.getName(), new ColumnMetadata("WKT")));
+ }
+ default -> {
+ //ignore
+ }
+ }
+ }
+ }
+ throw new IOException(
+ "No valid geometry columns found: " + metadata.getSchema().asGroupType().getFields().stream().map(
+ Type::getName).toList());
+ }
+}
diff --git a/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/Interval.java b/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/Interval.java
new file mode 100644
index 0000000000..f1cb4d464b
--- /dev/null
+++ b/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/Interval.java
@@ -0,0 +1,42 @@
+package com.onthegomap.planetiler.reader.parquet;
+
+import java.time.Duration;
+import java.time.Period;
+import java.time.temporal.Temporal;
+import java.time.temporal.TemporalAmount;
+import java.time.temporal.TemporalUnit;
+import java.util.List;
+import java.util.stream.Stream;
+
+/**
+ * Represents a parquet
+ * interval datatype which has a month, day, and millisecond part.
+ *
+ * Built-in java {@link TemporalAmount} implementations can only store a period or duration amount, but not both.
+ */
+public record Interval(Period period, Duration duration) implements TemporalAmount {
+
+ public static Interval of(int months, long days, long millis) {
+ return new Interval(Period.ofMonths(months).plusDays(days), Duration.ofMillis(millis));
+ }
+
+ @Override
+ public long get(TemporalUnit unit) {
+ return period.get(unit) + duration.get(unit);
+ }
+
+ @Override
+ public List getUnits() {
+ return Stream.concat(period.getUnits().stream(), duration.getUnits().stream()).toList();
+ }
+
+ @Override
+ public Temporal addTo(Temporal temporal) {
+ return temporal.plus(period).plus(duration);
+ }
+
+ @Override
+ public Temporal subtractFrom(Temporal temporal) {
+ return temporal.minus(period).minus(duration);
+ }
+}
diff --git a/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/MapRecordMaterializer.java b/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/MapRecordMaterializer.java
new file mode 100644
index 0000000000..2de7ee0a75
--- /dev/null
+++ b/planetiler-core/src/main/java/com/onthegomap/planetiler/reader/parquet/MapRecordMaterializer.java
@@ -0,0 +1,515 @@
+package com.onthegomap.planetiler.reader.parquet;
+
+import java.math.BigDecimal;
+import java.math.BigInteger;
+import java.nio.ByteBuffer;
+import java.nio.ByteOrder;
+import java.time.Duration;
+import java.time.Instant;
+import java.time.LocalDate;
+import java.time.LocalDateTime;
+import java.time.LocalTime;
+import java.time.Period;
+import java.time.ZoneOffset;
+import java.time.temporal.ChronoUnit;
+import java.util.ArrayList;
+import java.util.HashMap;
+import java.util.List;
+import java.util.Locale;
+import java.util.Map;
+import java.util.UUID;
+import java.util.function.Function;
+import java.util.function.IntConsumer;
+import java.util.function.LongFunction;
+import java.util.stream.IntStream;
+import org.apache.parquet.column.Dictionary;
+import org.apache.parquet.io.api.Binary;
+import org.apache.parquet.io.api.Converter;
+import org.apache.parquet.io.api.GroupConverter;
+import org.apache.parquet.io.api.PrimitiveConverter;
+import org.apache.parquet.io.api.RecordMaterializer;
+import org.apache.parquet.schema.GroupType;
+import org.apache.parquet.schema.LogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.DateLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.DecimalLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.EnumLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.IntLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.IntervalLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.JsonLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.StringLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.TimeLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.TimestampLogicalTypeAnnotation;
+import org.apache.parquet.schema.LogicalTypeAnnotation.UUIDLogicalTypeAnnotation;
+import org.apache.parquet.schema.MessageType;
+import org.apache.parquet.schema.Type;
+
+/**
+ * Simple converter for parquet datatypes that maps all structs to {@code Map} and handles deserializing
+ * list and map nested
+ * types into java {@link List Lists} and {@link Map Maps}.
+ */
+public class MapRecordMaterializer extends RecordMaterializer> {
+
+ private final StructConverter root;
+ private Map map;
+
+ MapRecordMaterializer(MessageType schema) {
+ root = new StructConverter(null, schema) {
+ @Override
+ public void start() {
+ var group = new MapGroup(schema.getFieldCount());
+ this.current = group;
+ map = group.getMap();
+ }
+ };
+ }
+
+ @Override
+ public Map getCurrentRecord() {
+ return map;
+ }
+
+ @Override
+ public void skipCurrentRecord() {
+ root.current = null;
+ }
+
+ @Override
+ public GroupConverter getRootConverter() {
+ return root;
+ }
+
+
+ private static class ListConverter extends StructConverter {
+
+ ListConverter(StructConverter parent, String fieldOnParent, GroupType schema) {
+ super(parent, schema, fieldOnParent, schema.isRepetition(Type.Repetition.REPEATED));
+ }
+
+ ListConverter(StructConverter parent, GroupType schema) {
+ this(parent, schema.getName(), schema);
+ }
+
+ private boolean onlyField(Type type, String name) {
+ return !type.isPrimitive() && type.asGroupType().getFieldCount() == 1 &&
+ type.asGroupType().getFieldName(0).equalsIgnoreCase(name);
+ }
+
+ @Override
+ protected Converter makeConverter(int fieldIdx, String fieldOnParent) {
+ if (schema.getFieldCount() == 1) {
+ Type type = schema.getType(0);
+ if ((type.getName().equalsIgnoreCase("list") || type.getName().equalsIgnoreCase("array")) &&
+ onlyField(type, "element")) {
+ return new ListElementConverter(this, this.fieldOnParent, type.asGroupType());
+ }
+ }
+ return super.makeConverter(fieldIdx, fieldOnParent);
+ }
+
+ @Override
+ public void start() {
+ this.current = new ListGroup();
+ parent.current.add(this.fieldOnParent, current.value(), repeated);
+ }
+ }
+
+
+ private static class ListElementConverter extends StructConverter {
+
+ ListElementConverter(StructConverter parent, String fieldOnParent, GroupType schema) {
+ super(parent, schema, fieldOnParent, true);
+ }
+
+ @Override
+ public void start() {
+ this.current = new ItemGroup();
+ }
+
+ @Override
+ public void end() {
+ parent.current.add(this.fieldOnParent, current.value(), parent.repeated);
+ }
+ }
+
+ private static class MapConverter extends StructConverter {
+
+ MapConverter(StructConverter parent, String fieldOnParent, GroupType schema) {
+ super(parent, schema, fieldOnParent, schema.isRepetition(Type.Repetition.REPEATED));
+ }
+
+ @Override
+ protected Converter makeConverter(int fieldIdx, String fieldOnParent) {
+ if (schema.getFieldCount() == 1) {
+ Type type = schema.getType(fieldIdx);
+ String onlyFieldName = type.getName().toLowerCase(Locale.ROOT);
+ if (!type.isPrimitive() && type.asGroupType().getFieldCount() == 2 &&
+ (onlyFieldName.equals("key_value") || onlyFieldName.equals("map"))) {
+ return new MapEntryConverter(this, fieldOnParent, type.asGroupType());
+ }
+ }
+ return super.makeConverter(fieldIdx, fieldOnParent);
+ }
+
+ @Override
+ public void start() {
+ this.current = new MapGroup();
+ parent.current.add(this.fieldOnParent, current.value(), repeated);
+ }
+ }
+
+ private static class MapEntryConverter extends StructConverter {
+ MapEntryGroup entry;
+
+ MapEntryConverter(StructConverter parent, String fieldOnParent, GroupType schema) {
+ super(parent, schema, fieldOnParent, true);
+ }
+
+ @Override
+ public void start() {
+ current = entry = new MapEntryGroup();
+ }
+
+ @Override
+ public void end() {
+ if (entry.v != null) {
+ parent.current.add(entry.k, entry.v, false);
+ }
+ }
+ }
+
+
+ private static class StructConverter extends GroupConverter {
+
+ final StructConverter parent;
+ final boolean repeated;
+ final GroupType schema;
+ final String fieldOnParent;
+ Group current;
+ private final Converter[] converters;
+
+ StructConverter(StructConverter parent, GroupType schema) {
+ this(parent, schema, schema.getName(), schema.isRepetition(Type.Repetition.REPEATED));
+ }
+
+ StructConverter(StructConverter parent, GroupType schema, String fieldOnParent, boolean repeated) {
+ this.parent = parent;
+ this.schema = schema;
+ this.repeated = repeated;
+ this.fieldOnParent = fieldOnParent;
+ converters = IntStream.range(0, schema.getFieldCount()).mapToObj(this::makeConverter).toArray(Converter[]::new);
+ }
+
+ protected Converter makeConverter(int fieldIdx) {
+ return makeConverter(fieldIdx, schema.getFieldName(fieldIdx));
+ }
+
+ protected Converter makeConverter(int fieldIdx, String fieldOnParent) {
+ return makeConverter(fieldIdx, fieldOnParent, schema.getType(fieldIdx).isRepetition(Type.Repetition.REPEATED));
+ }
+
+ protected Converter makeConverter(int fieldIdx, String fieldOnParent, boolean repeated) {
+ Type type = schema.getType(fieldIdx);
+ LogicalTypeAnnotation logical = type.getLogicalTypeAnnotation();
+ if (!type.isPrimitive()) {
+ return switch (logical) {
+ case LogicalTypeAnnotation.ListLogicalTypeAnnotation list ->
+ // If the repeated field is not a group, then its type is the element type and elements are required.
+ // If the repeated field is a group with multiple fields, then its type is the element type and elements are required.
+ // If the repeated field is a group with one field and is named either array or uses the LIST-annotated group's name with _tuple appended then the repeated type is the element type and elements are required.
+ // Otherwise, the repeated field's type is the element type with the repeated field's repetition.
+ new ListConverter(this, type.asGroupType());
+ case LogicalTypeAnnotation.MapLogicalTypeAnnotation m ->
+ // The outer-most level must be a group annotated with MAP that contains a single field named key_value. The repetition of this level must be either optional or required and determines whether the list is nullable.
+ // The middle level, named key_value, must be a repeated group with a key field for map keys and, optionally, a value field for map values.
+ // The key field encodes the map's key type. This field must have repetition required and must always be present.
+ // The value field encodes the map's value type and repetition. This field can be required, optional, or omitted.
+ new MapConverter(this, fieldOnParent, type.asGroupType());
+ case LogicalTypeAnnotation.MapKeyValueTypeAnnotation m ->
+ new MapConverter(this, fieldOnParent, type.asGroupType());
+ case null, default -> new StructConverter(this, type.asGroupType());
+ };
+ }
+ var primitiveType = type.asPrimitiveType().getPrimitiveTypeName();
+ return switch (primitiveType) {
+ case BOOLEAN -> new Primitive(this, fieldOnParent, type, repeated) {
+ @Override
+ public void addBoolean(boolean value) {
+ add(value);
+ }
+ };
+ case INT64, INT32 -> {
+ LongFunction