Examples with IBinaryIntegerInspector org.apache.hyracks.algebricks.data.IBinaryIntegerInspector used on opensource projects

Example 1 with IBinaryIntegerInspector

use of org.apache.hyracks.algebricks.data.IBinaryIntegerInspector in project asterixdb by apache.

the class StreamLimitRuntimeFactory method createOneOutputPushRuntime.

@Override
public AbstractOneInputOneOutputOneFramePushRuntime createOneOutputPushRuntime(final IHyracksTaskContext ctx) {
    final IBinaryIntegerInspector bii = binaryIntegerInspectorFactory.createBinaryIntegerInspector(ctx);
    return new AbstractOneInputOneOutputOneFramePushRuntime() {

        private final IPointable p = VoidPointable.FACTORY.createPointable();

        private IScalarEvaluator evalMaxObjects;

        private IScalarEvaluator evalOffset = null;

        // how many tuples still to write
        private int toWrite = 0;

        // how many tuples still to skip
        private int toSkip = 0;

        private boolean firstTuple = true;

        private boolean afterLastTuple = false;

        @Override
        public void open() throws HyracksDataException {
            writer.open();
            if (evalMaxObjects == null) {
                initAccessAppendRef(ctx);
                evalMaxObjects = maxObjectsEvalFactory.createScalarEvaluator(ctx);
                if (offsetEvalFactory != null) {
                    evalOffset = offsetEvalFactory.createScalarEvaluator(ctx);
                }
            }
            afterLastTuple = false;
        }

        @Override
        public void nextFrame(ByteBuffer buffer) throws HyracksDataException {
            if (afterLastTuple) {
                return;
            }
            tAccess.reset(buffer);
            int nTuple = tAccess.getTupleCount();
            int start = 0;
            if (nTuple <= toSkip) {
                toSkip -= nTuple;
                return;
            } else if (toSkip > 0) {
                start = toSkip;
                toSkip = 0;
            }
            for (int t = start; t < nTuple; t++) {
                if (firstTuple) {
                    firstTuple = false;
                    toWrite = evaluateInteger(evalMaxObjects, t);
                    if (evalOffset != null) {
                        toSkip = evaluateInteger(evalOffset, t);
                    }
                }
                if (toSkip > 0) {
                    toSkip--;
                } else if (toWrite > 0) {
                    toWrite--;
                    if (projectionList != null) {
                        appendProjectionToFrame(t, projectionList);
                    } else {
                        appendTupleToFrame(t);
                    }
                } else {
                    afterLastTuple = true;
                    break;
                }
            }
        }

        @Override
        public void close() throws HyracksDataException {
            // how many tuples still to write
            toWrite = 0;
            // how many tuples still to skip
            toSkip = 0;
            firstTuple = true;
            afterLastTuple = false;
            super.close();
        }

        private int evaluateInteger(IScalarEvaluator eval, int tIdx) throws HyracksDataException {
            tRef.reset(tAccess, tIdx);
            eval.evaluate(tRef, p);
            int lim = bii.getIntegerValue(p.getByteArray(), p.getStartOffset(), p.getLength());
            return lim;
        }

        @Override
        public void flush() throws HyracksDataException {
            appender.flush(writer);
        }
    };
}