Mailing-List: contact issues-help@flink.apache.org; run by ezmlm
Precedence: bulk
Reply-To: dev@flink.apache.org
From: zentol <git@git.apache.org>
To: issues@flink.incubator.apache.org
Reply-To: issues@flink.incubator.apache.org
References: <git-pr-3501-flink@git.apache.org>
In-Reply-To: <git-pr-3501-flink@git.apache.org>
Subject: [GitHub] flink pull request #3501: [FLINK-5874] Restrict key types in the DataStream ...
Content-Type: text/plain
Message-Id: <20170309185955.2E45ADFF66@git1-us-west.apache.org>
Date: Thu,  9 Mar 2017 18:59:55 +0000 (UTC)
archived-at: Thu, 09 Mar 2017 19:00:01 -0000

Github user zentol commented on a diff in the pull request:

    https://github.com/apache/flink/pull/3501#discussion_r105241358
  
    --- Diff: flink-streaming-java/src/test/java/org/apache/flink/streaming/api/DataStreamTest.java ---
    @@ -906,6 +919,256 @@ public void testChannelSelectors() {
     	}
     
     	/////////////////////////////////////////////////////////////
    +	// KeyBy testing
    +	/////////////////////////////////////////////////////////////
    +
    +	@Rule
    +	public ExpectedException expectedException = ExpectedException.none();
    +
    +	@Test
    +	public void testPrimitiveArrayKeyRejection() {
    +
    +		KeySelector<Tuple2<Integer[], String>, int[]> keySelector =
    +				new KeySelector<Tuple2<Integer[], String>, int[]>() {
    +
    +			@Override
    +			public int[] getKey(Tuple2<Integer[], String> value) throws Exception {
    +				int[] ks = new int[value.f0.length];
    +				for (int i = 0; i < ks.length; i++) {
    +					ks[i] = value.f0[i];
    +				}
    +				return ks;
    +			}
    +		};
    +
    +		testKeyRejection(keySelector, PrimitiveArrayTypeInfo.INT_PRIMITIVE_ARRAY_TYPE_INFO);
    +	}
    +
    +	@Test
    +	public void testBasicArrayKeyRejection() {
    +
    +		KeySelector<Tuple2<Integer[], String>, Integer[]> keySelector =
    +				new KeySelector<Tuple2<Integer[], String>, Integer[]>() {
    +
    +			@Override
    +			public Integer[] getKey(Tuple2<Integer[], String> value) throws Exception {
    +				return value.f0;
    +			}
    +		};
    +
    +		testKeyRejection(keySelector, BasicArrayTypeInfo.INT_ARRAY_TYPE_INFO);
    +	}
    +
    +	@Test
    +	public void testObjectArrayKeyRejection() {
    +
    +		KeySelector<Tuple2<Integer[], String>, TestClass[]> keySelector =
    +				new KeySelector<Tuple2<Integer[], String>, TestClass[]>() {
    +
    +					@Override
    +					public TestClass[] getKey(Tuple2<Integer[], String> value) throws Exception {
    +						TestClass[] ks = new TestClass[value.f0.length];
    +						for (int i = 0; i < ks.length; i++) {
    +							ks[i] = new TestClass(value.f0[i]);
    +						}
    +						return ks;
    +					}
    +				};
    +
    +		ObjectArrayTypeInfo<TestClass[], TestClass> keyTypeInfo = ObjectArrayTypeInfo.getInfoFor(
    +				TestClass[].class, new GenericTypeInfo<>(TestClass.class));
    +
    +		testKeyRejection(keySelector, keyTypeInfo);
    +	}
    +
    +	private <K> void testKeyRejection(KeySelector<Tuple2<Integer[], String>, K> keySelector, TypeInformation<K> expectedKeyType) {
    +
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +
    +		DataStream<Tuple2<Integer[], String>> input = env.fromElements(
    +				new Tuple2<>(new Integer[] {1, 2}, "barfoo")
    +		);
    +
    +		Assert.assertEquals(expectedKeyType, TypeExtractor.getKeySelectorTypes(keySelector, input.getType()));
    +
    +		// adjust the rule
    +		expectedException.expect(InvalidProgramException.class);
    +		expectedException.expectMessage("This type (" + expectedKeyType + ") cannot be used as key.");
    +
    +		input.keyBy(keySelector);
    +	}
    +
    +	// composite key tests : POJOs
    +
    +	@Test
    +	public void testPOJONestedArrayKeyRejection() {
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +
    +		DataStream<POJOwithHashCode> input = env.fromElements(
    +				new POJOwithHashCode(new int[] {1, 2}));
    +
    +		TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple1<int[]>>(
    +				PrimitiveArrayTypeInfo.INT_PRIMITIVE_ARRAY_TYPE_INFO);
    +
    +		// adjust the rule
    +		expectedException.expect(InvalidProgramException.class);
    +		expectedException.expectMessage("This type (" + expectedTypeInfo + ") cannot be used as key.");
    +
    +		input.keyBy("id");
    +	}
    +
    +	@Test
    +	public void testNestedArrayWorkArround() {
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +
    +		DataStream<POJOwithHashCode> input = env.fromElements(
    +				new POJOwithHashCode(new int[] {1, 2}));
    +
    +		input.keyBy(new KeySelector<POJOwithHashCode, POJOwithHashCode>() {
    +			@Override
    +			public POJOwithHashCode getKey(POJOwithHashCode value) throws Exception {
    +				return value;
    +			}
    +		}).addSink(new SinkFunction<POJOwithHashCode>() {
    +			@Override
    +			public void invoke(POJOwithHashCode value) throws Exception {
    +				Assert.assertEquals(value.getId(), new int[]{1, 2});
    +			}
    +		});
    +	}
    +
    +	@Test
    +	public void testPOJOnoHashCodeKeyRejection() {
    +
    +		KeySelector<POJOnoHashCode, POJOnoHashCode> keySelector =
    +				new KeySelector<POJOnoHashCode, POJOnoHashCode>() {
    +					@Override
    +					public POJOnoHashCode getKey(POJOnoHashCode value) throws Exception {
    +						return value;
    +					}
    +				};
    +
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +
    +		DataStream<POJOnoHashCode> input = env.fromElements(
    +				new POJOnoHashCode(new int[] {1, 2}));
    +
    +		// adjust the rule
    +		expectedException.expect(InvalidProgramException.class);
    +
    +		input.keyBy(keySelector);
    +	}
    +
    +	// composite key tests : Tuples
    +
    +	@Test
    +	public void testTupleNestedArrayKeyRejection() {
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +
    +		DataStream<Tuple2<Integer[], String>> input = env.fromElements(
    +				new Tuple2<>(new Integer[] {1, 2}, "test-test"));
    +
    +		TypeInformation<?> expectedTypeInfo = new TupleTypeInfo<Tuple2<Integer[], String>>(
    +				BasicArrayTypeInfo.INT_ARRAY_TYPE_INFO, BasicTypeInfo.STRING_TYPE_INFO);
    +
    +		// adjust the rule
    +		expectedException.expect(InvalidProgramException.class);
    +		expectedException.expectMessage("This type (" + expectedTypeInfo + ") cannot be used as key.");
    +
    +		input.keyBy(new KeySelector<Tuple2<Integer[],String>, Tuple2<Integer[],String>>() {
    +			@Override
    +			public Tuple2<Integer[], String> getKey(Tuple2<Integer[], String> value) throws Exception {
    +				return value;
    +			}
    +		});
    +	}
    +
    +	@Test
    +	public void testPrimitiveKeyRejection() throws Exception {
    +		StreamExecutionEnvironment env = StreamExecutionEnvironment.getExecutionEnvironment();
    +		env.setParallelism(1);
    +		env.setMaxParallelism(1);
    +
    +		DataStream<Integer> input = env.fromElements(new Integer(10000));
    +
    +		TypeInformation<?> expectedTypeInfo = IntegerTypeInfo.INT_TYPE_INFO;
    +
    +		KeyedStream<Integer, Integer> keyedStream = input.keyBy(new KeySelector<Integer, Integer>() {
    +			@Override
    +			public Integer getKey(Integer value) throws Exception {
    +				return value;
    +			}
    +		});
    +
    +		Assert.assertEquals(expectedTypeInfo, keyedStream.getKeyType());
    +
    +		keyedStream.addSink(new SinkFunction<Integer>() {
    +			@Override
    +			public void invoke(Integer value) throws Exception {
    +				Assert.assertEquals(10000L, (long) value);
    +			}
    +		});
    +
    +		env.execute();
    +	}
    +
    +	private static class TestClass {
    +
    +		private final int id;
    +
    +		TestClass(int id) {
    +			this.id = id;
    +		}
    +	}
    +
    +	public static class POJOnoHashCode {
    +
    +		private int[] id;
    +
    +		public POJOnoHashCode() {}
    +
    +		public POJOnoHashCode(int[] id) {
    +			this.id = id;
    +		}
    +
    +		public int[] getId() {
    +			return id;
    +		}
    +
    +		public void setId(int[] id) {
    +			this.id = id;
    +		}
    +	}
    +
    +	public static class POJOwithHashCode {
    --- End diff --
    
    You could extend PojoNoHashCode and only implement hashCode.


---
If your project is set up for it, you can reply to this email and have your
reply appear on GitHub as well. If your project does not have this feature
enabled and wishes so, or if the feature is enabled but not working, please
contact infrastructure at infrastructure@apache.org or file a JIRA ticket
with INFRA.
---