MarkLogic 10 Product Documentation

Search Developer's Guide — Chapter 31

<range type="indexedType" 
       collation="collURI"
       facet="boolean"
       nullable="boolean">
  <element ns="namespace" name="name"/>
  <attribute ns="namespace" name="name"/>
  <field name="name"/>
  <json-property>name</json-property>
  <path-index/>
  <fragment-scope>scope</fragment-scope>
  <bucket/>
  <computed-bucket/>
  <facet-option>option</facet-option>
  <range-option>option</range-option>
  <weight>double</weight>
</range>

"range": {
  "type": string,
  "collation" : string,
  "facet": boolean,

  "element": {
    "ns": "namespace",
    "name": "name"
  },
  "attribute": {
    "ns": "namespace",
    "name": "name"
  },
  "field": {"name": "name"},
  "json-property": "name",
  "path-index": [path index desc],
  "fragment-scope": "scope",
  "bucket": [bucket descriptor],
  "computed-bucket": [bucket desc],
  "facet-option" : [ "option" ],
  "range-option": [ "option" ],
  "nullable" : boolean,
  "weight": double
}

Defines an XML element to constrain by. If there is an element, there can also be an attribute. Specify the element local name in name. If the element is in a namespace, specify the namespace URI in ns.

The database configuration must include a corresponding element or element attribute range index.

Defines an XML element attribute to constrain by. There must be an accompanying element descriptor. Specify the attribute local name in name. If the attribute is in a namespace, specify the namespace URI in ns.

The database configuration must include a corresponding element attribute range index.

Defines a JSON property to constrain by.

The database configuration must include a corresponding element range index. (JSON properties are indexed using element range indexes.)

Defines a field to constrain by.

The database configuration must include a corresponding field range index.

Defines a path range index reference to constrain by. For details, see path-index. In XML, you can specify multiple indexes by including this component multiple times. In JSON, you can specify multiple indexes by setting the property value to an array of path index descriptors.

The database configuration must include a corresponding path range index.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="elem">
    <range type="xs:string">
      <element ns="myNsURI" name="anElemName"/>
    </range>
  </constraint>
  <constraint name="attr">
    <range type="xs:string">
      <element ns="myNsURI" name="anElemName"/>
      <attribute ns="myNsURI" name="anAttrName" />
    </range>
  </constraint>
  <constraint name="json-prop">
    <range type="xs:string">
      <json-property>aPropName</json-property>
    </range>
  </constraint>
  <constraint name="field">
    <range type="xs:string"
        collation="http://marklogic.com/collation/codepoint">
      <field name="aFieldName"/>
    </range>
  </constraint>
  <constraint name="path">
    <range type="xs:gYear" facet="true">
      <path-index xmlns:my="http://example.com">
        /publication/my:meta/my:year
      </path-index>
    </range>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "elem",
      "range": {
        "type": "xs:string",
        "element": { "ns": "myNsURI", "name": "anElemName" }
    }},
    { "name": "attr",
      "range": {
        "type": "xs:string",
        "element": { "ns": "myNsURI", "name": "anElemName" },
        "attribute": { "ns": "myNsURI", "name": "anAttrName" }
    }},
    { "name": "json-prop",
      "range": {
        "type": "xs:string",
        "json-property": { "name": "aPropName" }
    }},
    { "name": "field",
      "range": {
        "type": "xs:string",
        "collation": "http://marklogic.com/collation/codepoint",
        "field": { "name": "aFieldName" }
    }},
    { "name": "path",
      "range": {
        "type": "xs:gYear",
        "facet": true,
        "path-index": { 
          "namespaces": {"my": "http://example.com"}, 
          "text": "/publication/my:meta/my:year" 
        }
    }}
  ]
}}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="color">
    <range type="xs:string" facet="true">
      <element ns="myNsURI" name="bodycolor"/>
      <facet-option>frequency-order</facet-option>
      <facet-option>descending</facet-option>
    </range>
  </constraint>
  <constraint name="owner">
</options>

{"options": {
  "constraint": [
    { "name": "color",
      "range": {
        "type": "xs:string",
        "facet": true,
        "element": { "ns": "myNsURI", "name": "bodycolor" },
        "facet-option": [ "frequence-order", "descending" ]
  }}]
}}

