org.apache.flink.api.java.typeutils.TupleTypeInfo java code examples

@Override
protected TupleTypeInfo<?>[] getTestData() {
  return new TupleTypeInfo<?>[] {
    new TupleTypeInfo<>(BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO),
    new TupleTypeInfo<>(BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.BOOLEAN_TYPE_INFO)
  };
}

private TypeInformation<?>[] extractFieldTypes(int[] fields, TypeInformation<?> inType) {
  TupleTypeInfo<?> inTupleType = (TupleTypeInfo<?>) inType;
  TypeInformation<?>[] fieldTypes = new TypeInformation[fields.length];
  for (int i = 0; i < fields.length; i++) {
    fieldTypes[i] = inTupleType.getTypeAt(fields[i]);
  }
  return fieldTypes;
}

/**
 * Projects a {@link Tuple} {@link DataStream} to the previously selected fields.
 *
 * @return The projected DataStream.
 * @see Tuple
 * @see DataStream
 */
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20> SingleOutputStreamOperator<Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> projectTuple21() {
  TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
  TupleTypeInfo<Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>> tType = new TupleTypeInfo<Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>>(fTypes);
  return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple21<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20>>(fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
}

@SuppressWarnings("unchecked")
@Override
@PublicEvolving
public TupleSerializer<T> createSerializer(ExecutionConfig executionConfig) {
  if (getTypeClass() == Tuple0.class) {
    return (TupleSerializer<T>) Tuple0Serializer.INSTANCE;
  }
  TypeSerializer<?>[] fieldSerializers = new TypeSerializer<?>[getArity()];
  for (int i = 0; i < types.length; i++) {
    fieldSerializers[i] = types[i].createSerializer(executionConfig);
  }
  
  Class<T> tupleClass = getTypeClass();
  
  return new TupleSerializer<T>(tupleClass, fieldSerializers);
}

SimpleTupleFieldAccessor(int pos, TypeInformation<T> typeInfo) {
  checkNotNull(typeInfo, "typeInfo must not be null.");
  int arity = ((TupleTypeInfo) typeInfo).getArity();
  if (pos < 0 || pos >= arity) {
    throw new CompositeType.InvalidFieldReferenceException(
      "Tried to select " + ((Integer) pos).toString() + ". field on \"" +
      typeInfo.toString() + "\", which is an invalid index.");
  }
  this.pos = pos;
  this.fieldType = ((TupleTypeInfo) typeInfo).getTypeAt(pos);
}

@Test
public void testMyTupleHierarchyWithInference() {
  TypeInformation<Tuple1<MyTuple3<Tuple1<Float>>>> inTypeInfo = new TupleTypeInfo<>(new MyTupleTypeInfo<>(
    new TupleTypeInfo<Tuple1<Float>>(FLOAT_TYPE_INFO), BOOLEAN_TYPE_INFO));
  MapFunction<Tuple1<MyTuple3<Tuple1<Float>>>, Tuple1<MyTuple3<Tuple2<Float, String>>>> f = new MyTuple3Mapper<>();
  TypeInformation ti = TypeExtractor.getMapReturnTypes(f, inTypeInfo);
  assertTrue(ti instanceof TupleTypeInfo);
  TupleTypeInfo<?> tti = (TupleTypeInfo) ti;
  assertTrue(tti.getTypeAt(0) instanceof MyTupleTypeInfo);
  MyTupleTypeInfo mtti = (MyTupleTypeInfo) tti.getTypeAt(0);
  assertEquals(new TupleTypeInfo<>(FLOAT_TYPE_INFO, STRING_TYPE_INFO), mtti.getField0());
  assertEquals(BOOLEAN_TYPE_INFO, mtti.getField1());
}

protected ProjectCross(DataSet<I1> input1, DataSet<I2> input2, int[] fields, boolean[] isFromFirst,
    TupleTypeInfo<OUT> returnType, CrossHint hint) {
  super(input1, input2,
      new ProjectCrossFunction<I1, I2, OUT>(fields, isFromFirst, returnType.createSerializer(input1.getExecutionEnvironment().getConfig()).createInstance()),
      returnType, hint, "unknown");
  crossProjection = null;
}

RecursiveTupleFieldAccessor(int pos, FieldAccessor<R, F> innerAccessor, TypeInformation<T> typeInfo) {
  checkNotNull(typeInfo, "typeInfo must not be null.");
  checkNotNull(innerAccessor, "innerAccessor must not be null.");
  int arity = ((TupleTypeInfo) typeInfo).getArity();
  if (pos < 0 || pos >= arity) {
    throw new CompositeType.InvalidFieldReferenceException(
      "Tried to select " + ((Integer) pos).toString() + ". field on \"" +
        typeInfo.toString() + "\", which is an invalid index.");
  }
  this.pos = pos;
  this.innerAccessor = innerAccessor;
  this.fieldType = innerAccessor.fieldType;
}

@Test
public void testFunctionDependingOnInputWithFunctionHierarchy2() {
  IdentityMapper5<String> function = new IdentityMapper5<String>();
  @SuppressWarnings({ "rawtypes", "unchecked" })
  TypeInformation<?> ti = TypeExtractor.getMapReturnTypes(function, new TupleTypeInfo(BasicTypeInfo.STRING_TYPE_INFO,
      BasicTypeInfo.STRING_TYPE_INFO));
  Assert.assertTrue(ti.isTupleType());
  TupleTypeInfo<?> tti = (TupleTypeInfo<?>) ti;
  Assert.assertEquals(BasicTypeInfo.STRING_TYPE_INFO, tti.getTypeAt(0));
  Assert.assertEquals(BasicTypeInfo.STRING_TYPE_INFO, tti.getTypeAt(1));
}

protected ProjectCross(DataSet<I1> input1, DataSet<I2> input2, int[] fields, boolean[] isFromFirst,
    TupleTypeInfo<OUT> returnType, CrossProjection<I1, I2> crossProjection, CrossHint hint) {
  super(input1, input2,
    new ProjectCrossFunction<I1, I2, OUT>(fields, isFromFirst, returnType.createSerializer(input1.getExecutionEnvironment().getConfig()).createInstance()),
    returnType, hint, "unknown");
  this.crossProjection = crossProjection;
}

  @Override
  public TupleTypeInfo<Tuple2<Boolean, Row>> getOutputType() {
    return new TupleTypeInfo<>(Types.BOOLEAN, getRecordType());
  }
}

