CavalliumDBEngine/src/main/data-generator/lucene-query.yaml

# A type that starts with "-" is an optional type, otherwise it can't be null
currentVersion: "0.0.0"
interfacesData:
  Query: []
superTypesData:
  Query: [
    BoxedQuery, TermQuery, IntTermQuery, IntNDTermQuery, LongTermQuery, LongNDTermQuery, FloatTermQuery,
    FloatNDTermQuery, DoubleTermQuery, DoubleNDTermQuery,
    PhraseQuery, WildcardQuery, SynonymQuery, FuzzyQuery, MatchAllDocsQuery, MatchNoDocsQuery,
    BooleanQuery, SortedNumericDocValuesFieldSlowRangeQuery, SortedDocFieldExistsQuery,
    ConstantScoreQuery, BoostQuery, IntPointRangeQuery, IntNDPointRangeQuery, LongPointRangeQuery,
    FloatPointRangeQuery, DoublePointRangeQuery, LongNDPointRangeQuery, FloatNDPointRangeQuery,
    DoubleNDPointRangeQuery, IntPointExactQuery, IntNDPointExactQuery, LongPointExactQuery, FloatPointExactQuery,
    FloatPointExactQuery, DoublePointExactQuery, LongNDPointExactQuery, FloatNDPointExactQuery,
    DoubleNDPointExactQuery, IntPointSetQuery, LongPointSetQuery, FloatPointSetQuery, DoublePointSetQuery,
    StandardQuery, FieldExistsQuery
  ]
  Occur: [OccurMust, OccurMustNot, OccurShould, OccurFilter]
  Sort: [NoSort, NumericSort, ScoreSort, DocSort, RandomSort]
  NumberFormat: [NumberFormatDecimal]
  PointType: [PointTypeInt, PointTypeLong, PointTypeFloat, PointTypeDouble]
