com.foursquare.slashem.QueryBuilder

Ordering

Alphabetic
By inheritance

Inherited

Hide All
Show all

QueryBuilder
Serializable
Serializable
Product
Equals
AnyRef
Any

Visibility

Public
All

Instance Constructors

new QueryBuilder (meta: M with SlashemSchema[M], clauses: AbstractClause, filters: List[AbstractClause], boostQueries: List[AbstractClause], queryFields: List[WeightedField], phraseBoostFields: List[PhraseWeightedField], boostFields: List[ScoreBoost], start: Option[Long], limit: Option[Long], tieBreaker: Option[Double], sort: Option[(ScoreBoost, String)], minimumMatch: Option[String], queryType: Option[String], fieldsToFetch: List[String], hls: Option[String], hlFragSize: Option[Int], creator: Option[((Map[String, Any], Option[Map[String, ArrayList[String]]])) ⇒ Y], comment: Option[String], fallOf: Option[Double], min: Option[Int])

Value Members

def != (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def != (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
def ## (): Int

Attributes
final
Definition Classes
AnyRef → Any
def == (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def == (arg0: Any): Boolean

Attributes
final
Definition Classes
Any
val DefaultLimit : Int
val DefaultStart : Int
def addComment (s: String): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Add a comment
def and (c: (M) ⇒ AbstractClause): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]
def asInstanceOf [T0] : T0

Attributes
final
Definition Classes
Any
def boostField [F] (f: (M) ⇒ SlashemField[F, M], boost: Double): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Boost a field (type safe version)
def boostField (s: String): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Boost a specific field/query.
Boost a specific field/query. WARNING: NOT TYPE SAFE NO VALIDATION ETC.
val boostFields : List[ScoreBoost]
val boostQueries : List[AbstractClause]
def boostQuery [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

A boostQuery affects the scoring of the results.
A boostQuery affects the scoring of the results.
f
The boost query
def canEqual (arg0: Any): Boolean

Definition Classes
QueryBuilder → Equals
val clauses : AbstractClause
def clone (): AnyRef

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
val comment : Option[String]
def complexOrderAsc (f: (M) ⇒ ScoreBoost)(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

Handle a more complex field sort
def complexOrderDesc (f: (M) ⇒ ScoreBoost)(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

Handle a more complex field sort
val creator : Option[((Map[String, Any], Option[Map[String, ArrayList[String]]])) ⇒ Y]
def eq (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def equals (arg0: Any): Boolean

Definition Classes
QueryBuilder → Equals → AnyRef → Any
val fallOf : Option[Double]
def fetch (timeout: Duration): SearchResults[M, Y]

Fetch the results for a given query (blocking) with a specified timeout
def fetch (): SearchResults[M, Y]

Fetch the results for a given query (blocking)
def fetch (l: Int)(implicit ev: =:=[Lim, Unlimited]): SearchResults[M, Y]

Fetch the results with the limit of l.
Fetch the results with the limit of l. Can only be used on an unlimited query
def fetchBatch [T] (batchSize: Int, timeout: Duration = Duration(1, TimeUnit.SECONDS))(f: (SearchResults[M, Y]) ⇒ List[T]): List[T]

Call fetchBatch when you need a large number of results from SOLR.
Call fetchBatch when you need a large number of results from SOLR. Usage example: val res = (SVenue where (_.default eqs "coffee") start(10) limit(40) fetchBatch(10)) {_.response.oids }
batchSize
The size of the batch to be retrieved
f
A function to be applied over the result batches
def fetchField [F] (f: (M) ⇒ SlashemField[F, M]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Specify a field to be retrieved.
Specify a field to be retrieved. If you want to get back all fields you can use a field of name "*"
f
Field to be retrieved
def fetchFields (fs: (M) ⇒ com.foursquare.slashem.SlashemField[_, M]*): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Same as fetchField but takes multiple fields
Same as fetchField but takes multiple fields
fs
List of fields to be retrieved
def fetchFuture (): Future[SearchResults[M, Y]]

Fetch the results for a given query (non-blocking)
val fieldsToFetch : List[String]
def filter [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Filter the result set.
Filter the result set. Filter queries can be run in parallel from the main query and have a separate cache. Filter queries are great for queries that are repeated often which you want to constrain your result set by.
f
The query to filter on
val filters : List[AbstractClause]
def finalize (): Unit

Attributes
protected[lang]
Definition Classes
AnyRef
Annotations
@throws()
def getClass (): java.lang.Class[_]

Attributes
final
Definition Classes
AnyRef → Any
def hashCode (): Int

Definition Classes
QueryBuilder → AnyRef → Any
def highlighting (fragSize: Int)(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, Y, YesHighlighting, Q]
def highlighting ()(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, Y, YesHighlighting, Q]

Turn on highlighting.
Turn on highlighting. Must be done prior to select case
val hlFragSize : Option[Int]
val hls : Option[String]
def isInstanceOf [T0] : Boolean

Attributes
final
Definition Classes
Any
def limit (l: Int)(implicit ev: =:=[Lim, Unlimited]): QueryBuilder[M, Ord, Limited, MM, Y, H, Q]

Limit the query to only fetch back l results.
Limit the query to only fetch back l results. Can only be applied to a query without an existing limit
l
The limit
val limit : Option[Long]
val meta : M with SlashemSchema[M]
val min : Option[Int]
val minimumMatch : Option[String]
def minimumMatchAbsolute (count: Int)(implicit ev: =:=[MM, defaultMM]): QueryBuilder[M, Ord, Lim, customMM, Y, H, Q]

If you doing a phrase search this the absolute # of terms that must match.
If you doing a phrase search this the absolute # of terms that must match. You can only use one of minimumMatchAbsolute or minimumMatchPercent. to match. Note: You must chose one or the other.
count
The minimum number of tokens to match
def minimumMatchPercent (percent: Int)(implicit ev: =:=[MM, defaultMM]): QueryBuilder[M, Ord, Lim, customMM, Y, H, Q]

If you doing a phrase search this the percent of terms that must match, rounded down.
If you doing a phrase search this the percent of terms that must match, rounded down. So if you have it set to 50 and then do a search with 3 terms at least one term must match. A search of 4 however would require 2 terms to match. You can only use one of minimumMatchAbsolute or minimumMatchPercent.
percent
The minimum percent of tokens to match
def ne (arg0: AnyRef): Boolean

Attributes
final
Definition Classes
AnyRef
def notify (): Unit

Attributes
final
Definition Classes
AnyRef
def notifyAll (): Unit

Attributes
final
Definition Classes
AnyRef
def or (c: (M) ⇒ AbstractClause): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]
def orFilter [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]
def orderAsc [F] (f: (M) ⇒ SlashemField[F, M])(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

Order the results by a specific field in ascending order.
Order the results by a specific field in ascending order. Can only be applied to an unordered query.
f
Field to order by
def orderDesc [F] (f: (M) ⇒ SlashemField[F, M])(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

Order the results by a specific field in descending order.
Order the results by a specific field in descending order. Can only be applied to an unordered query.
f
Field to order by
def phraseBoost [F] (f: (M) ⇒ SlashemField[F, M], boost: Double, pf: Boolean, pf2: Boolean, pf3: Boolean): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Certain query parsers allow you to set a phraseBoost field.
Certain query parsers allow you to set a phraseBoost field. Generally these are only run on the returned documents. So if I want to return all documents matching either coffee or shop but I want documents with "coffee shop" to score higher I would set this. The params for pf,pf2,and pf3 control what type of phrase boost query to generate. In edismax pf2/pf3 results in a query which will match shingled phrase queries of length 2 & 3 respectively. For example pf2=true in edismax and a query of "delicious coffee shops" would boost documents containing "delicious coffee" and "coffee shops".
f
The field to boost phrase matches in
boost
The (optional) boost value
pf
Enable/disable full phrase boosting
pf2
Enable/disable 2-word shingle phrase boosting
pf3
Enable/disable 3-word shingle phrase boosting
val phraseBoostFields : List[PhraseWeightedField]
def productArity : Int

Definition Classes
QueryBuilder → Product
def productElement (arg0: Int): Any

Definition Classes
QueryBuilder → Product
def productIterator : Iterator[Any]

Definition Classes
Product
def productPrefix : String

Definition Classes
QueryBuilder → Product
def qualityFilter (f: Double, m: Int)(implicit ev: =:=[Q, NoQualityFilter]): QueryBuilder[M, Ord, Lim, MM, Y, H, StrictQualityFilter]

Turn on quality filtering.
def queryField [F] (f: (M) ⇒ SlashemField[F, M], boost: Double): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Depending on the query type you set, you can specify different fields to be queried.
Depending on the query type you set, you can specify different fields to be queried. This allows you to set a field and a boost. Fair warning: If you set this value, it may be ignored (it is by the default solr query parser)
f
The field to query
boost
The (optional) amount to boost the query weight for the provided field
def queryFields (fs: List[(M) ⇒ com.foursquare.slashem.SlashemField[_, M]], boost: Double = 1): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Same as queryField but takes a list of fields.
Same as queryField but takes a list of fields.
fs
A list of fields to query
boost
The (optional) amount to boost the query weight for the provided field
val queryFields : List[WeightedField]
val queryType : Option[String]
def scoreBoostField (f: (M) ⇒ ScoreBoost): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Handle a more complex field boost
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, F18, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], f14: (M) ⇒ SlashemField[F14, M], f15: (M) ⇒ SlashemField[F15, M], f16: (M) ⇒ SlashemField[F16, M], f17: (M) ⇒ SlashemField[F17, M], f18: (M) ⇒ SlashemField[F18, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13], Option[F14], Option[F15], Option[F16], Option[F17], Option[F18]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, F17, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], f14: (M) ⇒ SlashemField[F14, M], f15: (M) ⇒ SlashemField[F15, M], f16: (M) ⇒ SlashemField[F16, M], f17: (M) ⇒ SlashemField[F17, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13], Option[F14], Option[F15], Option[F16], Option[F17]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, F16, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], f14: (M) ⇒ SlashemField[F14, M], f15: (M) ⇒ SlashemField[F15, M], f16: (M) ⇒ SlashemField[F16, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13], Option[F14], Option[F15], Option[F16]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, F15, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], f14: (M) ⇒ SlashemField[F14, M], f15: (M) ⇒ SlashemField[F15, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13], Option[F14], Option[F15]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, F14, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], f14: (M) ⇒ SlashemField[F14, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13], Option[F14]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, F13, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], f13: (M) ⇒ SlashemField[F13, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12], Option[F13]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, F12, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], f12: (M) ⇒ SlashemField[F12, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11], Option[F12]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, F11, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], f11: (M) ⇒ SlashemField[F11, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10], Option[F11]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, F10, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], f10: (M) ⇒ SlashemField[F10, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9], Option[F10]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, F9, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], f9: (M) ⇒ SlashemField[F9, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8], Option[F9]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, F8, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], f8: (M) ⇒ SlashemField[F8, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7], Option[F8]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, F7, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], f7: (M) ⇒ SlashemField[F7, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6], Option[F7]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5], Option[F6]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, F6, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], f6: (M) ⇒ SlashemField[F6, M], create: (Option[F1], List[String], Option[F2], List[String], Option[F3], List[String], Option[F4], List[String], Option[F5], List[String], Option[F6], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], create: (Option[F1], Option[F2], Option[F3], Option[F4], Option[F5]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, F5, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], f5: (M) ⇒ SlashemField[F5, M], create: (Option[F1], List[String], Option[F2], List[String], Option[F3], List[String], Option[F4], List[String], Option[F5], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], create: (Option[F1], Option[F2], Option[F3], Option[F4]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, F4, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], f4: (M) ⇒ SlashemField[F4, M], create: (Option[F1], List[String], Option[F2], List[String], Option[F3], List[String], Option[F4], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], create: (Option[F1], Option[F2], Option[F3]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, F3, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], create: (Option[F1], List[String], Option[F2], List[String], Option[F3], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], create: (Option[F1], Option[F2]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, F2, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], create: (Option[F1], List[String], Option[F2], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, CC] (f: (M) ⇒ SlashemField[F1, M], create: (Option[F1], List[String]) ⇒ CC)(implicit ev: =:=[(Y, H), (NoSelect, YesHighlighting)]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
def selectCase [F1, CC] (f: (M) ⇒ SlashemField[F1, M], create: (Option[F1]) ⇒ CC)(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

Select into a case class
val sort : Option[(ScoreBoost, String)]
def start (s: Long): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Where you want to start fetching results back from
Where you want to start fetching results back from
s
Where you want to start fetching results from.
val start : Option[Long]
def synchronized [T0] (arg0: ⇒ T0): T0

Attributes
final
Definition Classes
AnyRef
def test (): Unit
def tieBreaker (t: Double): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

In edismax the score is max({scores})+tieBreak*\sum{scores})
val tieBreaker : Option[Double]
def toString (): String

Definition Classes
QueryBuilder → AnyRef → Any
def useQueryType (qt: String): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

Set the query type.
Set the query type. This corresponds to the "defType" field. Some sample values include "edismax" , "dismax" or just empty to use the default query type
qt
The query type
def wait (): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long, arg1: Int): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()
def wait (arg0: Long): Unit