/**
 * Projects a {@link Tuple} {@link DataStream} to the previously selected fields.
 *
 * @return The projected DataStream.
 * @see Tuple
 * @see DataStream
 */
public <T0, T1, T2, T3, T4, T5, T6, T7> SingleOutputStreamOperator<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>> projectTuple8() {
  TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
  TupleTypeInfo<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>> tType = new TupleTypeInfo<Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>>(fTypes);
  return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple8<T0, T1, T2, T3, T4, T5, T6, T7>>(fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
}

@Test
public void testMyOptionGenericType() {
  TypeInformation<MyOption<Tuple2<Boolean, String>>> inTypeInfo = new MyOptionTypeInfo<>(
    new TupleTypeInfo<Tuple2<Boolean, String>>(BOOLEAN_TYPE_INFO, STRING_TYPE_INFO));
  MapFunction<MyOption<Tuple2<Boolean, String>>, MyOption<Tuple2<Boolean, Boolean>>> f = new MyOptionMapper<>();
  TypeInformation<?> ti = TypeExtractor.getMapReturnTypes(f, inTypeInfo);
  assertTrue(ti instanceof MyOptionTypeInfo);
  MyOptionTypeInfo oti = (MyOptionTypeInfo) ti;
  assertTrue(oti.getInnerType() instanceof TupleTypeInfo);
  TupleTypeInfo tti = (TupleTypeInfo) oti.getInnerType();
  assertEquals(BOOLEAN_TYPE_INFO, tti.getTypeAt(0));
  assertEquals(BOOLEAN_TYPE_INFO, tti.getTypeAt(1));
}

public static TypeInformation<?>[] extractFieldTypes(int[] fields, TypeInformation<?> inType) {
  TupleTypeInfo<?> inTupleType = (TupleTypeInfo<?>) inType;
  TypeInformation<?>[] fieldTypes = new TypeInformation[fields.length];
  for (int i = 0; i < fields.length; i++) {
    fieldTypes[i] = inTupleType.getTypeAt(fields[i]);
  }
  return fieldTypes;
}

protected ProjectJoin(DataSet<I1> input1, DataSet<I2> input2, Keys<I1> keys1, Keys<I2> keys2, JoinHint hint, int[] fields, boolean[] isFromFirst, TupleTypeInfo<OUT> returnType) {
  super(input1, input2, keys1, keys2,
      new ProjectFlatJoinFunction<I1, I2, OUT>(fields, isFromFirst, returnType.createSerializer(input1.getExecutionEnvironment().getConfig()).createInstance()),
      returnType, hint, Utils.getCallLocationName(4)); // We need to use the 4th element in the stack because the call comes through .types().
  joinProj = null;
}

  @Override
  public TypeInformation<Tuple2<K, V>> getProducedType() {
    return new TupleTypeInfo<>(TypeExtractor.createTypeInfo(keyClass), TypeExtractor.createTypeInfo(valueClass));
  }
}

