public AttributePathStepScalarEvaluator(IScalarEvaluator[] args, IHyracksTaskContext ctx) { super(args, ctx); rootTVP = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); enp = (ElementNodePointable) ElementNodePointable.FACTORY.createPointable(); }
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { final ObjectNode json = registry.getClassIdentifier(getClass(), serialVersionUID); json.set("pf", pf.toJson(registry)); return json; }
@Override public IPrimitiveValueProvider createPrimitiveValueProvider() { final IPointable p = pf.createPointable(); ITypeTraits traits = pf.getTypeTraits(); assert traits.isFixedLength(); final int length = traits.getFixedLength(); return new IPrimitiveValueProvider() { @Override public double getValue(byte[] bytes, int offset) { p.set(bytes, offset, length); return ((INumeric) p).doubleValue(); } }; }
@Override public IBinaryHashFunction createBinaryHashFunction() { final IPointable p = pf.createPointable(); return new IBinaryHashFunction() { @Override public int hash(byte[] bytes, int offset, int length) { p.set(bytes, offset, length); return ((IHashable) p).hash(); } }; } }
@Override public JsonNode toJson(IPersistedResourceRegistry registry) throws HyracksDataException { ObjectNode classIdentifier = registry.getClassIdentifier(getClass(), serialVersionUID); classIdentifier.set("pointableFactory", pf.toJson(registry)); return classIdentifier; }
public AbstractDescendantPathStepScalarEvaluator(IScalarEvaluator[] args, IHyracksTaskContext ctx) { super(args, ctx); dnp = (DocumentNodePointable) DocumentNodePointable.FACTORY.createPointable(); enp = (ElementNodePointable) ElementNodePointable.FACTORY.createPointable(); }
public AbstractTaggedValueArgumentScalarEvaluator(IScalarEvaluator[] args) { this.args = args; tvps = new TaggedValuePointable[args.length]; for (int i = 0; i < tvps.length; ++i) { tvps[i] = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); } }
@Override public IBinaryIntegerInspector createBinaryIntegerInspector(IHyracksTaskContext ctx) { final TaggedValuePointable tvp = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); final IntegerPointable ip = (IntegerPointable) IntegerPointable.FACTORY.createPointable(); return new IBinaryIntegerInspector() { @Override public int getIntegerValue(byte[] bytes, int offset, int length) { tvp.set(bytes, offset, length); assert tvp.getTag() == ValueTag.XS_INT_TAG; tvp.getValue(ip); return ip.getInteger(); } }; } }
@Override public INullWriter createNullWriter() { final VoidPointable vp = (VoidPointable) VoidPointable.FACTORY.createPointable(); return new INullWriter() { @Override public void writeNull(DataOutput out) throws HyracksDataException { XDMConstants.setEmptySequence(vp); try { out.write(vp.getByteArray(), vp.getStartOffset(), vp.getLength()); } catch (IOException e) { throw new HyracksDataException(e); } } }; } }
@Override public IBinaryBooleanInspector createBinaryBooleanInspector(IHyracksTaskContext ctx) { final TaggedValuePointable tvp = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); final BooleanPointable bp = (BooleanPointable) BooleanPointable.FACTORY.createPointable(); return new IBinaryBooleanInspector() { @Override public boolean getBooleanValue(byte[] bytes, int offset, int length) { tvp.set(bytes, offset, length); assert tvp.getTag() == ValueTag.XS_BOOLEAN_TAG; tvp.getValue(bp); return bp.getBoolean(); } }; } }
@Override public IBinaryComparator createBinaryComparator() { final IPointable p = pf.createPointable(); return new IBinaryComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { if (l1 == 0 && l2 != 0) return -1; if (l1 != 0 && l2 == 0) return 1; p.set(b1, s1, l1); return ((IComparable) p).compareTo(b2, s2, l2); } }; }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable(); return new AbstractTaggedValueArgumentScalarEvaluator(args) { @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable tvp = args[0]; if (tvp.getTag() == ValueTag.SEQUENCE_TAG) { tvp.getValue(seqp); if (seqp.getEntryCount() == 1) { result.set(tvp); } else { throw new SystemException(ErrorCode.FORG0005); } } else { result.set(tvp); } } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { return new AbstractTaggedValueArgumentScalarEvaluator(args) { private final BooleanPointable bp = (BooleanPointable) BooleanPointable.FACTORY.createPointable(); @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable arg = args[0]; arg.getValue(bp); if (bp.getBoolean()) { XDMConstants.setFalse(result); } else { XDMConstants.setTrue(result); } } }; } }
@Override public IBinaryComparator createBinaryComparator() { final TaggedValuePointable tvp1 = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); final TaggedValuePointable tvp2 = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); return new IBinaryComparator() { @Override public int compare(byte[] b1, int s1, int l1, byte[] b2, int s2, int l2) { tvp1.set(b1, s1, l1); tvp2.set(b2, s2, l2); for (int i = 0; i < l1 && i < l2; ++i) { if (b1[s1 + i] != b2[s2 + i]) { return b1[s1 + i] - b2[s2 + i]; } } return l1 - l2; } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable(); return new AbstractTaggedValueArgumentScalarEvaluator(args) { @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable tvp = args[0]; if (tvp.getTag() == ValueTag.SEQUENCE_TAG) { tvp.getValue(seqp); if (seqp.getEntryCount() == 0) { XDMConstants.setFalse(result); return; } } XDMConstants.setTrue(result); } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable(); return new AbstractTaggedValueArgumentScalarEvaluator(args) { @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable tvp = args[0]; if (tvp.getTag() == ValueTag.SEQUENCE_TAG) { tvp.getValue(seqp); if (seqp.getEntryCount() == 0) { XDMConstants.setTrue(result); return; } } XDMConstants.setFalse(result); } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable(); return new AbstractTaggedValueArgumentScalarEvaluator(args) { @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable tvp = args[0]; if (tvp.getTag() == ValueTag.SEQUENCE_TAG) { tvp.getValue(seqp); if (seqp.getEntryCount() > 0) { result.set(tvp); } else { throw new SystemException(ErrorCode.FORG0004); } } else { result.set(tvp); } } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) throws AlgebricksException { final SequencePointable seqp = (SequencePointable) SequencePointable.FACTORY.createPointable(); return new AbstractTaggedValueArgumentScalarEvaluator(args) { @Override protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException { TaggedValuePointable tvp = args[0]; if (tvp.getTag() == ValueTag.SEQUENCE_TAG) { tvp.getValue(seqp); if (seqp.getEntryCount() == 0 || seqp.getEntryCount() == 1) { result.set(tvp); } else { throw new SystemException(ErrorCode.FORG0003); } } else { result.set(tvp); } } }; } }
@Override protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, final IScalarEvaluator[] args) throws AlgebricksException { final TaggedValuePointable conditionTvp = (TaggedValuePointable) TaggedValuePointable.FACTORY.createPointable(); final BooleanPointable bp = (BooleanPointable) BooleanPointable.FACTORY.createPointable(); return new IScalarEvaluator() { @Override public void evaluate(IFrameTupleReference tuple, IPointable result) throws AlgebricksException { args[CONDITION].evaluate(tuple, conditionTvp); try { if (conditionTvp.getTag() != ValueTag.XS_BOOLEAN_TAG) { throw new SystemException(ErrorCode.FORG0006); } conditionTvp.getValue(bp); if (bp.getBoolean()) { args[TRUE_CONDITION].evaluate(tuple, result); } else { args[FALSE_CONDITION].evaluate(tuple, result); } } catch (SystemException e) { throw new AlgebricksException(e); } } }; } }
public AttributeNodeConstructorScalarEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args) { super(ctx, args); anb = new AttributeNodeBuilder(); namep = (XSQNamePointable) XSQNamePointable.FACTORY.createPointable(); strp = (UTF8StringPointable) UTF8StringPointable.FACTORY.createPointable(); }