@Override public TaggedValuePointable createPointable() { return new TaggedValuePointable(); }
protected void checkTotallyOrderable() throws HyracksDataException { if (argLeft.getLength() != 0) { ATypeTag typeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argLeft.getTag()); switch (typeTag) { case DURATION: case INTERVAL: case LINE: case POINT: case POINT3D: case POLYGON: case CIRCLE: case RECTANGLE: throw new UnsupportedTypeException(sourceLoc, ComparisonHelper.COMPARISON, argLeft.getTag()); default: return; } } }
throws HyracksDataException { positionArgEval.evaluate(tuple, positionArg); if (positionArg.getTag() == ATypeTag.SERIALIZED_MISSING_TYPE_TAG) { return RETURN_MISSING; if (!ATypeHierarchy.isCompatible(ATypeTag.DOUBLE, ATYPETAGDESERIALIZER.deserialize(positionArg.getTag())) || !listTag.isListType()) { return RETURN_NULL; } else { String name = getIdentifier().getName(); position = ATypeHierarchy.getDoubleValue(name, 1, positionArg.getByteArray(), positionArg.getStartOffset()); if (Double.isNaN(position) || Double.isInfinite(position) || Math.floor(position) < position) { return RETURN_NULL;
argLeft.getValue(outLeft); evalRight.evaluate(tuple, argRight); argRight.getValue(outRight); argOptions[i].getValue(outOptions[i]); ATypeTag typeTag1 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argLeft.getTag()); ATypeTag typeTag2 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argRight.getTag());
@Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws HyracksDataException { // 1st arg: value to repeat repeatedValueEval.evaluate(tuple, repeatedValueArg); // 2nd arg: number of repetitions repeatEval.evaluate(tuple, repeatArg); repeatArgValue.set(repeatArg); if (!ATypeHierarchy.isCompatible(ATypeTag.DOUBLE, ATypeTag.VALUE_TYPE_MAPPING[repeatArgValue.getTag()])) { PointableHelper.setNull(result); return; } final String name = getIdentifier().getName(); final double repetitions = ATypeHierarchy.getDoubleValue(name, 1, repeatArg.getByteArray(), repeatArg.getStartOffset()); if (Double.isNaN(repetitions) || Double.isInfinite(repetitions) || Math.floor(repetitions) < repetitions || repetitions < 0) { PointableHelper.setNull(result); return; } // create list listBuilder.reset(repeatedValueListType); for (int i = 0; i < repetitions; ++i) { listBuilder.addItem(repeatedValueArg); } storage.reset(); listBuilder.write(storage.getDataOutput(), true); result.set(storage); } }
int compare() throws HyracksDataException { ATypeTag leftTypeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argLeft.getTag()); ATypeTag rightTypeTag = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argRight.getTag()); return ch.compare(leftTypeTag, rightTypeTag, outLeft, outRight, leftValue, rightValue); } }
endNumEval.evaluate(tuple, end); String n = getIdentifier().getName(); ATypeTag startTag = ATYPETAGDESERIALIZER.deserialize(start.getTag()); ATypeTag endTag = ATYPETAGDESERIALIZER.deserialize(end.getTag()); ATypeTag stepTag = ATypeTag.INTEGER; double stepNum = 1; if (stepNumEval != null) { stepNumEval.evaluate(tuple, step); stepTag = ATYPETAGDESERIALIZER.deserialize(step.getTag()); if (!ATypeHierarchy.isCompatible(ATypeTag.DOUBLE, stepTag)) { PointableHelper.setNull(result); return; stepNum = ATypeHierarchy.getDoubleValue(n, 2, step.getByteArray(), step.getStartOffset()); long startNum = ATypeHierarchy.getLongValue(n, 0, start.getByteArray(), start.getStartOffset()); long endNum = ATypeHierarchy.getLongValue(n, 1, end.getByteArray(), end.getStartOffset()); listBuilder.reset(ArrayRangeTypeComputer.LONG_LIST); while ((startNum < endNum && stepNum > 0) || (startNum > endNum && stepNum < 0)) { double startNum = ATypeHierarchy.getDoubleValue(n, 0, start.getByteArray(), start.getStartOffset()); double endNum = ATypeHierarchy.getDoubleValue(n, 1, end.getByteArray(), end.getStartOffset()); if (Double.isNaN(startNum) || Double.isInfinite(startNum) || Double.isNaN(endNum) || Double.isInfinite(endNum)) {
boolean comparabilityCheck() { // Checks whether two types are comparable or not ATypeTag typeTag1 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argLeft.getTag()); ATypeTag typeTag2 = EnumDeserializer.ATYPETAGDESERIALIZER.deserialize(argRight.getTag()); // Are two types compatible, meaning that they can be compared? (e.g., compare between numeric types return ATypeHierarchy.isCompatible(typeTag1, typeTag2); }
if (!ATypeHierarchy.isCompatible(ATYPETAGDESERIALIZER.deserialize(depthArg.getTag()), ATypeTag.DOUBLE) || !listType.isListType()) { PointableHelper.setNull(result); double depth = ATypeHierarchy.getDoubleValue(name, 1, depthArg.getByteArray(), depthArg.getStartOffset()); if (Double.isNaN(depth) || Double.isInfinite(depth) || Math.floor(depth) < depth) { PointableHelper.setNull(result);
public ArrayInsertEval(IScalarEvaluatorFactory[] args, IHyracksTaskContext ctx) throws HyracksDataException { super(args, ctx, 0, 2, args.length - 2, argTypes, false, sourceLoc, true, true); positionArg = new TaggedValuePointable(); positionArgEval = args[1].createScalarEvaluator(ctx); }
if (maxEval != null) { maxEval.evaluate(tuple, maxArg); ATypeTag maxTag = ATYPETAGDESERIALIZER.deserialize(maxArg.getTag()); if (maxTag == ATypeTag.MISSING) { PointableHelper.setMissing(result); return; maxDouble = ATypeHierarchy.getDoubleValue(name, 3, maxArg.getByteArray(), maxArg.getStartOffset());
public ArrayRangeEval(IScalarEvaluatorFactory[] args, IHyracksTaskContext ctx) throws HyracksDataException { storage = new ArrayBackedValueStorage(); start = new TaggedValuePointable(); end = new TaggedValuePointable(); startNumEval = args[0].createScalarEvaluator(ctx); endNumEval = args[1].createScalarEvaluator(ctx); listBuilder = new OrderedListBuilder(); aDouble = new AMutableDouble(0); aLong = new AMutableInt64(0); if (args.length == 3) { stepNumEval = args[2].createScalarEvaluator(ctx); step = new TaggedValuePointable(); } }
public ArrayRepeatEval(IScalarEvaluatorFactory[] args, IHyracksTaskContext ctx) throws HyracksDataException { storage = new ArrayBackedValueStorage(); repeatedValueEval = args[0].createScalarEvaluator(ctx); repeatEval = args[1].createScalarEvaluator(ctx); repeatedValueArg = new VoidPointable(); repeatArg = new VoidPointable(); repeatArgValue = new TaggedValuePointable(); listBuilder = new OrderedListBuilder(); }
public ArrayFlattenEval(IScalarEvaluatorFactory[] args, IHyracksTaskContext ctx) throws HyracksDataException { storageAllocator = new ListObjectPool<>(new AbvsBuilderFactory()); listAccessorAllocator = new ListObjectPool<>(new ListAccessorFactory()); storage = new ArrayBackedValueStorage(); listEval = args[0].createScalarEvaluator(ctx); depthEval = args[1].createScalarEvaluator(ctx); list = new VoidPointable(); item = new VoidPointable(); caster = new CastTypeEvaluator(); depthArg = new TaggedValuePointable(); orderedListBuilder = null; unorderedListBuilder = null; }
public ArrayReplaceEval(IScalarEvaluatorFactory[] args, IHyracksTaskContext ctx) throws HyracksDataException { storage = new ArrayBackedValueStorage(); listEval = args[0].createScalarEvaluator(ctx); targetValEval = args[1].createScalarEvaluator(ctx); newValEval = args[2].createScalarEvaluator(ctx); if (args.length == 4) { maxEval = args[3].createScalarEvaluator(ctx); maxArg = new TaggedValuePointable(); } list = new VoidPointable(); target = new VoidPointable(); newVal = new VoidPointable(); item = new VoidPointable(); listAccessor = new ListAccessor(); caster = new CastTypeEvaluator(); orderedListBuilder = null; unorderedListBuilder = null; comp = AObjectAscBinaryComparatorFactory.INSTANCE.createBinaryComparator(); }