<value type="jsonNodeType">
  <element ns="namespace" name="name"/>
  <attribute ns="namespace" name="name"/>
  <field name="fieldName"/>
  <json-property>name</json-property>
  <fragment-scope>scope</fragment-scope>
  <weight>double</weight>
  <term-option>option</term-option>
</value>

"value": {
  "type": "jsonNodeType"
  "element": {
    "ns": "namespace",
    "name": "name"
  },
  "attribute": {
    "ns": "namespace",
    "name": "name"
  },
  "json-property": "name",
  "field": {"name": "fieldName"},
  "weight": double,
  "fragment-scope": "scope",
  "term-option": [ "option" ]
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-elem-value">
    <value>
      <element ns="my-namespace" name="my-localname"/>
    </value>
  </constraint> 
  <constraint name="my-attr-value">
    <value>
      <attribute ns="" name="my-attribute"/>
      <element ns="my-namespace" name="my-localname"/>
    </value>
  </constraint>
  <constraint name="my-json-value">
    <value type="number">
      <json-property>myNumericPropName</json-property>
    </value>
  </constraint>
  <constraint name="my-field-value">
    <value>
      <field name="fieldvalue"/>
      <weight>2.0</weight>
    </value>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "my-elem-value",
      "value": {
        "element": {"ns": "my-namespace","name": "my-localname"}
    }},
    { "name": "my-attr-value",
      "value": {
        "element": {"ns": "my-namespace","name": "my-localname"},
        "attribute": {"ns": "","name": "my-attribute"}
    }},
    { "name": "my-json-value",
      "value": {
        "type": "number",
        "json-property": "myNumericPropName"
    }},
    { "name": "my-field-value",
      "value": {
        "field": {"name": "fieldName"},
        "weight": 2.0
    }}
  ]
}}

<word>
  <element ns="namespace" name="name"/>
  <attribute ns="namespace" name="name"/>
  <field name="name"/>
  <json-property>name</json-property>
  <fragment-scope>scope</fragment-scope>
  <weight>double</weight>
  <term-option>option</term-option>
</word>

"word": {
  "element": {
    "ns": "namespace",
    "name": "name"
  },
  "attribute": {
    "ns": "namespace",
    "name": "name"
  },
  "json-property": "name",
  "field": {"name": "name"},
  "weight": double,
  "fragment-scope": "scope",
  "term-option": [ "option" ]
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-elem-value">
    <word>
      <element ns="my-namespace" name="my-localname"/>
    </word>
  </constraint> 
  <constraint name="my-attr-value">
    <word>
      <attribute ns="" name="my-attribute"/>
      <element ns="my-namespace" name="my-localname"/>
    </word>
  </constraint>
  <constraint name="my-json-value">
    <word>
      <json-property>myPropName</json-property>
      <term-option>case-sensitive</term-option>
      <term-option>unstemmed</term-option>
    </word>
  </constraint>
  <constraint name="my-field-value">
    <word>
      <field name="fieldvalue"/>
      <weight>2.0</weight>
    </word>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "my-elem-value",
      "word": {
        "element": {"ns": "my-namespace","name": "my-localname"}
    }},
    { "name": "my-attr-value",
      "word": {
        "element": {"ns": "my-namespace","name": "my-localname"},
        "attribute": {"ns": "","name": "my-attribute"}
    }},
    { "name": "my-json-value",
      "word": {
        "json-property": "myPropName",
        "term-option": ["case-sensitive", "unstemmed"]
    }},
    { "name": "my-field-value",
      "value": {
        "field": {"name": "fieldName"},
        "weight": 2.0
    }}
  ]
}}

<collection prefix="URIpfx" facet="boolean">
  <facet-option>option</facet-option>
</collection>

"collection": {
  "prefix": "URIprefix",
  "facet-option": [ "option" ],
  "facet": boolean
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="mycoll" facet="true">
    <collection prefix="/my/collection/"/>
      <facet-option>limit=5</facet-option>
    </collection>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "mycoll",
      "collection": {
        "prefix": "/my/collection/",
        "facet": true,
        "facet-option": [ "limit=5" ]
    }}
  ]
}}

<container>
  <element ns="namespace" name="name"/>
  <json-property>name</json-property>
  <fragment-scope>scope</fragment-scope>
</container>

