You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@flink.apache.org by fh...@apache.org on 2015/01/28 02:24:04 UTC

[04/13] flink git commit: [FLINK-1328] [api-breaking][java-api][scala-api][optimizer] Reworked semantic annotations for functions. - Renamed constantField annotations to forwardedFields annotation - Forwarded fields can be defined for (nested) tuples, Po

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesProjectionTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesProjectionTest.java b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesProjectionTest.java
index e5d7155..341d87e 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesProjectionTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesProjectionTest.java
@@ -29,6 +29,8 @@ import org.apache.flink.api.common.operators.base.CrossOperatorBase;
 import org.apache.flink.api.common.operators.base.JoinOperatorBase;
 import org.apache.flink.api.common.typeinfo.BasicTypeInfo;
 import org.apache.flink.api.java.operators.translation.PlanProjectOperator;
+import org.apache.flink.api.java.tuple.Tuple2;
+import org.apache.flink.api.java.tuple.Tuple3;
 import org.apache.flink.api.java.tuple.Tuple4;
 import org.apache.flink.api.java.tuple.Tuple5;
 import org.apache.flink.api.java.typeutils.TupleTypeInfo;
@@ -37,16 +39,15 @@ import org.junit.Test;
 import java.util.ArrayList;
 import java.util.List;
 
+import static org.junit.Assert.assertEquals;
 import static org.junit.Assert.assertTrue;
-import static org.junit.Assert.fail;
+import static org.junit.Assert.assertNotNull;
 
-/**
- * Created by sebastian on 6/19/14.
- */
 public class SemanticPropertiesProjectionTest {
 
 	final List<Tuple5<Integer, Long, String, Long, Integer>> emptyTupleData = new ArrayList<Tuple5<Integer, Long, String, Long, Integer>>();
 
+
 	final TupleTypeInfo<Tuple5<Integer, Long, String, Long, Integer>> tupleTypeInfo = new
 			TupleTypeInfo<Tuple5<Integer, Long, String, Long, Integer>>(
 			BasicTypeInfo.INT_TYPE_INFO,
@@ -56,184 +57,228 @@ public class SemanticPropertiesProjectionTest {
 			BasicTypeInfo.INT_TYPE_INFO
 	);
 
+	final List<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>> emptyNestedTupleData =
+			new ArrayList<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>>();
+
+	final TupleTypeInfo<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>> nestedTupleTypeInfo = new
+			TupleTypeInfo<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>>(
+			BasicTypeInfo.INT_TYPE_INFO,
+			new TupleTypeInfo<Tuple3<String,  Integer, Long>>(BasicTypeInfo.STRING_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.LONG_TYPE_INFO),
+			new TupleTypeInfo<Tuple2<Long, Long>>(BasicTypeInfo.LONG_TYPE_INFO, BasicTypeInfo.LONG_TYPE_INFO),
+			BasicTypeInfo.STRING_TYPE_INFO
+			);
 
 	@Test
-	public void ProjectOperatorTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-
-			tupleDs.project(1, 3, 2).print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			PlanProjectOperator<?, ?> projectOperator = ((PlanProjectOperator<?, ?>) sink.getInput());
-
-			SingleInputSemanticProperties props = projectOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField(1).size() == 1);
-			assertTrue(props.getForwardedField(3).size() == 1);
-			assertTrue(props.getForwardedField(2).size() == 1);
-			assertTrue(props.getForwardedField(1).contains(0));
-			assertTrue(props.getForwardedField(3).contains(1));
-			assertTrue(props.getForwardedField(2).contains(2));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testProjectionSemProps1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
+
+		tupleDs.project(1, 3, 2).project(0, 3).print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		PlanProjectOperator<?, ?> projectOperator = ((PlanProjectOperator<?, ?>) sink.getInput());
+
+		SingleInputSemanticProperties props = projectOperator.getSemanticProperties();
+
+		assertEquals(1, props.getForwardingTargetFields(0, 0).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(2, props.getForwardingTargetFields(0, 3).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 1).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 3).contains(1));
+		assertTrue(props.getForwardingTargetFields(0, 2).contains(2));
+		assertTrue(props.getForwardingTargetFields(0, 0).contains(3));
+		assertTrue(props.getForwardingTargetFields(0, 3).contains(4));
 	}
-	
+
 	@Test
-	public void ProjectOperatorWithoutTypesClassTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-			
-			tupleDs.project(1, 3).project(2).project(0).print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			PlanProjectOperator<?, ?> projectOperator = ((PlanProjectOperator<?, ?>) sink.getInput());
-
-			SingleInputSemanticProperties props = projectOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField(1).size() == 1);
-			assertTrue(props.getForwardedField(3).size() == 1);
-			assertTrue(props.getForwardedField(2).size() == 1);
-			assertTrue(props.getForwardedField(0).size() == 1);
-			assertTrue(props.getForwardedField(1).contains(0));
-			assertTrue(props.getForwardedField(3).contains(1));
-			assertTrue(props.getForwardedField(2).contains(2));
-			assertTrue(props.getForwardedField(0).contains(3));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testProjectionSemProps2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>> tupleDs = env.fromCollection(emptyNestedTupleData, nestedTupleTypeInfo);
+
+		tupleDs.project(2, 3, 1).project(2).print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		PlanProjectOperator<?, ?> projectOperator = ((PlanProjectOperator<?, ?>) sink.getInput());
+
+		SingleInputSemanticProperties props = projectOperator.getSemanticProperties();
+
+		assertNotNull(props.getForwardingTargetFields(0, 0));
+		assertEquals(1, props.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 3).size());
+		assertEquals(2, props.getForwardingTargetFields(0, 4).size());
+		assertEquals(2, props.getForwardingTargetFields(0, 5).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 6).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 0).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 4).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 5).contains(1));
+		assertTrue(props.getForwardingTargetFields(0, 6).contains(2));
+		assertTrue(props.getForwardingTargetFields(0, 1).contains(3));
+		assertTrue(props.getForwardingTargetFields(0, 2).contains(4));
+		assertTrue(props.getForwardingTargetFields(0, 3).contains(5));
+		assertTrue(props.getForwardingTargetFields(0, 4).contains(6));
+		assertTrue(props.getForwardingTargetFields(0, 5).contains(7));
 	}
 
 	@Test
-	public void JoinProjectionTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-
-			tupleDs.join(tupleDs).where(0).equalTo(0).projectFirst(2, 3).projectSecond(1, 4).print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			JoinOperatorBase<?, ?, ?, ?> projectJoinOperator = ((JoinOperatorBase<?, ?, ?, ?>) sink.getInput());
-
-			DualInputSemanticProperties props = projectJoinOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField1(2).size() == 1);
-			assertTrue(props.getForwardedField1(3).size() == 1);
-			assertTrue(props.getForwardedField2(1).size() == 1);
-			assertTrue(props.getForwardedField2(4).size() == 1);
-			assertTrue(props.getForwardedField1(2).contains(0));
-			assertTrue(props.getForwardedField1(3).contains(1));
-			assertTrue(props.getForwardedField2(1).contains(2));
-			assertTrue(props.getForwardedField2(4).contains(3));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testJoinProjectionSemProps1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
+
+		tupleDs.join(tupleDs).where(0).equalTo(0)
+				.projectFirst(2, 3)
+				.projectSecond(1, 4)
+				.print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> projectJoinOperator = ((JoinOperatorBase<?, ?, ?, ?>) sink.getInput());
+
+		DualInputSemanticProperties props = projectJoinOperator.getSemanticProperties();
+
+		assertEquals(1, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 3).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 4).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 2).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 3).contains(1));
+		assertTrue(props.getForwardingTargetFields(1, 1).contains(2));
+		assertTrue(props.getForwardingTargetFields(1, 4).contains(3));
 	}
-	
+
 	@Test
-	public void JoinProjectionWithoutTypesClassTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-			
-			tupleDs.join(tupleDs).where(0).equalTo(0).projectFirst(2).projectFirst(3).projectSecond(1, 4).print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			JoinOperatorBase<?, ?, ?, ?> projectJoinOperator = ((JoinOperatorBase<?, ?, ?, ?>) sink.getInput());
-
-			DualInputSemanticProperties props = projectJoinOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField1(2).size() == 1);
-			assertTrue(props.getForwardedField1(3).size() == 1);
-			assertTrue(props.getForwardedField2(1).size() == 1);
-			assertTrue(props.getForwardedField2(4).size() == 1);
-			assertTrue(props.getForwardedField1(2).contains(0));
-			assertTrue(props.getForwardedField1(3).contains(1));
-			assertTrue(props.getForwardedField2(1).contains(2));
-			assertTrue(props.getForwardedField2(4).contains(3));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testJoinProjectionSemProps2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>> tupleDs = env.fromCollection(emptyNestedTupleData, nestedTupleTypeInfo);
+
+		tupleDs.join(tupleDs).where(0).equalTo(0)
+				.projectFirst(2,0)
+				.projectSecond(1,3)
+				.print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> projectJoinOperator = ((JoinOperatorBase<?, ?, ?, ?>) sink.getInput());
+
+		DualInputSemanticProperties props = projectJoinOperator.getSemanticProperties();
+
+		assertEquals(1, props.getForwardingTargetFields(0, 0).size());
+		assertNotNull(props.getForwardingTargetFields(0, 1));
+		assertNotNull(props.getForwardingTargetFields(0, 2));
+		assertNotNull(props.getForwardingTargetFields(0, 3));
+		assertEquals(1, props.getForwardingTargetFields(0, 4).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 5).size());
+		assertNotNull(props.getForwardingTargetFields(0, 6));
+		assertEquals(0, props.getForwardingTargetFields(0, 1).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 3).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 6).size());
+
+		assertNotNull(props.getForwardingTargetFields(1, 0));
+		assertEquals(1, props.getForwardingTargetFields(1, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 2).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 3).size());
+		assertNotNull(props.getForwardingTargetFields(1, 4));
+		assertNotNull(props.getForwardingTargetFields(1, 5));
+		assertEquals(1, props.getForwardingTargetFields(1, 6).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 0).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 4).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 5).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 4).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 5).contains(1));
+		assertTrue(props.getForwardingTargetFields(0, 0).contains(2));
+		assertTrue(props.getForwardingTargetFields(1, 1).contains(3));
+		assertTrue(props.getForwardingTargetFields(1, 2).contains(4));
+		assertTrue(props.getForwardingTargetFields(1, 3).contains(5));
+		assertTrue(props.getForwardingTargetFields(1, 6).contains(6));
 	}
 
 	@Test
-	public void CrossProjectionTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-
-			DataSet<Tuple4<String, Long, Long, Integer>> result = tupleDs.cross(tupleDs).projectFirst(2, 3).projectSecond(1, 4);
-			result.print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			CrossOperatorBase<?, ?, ?, ?> projectCrossOperator = ((CrossOperatorBase<?, ?, ?, ?>) sink.getInput());
-
-			DualInputSemanticProperties props = projectCrossOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField1(2).size() == 1);
-			assertTrue(props.getForwardedField1(3).size() == 1);
-			assertTrue(props.getForwardedField2(1).size() == 1);
-			assertTrue(props.getForwardedField2(4).size() == 1);
-			assertTrue(props.getForwardedField1(2).contains(0));
-			assertTrue(props.getForwardedField1(3).contains(1));
-			assertTrue(props.getForwardedField2(1).contains(2));
-			assertTrue(props.getForwardedField2(4).contains(3));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testCrossProjectionSemProps1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
+
+		tupleDs.cross(tupleDs)
+				.projectFirst(2, 3)
+				.projectSecond(1, 4)
+				.print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		CrossOperatorBase<?, ?, ?, ?> projectCrossOperator = ((CrossOperatorBase<?, ?, ?, ?>) sink.getInput());
+
+		DualInputSemanticProperties props = projectCrossOperator.getSemanticProperties();
+
+		assertEquals(1, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 3).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 4).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 2).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 3).contains(1));
+		assertTrue(props.getForwardingTargetFields(1, 1).contains(2));
+		assertTrue(props.getForwardingTargetFields(1, 4).contains(3));
 	}
-	
+
 	@Test
-	public void CrossProjectionWithoutTypesClassTest() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			DataSet<Tuple5<Integer, Long, String, Long, Integer>> tupleDs = env.fromCollection(emptyTupleData, tupleTypeInfo);
-
-			DataSet<Tuple4<String, Long, Long, Integer>> result = tupleDs.cross(tupleDs).projectFirst(2, 3).projectSecond(1, 4);
-			result.print();
-
-			Plan plan = env.createProgramPlan();
-
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			CrossOperatorBase<?, ?, ?, ?> projectCrossOperator = ((CrossOperatorBase<?, ?, ?, ?>) sink.getInput());
-
-			DualInputSemanticProperties props = projectCrossOperator.getSemanticProperties();
-
-			assertTrue(props.getForwardedField1(2).size() == 1);
-			assertTrue(props.getForwardedField1(3).size() == 1);
-			assertTrue(props.getForwardedField2(1).size() == 1);
-			assertTrue(props.getForwardedField2(4).size() == 1);
-			assertTrue(props.getForwardedField1(2).contains(0));
-			assertTrue(props.getForwardedField1(3).contains(1));
-			assertTrue(props.getForwardedField2(1).contains(2));
-			assertTrue(props.getForwardedField2(4).contains(3));
-		} catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testCrossProjectionSemProps2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+		DataSet<Tuple4<Integer, Tuple3<String, Integer, Long>, Tuple2<Long, Long>, String>> tupleDs = env.fromCollection(emptyNestedTupleData, nestedTupleTypeInfo);
+
+		tupleDs.cross(tupleDs)
+				.projectFirst(2, 0)
+				.projectSecond(1,3)
+				.print();
+
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		CrossOperatorBase<?, ?, ?, ?> projectCrossOperator = ((CrossOperatorBase<?, ?, ?, ?>) sink.getInput());
+
+		DualInputSemanticProperties props = projectCrossOperator.getSemanticProperties();
+
+		assertEquals(1, props.getForwardingTargetFields(0, 0).size());
+		assertNotNull(props.getForwardingTargetFields(0, 1));
+		assertNotNull(props.getForwardingTargetFields(0, 2));
+		assertNotNull(props.getForwardingTargetFields(0, 3));
+		assertEquals(1, props.getForwardingTargetFields(0, 4).size());
+		assertEquals(1, props.getForwardingTargetFields(0, 5).size());
+		assertNotNull(props.getForwardingTargetFields(0, 6));
+		assertEquals(0, props.getForwardingTargetFields(0, 1).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 2).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 3).size());
+		assertEquals(0, props.getForwardingTargetFields(0, 6).size());
+
+		assertNotNull(props.getForwardingTargetFields(1, 0));
+		assertEquals(1, props.getForwardingTargetFields(1, 1).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 2).size());
+		assertEquals(1, props.getForwardingTargetFields(1, 3).size());
+		assertNotNull(props.getForwardingTargetFields(1, 4));
+		assertNotNull(props.getForwardingTargetFields(1, 5));
+		assertEquals(1, props.getForwardingTargetFields(1, 6).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 0).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 4).size());
+		assertEquals(0, props.getForwardingTargetFields(1, 5).size());
+
+		assertTrue(props.getForwardingTargetFields(0, 4).contains(0));
+		assertTrue(props.getForwardingTargetFields(0, 5).contains(1));
+		assertTrue(props.getForwardingTargetFields(0, 0).contains(2));
+		assertTrue(props.getForwardingTargetFields(1, 1).contains(3));
+		assertTrue(props.getForwardingTargetFields(1, 2).contains(4));
+		assertTrue(props.getForwardingTargetFields(1, 3).contains(5));
+		assertTrue(props.getForwardingTargetFields(1, 6).contains(6));
 	}
+
 }

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesTranslationTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesTranslationTest.java b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesTranslationTest.java
index bd8b55e..f0124e3 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesTranslationTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/functions/SemanticPropertiesTranslationTest.java
@@ -22,17 +22,18 @@ package org.apache.flink.api.java.functions;
 import static org.junit.Assert.*;
 
 import org.apache.flink.api.common.Plan;
-import org.apache.flink.api.common.functions.RichJoinFunction;
-import org.apache.flink.api.common.functions.RichMapFunction;
+import org.apache.flink.api.common.functions.JoinFunction;
+import org.apache.flink.api.common.functions.MapFunction;
 import org.apache.flink.api.common.operators.DualInputSemanticProperties;
 import org.apache.flink.api.common.operators.GenericDataSinkBase;
+import org.apache.flink.api.common.operators.SemanticProperties;
 import org.apache.flink.api.common.operators.SingleInputSemanticProperties;
 import org.apache.flink.api.common.operators.base.JoinOperatorBase;
 import org.apache.flink.api.common.operators.base.MapOperatorBase;
 import org.apache.flink.api.common.operators.util.FieldSet;
