use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.avatica.util.ByteString in project calcite-avatica by apache.
the class AvaticaUtilsTest method testByteString.
@Test
public void testByteString() {
final byte[] bytes = { 3, 14, 15, 92, 0, 65, 35, 0 };
final ByteString s = new ByteString(bytes);
final ByteString s2 = new ByteString(bytes.clone());
final ByteString s3 = new ByteString(new byte[0]);
final ByteString s4 = new ByteString(new byte[] { 0 });
final ByteString s5 = new ByteString(new byte[] { 15, 92 });
// length
assertThat(s.length(), is(8));
assertThat(s3.length(), is(0));
assertThat(s4.length(), is(1));
// equals and hashCode
assertThat(s.hashCode(), is(s2.hashCode()));
assertThat(s.equals(s2), is(true));
assertThat(s2.equals(s), is(true));
assertThat(s.equals(s3), is(false));
assertThat(s3.equals(s), is(false));
// toString
assertThat(s.toString(), is("030e0f5c00412300"));
assertThat(s3.toString(), is(""));
assertThat(s4.toString(), is("00"));
// indexOf
assertThat(s.indexOf(s3), is(0));
assertThat(s.indexOf(s3, 5), is(5));
assertThat(s.indexOf(s3, 15), is(-1));
assertThat(s.indexOf(s4), is(4));
assertThat(s.indexOf(s4, 4), is(4));
assertThat(s.indexOf(s4, 5), is(7));
assertThat(s.indexOf(s5), is(2));
assertThat(s.indexOf(s5, 2), is(2));
assertThat(s.indexOf(s5, 3), is(-1));
assertThat(s.indexOf(s5, 7), is(-1));
// substring
assertThat(s.substring(8), is(s3));
assertThat(s.substring(7), is(s4));
assertThat(s.substring(0), is(s));
// getBytes
assertThat(s.getBytes().length, is(8));
assertThat(Arrays.equals(s.getBytes(), bytes), is(true));
assertThat(s.getBytes()[3], is((byte) 92));
final byte[] copyBytes = s.getBytes();
copyBytes[3] = 11;
assertThat(s.getBytes()[3], is((byte) 92));
assertThat(s, is(s2));
}
use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.avatica.util.ByteString in project calcite-avatica by apache.
the class TypedValue method jdbcToSerial.
/**
* Converts a value from JDBC format to a type that can be serialized as
* JSON.
*/
private static Object jdbcToSerial(ColumnMetaData.Rep rep, Object value, Calendar calendar, SqlType componentType) {
if (null == value) {
return null;
}
switch(rep) {
case BYTE_STRING:
return new ByteString((byte[]) value).toBase64String();
case JAVA_UTIL_DATE:
case JAVA_SQL_TIMESTAMP:
case JAVA_SQL_DATE:
case JAVA_SQL_TIME:
long t = ((Date) value).getTime();
if (calendar != null) {
t += calendar.getTimeZone().getOffset(t);
}
switch(rep) {
case JAVA_SQL_DATE:
return (int) DateTimeUtils.floorDiv(t, DateTimeUtils.MILLIS_PER_DAY);
case JAVA_SQL_TIME:
return (int) DateTimeUtils.floorMod(t, DateTimeUtils.MILLIS_PER_DAY);
default:
return t;
}
case ARRAY:
Array array = (Array) value;
Objects.requireNonNull(componentType, "Component Type must not be null for ARRAYs");
try {
switch(componentType) {
case BINARY:
case VARBINARY:
case LONGVARBINARY:
Object[] byteStrings = (Object[]) array.getArray();
List<String> convertedStrings = new ArrayList<>(byteStrings.length);
for (Object byteString : byteStrings) {
convertedStrings.add((String) jdbcToSerial(Rep.BYTE_STRING, byteString, calendar, null));
}
return convertedStrings;
case DATE:
case TIME:
Object[] dates = (Object[]) array.getArray();
List<Integer> serializedDates = new ArrayList<>(dates.length);
for (Object obj : dates) {
Date date = (Date) obj;
if (null == obj) {
serializedDates.add(null);
} else if (componentType == SqlType.DATE) {
serializedDates.add((int) jdbcToSerial(Rep.JAVA_SQL_DATE, date, calendar, null));
} else if (componentType == SqlType.TIME) {
serializedDates.add((int) jdbcToSerial(Rep.JAVA_SQL_TIME, date, calendar, null));
} else {
throw new RuntimeException("Unexpected type: " + componentType);
}
}
return serializedDates;
case TIMESTAMP:
Object[] timestamps = (Object[]) array.getArray();
List<Long> serializedTimestamps = new ArrayList<>(timestamps.length);
for (Object obj : timestamps) {
Timestamp timestamp = (Timestamp) obj;
if (null == obj) {
serializedTimestamps.add(null);
} else {
serializedTimestamps.add((long) jdbcToSerial(Rep.JAVA_SQL_TIMESTAMP, timestamp, calendar, null));
}
}
return serializedTimestamps;
default:
// Either a primitive array or Object[], converted into List<Object>
return AvaticaUtils.primitiveList(array.getArray());
}
} catch (SQLException e) {
throw new RuntimeException("Could not obtain base array object", e);
}
default:
return value;
}
}
use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.avatica.util.ByteString in project calcite-avatica by apache.
the class TypedValue method getSerialFromProto.
/**
* Converts the serialized value into the appropriate primitive/object.
*
* @param protoValue The serialized TypedValue.
* @return The appropriate concrete type for the parameter value (as an Object).
*/
public static Object getSerialFromProto(Common.TypedValue protoValue) {
// Deserialize the value again
switch(protoValue.getType()) {
case BOOLEAN:
case PRIMITIVE_BOOLEAN:
return protoValue.getBoolValue();
case BYTE_STRING:
if (protoValue.hasField(STRING_DESCRIPTOR) && !protoValue.hasField(BYTES_DESCRIPTOR)) {
// server to support older clients, so only parse the string value when it is alone.
return protoValue.getStringValue();
}
// across the wire natively as bytes. Return it as b64.
return (new ByteString(protoValue.getBytesValue().toByteArray())).toBase64String();
case STRING:
return protoValue.getStringValue();
case PRIMITIVE_CHAR:
case CHARACTER:
return protoValue.getStringValue().charAt(0);
case BYTE:
case PRIMITIVE_BYTE:
return Long.valueOf(protoValue.getNumberValue()).byteValue();
case DOUBLE:
case PRIMITIVE_DOUBLE:
return protoValue.getDoubleValue();
case FLOAT:
case PRIMITIVE_FLOAT:
return Float.intBitsToFloat((int) protoValue.getNumberValue());
case INTEGER:
case PRIMITIVE_INT:
return Long.valueOf(protoValue.getNumberValue()).intValue();
case PRIMITIVE_SHORT:
case SHORT:
return Long.valueOf(protoValue.getNumberValue()).shortValue();
case LONG:
case PRIMITIVE_LONG:
return Long.valueOf(protoValue.getNumberValue());
case JAVA_SQL_DATE:
case JAVA_SQL_TIME:
return Long.valueOf(protoValue.getNumberValue()).intValue();
case JAVA_SQL_TIMESTAMP:
case JAVA_UTIL_DATE:
return protoValue.getNumberValue();
case BIG_INTEGER:
return new BigInteger(protoValue.getBytesValue().toByteArray());
case BIG_DECIMAL:
// CALCITE-1103 shifts BigDecimals to be serialized as strings.
if (protoValue.hasField(NUMBER_DESCRIPTOR)) {
// This is the old (broken) style.
BigInteger bigInt = new BigInteger(protoValue.getBytesValue().toByteArray());
return new BigDecimal(bigInt, (int) protoValue.getNumberValue());
}
return new BigDecimal(protoValue.getStringValueBytes().toStringUtf8());
case NUMBER:
return Long.valueOf(protoValue.getNumberValue());
case NULL:
return null;
case ARRAY:
final List<Common.TypedValue> protoList = protoValue.getArrayValueList();
final List<Object> list = new ArrayList<>(protoList.size());
for (Common.TypedValue protoElement : protoList) {
// Deserialize the TypedValue protobuf into the JDBC type
TypedValue listElement = TypedValue.fromProto(protoElement);
// Must preserve the TypedValue so serial/jdbc/local conversion can work as expected
list.add(listElement);
}
return list;
case OBJECT:
if (protoValue.getNull()) {
return null;
}
// fall through
case UNRECOGNIZED:
// Fail?
throw new RuntimeException("Unhandled type: " + protoValue.getType());
default:
// Fail?
throw new RuntimeException("Unknown type: " + protoValue.getType());
}
}
use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.avatica.util.ByteString in project samza by apache.
the class TestAvroRelConversion method validateAvroSerializedData.
private void validateAvroSerializedData(byte[] serializedData, Object unionValue) throws IOException {
GenericRecord complexRecordValue = genericRecordFromBytes(serializedData, ComplexRecord.SCHEMA$);
SamzaSqlRelMessage message = complexRecordAvroRelConverter.convertToRelMessage(new KV<>("key", complexRecordValue));
Assert.assertEquals(message.getSamzaSqlRelRecord().getFieldNames().size(), ComplexRecord.SCHEMA$.getFields().size() + 1);
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("id").get(), id);
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("bool_value").get(), boolValue);
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("double_value").get(), doubleValue);
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("string_value").get(), new Utf8(testStrValue));
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("float_value0").get(), floatValue);
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("long_value").get(), longValue);
if (unionValue instanceof String) {
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("union_value").get(), new Utf8((String) unionValue));
} else {
Assert.assertEquals(message.getSamzaSqlRelRecord().getField("union_value").get(), unionValue);
}
Assert.assertTrue(arrayValue.stream().map(Utf8::new).collect(Collectors.toList()).equals(message.getSamzaSqlRelRecord().getField("array_values").get()));
Assert.assertTrue(mapValue.entrySet().stream().collect(Collectors.toMap(x -> new Utf8(x.getKey()), y -> new Utf8(y.getValue()))).equals(message.getSamzaSqlRelRecord().getField("map_values").get()));
Assert.assertTrue(Arrays.equals(((ByteString) message.getSamzaSqlRelRecord().getField("bytes_value").get()).getBytes(), testBytes.array()));
Assert.assertTrue(Arrays.equals(((ByteString) message.getSamzaSqlRelRecord().getField("fixed_value").get()).getBytes(), DEFAULT_TRACKING_ID_BYTES));
LOG.info(message.toString());
KV<Object, Object> samzaMessage = complexRecordAvroRelConverter.convertToSamzaMessage(message);
GenericRecord record = (GenericRecord) samzaMessage.getValue();
for (Schema.Field field : ComplexRecord.SCHEMA$.getFields()) {
if (field.name().equals("array_values")) {
Assert.assertTrue(record.get(field.name()).equals(complexRecordValue.get(field.name())));
} else {
Object expected = complexRecordValue.get(field.name());
Assert.assertEquals(expected, record.get(field.name()));
}
}
}
use of org.apache.beam.vendor.calcite.v1_28_0.org.apache.calcite.avatica.util.ByteString in project calcite by apache.
the class RexBuilder method makeLiteral.
/**
* Creates a literal of a given type. The value is assumed to be
* compatible with the type.
*
* @param value Value
* @param type Type
* @param allowCast Whether to allow a cast. If false, value is always a
* {@link RexLiteral} but may not be the exact type
* @return Simple literal, or cast simple literal
*/
public RexNode makeLiteral(Object value, RelDataType type, boolean allowCast) {
if (value == null) {
return makeCast(type, constantNull);
}
if (type.isNullable()) {
final RelDataType typeNotNull = typeFactory.createTypeWithNullability(type, false);
RexNode literalNotNull = makeLiteral(value, typeNotNull, allowCast);
return makeAbstractCast(type, literalNotNull);
}
value = clean(value, type);
RexLiteral literal;
final List<RexNode> operands;
switch(type.getSqlTypeName()) {
case CHAR:
return makeCharLiteral(padRight((NlsString) value, type.getPrecision()));
case VARCHAR:
literal = makeCharLiteral((NlsString) value);
if (allowCast) {
return makeCast(type, literal);
} else {
return literal;
}
case BINARY:
return makeBinaryLiteral(padRight((ByteString) value, type.getPrecision()));
case VARBINARY:
literal = makeBinaryLiteral((ByteString) value);
if (allowCast) {
return makeCast(type, literal);
} else {
return literal;
}
case TINYINT:
case SMALLINT:
case INTEGER:
case BIGINT:
case DECIMAL:
return makeExactLiteral((BigDecimal) value, type);
case FLOAT:
case REAL:
case DOUBLE:
return makeApproxLiteral((BigDecimal) value, type);
case BOOLEAN:
return (Boolean) value ? booleanTrue : booleanFalse;
case TIME:
return makeTimeLiteral((TimeString) value, type.getPrecision());
case TIME_WITH_LOCAL_TIME_ZONE:
return makeTimeWithLocalTimeZoneLiteral((TimeString) value, type.getPrecision());
case DATE:
return makeDateLiteral((DateString) value);
case TIMESTAMP:
return makeTimestampLiteral((TimestampString) value, type.getPrecision());
case TIMESTAMP_WITH_LOCAL_TIME_ZONE:
return makeTimestampWithLocalTimeZoneLiteral((TimestampString) value, type.getPrecision());
case INTERVAL_YEAR:
case INTERVAL_YEAR_MONTH:
case INTERVAL_MONTH:
case INTERVAL_DAY:
case INTERVAL_DAY_HOUR:
case INTERVAL_DAY_MINUTE:
case INTERVAL_DAY_SECOND:
case INTERVAL_HOUR:
case INTERVAL_HOUR_MINUTE:
case INTERVAL_HOUR_SECOND:
case INTERVAL_MINUTE:
case INTERVAL_MINUTE_SECOND:
case INTERVAL_SECOND:
return makeIntervalLiteral((BigDecimal) value, type.getIntervalQualifier());
case MAP:
final MapSqlType mapType = (MapSqlType) type;
@SuppressWarnings("unchecked") final Map<Object, Object> map = (Map) value;
operands = new ArrayList<>();
for (Map.Entry<Object, Object> entry : map.entrySet()) {
operands.add(makeLiteral(entry.getKey(), mapType.getKeyType(), allowCast));
operands.add(makeLiteral(entry.getValue(), mapType.getValueType(), allowCast));
}
return makeCall(SqlStdOperatorTable.MAP_VALUE_CONSTRUCTOR, operands);
case ARRAY:
final ArraySqlType arrayType = (ArraySqlType) type;
@SuppressWarnings("unchecked") final List<Object> listValue = (List) value;
operands = new ArrayList<>();
for (Object entry : listValue) {
operands.add(makeLiteral(entry, arrayType.getComponentType(), allowCast));
}
return makeCall(SqlStdOperatorTable.ARRAY_VALUE_CONSTRUCTOR, operands);
case MULTISET:
final MultisetSqlType multisetType = (MultisetSqlType) type;
operands = new ArrayList<>();
for (Object entry : (List) value) {
final RexNode e = entry instanceof RexLiteral ? (RexNode) entry : makeLiteral(entry, multisetType.getComponentType(), allowCast);
operands.add(e);
}
if (allowCast) {
return makeCall(SqlStdOperatorTable.MULTISET_VALUE, operands);
} else {
return new RexLiteral((Comparable) FlatLists.of(operands), type, type.getSqlTypeName());
}
case ROW:
operands = new ArrayList<>();
// noinspection unchecked
for (Pair<RelDataTypeField, Object> pair : Pair.zip(type.getFieldList(), (List<Object>) value)) {
final RexNode e = pair.right instanceof RexLiteral ? (RexNode) pair.right : makeLiteral(pair.right, pair.left.getType(), allowCast);
operands.add(e);
}
return new RexLiteral((Comparable) FlatLists.of(operands), type, type.getSqlTypeName());
case ANY:
return makeLiteral(value, guessType(value), allowCast);
default:
throw Util.unexpected(type.getSqlTypeName());
}
}
Aggregations