org.apache.lucene.search.spans

## Class FieldMaskingSpanQuery

- java.lang.Object
- - org.apache.lucene.search.Query
  - - org.apache.lucene.search.spans.SpanQuery
    - - org.apache.lucene.search.spans.FieldMaskingSpanQuery

- All Implemented Interfaces:
    java.io.Serializable, java.lang.Cloneable

      public class FieldMaskingSpanQuery
      extends SpanQuery

  Wrapper to allow `SpanQuery` objects participate in composite single-field SpanQueries by 'lying' about their search field. That is, the masked SpanQuery will function as normal, but `SpanQuery.getField()` simply hands back the value supplied in this class's constructor.

  This can be used to support Queries like `SpanNearQuery` or `SpanOrQuery` across different fields, which is not ordinarily permitted.

  This can be useful for denormalized relational data: for example, when indexing a document with conceptually many 'children':

        teacherid: 1
        studentfirstname: james
        studentsurname: jones

        teacherid: 2
        studenfirstname: james
        studentsurname: smith
        studentfirstname: sally
        studentsurname: jones

  a SpanNearQuery with a slop of 0 can be applied across two `SpanTermQuery` objects as follows:

          SpanQuery q1  = new SpanTermQuery(new Term("studentfirstname", "james"));
          SpanQuery q2  = new SpanTermQuery(new Term("studentsurname", "jones"));
          SpanQuery q2m new FieldMaskingSpanQuery(q2, "studentfirstname");
          Query q = new SpanNearQuery(new SpanQuery[]{q1, q2m}, -1, false);

  to search for 'studentfirstname:james studentsurname:jones' and find teacherid 1 without matching teacherid 2 (which has a 'james' in position 0 and 'jones' in position 1).

  Note: as `getField()` returns the masked field, scoring will be done using the norms of the field name supplied. This may lead to unexpected scoring behaviour.

  See Also:
    Serialized Form

- - ### Constructor Summary

    Constructors
    Constructor and Description
    `FieldMaskingSpanQuery(SpanQuery maskedQuery, java.lang.String maskedField)`

  - ### Method Summary

    All Methods Instance Methods Concrete Methods Deprecated Methods
    Modifier and Type | Method and Description
    --- | ---
    `Weight` | `createWeight(Searcher searcher)` Expert: Constructs an appropriate Weight implementation for this query.
    `boolean` | `equals(java.lang.Object o)`
    `void` | `extractTerms(java.util.Set terms)` Expert: adds all terms occurring in this query to the terms set.
    `java.lang.String` | `getField()` Returns the name of the field matched by this query.
    `SpanQuery` | `getMaskedQuery()`
    `Similarity` | `getSimilarity(Searcher searcher)` Expert: Returns the Similarity implementation to be used for this query.
    `Spans` | `getSpans(IndexReader reader)` Expert: Returns the matches for this query in an index.
    `java.util.Collection` | `getTerms()` Deprecated. use `extractTerms(Set)` instead.
    `int` | `hashCode()`
    `Query` | `rewrite(IndexReader reader)` Expert: called to re-write queries into primitive queries.
    `java.lang.String` | `toString(java.lang.String field)` Prints a query to a string, with `field` assumed to be the default field and omitted.

    - ### Methods inherited from class org.apache.lucene.search.Query

      `clone, combine, getBoost, mergeBooleanQueries, setBoost, toString, weight`

    - ### Methods inherited from class java.lang.Object

      `finalize, getClass, notify, notifyAll, wait, wait, wait`

- - ### Constructor Detail

    - #### FieldMaskingSpanQuery

          public FieldMaskingSpanQuery(SpanQuery maskedQuery,
                                       java.lang.String maskedField)

  - ### Method Detail

    - #### getField

          public java.lang.String getField()

      Description copied from class: `SpanQuery`
      Returns the name of the field matched by this query.
      Specified by:
        `getField` in class `SpanQuery`

    - #### getMaskedQuery

          public SpanQuery getMaskedQuery()

    - #### getSpans

          public Spans getSpans(IndexReader reader)
                         throws java.io.IOException

      Description copied from class: `SpanQuery`
      Expert: Returns the matches for this query in an index. Used internally to search for spans.
      Specified by:
        `getSpans` in class `SpanQuery`
      Throws:
        `java.io.IOException`

    - #### getTerms

          public java.util.Collection getTerms()

      Deprecated. use `extractTerms(Set)` instead.
      Description copied from class: `SpanQuery`
      Returns a collection of all terms matched by this query.
      Specified by:
        `getTerms` in class `SpanQuery`
      See Also:
        `Query.extractTerms(Set)`

    - #### extractTerms

          public void extractTerms(java.util.Set terms)

      Description copied from class: `Query`
      Expert: adds all terms occurring in this query to the terms set. Only works if this query is in its `rewritten` form.
      Overrides:
        `extractTerms` in class `Query`

    - #### createWeight

          public Weight createWeight(Searcher searcher)
                              throws java.io.IOException

      Description copied from class: `Query`
      Expert: Constructs an appropriate Weight implementation for this query.

      Only implemented by primitive queries, which re-write to themselves.

      Overrides:
        `createWeight` in class `SpanQuery`
      Throws:
        `java.io.IOException`

    - #### getSimilarity

          public Similarity getSimilarity(Searcher searcher)

      Description copied from class: `Query`
      Expert: Returns the Similarity implementation to be used for this query. Subclasses may override this method to specify their own Similarity implementation, perhaps one that delegates through that of the Searcher. By default the Searcher's Similarity implementation is returned.
      Overrides:
        `getSimilarity` in class `Query`

    - #### rewrite

          public Query rewrite(IndexReader reader)
                        throws java.io.IOException

      Description copied from class: `Query`
      Expert: called to re-write queries into primitive queries. For example, a PrefixQuery will be rewritten into a BooleanQuery that consists of TermQuerys.
      Overrides:
        `rewrite` in class `Query`
      Throws:
        `java.io.IOException`

    - #### toString

          public java.lang.String toString(java.lang.String field)

      Description copied from class: `Query`
      Prints a query to a string, with `field` assumed to be the default field and omitted.

      The representation used is one that is supposed to be readable by `QueryParser`. However, there are the following limitations:

      - If the query was created by the parser, the printed representation may not be exactly what was parsed. For example, characters that need to be escaped will be represented without the required backslash.
      - Some of the more complicated queries (e.g. span queries) don't have a representation that can be parsed by QueryParser.
      Specified by:
        `toString` in class `Query`

    - #### equals

          public boolean equals(java.lang.Object o)

      Overrides:
        `equals` in class `Query`

    - #### hashCode

          public int hashCode()

      Overrides:
        `hashCode` in class `Query`

Copyright © 2000-2016 Apache Software Foundation. All Rights Reserved.