-import org.apache.flink.api.java.functions.FunctionAnnotation.ConstantFields;
-import org.apache.flink.api.java.functions.FunctionAnnotation.ConstantFieldsFirst;
-import org.apache.flink.api.java.functions.FunctionAnnotation.ConstantFieldsSecond;
+import org.apache.flink.api.java.functions.FunctionAnnotation.ForwardedFields;
+import org.apache.flink.api.java.functions.FunctionAnnotation.ForwardedFieldsFirst;
+import org.apache.flink.api.java.functions.FunctionAnnotation.ForwardedFieldsSecond;
 import org.apache.flink.api.java.tuple.Tuple2;
 import org.apache.flink.api.java.tuple.Tuple3;
 import org.junit.Test;
@@ -43,247 +44,496 @@ import org.apache.flink.api.java.ExecutionEnvironment;
 /**
  * This is a minimal test to verify that semantic annotations are evaluated against
  * the type information properly translated correctly to the common data flow API.
- * 
- * This covers only the constant fields annotations currently !!!
+ *
  */
 @SuppressWarnings("serial")
 public class SemanticPropertiesTranslationTest {
 	
-	/**
-	 * A mapper that preserves all fields over a tuple data set.
-	 */
 	@Test
-	public void translateUnaryFunctionAnnotationTuplesWildCard() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			
-			@SuppressWarnings("unchecked")
-			DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42));
-			input.map(new WildcardConstantMapper<Tuple3<Long,String,Integer>>()).print();
-			
-			Plan plan = env.createProgramPlan();
-			
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
-			
-			SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
-			
-			FieldSet fw1 = semantics.getForwardedField(0);
-			FieldSet fw2 = semantics.getForwardedField(1);
-			FieldSet fw3 = semantics.getForwardedField(2);
-			
-			assertNotNull(fw1);
-			assertNotNull(fw2);
-			assertNotNull(fw3);
-			
-			assertTrue(fw1.contains(0));
-			assertTrue(fw2.contains(1));
-			assertTrue(fw3.contains(2));
-		}
-		catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testUnaryFunctionWildcardForwardedAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42));
+		input.map(new WildcardForwardedMapper<Tuple3<Long,String,Integer>>()).print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 1);
+		FieldSet fw3 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertNotNull(fw3);
+		assertTrue(fw1.contains(0));
+		assertTrue(fw2.contains(1));
+		assertTrue(fw3.contains(2));
 	}
 	
-	/**
-	 * A mapper that preserves fields 0, 1, 2 of a tuple data set.
-	 */
 	@Test
-	public void translateUnaryFunctionAnnotationTuples() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			
-			@SuppressWarnings("unchecked")
-			DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42));
-			input.map(new IndividualConstantMapper<Long, String, Integer>()).print();
-			
-			Plan plan = env.createProgramPlan();
-			
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
-			
-			SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
-			
-			FieldSet fw1 = semantics.getForwardedField(0);
-			FieldSet fw2 = semantics.getForwardedField(1);
-			FieldSet fw3 = semantics.getForwardedField(2);
-			
-			assertNotNull(fw1);
-			assertNotNull(fw2);
-			assertNotNull(fw3);
-			
-			assertTrue(fw1.contains(0));
-			assertTrue(fw2.contains(1));
-			assertTrue(fw3.contains(2));
-		}
-		catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+	public void testUnaryFunctionInPlaceForwardedAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, String, Integer>> input = env.fromElements(new Tuple3<Long, String, Integer>(3l, "test", 42));
+		input.map(new IndividualForwardedMapper<Long, String, Integer>()).print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertTrue(fw1.contains(0));
+		assertTrue(fw2.contains(2));
 	}
-	
-//	/**
-//	 * A mapper that preserves all fields over a data set of an atomic type.
-//	 */
-//	@Test
-//	public void translateUnaryFunctionAnnotationAtomicWildCard() {
-//		try {
-//			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-//			DataSet<Long> input = env.generateSequence(0, 1000);
-//			input.map(new WildcardConstantMapper<Long>()).print();
-//			
-//			Plan plan = env.createProgramPlan();
-//			
-//			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-//			MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
-//			
-//			SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
-//			
-//			FieldSet fw1 = semantics.getForwardedField(0);
-//			assertNotNull(fw1);
-//			assertTrue(fw1.contains(0));
-//		}
-//		catch (Exception e) {
-//			System.err.println(e.getMessage());
-//			e.printStackTrace();
-//			fail("Exception in test: " + e.getMessage());
-//		}
-//	}
-	
-//	/**
-//	 * A mapper that preserves field zero of a data set of an atomic type.
-//	 */
-//	@Test
-//	public void translateUnaryFunctionAnnotationAtomicZero() {
-//		try {
-//			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-//			DataSet<Long> input = env.generateSequence(0, 1000);
-//			input.map(new ZeroConstantMapper<Long>()).print();
-//			
-//			Plan plan = env.createProgramPlan();
-//			
-//			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-//			MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
-//			
-//			SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
-//			
-//			FieldSet fw1 = semantics.getForwardedField(0);
-//			FieldSet fw2 = semantics.getForwardedField(1);
-//			FieldSet fw3 = semantics.getForwardedField(2);
-//			
-//			assertNotNull(fw1);
-//			assertNotNull(fw2);
-//			assertNotNull(fw3);
-//			
-//			assertTrue(fw1.contains(0));
-//			assertTrue(fw2.contains(1));
-//			assertTrue(fw3.contains(2));
-//		}
-//		catch (Exception e) {
-//			System.err.println(e.getMessage());
-//			e.printStackTrace();
-//			fail("Exception in test: " + e.getMessage());
-//		}
-//	}
-	
-	
-	/**
-	 * A join that preserves tuple fields from both sides.
-	 */
+
 	@Test
-	public void translateBinaryFunctionAnnotationTuples() {
-		try {
-			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-			
-			@SuppressWarnings("unchecked")
-			DataSet<Tuple2<Long, String>> input1 = env.fromElements(new Tuple2<Long, String>(3l, "test"));
-			@SuppressWarnings("unchecked")
-			DataSet<Tuple2<Long, Double>> input2 = env.fromElements(new Tuple2<Long, Double>(3l, 3.1415));
-			
-			input1.join(input2).where(0).equalTo(0).with(new ForwardingTupleJoin<Long, String, Long, Double>())
+	public void testUnaryFunctionMovingForwardedAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new ShufflingMapper<Long>()).print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 1);
+		FieldSet fw3 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertNotNull(fw3);
+		assertTrue(fw1.contains(2));
+		assertTrue(fw2.contains(0));
+		assertTrue(fw3.contains(1));
+	}
+
+	@Test
+	public void testUnaryFunctionForwardedInLine1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new NoAnnotationMapper<Tuple3<Long, Long, Long>>()).withForwardedFields("0->1; 2")
 				.print();
-			
-			Plan plan = env.createProgramPlan();
-			
-			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-			JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
-			
-			DualInputSemanticProperties semantics = join.getSemanticProperties();
-			
-			FieldSet fw11 = semantics.getForwardedField1(0);
-			FieldSet fw12 = semantics.getForwardedField1(1);
-			FieldSet fw21 = semantics.getForwardedField2(0);
-			FieldSet fw22 = semantics.getForwardedField2(1);
-			
-			assertNull(fw11);
-			assertNull(fw21);
-			
-			assertNotNull(fw12);
-			assertNotNull(fw22);
-			
-			assertTrue(fw12.contains(0));
-			assertTrue(fw22.contains(1));
-		}
-		catch (Exception e) {
-			System.err.println(e.getMessage());
-			e.printStackTrace();
-			fail("Exception in test: " + e.getMessage());
-		}
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertTrue(fw1.contains(1));
+		assertTrue(fw2.contains(2));
 	}
