## 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
`FieldMaskingSpanQuery(SpanQuery maskedQuery, java.lang.String maskedField)`

Method Summary
`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-2011 Apache Software Foundation. All Rights Reserved.