"container": {
  "element": {
    "ns": "namespace",
    "name": "name"
  },
  "json-property": "name",
  "fragment-scope": "scope"
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="ele-container-constraint">
    <container>
      <element name="title" ns="http://my/namespace" />
    </container>
  </constraint>
  <constraint name="json-container-constraint">
    <container>
      <json-property>author</json-property>
    </container>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "ele-container-constraint",
      "container": {
        "element": {"ns": "http://my/namespace","name": "title"}
    }},
    { "name": "json-container-constraint",
      "container": {
        "json-property": "author",
    }}
  ]
}}

<element-query ns="namespace" name="name"/>
  <fragment-scope>scope</fragment-scope>
</element-query>

"element-query": {
  "ns": "namespace",
  "name": "name",
  "fragment-scope": "scope"
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="elem-constraint">
    <element-query name="title" ns="http://my/namespace" />
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "elem-constraint",
      "element-query": {
        "ns": "http://my/namespace",
        "name": "title"
    }}
  ]
}}

<properties/>

{ "properties": null }

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="prop-constraint">
    <properties />
  </constraint>
</options>

{"options": {
  "constraint": [{
    "name": "prop-constraint", 
    "properties": null" }
  }]
}}

<geo-attr-pair>
  <parent ns="namespace" name="elemName" />
  <lat ns="namespace" name="attrName" />
  <lon ns="namespace" name="attrName" />
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-attr-pair>