/**
 * Projects a {@link Tuple} {@link DataStream} to the previously selected fields.
 *
 * @return The projected DataStream.
 * @see Tuple
 * @see DataStream
 */
public <T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22> SingleOutputStreamOperator<Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> projectTuple23() {
  TypeInformation<?>[] fTypes = extractFieldTypes(fieldIndexes, dataStream.getType());
  TupleTypeInfo<Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>> tType = new TupleTypeInfo<Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>>(fTypes);
  return dataStream.transform("Projection", tType, new StreamProject<IN, Tuple23<T0, T1, T2, T3, T4, T5, T6, T7, T8, T9, T10, T11, T12, T13, T14, T15, T16, T17, T18, T19, T20, T21, T22>>(fieldIndexes, tType.createSerializer(dataStream.getExecutionConfig())));
}

@Test
public void testMyTuple() {
  TypeInformation<Tuple1<MyTuple<Double, String>>> inTypeInfo = new TupleTypeInfo<>(
    new MyTupleTypeInfo(DOUBLE_TYPE_INFO, STRING_TYPE_INFO));
  MapFunction<Tuple1<MyTuple<Double, String>>, Tuple1<MyTuple<Boolean, Double>>> f = new MyTupleMapperL2<>();
  TypeInformation<?> ti = TypeExtractor.getMapReturnTypes(f, inTypeInfo);
  assertTrue(ti instanceof TupleTypeInfo);
  TupleTypeInfo<?> tti = (TupleTypeInfo<?>) ti;
  assertTrue(tti.getTypeAt(0) instanceof MyTupleTypeInfo);
  MyTupleTypeInfo mtti = (MyTupleTypeInfo) tti.getTypeAt(0);
  assertEquals(BOOLEAN_TYPE_INFO, mtti.getField0());
  assertEquals(DOUBLE_TYPE_INFO, mtti.getField1());
}

@SuppressWarnings({ "unchecked", "rawtypes" })
@Test
public void testInputInference2() {
  EdgeMapper2<Boolean> em = new EdgeMapper2<Boolean>();
  TypeInformation<?> ti = TypeExtractor.getMapReturnTypes((MapFunction) em, Types.BOOLEAN);
  Assert.assertTrue(ti.isTupleType());
  Assert.assertEquals(3, ti.getArity());
  TupleTypeInfo<?> tti = (TupleTypeInfo<?>) ti;
  Assert.assertEquals(BasicTypeInfo.LONG_TYPE_INFO, tti.getTypeAt(0));
  Assert.assertEquals(BasicTypeInfo.LONG_TYPE_INFO, tti.getTypeAt(1));
  Assert.assertEquals(BasicTypeInfo.BOOLEAN_TYPE_INFO, tti.getTypeAt(2));
}

protected ProjectJoin(DataSet<I1> input1, DataSet<I2> input2, Keys<I1> keys1, Keys<I2> keys2, JoinHint hint, int[] fields, boolean[] isFromFirst, TupleTypeInfo<OUT> returnType, JoinProjection<I1, I2> joinProj) {
  super(input1, input2, keys1, keys2,
      new ProjectFlatJoinFunction<I1, I2, OUT>(fields, isFromFirst, returnType.createSerializer(input1.getExecutionEnvironment().getConfig()).createInstance()),
      returnType, hint, Utils.getCallLocationName(4));
  this.joinProj = joinProj;
}

Javadoc

A TypeInformation for the tuple types of the Java API.

Most used methods

Popular in Java

Updating database using SQL prepared statement
getContentResolver (Context)
runOnUiThread (Activity)
getApplicationContext (Context)
HttpServer (com.sun.net.httpserver)
This class implements a simple HTTP server. A HttpServer is bound to an IP address and port number a
Color (java.awt)
The Color class is used to encapsulate colors in the default sRGB color space or colors in arbitrary
Proxy (java.net)
This class represents proxy server settings. A created instance of Proxy stores a type and an addres
ArrayList (java.util)
ArrayList is an implementation of List, backed by an array. All optional operations including adding
TimerTask (java.util)
The TimerTask class represents a task to run at a specified time. The task may be run once or repeat
Callable (java.util.concurrent)
A task that returns a result and may throw an exception. Implementors define a single method with no

Best Java code snippets using org.apache.flink.api.java.typeutils.TupleTypeInfo (Showing top 20 results out of 369)