org.apache.flink.types.BooleanValue Java Examples

@Test
public void testCreate() throws Exception {
	// supported primitive types
	Assert.assertEquals(StringSummaryAggregator.class, SummaryAggregatorFactory.create(String.class).getClass());
	Assert.assertEquals(ShortSummaryAggregator.class, SummaryAggregatorFactory.create(Short.class).getClass());
	Assert.assertEquals(IntegerSummaryAggregator.class, SummaryAggregatorFactory.create(Integer.class).getClass());
	Assert.assertEquals(LongSummaryAggregator.class, SummaryAggregatorFactory.create(Long.class).getClass());
	Assert.assertEquals(FloatSummaryAggregator.class, SummaryAggregatorFactory.create(Float.class).getClass());
	Assert.assertEquals(DoubleSummaryAggregator.class, SummaryAggregatorFactory.create(Double.class).getClass());
	Assert.assertEquals(BooleanSummaryAggregator.class, SummaryAggregatorFactory.create(Boolean.class).getClass());

	// supported value types
	Assert.assertEquals(ValueSummaryAggregator.StringValueSummaryAggregator.class, SummaryAggregatorFactory.create(StringValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.ShortValueSummaryAggregator.class, SummaryAggregatorFactory.create(ShortValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.IntegerValueSummaryAggregator.class, SummaryAggregatorFactory.create(IntValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.LongValueSummaryAggregator.class, SummaryAggregatorFactory.create(LongValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.FloatValueSummaryAggregator.class, SummaryAggregatorFactory.create(FloatValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.DoubleValueSummaryAggregator.class, SummaryAggregatorFactory.create(DoubleValue.class).getClass());
	Assert.assertEquals(ValueSummaryAggregator.BooleanValueSummaryAggregator.class, SummaryAggregatorFactory.create(BooleanValue.class).getClass());

	// some not well supported types - these fallback to ObjectSummaryAggregator
	Assert.assertEquals(ObjectSummaryAggregator.class, SummaryAggregatorFactory.create(Object.class).getClass());
	Assert.assertEquals(ObjectSummaryAggregator.class, SummaryAggregatorFactory.create(List.class).getClass());
}
 

/**
 * Helper method for summarizing a list of values.
 *
 * <p>This method breaks the rule of "testing only one thing" by aggregating and combining
 * a bunch of different ways.
 */
protected BooleanColumnSummary summarize(Boolean... values) {

	BooleanValue[] booleanValues = new BooleanValue[values.length];
	for (int i = 0; i < values.length; i++) {
		if (values[i] != null) {
			booleanValues[i] = new BooleanValue(values[i]);
		}
	}

	return new AggregateCombineHarness<BooleanValue, BooleanColumnSummary, ValueSummaryAggregator.BooleanValueSummaryAggregator>() {
		@Override
		protected void compareResults(BooleanColumnSummary result1, BooleanColumnSummary result2) {
			Assert.assertEquals(result1.getNullCount(), result2.getNullCount());
			Assert.assertEquals(result1.getNonNullCount(), result2.getNonNullCount());
			Assert.assertEquals(result1.getTrueCount(), result2.getTrueCount());
			Assert.assertEquals(result1.getFalseCount(), result2.getFalseCount());
		}
	}.summarize(booleanValues);
}
 

@Override
public BooleanValue[] getValidTestResults() {
	return new BooleanValue[] {
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(false), new BooleanValue(true),
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(true), new BooleanValue(false)
	};
}
 

@Override
public int parseField(byte[] bytes, int startPos, int limit, byte[] delim, BooleanValue reuse) {
	int returnValue = parser.parseField(bytes, startPos, limit, delim, reuse.getValue());
	setErrorState(parser.getErrorState());
	reuse.setValue(parser.getLastResult());
	result = reuse;
	return returnValue;
}
 

@Override
public int parseField(byte[] bytes, int startPos, int limit, byte[] delim, BooleanValue reuse) {
	int returnValue = parser.parseField(bytes, startPos, limit, delim, reuse.getValue());
	setErrorState(parser.getErrorState());
	reuse.setValue(parser.getLastResult());
	result = reuse;
	return returnValue;
}
 

@Override
public BooleanValue[] getValidTestResults() {
	return new BooleanValue[] {
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(false), new BooleanValue(true),
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(true), new BooleanValue(false)
	};
}
 

@Test
public void testValueTypes() throws Exception {
	final String inputData = "ABC,true,1,2,3,4,5.0,6.0\nBCD,false,1,2,3,4,5.0,6.0";
	final String dataPath = createInputData(inputData);
	final ExecutionEnvironment env = ExecutionEnvironment.getExecutionEnvironment();

	DataSet<Tuple8<StringValue, BooleanValue, ByteValue, ShortValue, IntValue, LongValue, FloatValue, DoubleValue>> data =
			env.readCsvFile(dataPath).types(StringValue.class, BooleanValue.class, ByteValue.class, ShortValue.class, IntValue.class, LongValue.class, FloatValue.class, DoubleValue.class);
	List<Tuple8<StringValue, BooleanValue, ByteValue, ShortValue, IntValue, LongValue, FloatValue, DoubleValue>> result = data.collect();

	expected = inputData;
	compareResultAsTuples(result, expected);
}
 

@Override
protected BooleanValue[] getTestData() {
	Random rnd = new Random(874597969123412341L);
	
	return new BooleanValue[] {new BooleanValue(true), new BooleanValue(false),
							new BooleanValue(rnd.nextBoolean()),
							new BooleanValue(rnd.nextBoolean()),
							new BooleanValue(rnd.nextBoolean())};
}
 

@Override
public BooleanValue[] getValidTestResults() {
	return new BooleanValue[] {
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(false), new BooleanValue(true),
			new BooleanValue(true), new BooleanValue(false), new BooleanValue(true), new BooleanValue(false)
	};
}
 

@Override
protected BooleanValue[] getTestData() {
	Random rnd = new Random(874597969123412341L);
	
	return new BooleanValue[] {new BooleanValue(true), new BooleanValue(false),
							new BooleanValue(rnd.nextBoolean()),
							new BooleanValue(rnd.nextBoolean()),
							new BooleanValue(rnd.nextBoolean())};
}
 

@Override
public int parseField(byte[] bytes, int startPos, int limit, byte[] delim, BooleanValue reuse) {
	int returnValue = parser.parseField(bytes, startPos, limit, delim, reuse.getValue());
	setErrorState(parser.getErrorState());
	reuse.setValue(parser.getLastResult());
	result = reuse;
	return returnValue;
}
 

@Test
public void testWithValueType() throws Exception {
	CsvReader reader = getCsvReader();
	DataSource<Tuple8<StringValue, BooleanValue, ByteValue, ShortValue, IntValue, LongValue, FloatValue, DoubleValue>> items =
			reader.types(StringValue.class, BooleanValue.class, ByteValue.class, ShortValue.class, IntValue.class, LongValue.class, FloatValue.class, DoubleValue.class);
	TypeInformation<?> info = items.getType();

	Assert.assertEquals(true, info.isTupleType());
	Assert.assertEquals(Tuple8.class, info.getTypeClass());
}
 

@Test
public void testWithValueType() throws Exception {
	CsvReader reader = getCsvReader();
	DataSource<Tuple8<StringValue, BooleanValue, ByteValue, ShortValue, IntValue, LongValue, FloatValue, DoubleValue>> items =
			reader.types(StringValue.class, BooleanValue.class, ByteValue.class, ShortValue.class, IntValue.class, LongValue.class, FloatValue.class, DoubleValue.class);
	TypeInformation<?> info = items.getType();

	Assert.assertEquals(true, info.isTupleType());
	Assert.assertEquals(Tuple8.class, info.getTypeClass());
}
 

@Test
public void testWithValueType() throws Exception {
	CsvReader reader = getCsvReader();
	DataSource<Tuple8<StringValue, BooleanValue, ByteValue, ShortValue, IntValue, LongValue, FloatValue, DoubleValue>> items =
			reader.types(StringValue.class, BooleanValue.class, ByteValue.class, ShortValue.class, IntValue.class, LongValue.class, FloatValue.class, DoubleValue.class);
	TypeInformation<?> info = items.getType();

	Assert.assertEquals(true, info.isTupleType());
	Assert.assertEquals(Tuple8.class, info.getTypeClass());
}
 

@Override
public BooleanValue createInstance() {
	return new BooleanValue();
}
 

@Override
public BooleanValue createTestData() {
	return BooleanValue.TRUE;
}
 

@Override
public boolean supportsNormalizedKey() {
	return NormalizableKey.class.isAssignableFrom(BooleanValue.class);
}
 

@Override
public TypeComparator<BooleanValue> duplicate() {
	return new BooleanValueComparator(ascendingComparison);
}
 

@Override
public void writeWithKeyNormalization(BooleanValue record, DataOutputView target) throws IOException {
	throw new UnsupportedOperationException();
}
 

@Override
public BooleanValue getLastResult() {
	return result;
}
 

@Override
public FieldParser<BooleanValue> getParser() {
	return new BooleanValueParser();
}
 

@Override
protected Class<BooleanValue> getTypeClass() {
	return BooleanValue.class;
}
 

@Override
public int compare(BooleanValue first, BooleanValue second) {
	int comp = first.compareTo(second);
	return ascendingComparison ? comp : -comp;
}
 

@Override
public TypeSerializer<BooleanValue> createUpgradedSerializer() {
	return BooleanValueSerializer.INSTANCE;
}
 

@Override
public Class<BooleanValue> getTypeClass() {
	return BooleanValue.class;
}
 

@Override
public void writeWithKeyNormalization(BooleanValue record, DataOutputView target) throws IOException {
	throw new UnsupportedOperationException();
}
 

@Override
public int hash(BooleanValue record) {
	return record.hashCode();
}
 

@SuppressWarnings({ "unchecked", "rawtypes" })
@Override
@PublicEvolving
public TypeComparator<T> createComparator(boolean sortOrderAscending, ExecutionConfig executionConfig) {
	if (!isKeyType()) {
		throw new RuntimeException("The type " + type.getName() + " is not Comparable.");
	}

	if (BooleanValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new BooleanValueComparator(sortOrderAscending);
	}
	else if (ByteValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new ByteValueComparator(sortOrderAscending);
	}
	else if (CharValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new CharValueComparator(sortOrderAscending);
	}
	else if (DoubleValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new DoubleValueComparator(sortOrderAscending);
	}
	else if (FloatValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new FloatValueComparator(sortOrderAscending);
	}
	else if (IntValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new IntValueComparator(sortOrderAscending);
	}
	else if (LongValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new LongValueComparator(sortOrderAscending);
	}
	else if (NullValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) NullValueComparator.getInstance();
	}
	else if (ShortValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new ShortValueComparator(sortOrderAscending);
	}
	else if (StringValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new StringValueComparator(sortOrderAscending);
	}
	else if (CopyableValue.class.isAssignableFrom(type)) {
		return (TypeComparator<T>) new CopyableValueComparator(sortOrderAscending, type);
	}
	else {
		return (TypeComparator<T>) new ValueComparator(sortOrderAscending, type);
	}
}
 

@Override
public int hash(BooleanValue record) {
	return record.hashCode();
}
 

@PublicEvolving
public boolean isBasicValueType() {
	return type.equals(StringValue.class) || type.equals(ByteValue.class) || type.equals(ShortValue.class) || type.equals(CharValue.class) ||
			type.equals(DoubleValue.class) || type.equals(FloatValue.class) || type.equals(IntValue.class) || type.equals(LongValue.class) ||
			type.equals(NullValue.class) || type.equals(BooleanValue.class);
}