You are viewing a plain text version of this content. The canonical link for it is here.
Posted to commits@vxquery.apache.org by pr...@apache.org on 2012/07/12 04:48:29 UTC
svn commit: r1360517 [1/2] - in
/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery:
functions/ runtime/functions/comparison/
Author: prestonc
Date: Thu Jul 12 02:48:28 2012
New Revision: 1360517
URL: http://svn.apache.org/viewvc?rev=1360517&view=rev
Log:
VXQUERY-42 The implementation for all supported type comparison for lt, le, gt, ge, eq and ne.
Added:
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLtComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLtComparisonScalarEvaluatorFactory.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueNeComparisonOperation.java (with props)
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueNeComparisonScalarEvaluatorFactory.java (with props)
Modified:
incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml
Modified: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml?rev=1360517&r1=1360516&r2=1360517&view=diff
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml (original)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/functions/builtin-operators.xml Thu Jul 12 02:48:28 2012
@@ -511,6 +511,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueEqComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:value-ne($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
@@ -518,6 +519,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueNeComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:value-lt($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
@@ -525,6 +527,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueLtComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:value-le($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
@@ -532,6 +535,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueLeComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:value-gt($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
@@ -539,6 +543,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueGtComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:value-ge($arg1 as xs:anyAtomicType?, $arg2 as xs:anyAtomicType?) as xs:boolean? -->
@@ -546,6 +551,7 @@
<param name="arg1" type="xs:anyAtomicType?"/>
<param name="arg2" type="xs:anyAtomicType?"/>
<return type="xs:boolean?"/>
+ <runtime type="scalar" class="org.apache.vxquery.runtime.functions.comparison.ValueGeComparisonScalarEvaluatorFactory"/>
</operator>
<!-- opext:general-eq($arg1 as item()*, $arg2 as item()*) as xs:boolean -->
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,203 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import org.apache.vxquery.context.DynamicContext;
+import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable;
+
+import edu.uci.ics.hyracks.data.std.primitive.BooleanPointable;
+import edu.uci.ics.hyracks.data.std.primitive.DoublePointable;
+import edu.uci.ics.hyracks.data.std.primitive.FloatPointable;
+import edu.uci.ics.hyracks.data.std.primitive.IntegerPointable;
+import edu.uci.ics.hyracks.data.std.primitive.LongPointable;
+import edu.uci.ics.hyracks.data.std.primitive.UTF8StringPointable;
+
+public abstract class AbstractDisjunctiveComparisonOperation extends AbstractValueComparisonOperation {
+ final AbstractValueComparisonOperation aOp1 = createBaseComparisonOperation1();
+ final AbstractValueComparisonOperation aOp2 = createBaseComparisonOperation2();
+
+ protected abstract AbstractValueComparisonOperation createBaseComparisonOperation1();
+
+ protected abstract AbstractValueComparisonOperation createBaseComparisonOperation2();
+
+ @Override
+ public boolean operateAnyURIAnyURI(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (aOp1.operateAnyURIAnyURI(stringp1, stringp2) || aOp2.operateAnyURIAnyURI(stringp1, stringp2));
+ }
+
+ @Override
+ public boolean operateBase64BinaryBase64Binary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2)
+ throws Exception {
+ return (aOp1.operateBase64BinaryBase64Binary(binaryp1, binaryp2) || aOp2.operateBase64BinaryBase64Binary(
+ binaryp1, binaryp2));
+ }
+
+ @Override
+ public boolean operateBooleanBoolean(BooleanPointable boolp1, BooleanPointable boolp2) throws Exception {
+ return (aOp1.operateBooleanBoolean(boolp1, boolp2) || aOp2.operateBooleanBoolean(boolp1, boolp2));
+ }
+
+ @Override
+ public boolean operateDateDate(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateDateDate(datep1, datep2, dCtx) || aOp2.operateDateDate(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateDatetimeDatetime(XSDateTimePointable datetimep1, XSDateTimePointable datetimep2, DynamicContext dCtx)
+ throws Exception {
+ return (aOp1.operateDatetimeDatetime(datetimep1, datetimep2, dCtx) || aOp2.operateDatetimeDatetime(datetimep1,
+ datetimep2, dCtx));
+ }
+
+ @Override
+ public boolean operateDecimalDecimal(XSDecimalPointable decp1, XSDecimalPointable decp2) throws Exception {
+ return (aOp1.operateDecimalDecimal(decp1, decp2) || aOp2.operateDecimalDecimal(decp1, decp2));
+ }
+
+ @Override
+ public boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws Exception {
+ return (aOp1.operateDecimalDouble(decp1, doublep2) || aOp2.operateDecimalDouble(decp1, doublep2));
+ }
+
+ @Override
+ public boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws Exception {
+ return (aOp1.operateDecimalFloat(decp1, floatp2) || aOp2.operateDecimalFloat(decp1, floatp2));
+ }
+
+ @Override
+ public boolean operateDecimalInteger(XSDecimalPointable decp1, LongPointable longp2) throws Exception {
+ return (aOp1.operateDecimalInteger(decp1, longp2) || aOp2.operateDecimalInteger(decp1, longp2));
+ }
+
+ @Override
+ public boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws Exception {
+ return (aOp1.operateDoubleDecimal(doublep1, decp2) || aOp2.operateDoubleDecimal(doublep1, decp2));
+ }
+
+ @Override
+ public boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws Exception {
+ return (aOp1.operateDoubleDouble(doublep1, doublep2) || aOp2.operateDoubleDouble(doublep1, doublep2));
+ }
+
+ @Override
+ public boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws Exception {
+ return (aOp1.operateDoubleFloat(doublep1, floatp2) || aOp2.operateDoubleFloat(doublep1, floatp2));
+ }
+
+ @Override
+ public boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws Exception {
+ return (aOp1.operateDoubleInteger(doublep1, longp2) || aOp2.operateDoubleInteger(doublep1, longp2));
+ }
+
+ @Override
+ public boolean operateDTDurationDTDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return (aOp1.operateDTDurationDTDuration(intp1, intp2) || aOp2.operateDTDurationDTDuration(intp1, intp2));
+ }
+
+ @Override
+ public boolean operateDurationDuration(XSDurationPointable durationp1, XSDurationPointable durationp2)
+ throws Exception {
+ return (aOp1.operateDurationDuration(durationp1, durationp2) || aOp2.operateDurationDuration(durationp1,
+ durationp2));
+ }
+
+ @Override
+ public boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws Exception {
+ return (aOp1.operateFloatDecimal(floatp1, decp2) || aOp2.operateFloatDecimal(floatp1, decp2));
+ }
+
+ @Override
+ public boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws Exception {
+ return (aOp1.operateFloatDouble(floatp1, doublep2) || aOp2.operateFloatDouble(floatp1, doublep2));
+ }
+
+ @Override
+ public boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws Exception {
+ return (aOp1.operateFloatFloat(floatp1, floatp2) || aOp2.operateFloatFloat(floatp1, floatp2));
+ }
+
+ @Override
+ public boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws Exception {
+ return (aOp1.operateFloatInteger(floatp1, longp2) || aOp2.operateFloatInteger(floatp1, longp2));
+ }
+
+ @Override
+ public boolean operateGDayGDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateGDayGDay(datep1, datep2, dCtx) || aOp2.operateGDayGDay(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateGMonthDayGMonthDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateGMonthDayGMonthDay(datep1, datep2, dCtx) || aOp2.operateGMonthDayGMonthDay(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateGMonthGMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateGMonthGMonth(datep1, datep2, dCtx) || aOp2.operateGMonthGMonth(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateGYearGYear(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateGYearGYear(datep1, datep2, dCtx) || aOp2.operateGYearGYear(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateGYearMonthGYearMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateGYearMonthGYearMonth(datep1, datep2, dCtx) || aOp2.operateGYearMonthGYearMonth(datep1, datep2, dCtx));
+ }
+
+ @Override
+ public boolean operateHexBinaryHexBinary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2) throws Exception {
+ return (aOp1.operateHexBinaryHexBinary(binaryp1, binaryp2) || aOp2
+ .operateHexBinaryHexBinary(binaryp1, binaryp2));
+ }
+
+ @Override
+ public boolean operateIntegerDecimal(LongPointable longp1, XSDecimalPointable decp2) throws Exception {
+ return (aOp1.operateIntegerDecimal(longp1, decp2) || aOp2.operateIntegerDecimal(longp1, decp2));
+ }
+
+ @Override
+ public boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws Exception {
+ return (aOp1.operateIntegerDouble(longp1, doublep2) || aOp2.operateIntegerDouble(longp1, doublep2));
+ }
+
+ @Override
+ public boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws Exception {
+ return (aOp1.operateIntegerFloat(longp1, floatp2) || aOp2.operateIntegerFloat(longp1, floatp2));
+ }
+
+ @Override
+ public boolean operateIntegerInteger(LongPointable longp1, LongPointable longp2) throws Exception {
+ return (aOp1.operateIntegerInteger(longp1, longp2) || aOp2.operateIntegerInteger(longp1, longp2));
+ }
+
+ @Override
+ public boolean operateNotationNotation(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (aOp1.operateNotationNotation(stringp1, stringp2) || aOp2.operateNotationNotation(stringp1, stringp2));
+ }
+
+ @Override
+ public boolean operateQNameQName(XSQNamePointable qnamep1, XSQNamePointable qnamep2) throws Exception {
+ return (aOp1.operateQNameQName(qnamep1, qnamep2) || aOp2.operateQNameQName(qnamep1, qnamep2));
+ }
+
+ @Override
+ public boolean operateStringString(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (aOp1.operateStringString(stringp1, stringp2) || aOp2.operateStringString(stringp1, stringp2));
+ }
+
+ @Override
+ public boolean operateTimeTime(XSTimePointable timep1, XSTimePointable timep2, DynamicContext dCtx) throws Exception {
+ return (aOp1.operateTimeTime(timep1, timep2, dCtx) || aOp2.operateTimeTime(timep1, timep2, dCtx));
+ }
+
+ @Override
+ public boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return (aOp1.operateYMDurationYMDuration(intp1, intp2) || aOp2.operateYMDurationYMDuration(intp1, intp2));
+ }
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractDisjunctiveComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,197 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import org.apache.vxquery.context.DynamicContext;
+import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable;
+
+import edu.uci.ics.hyracks.data.std.primitive.BooleanPointable;
+import edu.uci.ics.hyracks.data.std.primitive.DoublePointable;
+import edu.uci.ics.hyracks.data.std.primitive.FloatPointable;
+import edu.uci.ics.hyracks.data.std.primitive.IntegerPointable;
+import edu.uci.ics.hyracks.data.std.primitive.LongPointable;
+import edu.uci.ics.hyracks.data.std.primitive.UTF8StringPointable;
+
+public abstract class AbstractNegatingComparisonOperation extends AbstractValueComparisonOperation {
+ final AbstractValueComparisonOperation aOp = createBaseComparisonOperation();
+
+ protected abstract AbstractValueComparisonOperation createBaseComparisonOperation();
+
+ @Override
+ public boolean operateAnyURIAnyURI(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return !aOp.operateAnyURIAnyURI(stringp1, stringp2);
+ }
+
+ @Override
+ public boolean operateBase64BinaryBase64Binary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2)
+ throws Exception {
+ return !aOp.operateBase64BinaryBase64Binary(binaryp1, binaryp2);
+ }
+
+ @Override
+ public boolean operateBooleanBoolean(BooleanPointable boolp1, BooleanPointable boolp2) throws Exception {
+ return !aOp.operateBooleanBoolean(boolp1, boolp2);
+ }
+
+ @Override
+ public boolean operateDateDate(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateDatetimeDatetime(XSDateTimePointable datetimep1, XSDateTimePointable datetimep2, DynamicContext dCtx)
+ throws Exception {
+ return !aOp.operateDatetimeDatetime(datetimep1, datetimep2, dCtx);
+ }
+
+ @Override
+ public boolean operateDecimalDecimal(XSDecimalPointable decp1, XSDecimalPointable decp2) throws Exception {
+ return !aOp.operateDecimalDecimal(decp1, decp2);
+ }
+
+ @Override
+ public boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws Exception {
+ return !aOp.operateDecimalDouble(decp1, doublep2);
+ }
+
+ @Override
+ public boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws Exception {
+ return !aOp.operateDecimalFloat(decp1, floatp2);
+ }
+
+ @Override
+ public boolean operateDecimalInteger(XSDecimalPointable decp1, LongPointable longp2) throws Exception {
+ return !aOp.operateDecimalInteger(decp1, longp2);
+ }
+
+ @Override
+ public boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws Exception {
+ return !aOp.operateDoubleDecimal(doublep1, decp2);
+ }
+
+ @Override
+ public boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws Exception {
+ return !aOp.operateDoubleDouble(doublep1, doublep2);
+ }
+
+ @Override
+ public boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws Exception {
+ return !aOp.operateDoubleFloat(doublep1, floatp2);
+ }
+
+ @Override
+ public boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws Exception {
+ return !aOp.operateDoubleInteger(doublep1, longp2);
+ }
+
+ @Override
+ public boolean operateDTDurationDTDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return !aOp.operateDTDurationDTDuration(intp1, intp2);
+ }
+
+ @Override
+ public boolean operateDurationDuration(XSDurationPointable durationp1, XSDurationPointable durationp2)
+ throws Exception {
+ return !aOp.operateDurationDuration(durationp1, durationp2);
+ }
+
+ @Override
+ public boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws Exception {
+ return !aOp.operateFloatDecimal(floatp1, decp2);
+ }
+
+ @Override
+ public boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws Exception {
+ return !aOp.operateFloatDouble(floatp1, doublep2);
+ }
+
+ @Override
+ public boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws Exception {
+ return !aOp.operateFloatFloat(floatp1, floatp2);
+ }
+
+ @Override
+ public boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws Exception {
+ return !aOp.operateFloatInteger(floatp1, longp2);
+ }
+
+ @Override
+ public boolean operateGDayGDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateGDayGDay(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGMonthDayGMonthDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateGMonthDayGMonthDay(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGMonthGMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateGMonthGMonth(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGYearGYear(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateGYearGYear(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGYearMonthGYearMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateGYearMonthGYearMonth(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateHexBinaryHexBinary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2) throws Exception {
+ return !aOp.operateHexBinaryHexBinary(binaryp1, binaryp2);
+ }
+
+ @Override
+ public boolean operateIntegerDecimal(LongPointable longp1, XSDecimalPointable decp2) throws Exception {
+ return !aOp.operateIntegerDecimal(longp1, decp2);
+ }
+
+ @Override
+ public boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws Exception {
+ return !aOp.operateIntegerDouble(longp1, doublep2);
+ }
+
+ @Override
+ public boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws Exception {
+ return !aOp.operateIntegerFloat(longp1, floatp2);
+ }
+
+ @Override
+ public boolean operateIntegerInteger(LongPointable longp1, LongPointable longp2) throws Exception {
+ return !aOp.operateIntegerInteger(longp1, longp2);
+ }
+
+ @Override
+ public boolean operateNotationNotation(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return !aOp.operateNotationNotation(stringp1, stringp2);
+ }
+
+ @Override
+ public boolean operateQNameQName(XSQNamePointable qnamep1, XSQNamePointable qnamep2) throws Exception {
+ return !aOp.operateQNameQName(qnamep1, qnamep2);
+ }
+
+ @Override
+ public boolean operateStringString(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return !aOp.operateStringString(stringp1, stringp2);
+ }
+
+ @Override
+ public boolean operateTimeTime(XSTimePointable timep1, XSTimePointable timep2, DynamicContext dCtx) throws Exception {
+ return !aOp.operateTimeTime(timep1, timep2, dCtx);
+ }
+
+ @Override
+ public boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return !aOp.operateYMDurationYMDuration(intp1, intp2);
+ }
+
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractNegatingComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,103 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import org.apache.vxquery.context.DynamicContext;
+import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable;
+
+import edu.uci.ics.hyracks.data.std.primitive.BooleanPointable;
+import edu.uci.ics.hyracks.data.std.primitive.DoublePointable;
+import edu.uci.ics.hyracks.data.std.primitive.FloatPointable;
+import edu.uci.ics.hyracks.data.std.primitive.IntegerPointable;
+import edu.uci.ics.hyracks.data.std.primitive.LongPointable;
+import edu.uci.ics.hyracks.data.std.primitive.UTF8StringPointable;
+
+public abstract class AbstractValueComparisonOperation {
+ public abstract boolean operateAnyURIAnyURI(UTF8StringPointable stringp, UTF8StringPointable stringp2)
+ throws Exception;
+
+ public abstract boolean operateBase64BinaryBase64Binary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2)
+ throws Exception;
+
+ public abstract boolean operateBooleanBoolean(BooleanPointable boolp1, BooleanPointable boolp2) throws Exception;
+
+ public abstract boolean operateDateDate(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception;
+
+ public abstract boolean operateDatetimeDatetime(XSDateTimePointable datetimep1, XSDateTimePointable datetimep2,
+ DynamicContext dCtx) throws Exception;
+
+ public abstract boolean operateDecimalDecimal(XSDecimalPointable decp1, XSDecimalPointable decp2) throws Exception;
+
+ public abstract boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws Exception;
+
+ public abstract boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws Exception;
+
+ public abstract boolean operateDecimalInteger(XSDecimalPointable decp1, LongPointable longp2) throws Exception;
+
+ public abstract boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws Exception;
+
+ public abstract boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws Exception;
+
+ public abstract boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws Exception;
+
+ public abstract boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws Exception;
+
+ public abstract boolean operateDTDurationDTDuration(IntegerPointable intp1, IntegerPointable intp2)
+ throws Exception;
+
+ public abstract boolean operateDurationDuration(XSDurationPointable durationp1, XSDurationPointable durationp2)
+ throws Exception;
+
+ public abstract boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws Exception;
+
+ public abstract boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws Exception;
+
+ public abstract boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws Exception;
+
+ public abstract boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws Exception;
+
+ public abstract boolean operateGDayGDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception;
+
+ public abstract boolean operateGMonthDayGMonthDay(XSDatePointable datep1, XSDatePointable datep2,
+ DynamicContext dCtx) throws Exception;
+
+ public abstract boolean operateGMonthGMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception;
+
+ public abstract boolean operateGYearGYear(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception;
+
+ public abstract boolean operateGYearMonthGYearMonth(XSDatePointable datep1, XSDatePointable datep2,
+ DynamicContext dCtx) throws Exception;
+
+ public abstract boolean operateHexBinaryHexBinary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2)
+ throws Exception;
+
+ public abstract boolean operateIntegerDecimal(LongPointable longp1, XSDecimalPointable decp2) throws Exception;
+
+ public abstract boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws Exception;
+
+ public abstract boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws Exception;
+
+ public abstract boolean operateIntegerInteger(LongPointable longp1, LongPointable longp2) throws Exception;
+
+ public abstract boolean operateNotationNotation(UTF8StringPointable stringp1, UTF8StringPointable stringp2)
+ throws Exception;
+
+ public abstract boolean operateQNameQName(XSQNamePointable qnamep1, XSQNamePointable qnamep2) throws Exception;
+
+ public abstract boolean operateStringString(UTF8StringPointable stringp1, UTF8StringPointable stringp2)
+ throws Exception;
+
+ public abstract boolean operateTimeTime(XSTimePointable timep1, XSTimePointable timep2, DynamicContext dCtx)
+ throws Exception;
+
+ public abstract boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2)
+ throws Exception;
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,433 @@
+/*
+* Licensed to the Apache Software Foundation (ASF) under one or more
+* contributor license agreements. See the NOTICE file distributed with
+* this work for additional information regarding copyright ownership.
+* The ASF licenses this file to You under the Apache License, Version 2.0
+* (the "License"); you may not use this file except in compliance with
+* the License. You may obtain a copy of the License at
+*
+* http://www.apache.org/licenses/LICENSE-2.0
+*
+* Unless required by applicable law or agreed to in writing, software
+* distributed under the License is distributed on an "AS IS" BASIS,
+* WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+* See the License for the specific language governing permissions and
+* limitations under the License.
+*/
+package org.apache.vxquery.runtime.functions.comparison;
+
+import org.apache.vxquery.context.DynamicContext;
+import org.apache.vxquery.datamodel.accessors.TaggedValuePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable;
+import org.apache.vxquery.datamodel.values.ValueTag;
+import org.apache.vxquery.exceptions.ErrorCode;
+import org.apache.vxquery.exceptions.SystemException;
+import org.apache.vxquery.runtime.functions.base.AbstractTaggedValueArgumentScalarEvaluator;
+import org.apache.vxquery.runtime.functions.base.AbstractTaggedValueArgumentScalarEvaluatorFactory;
+import org.apache.vxquery.types.BuiltinTypeRegistry;
+
+import edu.uci.ics.hyracks.algebricks.common.exceptions.AlgebricksException;
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluator;
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
+import edu.uci.ics.hyracks.api.context.IHyracksTaskContext;
+import edu.uci.ics.hyracks.data.std.api.IPointable;
+import edu.uci.ics.hyracks.data.std.primitive.BooleanPointable;
+import edu.uci.ics.hyracks.data.std.primitive.BytePointable;
+import edu.uci.ics.hyracks.data.std.primitive.DoublePointable;
+import edu.uci.ics.hyracks.data.std.primitive.FloatPointable;
+import edu.uci.ics.hyracks.data.std.primitive.IntegerPointable;
+import edu.uci.ics.hyracks.data.std.primitive.LongPointable;
+import edu.uci.ics.hyracks.data.std.primitive.ShortPointable;
+import edu.uci.ics.hyracks.data.std.primitive.UTF8StringPointable;
+
+public abstract class AbstractValueComparisonScalarEvaluatorFactory extends
+ AbstractTaggedValueArgumentScalarEvaluatorFactory {
+ private static final long serialVersionUID = 1L;
+
+ public AbstractValueComparisonScalarEvaluatorFactory(IScalarEvaluatorFactory[] args) {
+ super(args);
+ }
+
+ @Override
+ protected IScalarEvaluator createEvaluator(IHyracksTaskContext ctx, IScalarEvaluator[] args)
+ throws AlgebricksException {
+ final AbstractValueComparisonOperation aOp = createValueComparisonOperation();
+ final TypedPointables tp1 = new TypedPointables();
+ final TypedPointables tp2 = new TypedPointables();
+ final DynamicContext dCtx = (DynamicContext) ctx.getJobletContext().getGlobalJobData();
+
+ return new AbstractTaggedValueArgumentScalarEvaluator(args) {
+ @Override
+ protected void evaluate(TaggedValuePointable[] args, IPointable result) throws SystemException {
+ boolean booleanResult = false;
+ TaggedValuePointable tvp1 = args[0];
+ TaggedValuePointable tvp2 = args[1];
+ int tid1 = getBaseTypeForComparisons(tvp1.getTag());
+ int tid2 = getBaseTypeForComparisons(tvp2.getTag());
+ if (tid1 == ValueTag.XS_UNTYPED_ATOMIC_TAG) {
+ // TODO Convert to double
+ tid1 = ValueTag.XS_DOUBLE_TAG;
+ throw new UnsupportedOperationException();
+ }
+ if (tid2 == ValueTag.XS_UNTYPED_ATOMIC_TAG) {
+ // TODO Convert to double
+ tid2 = ValueTag.XS_DOUBLE_TAG;
+ throw new UnsupportedOperationException();
+ }
+ try {
+ switch (tid1) {
+ case ValueTag.XS_DECIMAL_TAG:
+ tvp1.getValue(tp1.decp);
+ switch (tid2) {
+ case ValueTag.XS_DECIMAL_TAG:
+ tvp2.getValue(tp2.decp);
+ booleanResult = aOp.operateDecimalDecimal(tp1.decp, tp2.decp);
+ break;
+
+ case ValueTag.XS_INTEGER_TAG:
+ tvp2.getValue(tp2.longp);
+ booleanResult = aOp.operateDecimalInteger(tp1.decp, tp2.longp);
+ break;
+
+ case ValueTag.XS_FLOAT_TAG:
+ tvp2.getValue(tp2.floatp);
+ booleanResult = aOp.operateDecimalFloat(tp1.decp, tp2.floatp);
+ break;
+
+ case ValueTag.XS_DOUBLE_TAG:
+ tvp2.getValue(tp2.doublep);
+ booleanResult = aOp.operateDecimalDouble(tp1.decp, tp2.doublep);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_INTEGER_TAG:
+ tvp1.getValue(tp1.longp);
+ switch (tid2) {
+ case ValueTag.XS_DECIMAL_TAG:
+ tvp2.getValue(tp2.decp);
+ booleanResult = aOp.operateIntegerDecimal(tp1.longp, tp2.decp);
+ break;
+
+ case ValueTag.XS_INTEGER_TAG:
+ tvp2.getValue(tp2.longp);
+ booleanResult = aOp.operateIntegerInteger(tp1.longp, tp2.longp);
+ break;
+
+ case ValueTag.XS_FLOAT_TAG:
+ tvp2.getValue(tp2.floatp);
+ booleanResult = aOp.operateIntegerFloat(tp1.longp, tp2.floatp);
+ break;
+
+ case ValueTag.XS_DOUBLE_TAG:
+ tvp2.getValue(tp2.doublep);
+ booleanResult = aOp.operateIntegerDouble(tp1.longp, tp2.doublep);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_FLOAT_TAG:
+ tvp1.getValue(tp1.floatp);
+ switch (tid2) {
+ case ValueTag.XS_DECIMAL_TAG:
+ tvp2.getValue(tp2.decp);
+ booleanResult = aOp.operateFloatDecimal(tp1.floatp, tp2.decp);
+ break;
+
+ case ValueTag.XS_INTEGER_TAG:
+ tvp2.getValue(tp2.longp);
+ booleanResult = aOp.operateFloatInteger(tp1.floatp, tp2.longp);
+ break;
+
+ case ValueTag.XS_FLOAT_TAG:
+ tvp2.getValue(tp2.floatp);
+ booleanResult = aOp.operateFloatFloat(tp1.floatp, tp2.floatp);
+ break;
+
+ case ValueTag.XS_DOUBLE_TAG:
+ tvp2.getValue(tp2.doublep);
+ booleanResult = aOp.operateFloatDouble(tp1.floatp, tp2.doublep);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_DOUBLE_TAG:
+ tvp1.getValue(tp1.doublep);
+ switch (tid2) {
+ case ValueTag.XS_DECIMAL_TAG:
+ tvp2.getValue(tp2.decp);
+ booleanResult = aOp.operateDoubleDecimal(tp1.doublep, tp2.decp);
+ break;
+
+ case ValueTag.XS_INTEGER_TAG:
+ tvp2.getValue(tp2.longp);
+ booleanResult = aOp.operateDoubleInteger(tp1.doublep, tp2.longp);
+ break;
+
+ case ValueTag.XS_FLOAT_TAG:
+ tvp2.getValue(tp2.floatp);
+ booleanResult = aOp.operateDoubleFloat(tp1.doublep, tp2.floatp);
+ break;
+
+ case ValueTag.XS_DOUBLE_TAG:
+ tvp2.getValue(tp2.doublep);
+ booleanResult = aOp.operateDoubleDouble(tp1.doublep, tp2.doublep);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_BOOLEAN_TAG:
+ tvp1.getValue(tp1.boolp);
+ switch (tid2) {
+ case ValueTag.XS_BOOLEAN_TAG:
+ tvp2.getValue(tp2.boolp);
+ booleanResult = aOp.operateBooleanBoolean(tp1.boolp, tp2.boolp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_STRING_TAG:
+ tvp1.getValue(tp1.utf8sp);
+ switch (tid2) {
+ case ValueTag.XS_STRING_TAG:
+ tvp2.getValue(tp2.utf8sp);
+ booleanResult = aOp.operateStringString(tp1.utf8sp, tp2.utf8sp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_DATE_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_DATE_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateDateDate(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_DATETIME_TAG:
+ tvp1.getValue(tp1.datetimep);
+ switch (tid2) {
+ case ValueTag.XS_DATETIME_TAG:
+ tvp2.getValue(tp2.datetimep);
+ booleanResult = aOp.operateDatetimeDatetime(tp1.datetimep, tp2.datetimep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_TIME_TAG:
+ tvp1.getValue(tp1.timep);
+ switch (tid2) {
+ case ValueTag.XS_TIME_TAG:
+ tvp2.getValue(tp2.timep);
+ booleanResult = aOp.operateTimeTime(tp1.timep, tp2.timep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_DURATION_TAG:
+ tvp1.getValue(tp1.durationp);
+ switch (tid2) {
+ case ValueTag.XS_DURATION_TAG:
+ tvp2.getValue(tp2.durationp);
+ booleanResult = aOp.operateDurationDuration(tp1.durationp, tp2.durationp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_DAY_TIME_DURATION_TAG:
+ tvp1.getValue(tp1.intp);
+ switch (tid2) {
+ case ValueTag.XS_DAY_TIME_DURATION_TAG:
+ tvp2.getValue(tp2.intp);
+ booleanResult = aOp.operateDTDurationDTDuration(tp1.intp, tp2.intp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_YEAR_MONTH_DURATION_TAG:
+ tvp1.getValue(tp1.intp);
+ switch (tid2) {
+ case ValueTag.XS_YEAR_MONTH_DURATION_TAG:
+ tvp2.getValue(tp2.intp);
+ booleanResult = aOp.operateYMDurationYMDuration(tp1.intp, tp2.intp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_G_DAY_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_G_DAY_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateGDayGDay(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_G_MONTH_DAY_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_G_MONTH_DAY_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateGMonthDayGMonthDay(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_G_MONTH_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_G_MONTH_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateGMonthGMonth(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_G_YEAR_MONTH_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_G_YEAR_MONTH_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateGYearMonthGYearMonth(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_G_YEAR_TAG:
+ tvp1.getValue(tp1.datep);
+ switch (tid2) {
+ case ValueTag.XS_G_YEAR_TAG:
+ tvp2.getValue(tp2.datep);
+ booleanResult = aOp.operateGYearGYear(tp1.datep, tp2.datep, dCtx);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_HEX_BINARY_TAG:
+ tvp1.getValue(tp1.binaryp);
+ switch (tid2) {
+ case ValueTag.XS_HEX_BINARY_TAG:
+ tvp2.getValue(tp2.binaryp);
+ booleanResult = aOp.operateHexBinaryHexBinary(tp1.binaryp, tp2.binaryp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_BASE64_BINARY_TAG:
+ tvp1.getValue(tp1.binaryp);
+ switch (tid2) {
+ case ValueTag.XS_BASE64_BINARY_TAG:
+ tvp2.getValue(tp2.binaryp);
+ booleanResult = aOp.operateBase64BinaryBase64Binary(tp1.binaryp, tp2.binaryp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_ANY_URI_TAG:
+ tvp1.getValue(tp1.utf8sp);
+ switch (tid2) {
+ case ValueTag.XS_ANY_URI_TAG:
+ tvp2.getValue(tp2.utf8sp);
+ booleanResult = aOp.operateAnyURIAnyURI(tp1.utf8sp, tp2.utf8sp);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_QNAME_TAG:
+ tvp1.getValue(tp1.qnamep);
+ switch (tid2) {
+ case ValueTag.XS_QNAME_TAG:
+ tvp2.getValue(tp2.qnamep);
+ booleanResult = aOp.operateQNameQName(tp1.qnamep, tp2.qnamep);
+ break;
+ }
+ break;
+
+ case ValueTag.XS_NOTATION_TAG:
+ tvp1.getValue(tp1.utf8sp);
+ switch (tid2) {
+ case ValueTag.XS_NOTATION_TAG:
+ tvp2.getValue(tp2.utf8sp);
+ booleanResult = aOp.operateNotationNotation(tp1.utf8sp, tp2.utf8sp);
+ break;
+ }
+ break;
+ }
+
+ byte[] byteResult = new byte[2];
+ byteResult[0] = ValueTag.XS_BOOLEAN_TAG;
+ byteResult[1] = (byte) (booleanResult ? 1 : 0);
+ result.set(byteResult, 0, 2);
+ } catch (SystemException se) {
+ throw se;
+ } catch (Exception e) {
+ throw new SystemException(ErrorCode.SYSE0001, e);
+ }
+ }
+
+ private int getBaseTypeForComparisons(int tid) throws SystemException {
+ while (true) {
+ switch (tid) {
+ case ValueTag.XS_STRING_TAG:
+ case ValueTag.XS_DECIMAL_TAG:
+ case ValueTag.XS_INTEGER_TAG:
+ case ValueTag.XS_FLOAT_TAG:
+ case ValueTag.XS_DOUBLE_TAG:
+ case ValueTag.XS_ANY_URI_TAG:
+ case ValueTag.XS_BOOLEAN_TAG:
+ case ValueTag.XS_DATE_TAG:
+ case ValueTag.XS_DATETIME_TAG:
+ case ValueTag.XS_TIME_TAG:
+ case ValueTag.XS_DAY_TIME_DURATION_TAG:
+ case ValueTag.XS_YEAR_MONTH_DURATION_TAG:
+ case ValueTag.XS_BASE64_BINARY_TAG:
+ case ValueTag.XS_HEX_BINARY_TAG:
+ case ValueTag.XS_QNAME_TAG:
+ case ValueTag.XS_G_DAY_TAG:
+ case ValueTag.XS_G_MONTH_DAY_TAG:
+ case ValueTag.XS_G_MONTH_TAG:
+ case ValueTag.XS_G_YEAR_MONTH_TAG:
+ case ValueTag.XS_G_YEAR_TAG:
+ case ValueTag.XS_UNTYPED_ATOMIC_TAG:
+ return tid;
+
+ case ValueTag.XS_ANY_ATOMIC_TAG:
+ throw new SystemException(ErrorCode.XPTY0004);
+
+ default:
+ tid = BuiltinTypeRegistry.INSTANCE.getSchemaTypeById(tid).getBaseType().getTypeId();
+ }
+ }
+ }
+ };
+ }
+
+ private static class TypedPointables {
+ BooleanPointable boolp = (BooleanPointable) BooleanPointable.FACTORY.createPointable();
+ BytePointable bytep = (BytePointable) BytePointable.FACTORY.createPointable();
+ ShortPointable shortp = (ShortPointable) ShortPointable.FACTORY.createPointable();
+ IntegerPointable intp = (IntegerPointable) IntegerPointable.FACTORY.createPointable();
+ LongPointable longp = (LongPointable) LongPointable.FACTORY.createPointable();
+ FloatPointable floatp = (FloatPointable) FloatPointable.FACTORY.createPointable();
+ DoublePointable doublep = (DoublePointable) DoublePointable.FACTORY.createPointable();
+ UTF8StringPointable utf8sp = (UTF8StringPointable) UTF8StringPointable.FACTORY.createPointable();
+ XSBinaryPointable binaryp = (XSBinaryPointable) XSBinaryPointable.FACTORY.createPointable();
+ XSDatePointable datep = (XSDatePointable) XSDatePointable.FACTORY.createPointable();
+ XSDateTimePointable datetimep = (XSDateTimePointable) XSDateTimePointable.FACTORY.createPointable();
+ XSDecimalPointable decp = (XSDecimalPointable) XSDecimalPointable.FACTORY.createPointable();
+ XSDurationPointable durationp = (XSDurationPointable) XSDurationPointable.FACTORY.createPointable();
+ XSTimePointable timep = (XSTimePointable) XSTimePointable.FACTORY.createPointable();
+ XSQNamePointable qnamep = (XSQNamePointable) XSQNamePointable.FACTORY.createPointable();
+ }
+
+ protected abstract AbstractValueComparisonOperation createValueComparisonOperation();
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:eol-style = native
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/AbstractValueComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:executable = *
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,264 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import java.io.DataOutput;
+import java.util.Arrays;
+
+import org.apache.vxquery.context.DynamicContext;
+import org.apache.vxquery.datamodel.accessors.atomic.XSBinaryPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDatePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDateTimePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDecimalPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSDurationPointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSQNamePointable;
+import org.apache.vxquery.datamodel.accessors.atomic.XSTimePointable;
+import org.apache.vxquery.datamodel.util.DateTime;
+
+import edu.uci.ics.hyracks.data.std.primitive.BooleanPointable;
+import edu.uci.ics.hyracks.data.std.primitive.DoublePointable;
+import edu.uci.ics.hyracks.data.std.primitive.FloatPointable;
+import edu.uci.ics.hyracks.data.std.primitive.IntegerPointable;
+import edu.uci.ics.hyracks.data.std.primitive.LongPointable;
+import edu.uci.ics.hyracks.data.std.primitive.UTF8StringPointable;
+import edu.uci.ics.hyracks.dataflow.common.data.accessors.ArrayBackedValueStorage;
+
+public class ValueEqComparisonOperation extends AbstractValueComparisonOperation {
+ protected final ArrayBackedValueStorage abvs = new ArrayBackedValueStorage();
+ protected final DataOutput dOut = abvs.getDataOutput();
+
+ @Override
+ public boolean operateAnyURIAnyURI(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (stringp1.compareTo(stringp2) == 0);
+ }
+
+ @Override
+ public boolean operateBase64BinaryBase64Binary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2)
+ throws Exception {
+ return Arrays.equals(binaryp1.getByteArray(), binaryp2.getByteArray());
+ }
+
+ @Override
+ public boolean operateBooleanBoolean(BooleanPointable boolp1, BooleanPointable boolp2) throws Exception {
+ return (boolp1.compareTo(boolp2) == 0);
+ }
+
+ @Override
+ public boolean operateDateDate(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ abvs.reset();
+ DateTime.getTimezoneDateTime(datep1, dCtx, dOut);
+ byte[] bytes1 = abvs.getByteArray();
+
+ abvs.reset();
+ DateTime.getTimezoneDateTime(datep2, dCtx, dOut);
+ byte[] bytes2 = abvs.getByteArray();
+
+ if (XSDateTimePointable.getYearMonth(bytes1, 0) == XSDateTimePointable.getYearMonth(bytes2, 0)
+ && XSDateTimePointable.getDayTime(bytes1, 0) == XSDateTimePointable.getDayTime(bytes2, 0)) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean operateDatetimeDatetime(XSDateTimePointable datetimep1, XSDateTimePointable datetimep2,
+ DynamicContext dCtx) throws Exception {
+ abvs.reset();
+ DateTime.getTimezoneDateTime(datetimep1, dCtx, dOut);
+ byte[] bytes1 = abvs.getByteArray();
+
+ abvs.reset();
+ DateTime.getTimezoneDateTime(datetimep2, dCtx, dOut);
+ byte[] bytes2 = abvs.getByteArray();
+
+ if (XSDateTimePointable.getYearMonth(bytes1, 0) == XSDateTimePointable.getYearMonth(bytes2, 0)
+ && XSDateTimePointable.getDayTime(bytes1, 0) == XSDateTimePointable.getDayTime(bytes2, 0)) {
+ return true;
+ }
+ return false;
+ }
+
+ @Override
+ public boolean operateDecimalDecimal(XSDecimalPointable decp1, XSDecimalPointable decp2) throws Exception {
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateDecimalDouble(XSDecimalPointable decp1, DoublePointable doublep2) throws Exception {
+ XSDecimalPointable decp2 = new XSDecimalPointable();
+ decp2.setDecimal(doublep2.doubleValue());
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateDecimalFloat(XSDecimalPointable decp1, FloatPointable floatp2) throws Exception {
+ XSDecimalPointable decp2 = new XSDecimalPointable();
+ decp2.setDecimal(floatp2.doubleValue());
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateDecimalInteger(XSDecimalPointable decp1, LongPointable longp2) throws Exception {
+ XSDecimalPointable decp2 = new XSDecimalPointable();
+ decp2.setDecimal(longp2.getLong(), (byte) 0);
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateDoubleDecimal(DoublePointable doublep1, XSDecimalPointable decp2) throws Exception {
+ double double1 = doublep1.doubleValue();
+ double double2 = decp2.doubleValue();
+ return (double1 == double2);
+ }
+
+ @Override
+ public boolean operateDoubleDouble(DoublePointable doublep1, DoublePointable doublep2) throws Exception {
+ return (doublep1.compareTo(doublep2) == 0);
+ }
+
+ @Override
+ public boolean operateDoubleFloat(DoublePointable doublep1, FloatPointable floatp2) throws Exception {
+ double double1 = doublep1.doubleValue();
+ double double2 = floatp2.doubleValue();
+ return (double1 == double2);
+ }
+
+ @Override
+ public boolean operateDoubleInteger(DoublePointable doublep1, LongPointable longp2) throws Exception {
+ double double1 = doublep1.doubleValue();
+ double double2 = longp2.doubleValue();
+ return (double1 == double2);
+ }
+
+ @Override
+ public boolean operateDTDurationDTDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return (intp1.compareTo(intp2) == 0);
+ }
+
+ @Override
+ public boolean operateDurationDuration(XSDurationPointable durationp1, XSDurationPointable durationp2)
+ throws Exception {
+ return Arrays.equals(durationp1.getByteArray(), durationp2.getByteArray());
+ }
+
+ @Override
+ public boolean operateFloatDecimal(FloatPointable floatp1, XSDecimalPointable decp2) throws Exception {
+ XSDecimalPointable decp1 = new XSDecimalPointable();
+ decp1.setDecimal(floatp1.doubleValue());
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateFloatDouble(FloatPointable floatp1, DoublePointable doublep2) throws Exception {
+ double double1 = floatp1.doubleValue();
+ double double2 = doublep2.doubleValue();
+ return (double1 == double2);
+ }
+
+ @Override
+ public boolean operateFloatFloat(FloatPointable floatp1, FloatPointable floatp2) throws Exception {
+ return (floatp1.compareTo(floatp2) == 0);
+ }
+
+ @Override
+ public boolean operateFloatInteger(FloatPointable floatp1, LongPointable longp2) throws Exception {
+ float float1 = floatp1.floatValue();
+ float float2 = longp2.floatValue();
+ return (float1 == float2);
+ }
+
+ @Override
+ public boolean operateGDayGDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ return operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGMonthDayGMonthDay(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ return operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGMonthGMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ return operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGYearGYear(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ return operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateGYearMonthGYearMonth(XSDatePointable datep1, XSDatePointable datep2, DynamicContext dCtx)
+ throws Exception {
+ return operateDateDate(datep1, datep2, dCtx);
+ }
+
+ @Override
+ public boolean operateHexBinaryHexBinary(XSBinaryPointable binaryp1, XSBinaryPointable binaryp2) throws Exception {
+ return Arrays.equals(binaryp1.getByteArray(), binaryp2.getByteArray());
+ }
+
+ @Override
+ public boolean operateIntegerDecimal(LongPointable longp1, XSDecimalPointable decp2) throws Exception {
+ XSDecimalPointable decp1 = new XSDecimalPointable();
+ decp1.setDecimal(longp1.getLong(), (byte) 0);
+ return (decp1.compareTo(decp2) == 0);
+ }
+
+ @Override
+ public boolean operateIntegerDouble(LongPointable longp1, DoublePointable doublep2) throws Exception {
+ double double1 = longp1.doubleValue();
+ double double2 = doublep2.doubleValue();
+ return (double1 == double2);
+ }
+
+ @Override
+ public boolean operateIntegerFloat(LongPointable longp1, FloatPointable floatp2) throws Exception {
+ float float1 = longp1.floatValue();
+ float float2 = floatp2.floatValue();
+ return (float1 == float2);
+ }
+
+ @Override
+ public boolean operateIntegerInteger(LongPointable longp1, LongPointable longp2) throws Exception {
+ return (longp1.compareTo(longp2) == 0);
+ }
+
+ @Override
+ public boolean operateNotationNotation(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (stringp1.compareTo(stringp2) == 0);
+ }
+
+ @Override
+ public boolean operateQNameQName(XSQNamePointable qnamep1, XSQNamePointable qnamep2) throws Exception {
+ return Arrays.equals(qnamep1.getByteArray(), qnamep2.getByteArray());
+ }
+
+ @Override
+ public boolean operateStringString(UTF8StringPointable stringp1, UTF8StringPointable stringp2) throws Exception {
+ return (stringp1.compareTo(stringp2) == 0);
+ }
+
+ @Override
+ public boolean operateTimeTime(XSTimePointable timep1, XSTimePointable timep2, DynamicContext dCtx)
+ throws Exception {
+ abvs.reset();
+ DateTime.getTimezoneDateTime(timep1, dCtx, dOut);
+ byte[] bytes1 = abvs.getByteArray();
+
+ abvs.reset();
+ DateTime.getTimezoneDateTime(timep2, dCtx, dOut);
+ byte[] bytes2 = abvs.getByteArray();
+
+ return XSDateTimePointable.getDayTime(bytes1, 0) == XSDateTimePointable.getDayTime(bytes2, 0);
+ }
+
+ @Override
+ public boolean operateYMDurationYMDuration(IntegerPointable intp1, IntegerPointable intp2) throws Exception {
+ return (intp1.compareTo(intp2) == 0);
+ }
+
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,16 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
+
+public class ValueEqComparisonScalarEvaluatorFactory extends AbstractValueComparisonScalarEvaluatorFactory {
+ private static final long serialVersionUID = 1L;
+
+ public ValueEqComparisonScalarEvaluatorFactory(IScalarEvaluatorFactory[] args) {
+ super(args);
+ }
+
+ @Override
+ protected AbstractValueComparisonOperation createValueComparisonOperation() {
+ return new ValueEqComparisonOperation();
+ }
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueEqComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,11 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+
+public class ValueGeComparisonOperation extends AbstractNegatingComparisonOperation {
+
+ @Override
+ protected AbstractValueComparisonOperation createBaseComparisonOperation() {
+ return new ValueLtComparisonOperation();
+ }
+
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,16 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
+
+public class ValueGeComparisonScalarEvaluatorFactory extends AbstractValueComparisonScalarEvaluatorFactory {
+ private static final long serialVersionUID = 1L;
+
+ public ValueGeComparisonScalarEvaluatorFactory(IScalarEvaluatorFactory[] args) {
+ super(args);
+ }
+
+ @Override
+ protected AbstractValueComparisonOperation createValueComparisonOperation() {
+ return new ValueGeComparisonOperation();
+ }
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGeComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,11 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+
+public class ValueGtComparisonOperation extends AbstractNegatingComparisonOperation {
+
+ @Override
+ protected AbstractValueComparisonOperation createBaseComparisonOperation() {
+ return new ValueLeComparisonOperation();
+ }
+
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,16 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
+
+public class ValueGtComparisonScalarEvaluatorFactory extends AbstractValueComparisonScalarEvaluatorFactory {
+ private static final long serialVersionUID = 1L;
+
+ public ValueGtComparisonScalarEvaluatorFactory(IScalarEvaluatorFactory[] args) {
+ super(args);
+ }
+
+ @Override
+ protected AbstractValueComparisonOperation createValueComparisonOperation() {
+ return new ValueGtComparisonOperation();
+ }
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueGtComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,16 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+
+public class ValueLeComparisonOperation extends AbstractDisjunctiveComparisonOperation {
+
+ @Override
+ protected AbstractValueComparisonOperation createBaseComparisonOperation1() {
+ return new ValueLtComparisonOperation();
+ }
+
+ @Override
+ protected AbstractValueComparisonOperation createBaseComparisonOperation2() {
+ return new ValueEqComparisonOperation();
+ }
+
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonOperation.java
------------------------------------------------------------------------------
svn:eol-style = native
Added: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java
URL: http://svn.apache.org/viewvc/incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java?rev=1360517&view=auto
==============================================================================
--- incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java (added)
+++ incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java Thu Jul 12 02:48:28 2012
@@ -0,0 +1,16 @@
+package org.apache.vxquery.runtime.functions.comparison;
+
+import edu.uci.ics.hyracks.algebricks.runtime.base.IScalarEvaluatorFactory;
+
+public class ValueLeComparisonScalarEvaluatorFactory extends AbstractValueComparisonScalarEvaluatorFactory {
+ private static final long serialVersionUID = 1L;
+
+ public ValueLeComparisonScalarEvaluatorFactory(IScalarEvaluatorFactory[] args) {
+ super(args);
+ }
+
+ @Override
+ protected AbstractValueComparisonOperation createValueComparisonOperation() {
+ return new ValueLeComparisonOperation();
+ }
+}
\ No newline at end of file
Propchange: incubator/vxquery/branches/vxquery_algebricks/vxquery-core/src/main/java/org/apache/vxquery/runtime/functions/comparison/ValueLeComparisonScalarEvaluatorFactory.java
------------------------------------------------------------------------------
svn:eol-style = native