Java Code Examples for org.apache.iceberg.types.TypeUtil#visit()

public static Iterable<InternalRow> generateSpark(Schema schema, int numRecords, long seed) {
  return () -> new Iterator<InternalRow>() {
    private SparkRandomDataGenerator generator = new SparkRandomDataGenerator(seed);
    private int count = 0;

    @Override
    public boolean hasNext() {
      return count < numRecords;
    }

    @Override
    public InternalRow next() {
      if (count >= numRecords) {
        throw new NoSuchElementException();
      }
      count += 1;
      return (InternalRow) TypeUtil.visit(schema, generator);
    }
  };
}
 

private static Iterable<Record> newIterable(Supplier<RandomDataGenerator> newGenerator,
                                            Schema schema, int numRecords) {
  return () -> new Iterator<Record>() {
    private int count = 0;
    private RandomDataGenerator generator = newGenerator.get();

    @Override
    public boolean hasNext() {
      return count < numRecords;
    }

    @Override
    public Record next() {
      if (count >= numRecords) {
        throw new NoSuchElementException();
      }
      count += 1;
      return (Record) TypeUtil.visit(schema, generator);
    }
  };
}
 

private static Iterable<Row> generateData(Schema schema, int numRecords, Supplier<RandomRowGenerator> supplier) {
  return () -> new Iterator<Row>() {
    private final RandomRowGenerator generator = supplier.get();
    private int count = 0;

    @Override
    public boolean hasNext() {
      return count < numRecords;
    }

    @Override
    public Row next() {
      if (!hasNext()) {
        throw new NoSuchElementException();
      }
      ++count;
      return (Row) TypeUtil.visit(schema, generator);
    }
  };
}
 

/**
 * Generates mapping from field IDs to ORC qualified names. See {@link IdToOrcName} for details.
 */
public static Map<Integer, String> idToOrcName(Schema schema) {
  return TypeUtil.visit(schema, new IdToOrcName());
}
 

static Map<Integer, Accessor<StructLike>> forSchema(Schema schema) {
  return TypeUtil.visit(schema, new BuildPositionAccessors());
}
 

private static Map<Integer, Accessor<InternalRow>> buildAccessors(Schema schema) {
  return TypeUtil.visit(schema, new BuildPositionAccessors());
}
 

public static String describe(Schema schema) {
  return TypeUtil.visit(schema, DescribeSchemaVisitor.INSTANCE);
}
 

public static String describe(Type type) {
  return TypeUtil.visit(type, DescribeSchemaVisitor.INSTANCE);
}
 

public static Schema convert(org.apache.iceberg.Schema schema,
                             Map<Types.StructType, String> names) {
  return TypeUtil.visit(schema, new TypeToSchema(names));
}
 

public static Schema convert(Type type, Map<Types.StructType, String> names) {
  return TypeUtil.visit(type, new TypeToSchema(names));
}
 

public static Map<Type, Schema> convertTypes(Types.StructType type, String name) {
  TypeToSchema converter = new TypeToSchema(ImmutableMap.of(type, name));
  TypeUtil.visit(type, converter);
  return ImmutableMap.copyOf(converter.getConversionMap());
}
 

/**
 * Convert a {@link Schema} to a {@link DataType Spark type}.
 *
 * @param schema a Schema
 * @return the equivalent Spark type
 * @throws IllegalArgumentException if the type cannot be converted to Spark
 */
public static StructType convert(Schema schema) {
  return (StructType) TypeUtil.visit(schema, new TypeToSparkType());
}
 

/**
 * Convert a {@link Type} to a {@link DataType Spark type}.
 *
 * @param type a Type
 * @return the equivalent Spark type
 * @throws IllegalArgumentException if the type cannot be converted to Spark
 */
public static DataType convert(Type type) {
  return TypeUtil.visit(type, new TypeToSparkType());
}
 

/**
 * Create a name-based mapping for a schema.
 * <p>
 * The mapping returned by this method will use the schema's name for each field.
 *
 * @param schema a {@link Schema}
 * @return a {@link NameMapping} initialized with the schema's fields and names
 */
public static NameMapping create(Schema schema) {
  return new NameMapping(TypeUtil.visit(schema, CreateMapping.INSTANCE));
}
 

/**
 *
 * @param schema iceberg schema
 * @return column name to integer ID mapping
 */
public static Map<String, Integer> getIcebergColumnNameToIDMap(Schema schema) {
  Map<String, Integer> schemaNameIDMap = TypeUtil.visit(Types.StructType.of(schema.columns()), new DremioIndexByName());
  return CaseInsensitiveMap.newImmutableMap(schemaNameIDMap);
}