-	
-//	/**
-//	 * A join that preserves atomic fields from both sides.
-//	 */
-//	@Test
-//	public void translateBinaryFunctionAnnotationAtomicType() {
-//		try {
-//			ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
-//			
-//			DataSet<Long> input1 = env.generateSequence(0, 1000);
-//			DataSet<Long> input2 = env.generateSequence(0, 1000);
-//			
-//			input1.join(input2)
-//					.where(new KeySelector<Long, Long>() { public Long getKey(Long value) { return value; }})
-//					.equalTo(new KeySelector<Long, Long>() { public Long getKey(Long value) { return value; }})
-//					.with(new ForwardingBasicJoin<Long, Long>())
-//				.print();
-//			
-//			Plan plan = env.createProgramPlan();
-//			
-//			GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
-//			JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
-//			
-//			DualInputSemanticProperties semantics = join.getSemanticProperties();
-//			
-//			FieldSet fw11 = semantics.getForwardedField1(0);
-//			FieldSet fw12 = semantics.getForwardedField1(1);
-//			FieldSet fw21 = semantics.getForwardedField2(0);
-//			FieldSet fw22 = semantics.getForwardedField2(1);
-//			
-//			assertNull(fw11);
-//			assertNull(fw21);
-//			
-//			assertNotNull(fw12);
-//			assertNotNull(fw22);
-//			
-//			assertTrue(fw12.contains(0));
-//			assertTrue(fw22.contains(1));
-//		}
-//		catch (Exception e) {
-//			System.err.println(e.getMessage());
-//			e.printStackTrace();
-//			fail("Exception in test: " + e.getMessage());
-//		}
-//	}
-	
+
+	@Test
+	public void testUnaryFunctionForwardedInLine2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new ReadSetMapper<Tuple3<Long, Long, Long>>()).withForwardedFields("0->1; 2")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertTrue(fw1.contains(1));
+		assertTrue(fw2.contains(2));
+	}
+
+	@Test
+	public void testUnaryFunctionForwardedInLine3() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new ReadSetMapper<Tuple3<Long, Long, Long>>()).withForwardedFields("0->1; 2")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertTrue(fw1.contains(1));
+		assertTrue(fw2.contains(2));
+	}
+
+	@Test
+	public void testUnaryFunctionAllForwardedExceptAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new AllForwardedExceptMapper<Tuple3<Long, Long, Long>>()).print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet fw1 = semantics.getForwardingTargetFields(0, 0);
+		FieldSet fw2 = semantics.getForwardingTargetFields(0, 2);
+		assertNotNull(fw1);
+		assertNotNull(fw2);
+		assertTrue(fw1.contains(0));
+		assertTrue(fw2.contains(2));
+	}
+
+	@Test
+	public void testUnaryFunctionReadFieldsAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new ReadSetMapper<Tuple3<Long, Long, Long>>()).print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		MapOperatorBase<?, ?, ?> mapper = (MapOperatorBase<?, ?, ?>) sink.getInput();
+
+		SingleInputSemanticProperties semantics = mapper.getSemanticProperties();
+
+		FieldSet read = semantics.getReadFields(0);
+		assertNotNull(read);
+		assertEquals(2, read.size());
+		assertTrue(read.contains(0));
+		assertTrue(read.contains(2));
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testUnaryForwardedOverwritingInLine1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new WildcardForwardedMapper<Tuple3<Long, Long, Long>>()).withForwardedFields("0->1; 2");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testUnaryForwardedOverwritingInLine2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input.map(new AllForwardedExceptMapper<Tuple3<Long, Long, Long>>()).withForwardedFields("0->1; 2");
+	}
+
+	@Test
+	public void testBinaryForwardedAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, String>> input1 = env.fromElements(new Tuple2<Long, String>(3l, "test"));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Double>> input2 = env.fromElements(new Tuple2<Long, Double>(3l, 3.1415));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedBothAnnotationJoin<Long, String, Long, Double>())
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(0, 0));
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 1).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 1).contains(0));
+		assertTrue(semantics.getForwardingTargetFields(1, 1).contains(1));
+		assertEquals(0, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+	}
+
+	@Test
+	public void testBinaryForwardedInLine1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new NoAnnotationJoin<Long>())
+				.withForwardedFieldsFirst("0->1; 1->2").withForwardedFieldsSecond("1->0")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(1, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 1).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 0).contains(1));
+		assertTrue(semantics.getForwardingTargetFields(0, 1).contains(2));
+		assertTrue(semantics.getForwardingTargetFields(1, 1).contains(0));
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+	}
+
+	@Test
+	public void testBinaryForwardedInLine2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ReadSetJoin<Long>())
+				.withForwardedFieldsFirst("0->1; 1->2").withForwardedFieldsSecond("1->0")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(1, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 1).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 0).contains(1));
+		assertTrue(semantics.getForwardingTargetFields(0, 1).contains(2));
+		assertTrue(semantics.getForwardingTargetFields(1, 1).contains(0));
+		assertNotNull(semantics.getReadFields(0));
+		assertNotNull(semantics.getReadFields(1));
+		assertEquals(1, semantics.getReadFields(0).size());
+		assertEquals(1, semantics.getReadFields(1).size());
+		assertTrue(semantics.getReadFields(0).contains(1));
+		assertTrue(semantics.getReadFields(1).contains(0));
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+	}
+
+	@Test
+	public void testBinaryForwardedAnnotationInLineMixed1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedFirstAnnotationJoin<Long>())
+				.withForwardedFieldsSecond("1")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(0, 1));
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertNotNull(semantics.getForwardingTargetFields(0, 0));
+		assertNotNull(semantics.getForwardingTargetFields(1, 1));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 1).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 0).contains(2));
+		assertTrue(semantics.getForwardingTargetFields(1, 1).contains(1));
+		assertEquals(0, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+
+	}
+
+	@Test
+	public void testBinaryForwardedAnnotationInLineMixed2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedSecondAnnotationJoin<Long>())
+				.withForwardedFieldsFirst("0->1")
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(0, 1));
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertNotNull(semantics.getForwardingTargetFields(0, 0));
+		assertNotNull(semantics.getForwardingTargetFields(1, 1));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 1).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 0).contains(1));
+		assertTrue(semantics.getForwardingTargetFields(1, 1).contains(2));
+		assertEquals(0, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+	}
+
+	@Test
+	public void testBinaryAllForwardedExceptAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input1 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 4l, 5l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input2 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input1.join(input2).where(0).equalTo(0).with(new AllForwardedExceptJoin<Long>())
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getForwardingTargetFields(0, 0));
+		assertNotNull(semantics.getForwardingTargetFields(0, 2));
+		assertNotNull(semantics.getForwardingTargetFields(1, 0));
+		assertNotNull(semantics.getForwardingTargetFields(1, 1));
+		assertEquals(1, semantics.getForwardingTargetFields(0, 1).size());
+		assertEquals(1, semantics.getForwardingTargetFields(1, 2).size());
+		assertTrue(semantics.getForwardingTargetFields(0, 1).contains(1));
+		assertTrue(semantics.getForwardingTargetFields(1, 2).contains(2));
+		assertEquals(0, semantics.getForwardingTargetFields(0, 0).size());
+		assertEquals(0, semantics.getForwardingTargetFields(0, 2).size());
+		assertEquals(0, semantics.getForwardingTargetFields(1, 0).size());
+		assertEquals(0, semantics.getForwardingTargetFields(1, 1).size());
+	}
+
+	@Test
+	public void testBinaryReadFieldsAnnotation() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ReadSetJoin<Long>())
+				.print();
+		Plan plan = env.createProgramPlan();
+
+		GenericDataSinkBase<?> sink = plan.getDataSinks().iterator().next();
+		JoinOperatorBase<?, ?, ?, ?> join = (JoinOperatorBase<?, ?, ?, ?>) sink.getInput();
+
+		DualInputSemanticProperties semantics = join.getSemanticProperties();
+		assertNotNull(semantics.getReadFields(0));
+		assertNotNull(semantics.getReadFields(1));
+		assertEquals(1, semantics.getReadFields(0).size());
+		assertEquals(1, semantics.getReadFields(1).size());
+		assertTrue(semantics.getReadFields(0).contains(1));
+		assertTrue(semantics.getReadFields(1).contains(0));
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine1() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedFirstAnnotationJoin<Long>())
+				.withForwardedFieldsFirst("0->1");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine2() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedSecondAnnotationJoin<Long>())
+				.withForwardedFieldsSecond("0->1");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine3() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedBothAnnotationJoin<Long, Long, Long, Long>())
+				.withForwardedFieldsFirst("0->1;");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine4() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input1 = env.fromElements(new Tuple2<Long, Long>(3l, 4l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple2<Long, Long>> input2 = env.fromElements(new Tuple2<Long, Long>(3l, 2l));
+		input1.join(input2).where(0).equalTo(0).with(new ForwardedBothAnnotationJoin<Long, Long, Long, Long>())
+				.withForwardedFieldsSecond("0->1;");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine5() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input1 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 4l, 5l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input2 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input1.join(input2).where(0).equalTo(0).with(new AllForwardedExceptJoin<Long>())
+				.withForwardedFieldsFirst("0->1;");
+	}
+
+	@Test(expected = SemanticProperties.InvalidSemanticAnnotationException.class)
+	public void testBinaryForwardedOverwritingInLine6() {
+		ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();
+
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input1 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 4l, 5l));
+		@SuppressWarnings("unchecked")
+		DataSet<Tuple3<Long, Long, Long>> input2 = env.fromElements(new Tuple3<Long, Long, Long>(3l, 2l, 1l));
+		input1.join(input2).where(0).equalTo(0).with(new AllForwardedExceptJoin<Long>())
+				.withForwardedFieldsSecond("0->1;");
+	}
+
 	// --------------------------------------------------------------------------------------------
