@SuppressWarnings("unchecked") public static void writeObject(IAObject obj, DataOutput dataOutput) throws HyracksDataException { switch (obj.getType().getTypeTag()) { case RECORD: { IARecordBuilder recordBuilder = new RecordBuilder(); recordBuilder.reset((ARecordType) obj.getType()); recordBuilder.init(); writeRecord((AMutableRecord) obj, dataOutput, recordBuilder); break; } case ORDEREDLIST: { OrderedListBuilder listBuilder = new OrderedListBuilder(); listBuilder.reset((AOrderedListType) ((AMutableOrderedList) obj).getType()); IACursor cursor = ((AMutableOrderedList) obj).getCursor(); ArrayBackedValueStorage listItemValue = new ArrayBackedValueStorage(); while (cursor.next()) { listItemValue.reset(); IAObject item = cursor.get(); writeObject(item, listItemValue.getDataOutput()); listBuilder.addItem(listItemValue); } listBuilder.write(dataOutput, true); break; } case UNORDEREDLIST: { UnorderedListBuilder listBuilder = new UnorderedListBuilder(); listBuilder.reset((AUnorderedListType) ((AMutableUnorderedList) obj).getType()); IACursor cursor = ((AMutableUnorderedList) obj).getCursor(); ArrayBackedValueStorage listItemValue = new ArrayBackedValueStorage(); while (cursor.next()) { listItemValue.reset(); IAObject item = cursor.get(); writeObject(item, listItemValue.getDataOutput()); listBuilder.addItem(listItemValue); } listBuilder.write(dataOutput, true); break; } default: AqlSerializerDeserializerProvider.INSTANCE .getSerializerDeserializer(obj.getType()) .serialize(obj, dataOutput); break; } }
/** Translates a Dataset metadata entity to an ITupleReference and vice versa. */ public class CompactionPolicyTupleTranslator extends AbstractTupleTranslator<CompactionPolicy> { // Field indexes of serialized CompactionPolicy in a tuple. // Key field. public static final int COMPACTION_POLICY_DATAVERSE_NAME_FIELD_INDEX = 0; public static final int COMPACTION_POLICY_NAME_FIELD_INDEX = 1; // Payload field containing serialized compactionPolicy. public static final int COMPACTION_POLICY_PAYLOAD_TUPLE_FIELD_INDEX = 2; @SuppressWarnings("unchecked") private ISerializerDeserializer<ARecord> recordSerDes = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer( MetadataRecordTypes.COMPACTION_POLICY_RECORDTYPE); public CompactionPolicyTupleTranslator(boolean getTuple) { super(getTuple, MetadataPrimaryIndexes.COMPACTION_POLICY_DATASET.getFieldCount()); } @Override public CompactionPolicy getMetadataEntityFromTuple(ITupleReference tuple) throws IOException { byte[] serRecord = tuple.getFieldData(COMPACTION_POLICY_PAYLOAD_TUPLE_FIELD_INDEX); int recordStartOffset = tuple.getFieldStart(COMPACTION_POLICY_PAYLOAD_TUPLE_FIELD_INDEX); int recordLength = tuple.getFieldLength(COMPACTION_POLICY_PAYLOAD_TUPLE_FIELD_INDEX); ByteArrayInputStream stream = new ByteArrayInputStream(serRecord, recordStartOffset, recordLength); DataInput in = new DataInputStream(stream); ARecord compactionPolicyRecord = (ARecord) recordSerDes.deserialize(in); return createCompactionPolicyFromARecord(compactionPolicyRecord); } private CompactionPolicy createCompactionPolicyFromARecord(ARecord compactionPolicyRecord) { CompactionPolicy compactionPolicy = null; String dataverseName = ((AString) compactionPolicyRecord.getValueByPos( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_DATAVERSE_NAME_FIELD_INDEX)) .getStringValue(); String policyName = ((AString) compactionPolicyRecord.getValueByPos( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_POLICY_NAME_FIELD_INDEX)) .getStringValue(); String className = ((AString) compactionPolicyRecord.getValueByPos( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_CLASSNAME_FIELD_INDEX)) .getStringValue(); compactionPolicy = new CompactionPolicy(dataverseName, policyName, className); return compactionPolicy; } @Override public ITupleReference getTupleFromMetadataEntity(CompactionPolicy compactionPolicy) throws IOException, MetadataException { tupleBuilder.reset(); aString.setValue(compactionPolicy.getDataverseName()); stringSerde.serialize(aString, tupleBuilder.getDataOutput()); tupleBuilder.addFieldEndOffset(); aString.setValue(compactionPolicy.getPolicyName()); stringSerde.serialize(aString, tupleBuilder.getDataOutput()); tupleBuilder.addFieldEndOffset(); recordBuilder.reset(MetadataRecordTypes.COMPACTION_POLICY_RECORDTYPE); // write field 0 fieldValue.reset(); aString.setValue(compactionPolicy.getDataverseName()); stringSerde.serialize(aString, fieldValue.getDataOutput()); recordBuilder.addField( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_DATAVERSE_NAME_FIELD_INDEX, fieldValue); // write field 1 fieldValue.reset(); aString.setValue(compactionPolicy.getPolicyName()); stringSerde.serialize(aString, fieldValue.getDataOutput()); recordBuilder.addField( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_POLICY_NAME_FIELD_INDEX, fieldValue); // write field 2 fieldValue.reset(); aString.setValue(compactionPolicy.getClassName()); stringSerde.serialize(aString, fieldValue.getDataOutput()); recordBuilder.addField( MetadataRecordTypes.COMPACTION_POLICY_ARECORD_CLASSNAME_FIELD_INDEX, fieldValue); // write record recordBuilder.write(tupleBuilder.getDataOutput(), true); tupleBuilder.addFieldEndOffset(); tuple.reset(tupleBuilder.getFieldEndOffsets(), tupleBuilder.getByteArray()); return tuple; } }
public abstract class AbstractAvgAggregateFunction implements ICopyAggregateFunction { private static final int SUM_FIELD_ID = 0; private static final int COUNT_FIELD_ID = 1; private final ARecordType recType; private DataOutput out; private ArrayBackedValueStorage inputVal = new ArrayBackedValueStorage(); private ICopyEvaluator eval; protected ATypeTag aggType; private double sum; private long count; private AMutableDouble aDouble = new AMutableDouble(0); private AMutableInt64 aInt64 = new AMutableInt64(0); private ArrayBackedValueStorage avgBytes = new ArrayBackedValueStorage(); private ByteArrayAccessibleOutputStream sumBytes = new ByteArrayAccessibleOutputStream(); private DataOutput sumBytesOutput = new DataOutputStream(sumBytes); private ByteArrayAccessibleOutputStream countBytes = new ByteArrayAccessibleOutputStream(); private DataOutput countBytesOutput = new DataOutputStream(countBytes); private ICopyEvaluator evalSum = new AccessibleByteArrayEval(avgBytes.getDataOutput(), sumBytes); private ICopyEvaluator evalCount = new AccessibleByteArrayEval(avgBytes.getDataOutput(), countBytes); private ClosedRecordConstructorEval recordEval; @SuppressWarnings("unchecked") private ISerializerDeserializer<ADouble> doubleSerde = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ADOUBLE); @SuppressWarnings("unchecked") private ISerializerDeserializer<AInt64> longSerde = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.AINT64); @SuppressWarnings("unchecked") private ISerializerDeserializer<ANull> nullSerde = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ANULL); public AbstractAvgAggregateFunction(ICopyEvaluatorFactory[] args, IDataOutputProvider output) throws AlgebricksException { eval = args[0].createEvaluator(inputVal); out = output.getDataOutput(); ARecordType tmpRecType; try { tmpRecType = new ARecordType( null, new String[] {"sum", "count"}, new IAType[] {BuiltinType.ADOUBLE, BuiltinType.AINT64}, false); } catch (AsterixException | HyracksDataException e) { throw new AlgebricksException(e); } recType = tmpRecType; recordEval = new ClosedRecordConstructorEval( recType, new ICopyEvaluator[] {evalSum, evalCount}, avgBytes, out); } @Override public void init() { aggType = ATypeTag.SYSTEM_NULL; sum = 0.0; count = 0; } public abstract void step(IFrameTupleReference tuple) throws AlgebricksException; public abstract void finish() throws AlgebricksException; public abstract void finishPartial() throws AlgebricksException; protected abstract void processNull(); protected void processDataValues(IFrameTupleReference tuple) throws AlgebricksException { if (skipStep()) { return; } inputVal.reset(); eval.evaluate(tuple); ATypeTag typeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(inputVal.getByteArray()[0]); if (typeTag == ATypeTag.NULL) { processNull(); return; } else if (aggType == ATypeTag.SYSTEM_NULL) { aggType = typeTag; } else if (typeTag != ATypeTag.SYSTEM_NULL && !ATypeHierarchy.isCompatible(typeTag, aggType)) { throw new AlgebricksException( "Unexpected type " + typeTag + " in aggregation input stream. Expected type " + aggType + "."); } else if (ATypeHierarchy.canPromote(aggType, typeTag)) { aggType = typeTag; } ++count; switch (typeTag) { case INT8: { byte val = AInt8SerializerDeserializer.getByte(inputVal.getByteArray(), 1); sum += val; break; } case INT16: { short val = AInt16SerializerDeserializer.getShort(inputVal.getByteArray(), 1); sum += val; break; } case INT32: { int val = AInt32SerializerDeserializer.getInt(inputVal.getByteArray(), 1); sum += val; break; } case INT64: { long val = AInt64SerializerDeserializer.getLong(inputVal.getByteArray(), 1); sum += val; break; } case FLOAT: { float val = AFloatSerializerDeserializer.getFloat(inputVal.getByteArray(), 1); sum += val; break; } case DOUBLE: { double val = ADoubleSerializerDeserializer.getDouble(inputVal.getByteArray(), 1); sum += val; break; } default: { throw new NotImplementedException("Cannot compute AVG for values of type " + typeTag); } } inputVal.reset(); } protected void finishPartialResults() throws AlgebricksException { try { // Double check that count 0 is accounted if (aggType == ATypeTag.SYSTEM_NULL) { if (GlobalConfig.DEBUG) { GlobalConfig.ASTERIX_LOGGER.finest("AVG aggregate ran over empty input."); } out.writeByte(ATypeTag.SYSTEM_NULL.serialize()); } else if (aggType == ATypeTag.NULL) { out.writeByte(ATypeTag.NULL.serialize()); } else { sumBytes.reset(); aDouble.setValue(sum); doubleSerde.serialize(aDouble, sumBytesOutput); countBytes.reset(); aInt64.setValue(count); longSerde.serialize(aInt64, countBytesOutput); recordEval.evaluate(null); } } catch (IOException e) { throw new AlgebricksException(e); } } protected void processPartialResults(IFrameTupleReference tuple) throws AlgebricksException { if (skipStep()) { return; } inputVal.reset(); eval.evaluate(tuple); byte[] serBytes = inputVal.getByteArray(); ATypeTag typeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(serBytes[0]); switch (typeTag) { case NULL: { processNull(); break; } case SYSTEM_NULL: { // Ignore and return. break; } case RECORD: { // Expected. aggType = ATypeTag.DOUBLE; int nullBitmapSize = 0; int offset1 = ARecordSerializerDeserializer.getFieldOffsetById( serBytes, SUM_FIELD_ID, nullBitmapSize, false); sum += ADoubleSerializerDeserializer.getDouble(serBytes, offset1); int offset2 = ARecordSerializerDeserializer.getFieldOffsetById( serBytes, COUNT_FIELD_ID, nullBitmapSize, false); count += AInt64SerializerDeserializer.getLong(serBytes, offset2); break; } default: { throw new AlgebricksException( "Global-Avg is not defined for values of type " + EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(serBytes[0])); } } } protected void finishFinalResults() throws AlgebricksException { try { if (count == 0 || aggType == ATypeTag.NULL) { nullSerde.serialize(ANull.NULL, out); } else { aDouble.setValue(sum / count); doubleSerde.serialize(aDouble, out); } } catch (IOException e) { throw new AlgebricksException(e); } } protected boolean skipStep() { return false; } }
public abstract class AbstractTripleStringStringEval implements ICopyEvaluator { private DataOutput dout; private static final byte SER_NULL_TYPE_TAG = ATypeTag.NULL.serialize(); private static final byte SER_STRING_TYPE_TAG = ATypeTag.STRING.serialize(); private ArrayBackedValueStorage array0 = new ArrayBackedValueStorage(); private ArrayBackedValueStorage array1 = new ArrayBackedValueStorage(); private ArrayBackedValueStorage array2 = new ArrayBackedValueStorage(); private ICopyEvaluator eval0; private ICopyEvaluator eval1; private ICopyEvaluator eval2; private AMutableString resultBuffer = new AMutableString(""); @SuppressWarnings("rawtypes") private ISerializerDeserializer nullSerde = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ANULL); @SuppressWarnings("rawtypes") private ISerializerDeserializer strSerde = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(BuiltinType.ASTRING); private final UTF8StringPointable strPtr1st = new UTF8StringPointable(); private final UTF8StringPointable strPtr2nd = new UTF8StringPointable(); private final UTF8StringPointable strPtr3rd = new UTF8StringPointable(); private final FunctionIdentifier funcID; public AbstractTripleStringStringEval( DataOutput dout, ICopyEvaluatorFactory eval0, ICopyEvaluatorFactory eval1, ICopyEvaluatorFactory eval2, FunctionIdentifier funcID) throws AlgebricksException { this.dout = dout; this.eval0 = eval0.createEvaluator(array0); this.eval1 = eval1.createEvaluator(array1); this.eval2 = eval2.createEvaluator(array2); this.funcID = funcID; } @SuppressWarnings("unchecked") @Override public void evaluate(IFrameTupleReference tuple) throws AlgebricksException { array0.reset(); eval0.evaluate(tuple); array1.reset(); eval1.evaluate(tuple); array2.reset(); eval2.evaluate(tuple); try { if (array0.getByteArray()[0] == SER_NULL_TYPE_TAG || array1.getByteArray()[0] == SER_NULL_TYPE_TAG || array2.getByteArray()[0] == SER_NULL_TYPE_TAG) { nullSerde.serialize(ANull.NULL, dout); return; } else if (array0.getByteArray()[0] != SER_STRING_TYPE_TAG || array1.getByteArray()[0] != SER_STRING_TYPE_TAG || array2.getByteArray()[0] != SER_STRING_TYPE_TAG) { throw new AlgebricksException( funcID.getName() + ": expects input type (STRING/NULL, STRING/NULL, STRING/NULL), but got (" + EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array0.getByteArray()[0]) + ", " + EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array1.getByteArray()[0]) + ", " + EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(array2.getByteArray()[0]) + "."); } } catch (HyracksDataException e) { throw new AlgebricksException(e); } strPtr1st.set(array0.getByteArray(), array0.getStartOffset() + 1, array0.getLength()); strPtr2nd.set(array1.getByteArray(), array1.getStartOffset() + 1, array1.getLength()); strPtr3rd.set(array2.getByteArray(), array2.getStartOffset() + 1, array2.getLength()); String res = compute(strPtr1st, strPtr2nd, strPtr3rd); resultBuffer.setValue(res); try { strSerde.serialize(resultBuffer, dout); } catch (HyracksDataException e) { throw new AlgebricksException(e); } } protected abstract String compute( UTF8StringPointable strPtr1st, UTF8StringPointable strPtr2nd, UTF8StringPointable strPtr3rd) throws AlgebricksException; }
@SuppressWarnings("rawtypes") public void testSchemaful() { try { File file = new File("target/classad-wtih-temporals.adm"); File expected = new File(getClass().getResource("/results/classad-with-temporals.adm").toURI().getPath()); FileUtils.deleteQuietly(file); PrintStream printStream = new PrintStream(Files.newOutputStream(Paths.get(file.toURI()))); String[] recordFieldNames = { "GlobalJobId", "Owner", "ClusterId", "ProcId", "RemoteWallClockTime", "CompletionDate", "QDate", "JobCurrentStartDate", "JobStartDate", "JobCurrentStartExecutingDate" }; IAType[] recordFieldTypes = { BuiltinType.ASTRING, BuiltinType.ASTRING, BuiltinType.AINT32, BuiltinType.AINT32, BuiltinType.ADURATION, BuiltinType.ADATETIME, BuiltinType.ADATETIME, BuiltinType.ADATETIME, BuiltinType.ADATETIME, BuiltinType.ADATETIME }; ARecordType recordType = new ARecordType("value", recordFieldNames, recordFieldTypes, true); int numOfTupleFields = 1; ISerializerDeserializer[] serdes = new ISerializerDeserializer[1]; serdes[0] = AqlSerializerDeserializerProvider.INSTANCE.getSerializerDeserializer(recordType); IPrinterFactory[] printerFactories = new IPrinterFactory[1]; printerFactories[0] = AqlADMPrinterFactoryProvider.INSTANCE.getPrinterFactory(recordType); // create output descriptor IPrinter[] printers = new IPrinter[printerFactories.length]; for (int i = 0; i < printerFactories.length; i++) { printers[i] = printerFactories[i].createPrinter(); } ClassAdObjectPool objectPool = new ClassAdObjectPool(); String[] files = new String[] {"/classad-with-temporals.classads"}; ClassAdParser parser = new ClassAdParser(recordType, false, false, false, null, null, null, objectPool); ArrayTupleBuilder tb = new ArrayTupleBuilder(numOfTupleFields); for (String path : files) { List<Path> paths = new ArrayList<>(); paths.add(Paths.get(getClass().getResource(path).toURI())); FileSystemWatcher watcher = new FileSystemWatcher(paths, null, false); LocalFSInputStream in = new LocalFSInputStream(watcher); SemiStructuredRecordReader recordReader = new SemiStructuredRecordReader(in, "[", "]"); while (recordReader.hasNext()) { tb.reset(); IRawRecord<char[]> record = recordReader.next(); parser.parse(record, tb.getDataOutput()); tb.addFieldEndOffset(); printTuple(tb, printers, printStream); } recordReader.close(); printStream.close(); Assert.assertTrue(FileUtils.contentEquals(file, expected)); } } catch (Throwable th) { System.err.println("TEST FAILED"); th.printStackTrace(); Assert.assertTrue(false); } System.err.println("TEST PASSED"); }