Attributes
final
Definition Classes
AnyRef
Annotations
@throws()

Deprecated Value Members

def productElements : Iterator[Any]

Definition Classes
Product
Annotations
@deprecated
Deprecated
use productIterator instead

QueryBuilder

Instance Constructors

Value Members

def != (arg0: AnyRef): Boolean

def != (arg0: Any): Boolean

def ## (): Int

def == (arg0: AnyRef): Boolean

def == (arg0: Any): Boolean

val DefaultLimit : Int

val DefaultStart : Int

def addComment (s: String): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def and (c: (M) ⇒ AbstractClause): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def asInstanceOf [T0] : T0

def boostField [F] (f: (M) ⇒ SlashemField[F, M], boost: Double): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def boostField (s: String): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

val boostFields : List[ScoreBoost]

val boostQueries : List[AbstractClause]

def boostQuery [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def canEqual (arg0: Any): Boolean

val clauses : AbstractClause

def clone (): AnyRef

val comment : Option[String]

def complexOrderAsc (f: (M) ⇒ ScoreBoost)(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

def complexOrderDesc (f: (M) ⇒ ScoreBoost)(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

val creator : Option[((Map[String, Any], Option[Map[String, ArrayList[String]]])) ⇒ Y]

def eq (arg0: AnyRef): Boolean

def equals (arg0: Any): Boolean

val fallOf : Option[Double]

def fetch (timeout: Duration): SearchResults[M, Y]

def fetch (): SearchResults[M, Y]

def fetch (l: Int)(implicit ev: =:=[Lim, Unlimited]): SearchResults[M, Y]

def fetchBatch [T] (batchSize: Int, timeout: Duration = Duration(1, TimeUnit.SECONDS))(f: (SearchResults[M, Y]) ⇒ List[T]): List[T]

def fetchField [F] (f: (M) ⇒ SlashemField[F, M]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def fetchFields (fs: (M) ⇒ com.foursquare.slashem.SlashemField[_, M]*): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def fetchFuture (): Future[SearchResults[M, Y]]

val fieldsToFetch : List[String]

def filter [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

val filters : List[AbstractClause]

def finalize (): Unit

def getClass (): java.lang.Class[_]

def hashCode (): Int

def highlighting (fragSize: Int)(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, Y, YesHighlighting, Q]

def highlighting ()(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, Y, YesHighlighting, Q]

val hlFragSize : Option[Int]

val hls : Option[String]

def isInstanceOf [T0] : Boolean

def limit (l: Int)(implicit ev: =:=[Lim, Unlimited]): QueryBuilder[M, Ord, Limited, MM, Y, H, Q]

val limit : Option[Long]

val meta : M with SlashemSchema[M]

val min : Option[Int]

val minimumMatch : Option[String]

def minimumMatchAbsolute (count: Int)(implicit ev: =:=[MM, defaultMM]): QueryBuilder[M, Ord, Lim, customMM, Y, H, Q]

def minimumMatchPercent (percent: Int)(implicit ev: =:=[MM, defaultMM]): QueryBuilder[M, Ord, Lim, customMM, Y, H, Q]

def ne (arg0: AnyRef): Boolean

def notify (): Unit

def notifyAll (): Unit

def or (c: (M) ⇒ AbstractClause): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def orFilter [F] (f: (M) ⇒ Clause[F]): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def orderAsc [F] (f: (M) ⇒ SlashemField[F, M])(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

def orderDesc [F] (f: (M) ⇒ SlashemField[F, M])(implicit ev: =:=[Ord, Unordered]): QueryBuilder[M, Ordered, Lim, MM, Y, H, Q]

def phraseBoost [F] (f: (M) ⇒ SlashemField[F, M], boost: Double, pf: Boolean, pf2: Boolean, pf3: Boolean): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

val phraseBoostFields : List[PhraseWeightedField]

def productArity : Int

def productElement (arg0: Int): Any

def productIterator : Iterator[Any]

def productPrefix : String

def qualityFilter (f: Double, m: Int)(implicit ev: =:=[Q, NoQualityFilter]): QueryBuilder[M, Ord, Lim, MM, Y, H, StrictQualityFilter]

def queryField [F] (f: (M) ⇒ SlashemField[F, M], boost: Double): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def queryFields (fs: List[(M) ⇒ com.foursquare.slashem.SlashemField[_, M]], boost: Double = 1): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

val queryFields : List[WeightedField]

val queryType : Option[String]

def scoreBoostField (f: (M) ⇒ ScoreBoost): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]

def selectCase [F1, F2, F3, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], create: (Option[F1], Option[F2], Option[F3]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

def selectCase [F1, F2, F3, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], f3: (M) ⇒ SlashemField[F3, M], create: (Option[F1], List[String], Option[F2], List[String], Option[F3], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

def selectCase [F1, F2, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], create: (Option[F1], Option[F2]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

def selectCase [F1, F2, CC] (f1: (M) ⇒ SlashemField[F1, M], f2: (M) ⇒ SlashemField[F2, M], create: (Option[F1], List[String], Option[F2], List[String]) ⇒ CC)(implicit ev: =:=[Y, NoSelect]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

def selectCase [F1, CC] (f: (M) ⇒ SlashemField[F1, M], create: (Option[F1], List[String]) ⇒ CC)(implicit ev: =:=[(Y, H), (NoSelect, YesHighlighting)]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

def selectCase [F1, CC] (f: (M) ⇒ SlashemField[F1, M], create: (Option[F1]) ⇒ CC)(implicit ev: =:=[(Y, H), (NoSelect, NoHighlighting)]): QueryBuilder[M, Ord, Lim, MM, CC, H, Q]

val sort : Option[(ScoreBoost, String)]

def start (s: Long): QueryBuilder[M, Ord, Lim, MM, Y, H, Q]