"geo-attr-pair": {
  "parent": [{
    "ns": "namespace",
    "name": "elemName",
  }],
  "lat": [{
    "ns": "namespace",
    "name": "attrName",
  }],
  "lon": [{
    "ns": "namespace",
    "name": "attrName",
  }],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Required. Identifies an element that can contain the latitude and longitude attributes. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple parents are defined, the query matches if any one of them matches. This component can have array value in JSON.

Required. Identifies the attribute of parent that contains the latitude value. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple elements are defined, the query matches if any one of them matches. However, only the first matching latitude attribute in any point instance is checked. This component can have array value in JSON.

Required. Identifies the attribute of parent that contains the longitude value. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple elements are defined, the query matches if any one of them matches. However, only the first matching longitude attribute in any point instance is checked. This component can have array value in JSON.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-attr-pair">
    <geo-attr-pair>
      <parent ns="ns1" name="my-elem"/>
      <lat ns="ns2" name="attr1"/>
      <lon ns="ns2" name="attr2"/>
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-attr-pair>
  </constraint>
</options>

{"options":{
  "constraint": [{
    "name": "my-geo-attr-pair",
    "geo-attr-pair": {
      "parent": { "ns": "ns1", "name": "my-elem" },
      "lat": { "ns": "ns2", "name": "attr1" },
      "lon": { "ns": "ns3", "name": "attr2" },
      "facet-option": [ "empties" ],
      "heatmap": {
        "s": 23.2, "w": -118.3, "n": 23.3, "e": -118.2,
        "latdivs": 4, "londivs": 4
      }
    }
  }]
}}

<geo-elem>
  <parent ns="namespace" name="elemName" />
  <element ns="namespace" name="elemName" />
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-elem>

"geo-attr-pair": {
  "parent": [{
    "ns": "namespace",
    "name": "elemName",
  }],
  "element": [{
    "ns": "namespace",
    "name": "elemName",
  }],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Optional. Identifies an element that can contain the latitude and longitude elements. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple parents are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the element containing the latitude and longitude values. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple elements are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-elem">
    <geo-elem> 
      <element ns="ns1" name="my-elem"/> 
      <geo-option>type=long-lat-point</geo-option>
    </geo-elem>
  </constraint>
  <constraint name="my-geo-elem-child">
    <geo-elem> 
      <parent ns="ns1" name="the-parent"/> 
      <element ns="ns1" name="the-child"/> 
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-elem>
  </constraint>
</options>

{"options":{
  "constraint": [
    { "name": "my-geo-elem",
      "geo-elem": {
        "element": { "ns": "ns1", "name": "my-elem" },
        "geo-option": [ "type=long-lat-point" ]
    }},
    { "name": "my-geo-elem-child",
      "geo-elem": {
        "parent": { "ns": "ns1", "name": "the-parent" },
        "element": { "ns": "ns1", "name": "the-child" },
        "facet-option": [ "empties" ],
        "heatmap": {
          "s": 23.2, "w": -118.3, "n": 23.3, "e": -118.2,
          "latdivs": 4, "londivs": 4
        }
    }}
  ]
}}

<geo-elem-pair>
  <parent ns="namespace" name="elemName" />
  <lat ns="namespace" name="attrName" />
  <lon ns="namespace" name="attrName" />
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-elem-pair>

"geo-elem-pair": {
  "parent": [{
    "ns": "namespace",
    "name": "elemName",
  }],
  "lat": [{
    "ns": "namespace",
    "name": "attrName",
  }],
  "lon": [{
    "ns": "namespace",
    "name": "attrName",
  }],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Required. Identifies an element that can contain the latitude and longitude elements. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple parents are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the element containing the latitude value. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple elements are defined, the query matches if any one of them matches. However, only the first matching child in any point instance is checked. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the element containing the longitude value. Use ns and name to define the namespace (if any) and local name of the element, respectively.

If multiple elements are defined, the query matches if any one of them matches. However, only the first matching child in any point instance is checked. This component can have an array value in JSON, but need not if there is only one item.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-elem-pair">
    <geo-elem-pair> 
      <parent ns="ns1" name="the-parent"/> 
      <lat ns="ns2" name="child1"/> 
      <lon ns="ns3" name="child2"/>
      <geo-option>boundaries-excluded</geo-option>
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-elem-pair>
  </constraint>
</options>

{"options":{
  "constraint": [{
    "name": "my-geo-elem-pair",
    "geo-elem": {
      "parent": { "ns": "ns1", "name": "the-parent" },
      "lat": { "ns": "ns2", "name": "child1" },
      "lon": { "ns": "ns3", "name": "child2" },
      "geo-option": [ "boundaries-excluded" ],
      "facet-option": [ "empties" ],
      "heatmap": {
        "s": 23.2, "w": -118.3, "n": 23.3, "e": -118.2,
        "latdivs": 4, "londivs": 4
      }
    }
  }]
}}

<geo-json-property>
  <parent-property>name</parent-property>
  <json-property>name</json-property>
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-json-property>

"geo-json-property": {
  "parent-property": ["name"],
  "json-property": ["name"],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Optional. Identifies the parent JSON property that can contain the latitude and longitude property.

If multiple parents are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the JSON property containing the latitude and longitude values.

If multiple properties are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-json-child">
    <geo-json-property> 
      <parent-property>parent<parent-property> 
      <json-property>child</json-property> 
    </geo-json-property>
  </constraint>
  <constraint name="my-geo-json-property">
    <geo-json-property> 
      <json-property>location</json-property> 
      <geo-option>boundaries-excluded</geo-option>
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-json-property>
  </constraint>
</options>

{"options":{
  "constraint": [
    { "name": "my-geo-json-child",
      "geo-json-property": {
        "parent-property": "parent",
        "json-property": "child",
    }},
    { "name": "my-geo-json",
      "geo-json-property": {
        "json-property": "location",
        "geo-option": [ "boundaries-excluded" ],
        "facet-option": [ "empties" ],
        "heatmap": {
          "s": 23.2, "w": -118.3, "n": 23.3, "e": -118.2,
          "latdivs": 4, "londivs": 4
        }
    }},
  ]
}}

<geo-json-property-pair>
  <parent-property>name</parent-property>
  <lat-property>name</lat-property>
  <lon-property>name</lon-property>
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-json-property-pair>

"geo-json-property-pair": {
  "parent-property": ["name"],
  "lat-property": ["name"],
  "lon-property": ["name"],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Required. Identifies the parent JSON property that can contain the latitude and longitude property.

If multiple parents are defined, the query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the JSON property containing the latitude.

If multiple properties are defined, the query matches if any one of them matches. However, only the first matching child in any point instance is checked. This component can have an array value in JSON, but need not if there is only one item.

Required. Identifies the JSON property containing the longitude.

If multiple properties are defined, the query matches if any one of them matches. However, only the first matching child in any point instance is checked. This component can have an array value in JSON, but need not if there is only one item.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-json-pair">
    <geo-json-property-pair> 
      <parent-property>parent</parent-property> 
      <lat-property>child1</lat-property> 
      <lon-property>child2</lon-property> 
      <geo-option>boundaries-excluded</geo-option>
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-json-property-pair>
  </constraint>
</options>

{"options":{
  "constraint": [
    { "name": "my-geo-json-pair",
      "geo-json-property": {
        "parent-property": "parent",
        "lat-property": "child1",
        "lon-property": "child2",
        "geo-option": [ "boundaries-excluded" ],
        "facet-option": [ "empties" ],
        "heatmap": {
          "s": 23.2, "w": -118.3, "n": 23.3, "e": -118.2,
          "latdivs": 4, "londivs": 4
        }
    }},
  ]
}}

<geo-path>
  <path-index/>
  <facet-option>option</facet-option>
  <heatmap>heatmap descriptor</heatmap>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-path>

"geo-path": {
  "path-index": [path index desc],
  "facet-option": [ option ],
  "heatmap": {heatmap desc},
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Required. A geospatial range index references to constrain by; for details, see path-index. The path should reference a point index; for region path indexes, see geo-region-path.

You can specify more than one path-index. The query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

The database configuration must include a geospatial region path index based on the same path. The path expression and namespace URIs must match the index configuration; namespace prefixes do not have to match.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-path">
    <geo-path> 
      <path-index>/a/b</path-index> 
      <geo-option>boundaries-excluded</geo-option>
      <facet-option>empties</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-path>
  </constraint>
</options>

{"options":{
  "constraint": [
    { "name": "my-geo-path",
      "geo-path": {
        "path-index": { "text" : "/a/b" },
        "geo-option": [ "boundaries-excluded" ],
        "facet-option": [ "empties" ],
        "heatmap": {
          "s": 23.2, 
          "w": -118.3, 
          "n": 23.3, 
          "e": -118.2,
          "latdivs": 4, 
          "londivs": 4
        }
    }},
  ]
}}

<geo-region-path coord="coord-sys">
  <path-index/>
  <fragment-scope>scope</fragment-scope>
  <geo-option>option</geo-option>
  <weight>double</weight>
</geo-region-path>

"geo-region-path": {
  "path-index": [path index desc],
  "coord": "coord-sys",
  "geo-option": [ option ],
  "fragment-scope": "scope",
  "weight": double
}

Required. A geospatial region path range index descriptor for an XML element or JSON property whose contents represent a region. Define any required namespace bindings as part of the path-index element or property. For details, see path-index. For geospatial point constraints, see geo-path.

You can specify more than one path-index. The query matches if any one of them matches. This component can have an array value in JSON, but need not if there is only one item.

The database configuration must include a geospatial region path index based on the same path. The path expression and namespace URIs must match the index configuration; namespace prefixes do not have to match.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-geo-region">
    <geo-region-path coord="wgs84"> 
      <path-index>/a/b</path-index> 
      <geo-option>units=feet</geo-option>
    </geo-region-path>
  </constraint>
</options>

{"options":{
  "constraint": [
    { "name": "my-geo-region",
      "geo-region-path": {
        "path-index": {"text": "/a/b"},
        "coord": "wgs84",
        "geo-option": [ "units=feet" ]
    }}
  ]
}}

<custom facet="boolean">
  <parse apply="funcName" 
      ns="namespace"
      at="/path/to/module.xqy"/>
  <start-facet apply="funcName"
      ns="namespace"
      at="/path/to/module.xqy"/>
  <finish-facet apply="funcName"
      ns="namespace"
      at="/path/to/module.xqy"/>
  <facet-option>option</facet-option>
  <term-option>option</term-option>
</custom>

"custom": {
  "facet": boolean
  "parse": {
    "apply": "funcName",
    "ns": "namespace",
    "at": "/path/to/module.xqy"
  },
  "start-facet": {
    "apply": "funcName",
    "ns": "namespace",
    "at": "/path/to/module.xqy"
  },
  "finish-facet": {
    "apply": "funcName",
    "ns": "namespace",
    "at": "/path/to/module.xqy"
  },
  "facet-option": [ option ],
  "term-option": [ option ]
}

Required. Whether or not to use this constraint for faceting.

If facet is false, you do not need to specify start-facet or finish-facet functions. If facet is true, you must specify a finish-facet function and can specify a start-facet function.

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="my-custom">
    <custom facet="true">
      <parse apply="my-parse-function" 
          ns="my-namespace" at="/my/module.xqy"/>
      <start-facet apply="my-start-function" 
          ns="my-namespace" at="/my/module.xqy"/>
      <finish-facet apply="my-finish-function" 
          ns="my-namespace" at="/my/module.xqy"/>
      <facet-option>concurrent</facet-option>
    </custom>
  </constraint>
</options>

{"options": {
  "constraint": [
    { "name": "my-custom",
      "custom": {
        "facet": true,
        "parse": {
          "apply": "my-parse-function",
          "ns": "my-namespace",
          "at": "/my/module.xqy"
        },
        "start-facet": {
          "apply": "my-start-function",
          "ns": "my-namespace",
          "at": "/my/module.xqy"
        },
        "finish-facet": {
          "apply": "my-finish-function",
          "ns": "my-namespace",
          "at": "/my/module.xqy"
        },
        "facet-option": [ "concurrent" ],
    }},
  ]
}}

<heatmap s="double" w="double"
         n="double" e="double"
         latdivs="unsignedInt",
         londivs="unsignedInt" />

"heatmap": {
  "n": double,
  "s": double,
  "e": double,
  "w": double,
  "latdivs": unsignedInt,
  "londivs": unsignedInt
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="geo-pair">
    <geo-json-property-pair> 
      <parent-property>event</parent-property> 
      <lat-property>latitude</lat-property>
      <lon-property>longitude</lon-property>
      <facet-option>gridded</facet-option>
      <heatmap s="23.2" w="-118.3" n="23.3" e="-118.2" 
               latdivs="4" londivs="4"/>
    </geo-json-property-pair>
  </constraint>
</options>

{"options": {
  "constraint": [{
    "name": "geo-pair",
    "geo-json-property-pair": {
      "parent-property": "event",
      "lat-property": "latitude",
      "lon-property": "longitude",
      "facet-option": [ "gridded" ],
      "heatmap": {
        "s": 24.0, "n": 49.0,
        "e": -67.0,"w": -125.0,
        "latdivs": 5, "londivs": 4
    }}
  }]
}}

...
<boxes name="geo-pair">
  <box count="2" s="34" w="-125" n="39" e="-110.5"/>
  <box count="12" s="34" w="-110.5" n="39" e="-96"/>
</boxes>
...

...
"facets": {
  "geo-pair": {
    "boxes": [
      { "count": 2,
        "s": 34, "w": -125,
        "n": 39, "e": -110.5
      },
      { "count": 12,
        "s": 34, "w": -110.5,
        "n": 39, "e": -96
      }
    ]
...

<bucket name="name" 
    ge="value" lt="value">
  displayLabel
</bucket>

"bucket": [{
  "name": "name",
  "label": "displayLabel",
  "lt": value,
  "ge": value
}]

label (JSON)

fn:data() (XML)

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="pindex">
    <range type="xs:string" facet="true">
      <path-index>/Employee/fn</path-index>
      <bucket name="low" lt="5">less than 5</bucket>
      <bucket name="medium" lt="10" ge="5">5 to 9</bucket>
      <bucket name="high" lt="15" ge="10">10 to 15</bucket>
    </range>
  </constraint>
</options>

{"options": {
  "constraint": [{
    "name": "pindex",
    "range": {
      "type": "xs:string",
      "facet": true,
      "path-index": {"text": "/Employee/fn"},
      "bucket": [
        { "name": "low",
          "lt": "5",
          "label": "less than 5"
        },
        { "name": "medium",
          "ge": "5",
          "lt": "10",
          "label": "5 to 9"
        },
        { "name": "high",
          "ge": "10",
          "lt": "15",
          "label": "10 to 15"
        }
      ]
    }
  }]
}}

<computed-bucket name="name" 
    ge="value" lt="value">
    anchor="anchorValue"
    lt-anchor="anchorValue"
    ge-anchor="anchorValue"
  displayLabel
</computed-bucket>

"computed-bucket": [{
  "name": "name",
  "label": "displayLabel",
  "lt": value,
  "ge": value,
  "anchor": "anchorValue",
  "lt-anchor": "anchorValue",
  "gt-anchor": "anchorValue"
}]

label (JSON)

data() (XML)

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="made">
    <range type="xs:dateTime">
      <element ns="http://example.com" name="manufactured"/>
      <computed-bucket name="today" ge="P0D" lt="P1D"
            anchor="now">Today</computed-bucket>
      <computed-bucket name="30-days" ge="-P30D" lt="P1D"
            anchor="now">Last 30 days</computed-bucket>
      <computed-bucket name="60-days" ge="-P60D" lt="P1D"
            anchor="now">Last 60 Days</computed-bucket>
      <computed-bucket name="year" ge="-P1Y" lt="P1D"
            anchor="now">Last Year</computed-bucket>
    </range>
  </constraint>
</options>

{ "options": {
    "constraint": [{
      "name": "made",
      "range": {
        "type": "xs:dateTime",
        "element": {
          "ns": "http://example.com",
          "name": "manufactured"
        },
        "computed-bucket": [
          { "name": "today",
            "ge": "P0D",
            "lt": "P1D",
            "anchor": "now",
            "label": "Today"
          },
          { "name": "30-days",
            "ge": "-P30D",
            "lt": "P1D",
            "anchor": "now",
            "label": "Last 30 days"
          },
          { "name": "60-days",
            "ge": "-P60D",
            "lt": "P1D",
            "anchor": "now",
            "label": "Last 60 Days"
          },
          { "name": "year",
            "ge": "-P1Y",
            "lt": "P1D",
            "anchor": "now",
            "label": "Last Year"
          }
        ]
      }
  }]
}}

<path-index xmlns:nsPrefix="nsURI">
  pathExpression
</path-index>

"path-index": {
  "text": "pathExpression"
  "namespaces": {
    "nsPrefix": "nsURI"
  }
}

<options xmlns="http://marklogic.com/appservices/search">
  <constraint name="myPathConstraint">
    <range type="xs:int">
      <path-index>/data/a</path-index>
      <path-index xmlns:ns1="/my/ns1"
        xmlns:ns2="/my/ns2">/ns1:data/ns2:b</path-index>
    </range>
  </constraint>
  <values name="myValuesSpec">
    <range type="xs:int">
      <path-index>/data/a</path-index>
    </range>
  </values>
</options>

{ "options": {
    "constraint": [ {
      "name": "myPathConstraint",
      "range": {
        "type": "xs:int",
        "path-index": [
          { "text": "/data/a" },
          { "text": "/ns1:data/ns2:b",
            "namespaces": {
              "ns1": "/my/ns1",
              "ns2": "/my/ns2"
            }
          }
        ]
      }
    } ],
    "values": [
      { "name": "myValuesSpec",
        "range": {
          "type": "xs:int",
          "path-index": { "text": "/data/a" }
        }
      }
    ]
} }

<starter strength="int"
         apply="funcName"
         ns="namespaceURI"
         at="modulePath"
         element="qName"
         options="optList"
         delimiter="delimChar"
         tokenize="value">
  opToken
</starter>

"starter": [{
  "label": "opToken",
  "strength": number,
  "apply": "funcName",
  "ns": "namespaceURI",
  "at": "modulePath",
  "element": "qName",
  "options": "optList",
  "tokenize": "value",
  "delimiter": "delimChar",
}]

fn:data() (XML)

label (JSON)

Required. The starter operator token. For example, the default grammar includes a starter with the minus sign (-) as the operator, which enables query text such as -cat.

If defining a pair of grouping delimiters such as ( and ), place set this component to the group start delimiter (() and set delimiter to the group end deliminter ()).

<starter strength="30" apply="grouping" delimiter=")">(</starter>
<starter strength="40" apply="prefix"
  element="cts:not-query">-</starter>

"starter": [
  { "strength": 30,
    "apply": "grouping",
    "delimiter": ")",
    "label": "("
  },
  { "strength": 40,
    "apply": "prefix",
    "element": "cts:not-query",
    "label": "-"
  }
]

<joiner strength="int"
         apply="funcName"
         ns="namespaceURI"
         at="modulePath"
         element="qName"
         options="optList"
         compare="operator"
         consume="nTokens"
         tokenize="value">
  opToken
</joiner>

"joiner": [{
  "label": "opToken",
  "strength": number,
  "apply": "funcName",
  "ns": "namespaceURI",
  "at": "modulePath",
  "element": "qName",
  "options": "optList",
  "compare": "operator",
  "consume": nTokens
  "tokenize": "value"
}]

fn:data() (XML)

label (JSON)

joiner strength="20" apply="infix" element="cts:and-query"
        tokenize="word">AND</joiner>
<joiner strength="50" apply="constraint" compare="LT"
        tokenize="word">LT</joiner>

"joiner": [
  { "strength": 20,
    "apply": "infix",
    "element": "cts:and-query",
    "tokenize": "word",
    "label": "label"
  },
  { "strength": 50,
    "apply": "constraint",
    "compare": "LT",
    "tokenize": "word",
    "label": "LT"
  },
]