#554 range and geo weights in query builder

Author: ehennum

lib/query-builder.js

@@ -1532,6 +1532,9 @@ function geoPath() {
  * @memberof queryBuilder#
  * @param {queryBuilder.GeoLocation} location - the JSON property or XML element
  * representing the geospatial locations
+ * @param {queryBuilder.WeightParam} [weight] - a weight returned
+ * by {@link queryBuilder#weight} to increase or decrease the score
+ * of the query relative to other queries in the complete search
  * @param {queryBuilder.FragmentScopeParam} [fragmentScope] - whether the query
  * applies to document content (the default) or document metadata properties
  * as returned by the {@link queryBuilder#fragmentScope} function
@@ -1562,6 +1565,9 @@ function geospatial() {
  * representing the geospatial locations
  * @param {string} operator - a spatial operator:
  * disjoint|contains|covers|intersects|within|covered-by|overlaps
+ * @param {queryBuilder.WeightParam} [weight] - a weight returned
+ * by {@link queryBuilder#weight} to increase or decrease the score
+ * of the query relative to other queries in the complete search
  * @param {queryBuilder.FragmentScopeParam} [fragmentScope] - whether the query
  * applies to document content (the default) or document metadata properties
  * as returned by the {@link queryBuilder#fragmentScope} function
@@ -1598,6 +1604,7 @@ function geospatialImpl(hasOperator, args) {
   var variant = null;
   var constraintName = null;
   var suggestOptions = null;
+  var seekingWeight = true;
   var seekingFragmentScope = true;
   var seekingGeoOption = true;
   var seekingRegion = true;
@@ -1621,6 +1628,11 @@ function geospatialImpl(hasOperator, args) {
       seekingGeoOption = false;
       continue;
     }
+    if (seekingWeight && arg instanceof WeightDef) {
+      query.weight = arg.weight;
+      seekingWeight = false;
+      continue;
+    }
     if (seekingFragmentScope && arg instanceof FragmentScopeDef) {
       query['fragment-scope'] = arg['fragment-scope'];
       seekingFragmentScope = false;
@@ -2816,6 +2828,9 @@ function TemporalOptionsDef(options) {
  * @param {queryBuilder.DefaultBindingParam} [defaultBinding] - a binding
  * (returned by the {@link queryBuilder#bindDefault} function) for parsing
  * the comparison operator and value from untagged values in a query string
+ * @param {queryBuilder.WeightParam} [weight] - a weight returned
+ * by {@link queryBuilder#weight} to increase or decrease the score
+ * of the query relative to other queries in the complete search
  * @param {queryBuilder.FragmentScopeParam} [fragmentScope] - whether the query
  * applies to document content (the default) or document metadata properties
  * as returned by the {@link queryBuilder#fragmentScope} function
@@ -2829,6 +2844,7 @@ function range() {
   var index = null;
   var datatype = null;
   var collation = null;
+  var weight = null;
   var fragmentScope = null;
   var rangeOptions = null;
   var values = null;
@@ -2848,6 +2864,10 @@ function range() {
       collation = arg.collation;
       continue;
     }
+    if (weight === null && arg instanceof WeightDef) {
+      weight = arg.weight;
+      continue;
+    }
     if (fragmentScope === null && arg instanceof FragmentScopeDef) {
       fragmentScope = arg['fragment-scope'];
       continue;
@@ -2900,7 +2920,7 @@ function range() {
   }
 
   var rangeDef = new RangeDef(
-      index, datatype, collation, operator, values, rangeOptions, fragmentScope
+      index, datatype, collation, operator, values, weight, rangeOptions, fragmentScope
   );
 
   if (values !== null) {
@@ -2958,11 +2978,11 @@ function RangeQueryDef(rangeDef) {
 util.inherits(RangeQueryDef, QueryDef);
 /** @ignore */
 function RangeDef(
-    index, datatype, collation, operator, values, rangeOptions, fragmentScope
+    index, datatype, collation, operator, values, weight, rangeOptions, fragmentScope
     ) {
   if (!(this instanceof RangeDef)) {
     return new RangeDef(
-        index, datatype, collation, operator, values, rangeOptions, fragmentScope
+        index, datatype, collation, operator, values, weight, rangeOptions, fragmentScope
         );
   }
 
@@ -2990,6 +3010,13 @@ function RangeDef(
   if (hasOperator) {
     this['range-operator'] = operator;
   }
+  if (weight != null) {
+    if (typeof weight === 'number' || weight instanceof Number) {
+      this.weight = weight;
+    } else {
+      throw new Error('invalid weight: '+mlutil.identify(weight, true));
+    }
+  }
   if (rangeOptions != null) {
     this['range-option'] = rangeOptions;
   }

test-basic/query-builder.js

@@ -394,10 +394,11 @@ describe('query-builder', function() {
     assert.deepEqual(
         q.geospatial(q.geoAttributePair('parent', 'latitude', 'longitude'),
             q.latlon(1.1, 2.2),
-            q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
+            q.weight(2), q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-attr-pair-query':{parent:{name:'parent'},
           lat:{name:'latitude'}, lon:{name:'longitude'},
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -451,11 +452,12 @@ describe('query-builder', function() {
         );
     assert.deepEqual(
         q.geospatial(q.geoElement('parent', 'element'),
-            q.latlon(1.1, 2.2), q.fragmentScope('documents'),
-            q.geoOptions('boundaries-included')),
+            q.latlon(1.1, 2.2), q.weight(2),
+            q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-elem-query':{parent:{name:'parent'},
           element:{name:'element'},
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -491,10 +493,11 @@ describe('query-builder', function() {
         );
     assert.deepEqual(
         q.geospatial(q.geoElementPair('parent', 'latitude', 'longitude'), q.latlon(1.1, 2.2),
-            q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
+            q.weight(2), q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-elem-pair-query':{parent:{name:'parent'},
           lat:{name:'latitude'}, lon:{name:'longitude'},
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -533,9 +536,10 @@ describe('query-builder', function() {
         );
     assert.deepEqual(
         q.geospatial(q.geoPath(q.pathIndex('foo', {bar: 'baz'})), q.point(1.1, 2.2),
-            q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
+            q.weight(2), q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-path-query':{'path-index':{text: 'foo', namespaces: {bar: 'baz'}},
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -585,11 +589,12 @@ describe('query-builder', function() {
         );
     assert.deepEqual(
         q.geospatial(q.geoProperty('parent', 'property1'),
-            q.latlon(1.1, 2.2), q.fragmentScope('documents'),
-            q.geoOptions('boundaries-included')),
+            q.latlon(1.1, 2.2), q.weight(2),
+            q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-json-property-query':{'parent-property':'parent',
           'json-property':'property1',
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -621,11 +626,12 @@ describe('query-builder', function() {
         );
     assert.deepEqual(
         q.geospatial(q.geoPropertyPair('parent', 'latitude', 'longitude'),
-            q.latlon(1.1, 2.2),
+            q.latlon(1.1, 2.2), q.weight(2),
             q.fragmentScope('documents'), q.geoOptions('boundaries-included')),
         {'geo-json-property-pair-query':{'parent-property':'parent',
           'lat-property':'latitude', 'lon-property':'longitude',
           point:[{latitude:1.1, longitude:2.2}],
+          weight: 2,
           'fragment-scope': 'documents',
           'geo-option':['boundaries-included']}}
         );
@@ -1154,6 +1160,15 @@ describe('query-builder', function() {
           'range-option':['cached']
           }}
         );
+    assert.deepEqual(
+        q.range('foo', 1, q.weight(2)),
+        {'range-query':{
+          'json-property': 'foo',
+          value: [1],
+          'range-operator': 'EQ',
+          weight: 2
+          }}
+        );
   });
 
   it('should create range options', function(){
@@ -1493,6 +1508,15 @@ describe('query-builder', function() {
           'fragment-scope': 'properties'},
           name:'constraint1'}
         );
+    assert.deepEqual(
+        q.geospatial(q.geoAttributePair('parent', 'latitude', 'longitude'),
+            q.bind('constraint1'),
+            q.weight(2)),
+        {'geo-attr-pair':{parent:{name:'parent'},
+          lat:{name:'latitude'}, lon:{name:'longitude'},
+          weight: 2},
+          name:'constraint1'}
+        );
     assert.deepEqual(
         q.geospatial(q.geoElement('parent', 'element'),
             q.bind('constraint1')),
@@ -1516,6 +1540,14 @@ describe('query-builder', function() {
           'fragment-scope': 'properties'},
           name:'constraint1'}
         );
+    assert.deepEqual(
+        q.geospatial(q.geoElement('parent', 'element'),
+            q.bind('constraint1'), q.weight(2)),
+        {'geo-elem':{parent:{name:'parent'},
+          element:{name:'element'},
+          weight: 2},
+          name:'constraint1'}
+        );
     assert.deepEqual(
         q.geospatial(q.geoElementPair('parent', 'latitude', 'longitude'),
             q.bind('constraint1')),
@@ -1539,6 +1571,14 @@ describe('query-builder', function() {
           'fragment-scope': 'properties'},
           name:'constraint1'}
         );
+    assert.deepEqual(
+        q.geospatial(q.geoElementPair('parent', 'latitude', 'longitude'),
+            q.bind('constraint1'), q.weight(2)),
+        {'geo-elem-pair':{parent:{name:'parent'},
+          lat:{name:'latitude'}, lon:{name:'longitude'},
+          weight: 2},
+          name:'constraint1'}
+        );
     assert.deepEqual(
         q.geospatial(q.geoPath('foo'), q.bind('constraint1')),
         {'geo-path':{'path-index':{text: 'foo', namespaces: ''}},
@@ -1558,6 +1598,13 @@ describe('query-builder', function() {
           'fragment-scope': 'properties'},
           name:'constraint1'}
         );
+    assert.deepEqual(
+        q.geospatial(q.geoPath('foo'),
+            q.bind('constraint1'), q.weight(2)),
+        {'geo-path':{'path-index':{text: 'foo', namespaces: ''},
+          weight: 2},
+          name:'constraint1'}
+        );
     assert.deepEqual(
         q.range('key1', q.bind('constraint1')),
         {range:{'json-property': 'key1', facet: false},
@@ -1573,6 +1620,11 @@ describe('query-builder', function() {
         {range:{'json-property': 'key1', 'fragment-scope': 'properties', facet: false},
           name:'constraint1'}
         );
+    assert.deepEqual(
+        q.range('key1', q.bind('constraint1'), q.weight(2)),
+        {range:{'json-property': 'key1', weight: 2, facet: false},
+          name:'constraint1'}
+        );
     assert.deepEqual(
         q.value('key1', q.bind('constraint1')),
         {value:{'json-property': 'key1'},