+
+	public static class NoAnnotationMapper<T> implements MapFunction<T, T> {
+
+		@Override
+		public T map(T value)  {
+			return value;
+		}
+	}
 	
-	
-	@ConstantFields("*")
-	public static class WildcardConstantMapper<T> extends RichMapFunction<T, T> {
+	@ForwardedFields("*")
+	public static class WildcardForwardedMapper<T> implements MapFunction<T, T> {
 
 		@Override
 		public T map(T value)  {
@@ -291,41 +541,95 @@ public class SemanticPropertiesTranslationTest {
 		}
 	}
 	
-	@ConstantFields("0->0;1->1;2->2")
-	public static class IndividualConstantMapper<X, Y, Z> extends RichMapFunction<Tuple3<X, Y, Z>, Tuple3<X, Y, Z>> {
+	@ForwardedFields("0;2")
+	public static class IndividualForwardedMapper<X, Y, Z> implements MapFunction<Tuple3<X, Y, Z>, Tuple3<X, Y, Z>> {
 
 		@Override
 		public Tuple3<X, Y, Z> map(Tuple3<X, Y, Z> value) {
 			return value;
 		}
 	}
-	
-	@ConstantFields("0")
-	public static class ZeroConstantMapper<T> extends RichMapFunction<T, T> {
+
+	@ForwardedFields("0->2;1->0;2->1")
+	public static class ShufflingMapper<X> implements MapFunction<Tuple3<X, X, X>, Tuple3<X, X, X>> {
+
+		@Override
+		public Tuple3<X, X, X> map(Tuple3<X, X, X> value) {
+			return value;
+		}
+	}
+
+	@FunctionAnnotation.NonForwardedFields({"1"})
+	public static class AllForwardedExceptMapper<T> implements MapFunction<T, T> {
+
+		@Override
+		public T map(T value)  {
+			return value;
+		}
+	}
+
+	@FunctionAnnotation.ReadFields({"0;2"})
+	public static class ReadSetMapper<T> implements MapFunction<T, T> {
 
 		@Override
 		public T map(T value)  {
 			return value;
 		}
 	}
-	
-	@ConstantFieldsFirst("1 -> 0")
-	@ConstantFieldsSecond("1 -> 1")
-	public static class ForwardingTupleJoin<A, B, C, D> extends RichJoinFunction<Tuple2<A, B>, Tuple2<C, D>, Tuple2<B, D>> {
+
+	public static class NoAnnotationJoin<X> implements JoinFunction<Tuple2<X,X>, Tuple2<X,X>, Tuple3<X,X,X>> {
+
+		@Override
+		public Tuple3<X, X, X> join(Tuple2<X, X> first, Tuple2<X, X> second) throws Exception {
+			return null;
+		}
+	}
+
+	@ForwardedFieldsFirst("0->2")
+	public static class ForwardedFirstAnnotationJoin<X> implements JoinFunction<Tuple2<X,X>, Tuple2<X,X>, Tuple3<X,X,X>> {
+
+		@Override
+		public Tuple3<X, X, X> join(Tuple2<X, X> first, Tuple2<X, X> second) throws Exception {
+			return null;
+		}
+	}
+
+	@ForwardedFieldsSecond("1->2")
+	public static class ForwardedSecondAnnotationJoin<X> implements JoinFunction<Tuple2<X,X>, Tuple2<X,X>, Tuple3<X,X,X>> {
+
+		@Override
+		public Tuple3<X, X, X> join(Tuple2<X, X> first, Tuple2<X, X> second) throws Exception {
+			return null;
+		}
+	}
+
+	@ForwardedFieldsFirst("1 -> 0")
+	@ForwardedFieldsSecond("1 -> 1")
+	public static class ForwardedBothAnnotationJoin<A, B, C, D> implements JoinFunction<Tuple2<A, B>, Tuple2<C, D>, Tuple2<B, D>> {
 
 		@Override
 		public Tuple2<B, D> join(Tuple2<A, B> first, Tuple2<C, D> second) {
 			return new Tuple2<B, D>(first.f1, second.f1);
 		}
 	}
-	
-	@ConstantFieldsFirst("0 -> 0")
-	@ConstantFieldsSecond("0 -> 1")
-	public static class ForwardingBasicJoin<A, B> extends RichJoinFunction<A, B, Tuple2<A, B>> {
+
+	@FunctionAnnotation.NonForwardedFieldsFirst("0;2")
+	@FunctionAnnotation.NonForwardedFieldsSecond("0;1")
+	public static class AllForwardedExceptJoin<X> implements JoinFunction<Tuple3<X,X,X>, Tuple3<X,X,X>, Tuple3<X,X,X>> {
+
+		@Override
+		public Tuple3<X, X, X> join(Tuple3<X, X, X> first, Tuple3<X, X, X> second) throws Exception {
+			return null;
+		}
+	}
+
+	@FunctionAnnotation.ReadFieldsFirst("1")
+	@FunctionAnnotation.ReadFieldsSecond("0")
+	public static class ReadSetJoin<X> implements JoinFunction<Tuple2<X,X>, Tuple2<X,X>, Tuple3<X,X,X>> {
 
 		@Override
-		public Tuple2<A, B> join(A first, B second) {
-			return new Tuple2<A, B>(first, second);
+		public Tuple3<X, X, X> join(Tuple2<X, X> first, Tuple2<X, X> second) throws Exception {
+			return null;
 		}
 	}
 }

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/operators/KeysTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/operators/KeysTest.java b/flink-java/src/test/java/org/apache/flink/api/java/operators/KeysTest.java
index c8e5ba3..67d0240 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/operators/KeysTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/operators/KeysTest.java
@@ -106,16 +106,14 @@ public class KeysTest {
 				new String[] {"f11"},
 				new String[] {"f-35"},
 				new String[] {"f0.f33"},
-				new String[] {"f1.f33"},
-				new String[] {"f1"} // select full tuple without saying "f1.*"
+				new String[] {"f1.f33"}
 		};
 		for(int i = 0; i < tests.length; i++) {
 			Throwable e = null;
 			try {
 				new ExpressionKeys<Tuple3<String, Tuple3<String, String, String>, String>>(tests[i], typeInfo);
 			} catch(Throwable t) {
-				// System.err.println("Message: "+t.getMessage()); t.printStackTrace();
-				e = t;	
+				e = t;
 			}
 			Assert.assertNotNull(e);
 		}
@@ -127,16 +125,14 @@ public class KeysTest {
 		
 		String[][] tests = new String[][] {
 				new String[] {"nonexistent"},
-				new String[] {"date.abc"}, // nesting into unnested
-				new String[] {"word"} // select full tuple without saying "f1.*"
+				new String[] {"date.abc"} // nesting into unnested
 		};
 		for(int i = 0; i < tests.length; i++) {
 			Throwable e = null;
 			try {
 				new ExpressionKeys<ComplexNestedClass>(tests[i], ti);
 			} catch(Throwable t) {
-				// System.err.println("Message: "+t.getMessage()); t.printStackTrace();
-				e = t;	
+				e = t;
 			}
 			Assert.assertNotNull(e);
 		}
@@ -214,6 +210,9 @@ public class KeysTest {
 		
 		complexFpk = new ExpressionKeys<Tuple3<String, Tuple3<Tuple3<String, String, String>, String, String>, String>>(new String[] {"f1.f0.*"}, complexTypeInfo);
 		Assert.assertArrayEquals(new int[] {1,2,3}, complexFpk.computeLogicalKeyPositions());
+
+		complexFpk = new ExpressionKeys<Tuple3<String, Tuple3<Tuple3<String, String, String>, String, String>, String>>(new String[] {"f1.f0"}, complexTypeInfo);
+		Assert.assertArrayEquals(new int[] {1,2,3}, complexFpk.computeLogicalKeyPositions());
 		
 		complexFpk = new ExpressionKeys<Tuple3<String, Tuple3<Tuple3<String, String, String>, String, String>, String>>(new String[] {"f2"}, complexTypeInfo);
 		Assert.assertArrayEquals(new int[] {6}, complexFpk.computeLogicalKeyPositions());
@@ -246,6 +245,12 @@ public class KeysTest {
 		ek = new ExpressionKeys<PojoWithMultiplePojos>(new String[]{"p2.*"}, ti);
 		Assert.assertArrayEquals(new int[] {3,4}, ek.computeLogicalKeyPositions());
 
+		ek = new ExpressionKeys<PojoWithMultiplePojos>(new String[]{"p1"}, ti);
+		Assert.assertArrayEquals(new int[] {1,2}, ek.computeLogicalKeyPositions());
+
+		ek = new ExpressionKeys<PojoWithMultiplePojos>(new String[]{"p2"}, ti);
+		Assert.assertArrayEquals(new int[] {3,4}, ek.computeLogicalKeyPositions());
+
 		ek = new ExpressionKeys<PojoWithMultiplePojos>(new String[]{"i0"}, ti);
 		Assert.assertArrayEquals(new int[] {0}, ek.computeLogicalKeyPositions());
 	}

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/record/CoGroupWrappingFunctionTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/record/CoGroupWrappingFunctionTest.java b/flink-java/src/test/java/org/apache/flink/api/java/record/CoGroupWrappingFunctionTest.java
index 9834a25..3f7e7c5 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/record/CoGroupWrappingFunctionTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/record/CoGroupWrappingFunctionTest.java
@@ -149,23 +149,8 @@ public class CoGroupWrappingFunctionTest {
 				CoGroupOperator coGroupOp = CoGroupOperator.builder(new TestCoGroupFunction(), LongValue.class, 1, 2).build();
 				
 				DualInputSemanticProperties props = coGroupOp.getSemanticProperties();
-				FieldSet fw2 = props.getForwardedField1(2);
-				FieldSet fw4 = props.getForwardedField2(4);
-				
-				assertNotNull(fw2);
-				assertNotNull(fw4);
-				assertEquals(1, fw2.size());
-				assertEquals(1, fw4.size());
-				assertTrue(fw2.contains(2));
-				assertTrue(fw4.contains(4));
-			}
-			{
-				CoGroupOperator coGroupOp = CoGroupOperator.builder(TestCoGroupFunction.class, LongValue.class, 1, 2).build();
-				
-				DualInputSemanticProperties props = coGroupOp.getSemanticProperties();
-				FieldSet fw2 = props.getForwardedField1(2);
-				FieldSet fw4 = props.getForwardedField2(4);
-				
+				FieldSet fw2 = props.getForwardingTargetFields(0, 2);
+				FieldSet fw4 = props.getForwardingTargetFields(1, 4);
 				assertNotNull(fw2);
 				assertNotNull(fw4);
 				assertEquals(1, fw2.size());

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/record/ReduceWrappingFunctionTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/record/ReduceWrappingFunctionTest.java b/flink-java/src/test/java/org/apache/flink/api/java/record/ReduceWrappingFunctionTest.java
index 9e262fc..f413b81 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/record/ReduceWrappingFunctionTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/record/ReduceWrappingFunctionTest.java
@@ -159,23 +159,8 @@ public class ReduceWrappingFunctionTest {
 				ReduceOperator reduceOp = ReduceOperator.builder(new TestReduceFunction()).build();
 				
 				SingleInputSemanticProperties props = reduceOp.getSemanticProperties();
-				FieldSet fw2 = props.getForwardedField(2);
-				FieldSet fw4 = props.getForwardedField(4);
-				
-				assertNotNull(fw2);
-				assertNotNull(fw4);
-				assertEquals(1, fw2.size());
-				assertEquals(1, fw4.size());
-				assertTrue(fw2.contains(2));
-				assertTrue(fw4.contains(4));
-			}
-			{
-				ReduceOperator reduceOp = ReduceOperator.builder(TestReduceFunction.class).build();
-				
-				SingleInputSemanticProperties props = reduceOp.getSemanticProperties();
-				FieldSet fw2 = props.getForwardedField(2);
-				FieldSet fw4 = props.getForwardedField(4);
-				
+				FieldSet fw2 = props.getForwardingTargetFields(0, 2);
+				FieldSet fw4 = props.getForwardingTargetFields(0, 4);
 				assertNotNull(fw2);
 				assertNotNull(fw4);
 				assertEquals(1, fw2.size());

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/PojoTypeExtractionTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/PojoTypeExtractionTest.java b/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/PojoTypeExtractionTest.java
index 27db31d..1f3f71c 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/PojoTypeExtractionTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/PojoTypeExtractionTest.java
@@ -82,7 +82,7 @@ public class PojoTypeExtractionTest {
 		public static int ignoreStaticField;
 		public transient int ignoreTransientField;
 		public Date date; // generic type
-		public Integer someNumber; // BasicType
+		public Integer someNumberWithÜnicödeNäme; // BasicType
 		public float someFloat; // BasicType
 		public Tuple3<Long, Long, String> word; //Tuple Type with three basic types
 		public Object nothing; // generic type
@@ -226,7 +226,7 @@ public class PojoTypeExtractionTest {
 				"complex.collection",
 				"complex.nothing",
 				"complex.someFloat",
-				"complex.someNumber",
+				"complex.someNumberWithÜnicödeNäme",
 				"complex.word.f0",
 				"complex.word.f1",
 				"complex.word.f2"};
@@ -242,13 +242,13 @@ public class PojoTypeExtractionTest {
 				8};
 		Assert.assertEquals(fields.length, positions.length);
 		for(int i = 0; i < fields.length; i++) {
-			pojoType.getKey(fields[i], 0, ffd);
+			pojoType.getFlatFields(fields[i], 0, ffd);
 			Assert.assertEquals("Too many keys returned", 1, ffd.size());
 			Assert.assertEquals("position of field "+fields[i]+" wrong", positions[i], ffd.get(0).getPosition());
 			ffd.clear();
 		}
 
-		pojoType.getKey("complex.word.*", 0, ffd);
+		pojoType.getFlatFields("complex.word.*", 0, ffd);
 		Assert.assertEquals(3, ffd.size());
 		// check if it returns 5,6,7
 		for(FlatFieldDescriptor ffdE : ffd) {
@@ -268,11 +268,11 @@ public class PojoTypeExtractionTest {
 		ffd.clear();
 
 		// scala style full tuple selection for pojos
-		pojoType.getKey("complex.word._", 0, ffd);
+		pojoType.getFlatFields("complex.word._", 0, ffd);
 		Assert.assertEquals(3, ffd.size());
 		ffd.clear();
 
-		pojoType.getKey("complex.*", 0, ffd);
+		pojoType.getFlatFields("complex.*", 0, ffd);
 		Assert.assertEquals(9, ffd.size());
 		// check if it returns 0-7
 		for(FlatFieldDescriptor ffdE : ffd) {
@@ -313,7 +313,7 @@ public class PojoTypeExtractionTest {
 		}
 		ffd.clear();
 
-		pojoType.getKey("*", 0, ffd);
+		pojoType.getFlatFields("*", 0, ffd);
 		Assert.assertEquals(10, ffd.size());
 		// check if it returns 0-8
 		for(FlatFieldDescriptor ffdE : ffd) {
@@ -344,7 +344,7 @@ public class PojoTypeExtractionTest {
 				dateSeen = true;
 				Assert.assertEquals(BasicTypeInfo.DATE_TYPE_INFO, field.type);
 				Assert.assertEquals(Date.class, field.type.getTypeClass());
-			} else if(name.equals("someNumber")) {
+			} else if(name.equals("someNumberWithÜnicödeNäme")) {
 				if(intSeen) {
 					Assert.fail("already seen");
 				}
@@ -450,7 +450,7 @@ public class PojoTypeExtractionTest {
 				strArraySeen = true;
 				Assert.assertEquals(BasicArrayTypeInfo.STRING_ARRAY_TYPE_INFO, field.type);
 				Assert.assertEquals(String[].class, field.type.getTypeClass());
-			} else if(Arrays.asList("date", "someNumber", "someFloat", "word", "nothing", "hadoopCitizen", "collection").contains(name)) {
+			} else if(Arrays.asList("date", "someNumberWithÜnicödeNäme", "someFloat", "word", "nothing", "hadoopCitizen", "collection").contains(name)) {
 				// ignore these, they are inherited from the ComplexNestedClass
 			}
 			else {

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/TypeExtractorTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/TypeExtractorTest.java b/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/TypeExtractorTest.java
index 8a2d675..bc36241 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/TypeExtractorTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/type/extractor/TypeExtractorTest.java
@@ -148,7 +148,7 @@ public class TypeExtractorTest {
 		Assert.assertEquals(9, ti.getArity());
 		Assert.assertTrue(ti instanceof TupleTypeInfo);
 		List<FlatFieldDescriptor> ffd = new ArrayList<FlatFieldDescriptor>();
-		((TupleTypeInfo) ti).getKey("f3", 0, ffd);
+		((TupleTypeInfo) ti).getFlatFields("f3", 0, ffd);
 		Assert.assertTrue(ffd.size() == 1);
 		Assert.assertEquals(3, ffd.get(0).getPosition() );
 
@@ -215,16 +215,16 @@ public class TypeExtractorTest {
 		Assert.assertTrue(ti instanceof TupleTypeInfo);
 		List<FlatFieldDescriptor> ffd = new ArrayList<FlatFieldDescriptor>();
 		
-		((TupleTypeInfo) ti).getKey("f0.f0", 0, ffd);
+		((TupleTypeInfo) ti).getFlatFields("f0.f0", 0, ffd);
 		Assert.assertEquals(0, ffd.get(0).getPosition() );
 		ffd.clear();
 		
-		((TupleTypeInfo) ti).getKey("f0.f0", 0, ffd);
+		((TupleTypeInfo) ti).getFlatFields("f0.f0", 0, ffd);
 		Assert.assertTrue( ffd.get(0).getType() instanceof BasicTypeInfo );
 		Assert.assertTrue( ffd.get(0).getType().getTypeClass().equals(String.class) );
 		ffd.clear();
 		
-		((TupleTypeInfo) ti).getKey("f1.f0", 0, ffd);
+		((TupleTypeInfo) ti).getFlatFields("f1.f0", 0, ffd);
 		Assert.assertEquals(1, ffd.get(0).getPosition() );
 		ffd.clear();
 
@@ -384,19 +384,19 @@ public class TypeExtractorTest {
 		Assert.assertEquals(Tuple2.class, tti.getTypeClass());
 		List<FlatFieldDescriptor> ffd = new ArrayList<FlatFieldDescriptor>();
 		
-		tti.getKey("f0", 0, ffd);
+		tti.getFlatFields("f0", 0, ffd);
 		Assert.assertEquals(1, ffd.size());
 		Assert.assertEquals(0, ffd.get(0).getPosition() ); // Long
 		Assert.assertTrue( ffd.get(0).getType().getTypeClass().equals(Long.class) );
 		ffd.clear();
 		
-		tti.getKey("f1.myField1", 0, ffd);
+		tti.getFlatFields("f1.myField1", 0, ffd);
 		Assert.assertEquals(1, ffd.get(0).getPosition() );
 		Assert.assertTrue( ffd.get(0).getType().getTypeClass().equals(String.class) );
 		ffd.clear();
 		
 		
-		tti.getKey("f1.myField2", 0, ffd);
+		tti.getFlatFields("f1.myField2", 0, ffd);
 		Assert.assertEquals(2, ffd.get(0).getPosition() );
 		Assert.assertTrue( ffd.get(0).getType().getTypeClass().equals(Integer.class) );
 		

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/typeutils/CompositeTypeTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/typeutils/CompositeTypeTest.java b/flink-java/src/test/java/org/apache/flink/api/java/typeutils/CompositeTypeTest.java
new file mode 100644
index 0000000..c71625a
--- /dev/null
+++ b/flink-java/src/test/java/org/apache/flink/api/java/typeutils/CompositeTypeTest.java
@@ -0,0 +1,178 @@
+/*
+ * 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.flink.api.java.typeutils;
+
+import static org.junit.Assert.*;
+
+import org.apache.flink.api.common.typeinfo.BasicTypeInfo;
+import org.apache.flink.api.java.tuple.Tuple2;
+import org.apache.flink.api.java.tuple.Tuple3;
+import org.apache.flink.api.java.tuple.Tuple4;
+import org.junit.Test;
+
+public class CompositeTypeTest {
+
+	private final TupleTypeInfo<?> tupleTypeInfo = new TupleTypeInfo<Tuple4<Integer, Integer, Integer, Integer>>(
+			BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO);
+
+	private final TupleTypeInfo<Tuple3<Integer, String, Long>> inNestedTuple1 = new TupleTypeInfo<Tuple3<Integer, String, Long>>(
+			BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO, BasicTypeInfo.LONG_TYPE_INFO);
+
+	private final TupleTypeInfo<Tuple2<Double, Double>> inNestedTuple2 = new TupleTypeInfo<Tuple2<Double, Double>>(
+			BasicTypeInfo.DOUBLE_TYPE_INFO, BasicTypeInfo.DOUBLE_TYPE_INFO);
+
+	private final TupleTypeInfo<?> nestedTypeInfo = new TupleTypeInfo<Tuple4<Integer, Tuple3<Integer, String, Long>, Integer, Tuple2<Double, Double>>>(
+			BasicTypeInfo.INT_TYPE_INFO,
+			inNestedTuple1,
+			BasicTypeInfo.INT_TYPE_INFO,
+			inNestedTuple2);
+
+	private final TupleTypeInfo<Tuple2<Integer, Tuple2<Integer, Integer>>> inNestedTuple3 = new TupleTypeInfo<Tuple2<Integer, Tuple2<Integer, Integer>>>(
+			BasicTypeInfo.INT_TYPE_INFO,
+			new TupleTypeInfo<Tuple2<Integer, Integer>>(BasicTypeInfo.INT_TYPE_INFO, BasicTypeInfo.INT_TYPE_INFO));
+
+	private final TupleTypeInfo<?> deepNestedTupleTypeInfo = new TupleTypeInfo<Tuple3<Integer, Tuple2<Integer, Tuple2<Integer, Integer>>, Integer>>(
+			BasicTypeInfo.INT_TYPE_INFO,
+			inNestedTuple3,
+			BasicTypeInfo.INT_TYPE_INFO	);
+
+	private final PojoTypeInfo<?> pojoTypeInfo = ((PojoTypeInfo<?>)TypeExtractor.getForClass(MyPojo.class));
+
+	private final TupleTypeInfo<?> pojoInTupleTypeInfo = new TupleTypeInfo<Tuple2<Integer, MyPojo>>(BasicTypeInfo.INT_TYPE_INFO, pojoTypeInfo);
+
+	@Test
+	public void testGetFlatFields() {
+
+		assertEquals(0, tupleTypeInfo.getFlatFields("0").get(0).getPosition());
+		assertEquals(1, tupleTypeInfo.getFlatFields("1").get(0).getPosition());
+		assertEquals(2, tupleTypeInfo.getFlatFields("2").get(0).getPosition());
+		assertEquals(3, tupleTypeInfo.getFlatFields("3").get(0).getPosition());
+		assertEquals(0, tupleTypeInfo.getFlatFields("f0").get(0).getPosition());
+		assertEquals(1, tupleTypeInfo.getFlatFields("f1").get(0).getPosition());
+		assertEquals(2, tupleTypeInfo.getFlatFields("f2").get(0).getPosition());
+		assertEquals(3, tupleTypeInfo.getFlatFields("f3").get(0).getPosition());
+
+		assertEquals(0, nestedTypeInfo.getFlatFields("0").get(0).getPosition());
+		assertEquals(1, nestedTypeInfo.getFlatFields("1.0").get(0).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("1.1").get(0).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("1.2").get(0).getPosition());
+		assertEquals(4, nestedTypeInfo.getFlatFields("2").get(0).getPosition());
+		assertEquals(5, nestedTypeInfo.getFlatFields("3.0").get(0).getPosition());
+		assertEquals(6, nestedTypeInfo.getFlatFields("3.1").get(0).getPosition());
+		assertEquals(4, nestedTypeInfo.getFlatFields("f2").get(0).getPosition());
+		assertEquals(5, nestedTypeInfo.getFlatFields("f3.f0").get(0).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("1").size());
+		assertEquals(1, nestedTypeInfo.getFlatFields("1").get(0).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("1").get(1).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("1").get(2).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("1.*").size());
+		assertEquals(1, nestedTypeInfo.getFlatFields("1.*").get(0).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("1.*").get(1).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("1.*").get(2).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("3").size());
+		assertEquals(5, nestedTypeInfo.getFlatFields("3").get(0).getPosition());
+		assertEquals(6, nestedTypeInfo.getFlatFields("3").get(1).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("f1").size());
+		assertEquals(1, nestedTypeInfo.getFlatFields("f1").get(0).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("f1").get(1).getPosition());
+		assertEquals(3, nestedTypeInfo.getFlatFields("f1").get(2).getPosition());
+		assertEquals(2, nestedTypeInfo.getFlatFields("f3").size());
+		assertEquals(5, nestedTypeInfo.getFlatFields("f3").get(0).getPosition());
+		assertEquals(6, nestedTypeInfo.getFlatFields("f3").get(1).getPosition());
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO,
+				nestedTypeInfo.getFlatFields("0").get(0).getType());
+		assertEquals(BasicTypeInfo.STRING_TYPE_INFO,
+				nestedTypeInfo.getFlatFields("1.1").get(0).getType());
+		assertEquals(BasicTypeInfo.LONG_TYPE_INFO,
+				nestedTypeInfo.getFlatFields("1").get(2).getType());
+		assertEquals(BasicTypeInfo.DOUBLE_TYPE_INFO,
+				nestedTypeInfo.getFlatFields("3").get(1).getType());
+
+		assertEquals(3, deepNestedTupleTypeInfo.getFlatFields("1").size());
+		assertEquals(1, deepNestedTupleTypeInfo.getFlatFields("1").get(0).getPosition());
+		assertEquals(2, deepNestedTupleTypeInfo.getFlatFields("1").get(1).getPosition());
+		assertEquals(3, deepNestedTupleTypeInfo.getFlatFields("1").get(2).getPosition());
+		assertEquals(5, deepNestedTupleTypeInfo.getFlatFields("*").size());
+		assertEquals(0, deepNestedTupleTypeInfo.getFlatFields("*").get(0).getPosition());
+		assertEquals(1, deepNestedTupleTypeInfo.getFlatFields("*").get(1).getPosition());
+		assertEquals(2, deepNestedTupleTypeInfo.getFlatFields("*").get(2).getPosition());
+		assertEquals(3, deepNestedTupleTypeInfo.getFlatFields("*").get(3).getPosition());
+		assertEquals(4, deepNestedTupleTypeInfo.getFlatFields("*").get(4).getPosition());
+
+		assertEquals(0, pojoTypeInfo.getFlatFields("a").get(0).getPosition());
+		assertEquals(1, pojoTypeInfo.getFlatFields("b").get(0).getPosition());
+		assertEquals(2, pojoTypeInfo.getFlatFields("*").size());
+		assertEquals(0, pojoTypeInfo.getFlatFields("*").get(0).getPosition());
+		assertEquals(1, pojoTypeInfo.getFlatFields("*").get(1).getPosition());
+
+		assertEquals(1, pojoInTupleTypeInfo.getFlatFields("f1.a").get(0).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("1.b").get(0).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("1").size());
+		assertEquals(1, pojoInTupleTypeInfo.getFlatFields("1.*").get(0).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("1").get(1).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("f1.*").size());
+		assertEquals(1, pojoInTupleTypeInfo.getFlatFields("f1.*").get(0).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("f1").get(1).getPosition());
+		assertEquals(3, pojoInTupleTypeInfo.getFlatFields("*").size());
+		assertEquals(0, pojoInTupleTypeInfo.getFlatFields("*").get(0).getPosition());
+		assertEquals(1, pojoInTupleTypeInfo.getFlatFields("*").get(1).getPosition());
+		assertEquals(2, pojoInTupleTypeInfo.getFlatFields("*").get(2).getPosition());
+
+	}
+
+	@Test
+	public void testFieldAtStringRef() {
+
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, tupleTypeInfo.getTypeAt("0"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, tupleTypeInfo.getTypeAt("2"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, tupleTypeInfo.getTypeAt("f1"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, tupleTypeInfo.getTypeAt("f3"));
+
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, nestedTypeInfo.getTypeAt("0"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, nestedTypeInfo.getTypeAt("1.0"));
+		assertEquals(BasicTypeInfo.STRING_TYPE_INFO, nestedTypeInfo.getTypeAt("1.1"));
+		assertEquals(BasicTypeInfo.LONG_TYPE_INFO, nestedTypeInfo.getTypeAt("1.2"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, nestedTypeInfo.getTypeAt("2"));
+		assertEquals(BasicTypeInfo.DOUBLE_TYPE_INFO, nestedTypeInfo.getTypeAt("3.0"));
+		assertEquals(BasicTypeInfo.DOUBLE_TYPE_INFO, nestedTypeInfo.getTypeAt("3.1"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, nestedTypeInfo.getTypeAt("f2"));
+		assertEquals(BasicTypeInfo.DOUBLE_TYPE_INFO, nestedTypeInfo.getTypeAt("f3.f0"));
+		assertEquals(inNestedTuple1, nestedTypeInfo.getTypeAt("1"));
+		assertEquals(inNestedTuple2, nestedTypeInfo.getTypeAt("3"));
+		assertEquals(inNestedTuple1, nestedTypeInfo.getTypeAt("f1"));
+		assertEquals(inNestedTuple2, nestedTypeInfo.getTypeAt("f3"));
+
+		assertEquals(inNestedTuple3, deepNestedTupleTypeInfo.getTypeAt("1"));
+
+		assertEquals(BasicTypeInfo.STRING_TYPE_INFO, pojoTypeInfo.getTypeAt("a"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, pojoTypeInfo.getTypeAt("b"));
+
+		assertEquals(BasicTypeInfo.STRING_TYPE_INFO, pojoInTupleTypeInfo.getTypeAt("f1.a"));
+		assertEquals(BasicTypeInfo.INT_TYPE_INFO, pojoInTupleTypeInfo.getTypeAt("1.b"));
+		assertEquals(pojoTypeInfo, pojoInTupleTypeInfo.getTypeAt("1"));
+		assertEquals(pojoTypeInfo, pojoInTupleTypeInfo.getTypeAt("f1"));
+
+	}
+
+	public static class MyPojo {
+		public String a;
+		public int b;
+	}
+
+}

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-java/src/test/java/org/apache/flink/api/java/typeutils/runtime/PojoSerializerTest.java
----------------------------------------------------------------------
diff --git a/flink-java/src/test/java/org/apache/flink/api/java/typeutils/runtime/PojoSerializerTest.java b/flink-java/src/test/java/org/apache/flink/api/java/typeutils/runtime/PojoSerializerTest.java
index 5d0917e..ae47fd3 100644
--- a/flink-java/src/test/java/org/apache/flink/api/java/typeutils/runtime/PojoSerializerTest.java
+++ b/flink-java/src/test/java/org/apache/flink/api/java/typeutils/runtime/PojoSerializerTest.java
@@ -187,7 +187,7 @@ public class PojoSerializerTest extends SerializerTestBase<PojoSerializerTest.Te
 		// test with a simple, string-key first.
 		PojoTypeInfo<TestUserClass> pType = (PojoTypeInfo<TestUserClass>) type;
 		List<FlatFieldDescriptor> result = new ArrayList<FlatFieldDescriptor>();
-		pType.getKey("nestedClass.dumm2", 0, result);
+		pType.getFlatFields("nestedClass.dumm2", 0, result);
 		int[] fields = new int[1]; // see below
 		fields[0] = result.get(0).getPosition();
 		TypeComparator<TestUserClass> pojoComp = pType.createComparator( fields, new boolean[]{true}, 0);

http://git-wip-us.apache.org/repos/asf/flink/blob/de8e066c/flink-scala/src/main/scala/org/apache/flink/api/scala/DataSet.scala
----------------------------------------------------------------------
diff --git a/flink-scala/src/main/scala/org/apache/flink/api/scala/DataSet.scala b/flink-scala/src/main/scala/org/apache/flink/api/scala/DataSet.scala
index 94c5461..c1796ee 100644
--- a/flink-scala/src/main/scala/org/apache/flink/api/scala/DataSet.scala
+++ b/flink-scala/src/main/scala/org/apache/flink/api/scala/DataSet.scala
@@ -219,31 +219,31 @@ class DataSet[T: ClassTag](set: JavaDataSet[T]) {
     this
   }
 
-  def withConstantSet(constantSets: String*) = {
+  def withForwardedFields(forwardedFields: String*) = {
     javaSet match {
-      case op: SingleInputUdfOperator[_, _, _] => op.withConstantSet(constantSets: _*)
+      case op: SingleInputUdfOperator[_, _, _] => op.withForwardedFields(forwardedFields: _*)
       case _ =>
-        throw new UnsupportedOperationException("Cannot specify constant sets on Operator " +
+        throw new UnsupportedOperationException("Cannot specify forwarded fields for Operator " +
           javaSet.toString + ".")
     }
     this
   }
 
-  def withConstantSetFirst(constantSets: String*) = {
+  def withForwardedFieldsFirst(forwardedFields: String*) = {
     javaSet match {
-      case op: TwoInputUdfOperator[_, _, _, _] => op.withConstantSetFirst(constantSets: _*)
+      case op: TwoInputUdfOperator[_, _, _, _] => op.withForwardedFieldsFirst(forwardedFields: _*)
       case _ =>
-        throw new UnsupportedOperationException("Cannot specify constant sets on Operator " +
+        throw new UnsupportedOperationException("Cannot specify forwarded fields for Operator " +
           javaSet.toString + ".")
     }
     this
   }
 
-  def withConstantSetSecond(constantSets: String*) = {
+  def withForwardedFieldsSecond(forwardedFields: String*) = {
     javaSet match {
-      case op: TwoInputUdfOperator[_, _, _, _] => op.withConstantSetSecond(constantSets: _*)
+      case op: TwoInputUdfOperator[_, _, _, _] => op.withForwardedFieldsSecond(forwardedFields: _*)
       case _ =>
-        throw new UnsupportedOperationException("Cannot specify constant sets on Operator " +
+        throw new UnsupportedOperationException("Cannot specify forwarded fields for Operator " +
           javaSet.toString + ".")
     }
     this