customTypesData: {}
baseTypesData:

  # Basic data
  # ==========

  # Wrapper for type Query
  BoxedQuery:
    data:
      query: Query
  # A term consists in a field that is exactly equal to the value string
  Term:
    data:
      field: String
      value: String
  # A Term with a position relative to the start of the query. Used internally in some specific queries
  TermPosition:
    data:
      term: Term
      position: int
  # A Term with a specified boost. Used internally in some specific queries
  TermAndBoost:
    data:
      term: Term
      boost: float
  # Occur options used for boolean queries
  OccurMust:
    data: { }
  OccurMustNot:
    data: { }
  OccurShould:
    data: { }
  OccurFilter:
    data: { }

  # Special queries
  # ===============

  # Raw lucene string query, parsable by lucene StandardQueryParser
  StandardQuery:
    data:
      query: String
      # Should be at least one field!
      defaultFields: String[]
      pointsConfig: PointConfig[]
      termFields: String[]
  PointConfig:
    data:
      field: String
      data: PointConfigData
  PointConfigData:
    data:
      numberFormat: NumberFormat
      type: PointType
  NumberFormatDecimal: { data: { } }
  PointTypeInt: { data: { } }
  PointTypeLong: { data: { } }
  PointTypeFloat: { data: { } }
  PointTypeDouble: { data: { } }

  # Text queries
  # ============

  # Query that matches a term.
  TermQuery:
    data:
      term: Term
  # Query that matches a term.
  LongTermQuery:
    data:
      field: String
      value: long
  LongNDTermQuery:
    data:
      field: String
      value: long[]
  # Query that matches a term.
  IntTermQuery:
    data:
      field: String
      value: int
  # Query that matches a term.
  IntNDTermQuery:
    data:
      field: String
      value: int[]
  # Query that matches a term.
  FloatTermQuery:
    data:
      field: String
      value: float
  # Query that matches a term.
  FloatNDTermQuery:
    data:
      field: String
      value: float[]
  # Query that matches a term.
  DoubleTermQuery:
    data:
      field: String
      value: double
  # Query that matches a term.
  DoubleNDTermQuery:
    data:
      field: String
      value: double[]
  # Query that matches the existence of a field.
  FieldExistsQuery:
    data:
      field: String
  # Query that matches a phrase.
  PhraseQuery:
    data:
      # A phrase is a collection of positioned terms, with absolute positions,
      #   counted as characters from the beginning of the phrase.
      phrase: TermPosition[]
      slop: int
  # Advanced query that matches text allowing asterisks in the query
  WildcardQuery:
    data:
      field: String
      pattern: String # Example: "*ing"
  # Advanced query that matches different exact values (synonyms)
  SynonymQuery:
    data:
      field: String
      parts: TermAndBoost[] # Each term has a boost. The preferred synonym has the highest boost value.
  # Advanced query. todo: document it
  FuzzyQuery:
    data:
      term: Term
      maxEdits: int
      prefixLength: int
      maxExpansions: int
      transpositions: boolean


  # Combination queries
  # ===================

  # Query that matches everything
  MatchAllDocsQuery:
    data: {}
  # Query that matches nothing
  MatchNoDocsQuery:
    data: {}
  # Query that matches if the document satisfies all the required parts
  BooleanQuery:
    data:
      # Each part can be:
      #  - "MUST"
      #  - "MUST_NOT"
      #  - "SHOULD"
      #  - "FILTER" (advanced, ignore this)
      # "SHOULD" is like "MUST" but it's not necessary.
      parts: BooleanQueryPart[]
      minShouldMatch: int # If set, it specifies how many "SHOULD" parts must be matched. 0 if not set
  # Part of a boolean query
  BooleanQueryPart:
    data:
      query: Query
      occur: Occur


  # Number queries
  # ==============

  # Advanced query that matches only a range of a sorted field, from "min" to "max".
  SortedNumericDocValuesFieldSlowRangeQuery:
    data:
      field: String
      min: long
      max: long
  # Query that matches if the sorted field exist in the document
  SortedDocFieldExistsQuery:
    data:
      field: String


  # Score modifying queries
  # ============

  # Query that fixes the score of a query to 1
  ConstantScoreQuery:
    data:
      query: Query
  # Query that boosts the query score
  BoostQuery:
    data:
      query: Query
      scoreBoost: float


  # Sorted fields queries
  # =====================

  # Query that matches an int point field, from "min", to "max"
  IntPointRangeQuery:
    data:
      field: String
      min: int
      max: int
  # Query that matches an int point field, from "min", to "max"
  IntNDPointRangeQuery:
    data:
      field: String
      min: int[]
      max: int[]
  # Query that matches a long point field, from "min", to "max"
  LongPointRangeQuery:
    data:
      field: String
      min: long
      max: long
  # Query that matches a float point field, from "min", to "max"
  FloatPointRangeQuery:
    data:
      field: String
      min: float
      max: float
  # Query that matches a double point field, from "min", to "max"
  DoublePointRangeQuery:
    data:
      field: String
      min: double
      max: double
  # Query that matches a long point field, from "min", to "max"
  LongNDPointRangeQuery:
    data:
      field: String
      min: long[]
      max: long[]
  # Query that matches a float point field, from "min", to "max"
  FloatNDPointRangeQuery:
    data:
      field: String
      min: float[]
      max: float[]
  # Query that matches a double point field, from "min", to "max"
  DoubleNDPointRangeQuery:
    data:
      field: String
      min: double[]
      max: double[]
  # Query that matches an int point field
  IntPointExactQuery:
    data:
      field: String
      value: int
  # Query that matches an int point field
  IntNDPointExactQuery:
    data:
      field: String
      value: int[]
  # Query that matches a long point field
  LongPointExactQuery:
    data:
      field: String
      value: long
  # Query that matches a float point field
  FloatPointExactQuery:
    data:
      field: String
      value: float
  # Query that matches a double point field
  DoublePointExactQuery:
    data:
      field: String
      value: double
  # Query that matches a long point field
  LongNDPointExactQuery:
    data:
      field: String
      value: long[]
  # Query that matches a float point field
  FloatNDPointExactQuery:
    data:
      field: String
      value: float[]
  # Query that matches a double point field
  DoubleNDPointExactQuery:
    data:
      field: String
      value: double[]
  # Query that matches a set of int point field
  IntPointSetQuery:
    data:
      field: String
      values: int[]
  # Query that matches a set of long point field
  LongPointSetQuery:
    data:
      field: String
      values: long[]
  # Query that matches a set of float point field
  FloatPointSetQuery:
    data:
      field: String
      values: float[]
  # Query that matches a set of double point field
  DoublePointSetQuery:
    data:
      field: String
      values: double[]


  # Extra data used for parameters and the client
  # =============================================

  # Query parameters
  QueryParams:
    data:
      query: Query
      offset: long
      limit: long
      sort: Sort
      computePreciseHitsCount: boolean
      timeoutMilliseconds: long
  NoSort:
    data: { }
  NumericSort:
    data:
      field: String
      reverse: boolean
  RandomSort:
    data: { }
  ScoreSort:
    data: { }
  DocSort:
    data: { }
  TotalHitsCount:
    stringRepresenter: "it.cavallium.dbengine.lucene.LuceneUtils.toHumanReadableString"
    data:
      value: long
      exact: boolean
versions:
  0.0.0:
    details:
      changelog: "First version"