private TypeMapping fromParquetPrimitive()

in parquet-arrow/src/main/java/org/apache/parquet/arrow/schema/SchemaConverter.java [400:558]
137 lines of code
14 McCabe index (conditional complexity)

  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));
      }
    });
  }