case class Dim extends Named[Dim] with Product with Serializable
This class represents a single dimension in a Druid datasource, along with all operations that can be performed in a query (e.g., filtering, aggregation, post-aggregation, etc.).
- Alphabetic
- By Inheritance
- Dim
- Serializable
- Product
- Equals
- Named
- AnyRef
- Any
- Hide All
- Show All
- Public
- Protected
Value Members
- final def !=(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- final def ##: Int
- Definition Classes
- AnyRef → Any
- def *(v: Dim): ArithmeticPostAgg
Arithmetic multiplication post-aggregator
- def *(v: Double): ArithmeticPostAgg
Arithmetic multiplication post-aggregator
- def +(v: Dim): ArithmeticPostAgg
Arithmetic addition post-aggregator
- def +(v: Double): ArithmeticPostAgg
Arithmetic addition post-aggregator
- def -(v: Dim): ArithmeticPostAgg
Arithmetic subtraction post-aggregator
- def -(v: Double): ArithmeticPostAgg
Arithmetic subtraction post-aggregator
- def /(v: Dim): ArithmeticPostAgg
Arithmetic division post-aggregator, that always returns 0 when dividing by 0, regardless of the numerator
- def /(v: Double): ArithmeticPostAgg
Arithmetic division post-aggregator, that always returns 0 when dividing by 0, regardless of the numerator
- def <(value: String): Bound
Filter based on a upper bound of dimension values, using lexicographic ordering.
Filter based on a upper bound of dimension values, using lexicographic ordering.
- returns
a bound filtering expression, with lexicographic ordering, specifying that the value of the dimension should be less than the given number.
- def <(value: Double): FilteringExpression
Filter based on a strict upper bound of dimension values, using numeric ordering.
Filter based on a strict upper bound of dimension values, using numeric ordering.
- returns
a bound filtering expression, with numeric ordering, specifying that the value of the dimension should be less than the given number.
- def <=(value: String): Bound
Filter based on a strict upper bound of dimension values, using lexicographic ordering.
Filter based on a strict upper bound of dimension values, using lexicographic ordering.
- returns
a bound filtering expression, with lexicographic ordering, specifying that the value of the dimension should be less than, or equal to the given number.
- def <=(value: Double): FilteringExpression
Filter based on an upper bound of dimension values, using numeric ordering.
Filter based on an upper bound of dimension values, using numeric ordering.
- returns
a bound filtering expression, with numeric ordering, specifying that the value of the dimension should be less than, or equal to the given number.
- def =!=(value: Long): FilteringExpression
- def =!=(value: Double): FilteringExpression
- returns
a filtering expression of not equals (numeric)
- def =!=(value: String): FilteringExpression
- returns
a filtering expression of not equals (string)
- def =!=(other: Dim): FilteringExpression
- returns
negated column-comparison filtering expression between this and the specified dimensions.
- final def ==(arg0: Any): Boolean
- Definition Classes
- AnyRef → Any
- def ===(value: Long): FilteringExpression
- def ===(value: Double): FilteringExpression
- returns
a filtering expression of value equals (numeric)
- def ===(value: String): FilteringExpression
- returns
a filtering expression of value equals (string)
- def ===(other: Dim): FilteringExpression
- returns
column-comparison filtering expression between this and the specified dimensions.
- def >(value: String): Bound
Filter based on a lower bound of dimension values, using lexicographic ordering.
Filter based on a lower bound of dimension values, using lexicographic ordering.
- returns
a bound filtering expression, with lexicographic ordering, specifying that the value of the dimension should be greater than the given number.
- def >(value: Double): FilteringExpression
Filter based on a strict lower bound of dimension values, using numeric ordering.
Filter based on a strict lower bound of dimension values, using numeric ordering.
- returns
a bound filtering expression, with numeric ordering, specifying that the value of the dimension should be greater than the given number.
- def >=(value: String): Bound
Filter based on a strict lower bound of dimension values, using lexicographic ordering.
Filter based on a strict lower bound of dimension values, using lexicographic ordering.
- returns
a bound filtering expression, with lexicographic ordering, specifying that the value of the dimension should be greater than, or equal to the given number.
- def >=(value: Double): FilteringExpression
Filter based on a lower bound of dimension values, using numeric ordering.
Filter based on a lower bound of dimension values, using numeric ordering.
- returns
a bound filtering expression, with numeric ordering, specifying that the value of the dimension should be greater than, or equal to the given number.
- def alias(name: String): Dim
Sets an alias of the dimension
- def as(name: String): Dim
- Definition Classes
- Named
- def asFloat: Dim
- returns
this dimension with FLOAT as output type
- final def asInstanceOf[T0]: T0
- Definition Classes
- Any
- def asLong: Dim
- returns
this dimension with LONG as output type
- def asString: Dim
- returns
this dimension with STRING as output type
- def asc(orderType: DimensionOrderType): OrderByColumnSpec
Set column ascending direction, using the specified ordering
- def asc: OrderByColumnSpec
Set column ascending direction, using lexicographic ordering
- def between(lower: String, upper: String): Bound
Filter on ranges of dimension values, using lexicographic ordering, where lower and upper bounds are non-strict.
Filter on ranges of dimension values, using lexicographic ordering, where lower and upper bounds are non-strict.
- lower
the lower bound
- upper
the upper bound
- returns
a bound filtering expression, with lexicographic ordering, where each bound is not-strict
- def between(lower: String, upper: String, lowerStrict: Boolean, upperStrict: Boolean): Bound
Filter on ranges of dimension values, using lexicographic ordering.
Filter on ranges of dimension values, using lexicographic ordering.
- lower
the lower bound
- upper
the upper bound
- lowerStrict
Perform strict comparison on the lower bound ("<" instead of "<=")
- upperStrict
Perform strict comparison on the upper bound (">" instead of ">=")
- returns
a bound filtering expression, with lexicographic ordering
- def between(lower: Double, upper: Double): Bound
Filter on ranges of dimension values, using numeric ordering, where lower and upper bounds are non-strict.
Filter on ranges of dimension values, using numeric ordering, where lower and upper bounds are non-strict.
- lower
the lower bound
- upper
the upper bound
- returns
a bound filtering expression, with numeric ordering, where each bound is not-strict
- def between(lower: Double, upper: Double, lowerStrict: Boolean, upperStrict: Boolean): Bound
Filter on ranges of dimension values, using numeric ordering.
Filter on ranges of dimension values, using numeric ordering.
- lower
the lower bound
- upper
the upper bound
- lowerStrict
Perform strict comparison on the lower bound ("<" instead of "<=")
- upperStrict
Perform strict comparison on the upper bound (">" instead of ">=")
- returns
a bound filtering expression, with numeric ordering
- def build(): Dimension
- returns
the resulting instance of Dimension. When
extractionFnis set, then give an instance of ExtractionDimension, otherwise DefaultDimension.
- Attributes
- protected[dql]
- def cast(outputType: DimType): Dim
- def cast(outputType: String): Dim
Set the output type of the dimension.
Set the output type of the dimension. In can be any of
STRING,LONGorFLOAT.- outputType
the output type (
STRING,LONGorFLOAT.)- returns
the dimension having set the specified output type
- def clone(): AnyRef
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.CloneNotSupportedException]) @native() @HotSpotIntrinsicCandidate()
- def contains(value: String, caseSensitive: Boolean = true): FilteringExpression
Filter on partial string matches
Filter on partial string matches
- value
the value to search
- caseSensitive
enable/disable case-sensitive search
- returns
the search filtering expression
- def containsIgnoreCase(value: String): FilteringExpression
Filter on partial string matches, with ignore case search
Filter on partial string matches, with ignore case search
- returns
the search filtering expression
- def containsInsensitive(value: String): FilteringExpression
Filter on partial string matches, with ignore case search
Filter on partial string matches, with ignore case search
- returns
the search filtering expression
- def count: AggregationExpression
Aggregation to count the number of rows
Aggregation to count the number of rows
Please note the count aggregator counts the number of Druid rows, which does not always reflect the number of raw events ingested. This is because Apache Druid can be configured to roll up data at ingestion time.
To count the number of ingested rows of data, include a count aggregator at ingestion time, and a longSum aggregator at query time.
- def desc(orderType: DimensionOrderType): OrderByColumnSpec
Set column descending direction, using the specified ordering
- def desc: OrderByColumnSpec
Set column descending direction, using lexicographic ordering
- def doubleFirst: AggregationExpression
Aggregation to compute the metric value with the minimum timestamp or 0 if no row exist
- def doubleLast: AggregationExpression
Aggregation to compute the metric value with the maximum timestamp or 0 if no row exist
- def doubleMax: AggregationExpression
Aggregation to compute the maximum of all metric values and Double.NEGATIVE_INFINITY
- def doubleMin: AggregationExpression
Aggregation to compute the minimum of all metric values and Double.POSITIVE_INFINITY
- def doubleSum: AggregationExpression
Aggregation to compute the sum of values (as a 64-bit floating point value)
- final def eq(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def extract(fn: ExtractionFn): Dim
Set an extraction function
Set an extraction function
- fn
the extraction function to use (see ExtractionFn)
- val extractionFnOpt: Option[ExtractionFn]
- def floatFirst: AggregationExpression
Aggregation to compute the metric value with the minimum timestamp or 0 if no row exist
- def floatLast: AggregationExpression
Aggregation to compute the metric value with the maximum timestamp or 0 if no row exist
- def floatMax: AggregationExpression
Aggregation to compute the maximum of all metric values and Float.NEGATIVE_INFINITY
- def floatMin: AggregationExpression
Aggregation to compute the minimum of all metric values and Float.POSITIVE_INFINITY
- def floatSum: AggregationExpression
Aggregation to compute the sum of values (as a 32-bit floating point value)
- final def getClass(): Class[_ <: AnyRef]
- Definition Classes
- AnyRef → Any
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- def getName: String
- def hyperUnique: HyperUniqueAgg
Aggregation to compute the estimated cardinality of a dimension that has been aggregated as a "hyperUnique" metric at indexing time.
- def hyperUniqueCardinality: HyperUniqueCardinalityPostAgg
HyperUnique Cardinality post-aggregator
- def in[T](values: Iterable[T])(implicit arg0: Numeric[T]): InNumeric[T]
- def in[T](value: T, values: T*)(implicit arg0: Numeric[T]): FilteringExpression
- def in(values: Iterable[String]): In
- def in(value: String, values: String*): FilteringExpression
- returns
in-filter of this dimension for the specified values
- def inFiltered(aggregator: AggregationExpression, values: Iterable[String]): AggregationExpression
- def inFiltered(aggregator: AggregationExpression, first: String, rest: String*): AggregationExpression
Wraps any given aggregator, but only aggregates the values for which the given dimension filter matches, by using the in filter.
Wraps any given aggregator, but only aggregates the values for which the given dimension filter matches, by using the in filter.
- aggregator
the aggregator to wrap
- first
the value to filter
- rest
the rest values to filter (when are more than one values to filter)
- def interval(value: String): FilteringExpression
Performs range filtering on columns that contain long millisecond values, the boundary specified as ISO 8601 time interval
Performs range filtering on columns that contain long millisecond values, the boundary specified as ISO 8601 time interval
- returns
the interval filtering expression
- def intervals(values: Iterable[String]): FilteringExpression
- def intervals(first: String, second: String, rest: String*): FilteringExpression
Performs range filtering on columns that contain long millisecond values, the boundaries specified as ISO 8601 time intervals
Performs range filtering on columns that contain long millisecond values, the boundaries specified as ISO 8601 time intervals
- returns
the interval filtering expression
- final def isInstanceOf[T0]: Boolean
- Definition Classes
- Any
- def isNotNull: FilteringExpression
- returns
selector expression stating that the contents of the dimension should not be null
- def isNull: FilteringExpression
- returns
selector expression stating that the contents of the dimension should be null
- def like(pattern: String): FilteringExpression
- returns
like-filter of this dimension for the specified LIKE pattern
- def longFirst: AggregationExpression
Aggregation to compute the metric value with the minimum timestamp or 0 if no row exist
- def longLast: AggregationExpression
Aggregation to compute the metric value with the maximum timestamp or 0 if no row exist
- def longMax: AggregationExpression
Aggregation to compute the maximum of all metric values and Long.MAX_VALUE
- def longMin: AggregationExpression
Aggregation to compute the minimum of all metric values and Long.MIN_VALUE
- def longSum: AggregationExpression
Aggregation to compute the sum of values (as a 64-bit signed integer)
- val name: String
- final def ne(arg0: AnyRef): Boolean
- Definition Classes
- AnyRef
- def notIn[T](values: Iterable[T])(implicit arg0: Numeric[T]): FilteringExpression
- def notIn[T](value: T, values: T*)(implicit arg0: Numeric[T]): FilteringExpression
- def notIn(values: Iterable[String]): FilteringExpression
- def notIn(value: String, values: String*): FilteringExpression
- returns
negated in-filter of this dimension for the specified values
- final def notify(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- final def notifyAll(): Unit
- Definition Classes
- AnyRef
- Annotations
- @native() @HotSpotIntrinsicCandidate()
- val outputNameOpt: Option[String]
- val outputTypeOpt: Option[String]
- def productElementNames: Iterator[String]
- Definition Classes
- Product
- def quotient(v: Dim): ArithmeticPostAgg
Arithmetic division post-aggregator
- def quotient(v: Double): ArithmeticPostAgg
Arithmetic division post-aggregator
- def regex(pattern: String): FilteringExpression
- returns
regex-filter of this dimension for the specified Java regular expression pattern
- def selectorFiltered(aggregator: AggregationExpression, value: String): SelectorFilteredAgg
Wraps any given aggregator, but only aggregates the values for which the given dimension filter matches, by using the selector filter.
Wraps any given aggregator, but only aggregates the values for which the given dimension filter matches, by using the selector filter.
- aggregator
the aggregator to wrap
- value
the values to select
- def selectorFiltered(aggregator: AggregationExpression): SelectorFilteredAgg
Wraps any given aggregator
Wraps any given aggregator
- aggregator
the aggregator to wrap
- def stringFirst: AggregationExpression
Aggregation to compute the metric value with the minimum timestamp or null if no row exist
- def stringLast: AggregationExpression
Aggregation to compute the metric value with the maximum timestamp or null if no row exist
- final def synchronized[T0](arg0: => T0): T0
- Definition Classes
- AnyRef
- def thetaSketch: ThetaSketchAgg
Aggregation to compute theta-sketches
- final def wait(arg0: Long, arg1: Int): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- final def wait(arg0: Long): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException]) @native()
- final def wait(): Unit
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.InterruptedException])
- def within(coords: Iterable[Double], distance: Double, unit: Unit = Distance.DistanceUnit.DEGREES): FilteringExpression
Filter spatially indexed columns by specifying the origin coordinates and a distance
Filter spatially indexed columns by specifying the origin coordinates and a distance
- coords
a list of origin coordinates in the form [x, y, z, ...]
- distance
the distance from origin coordinates. It can be specified in kilometers, miles or radius degrees (default)
- returns
the resulting spatial filtering expression
- def within(minCoords: Iterable[Double], maxCoords: Iterable[Double]): FilteringExpression
Filter spatially indexed columns by specifying the bounds of minimum and maximum coordinates
Filter spatially indexed columns by specifying the bounds of minimum and maximum coordinates
- minCoords
a list of minimum dimension coordinates for coordinates [x, y, z, ...]
- maxCoords
a list of maximum dimension coordinates for coordinates [x, y, z, ...]
- returns
the resulting spatial filtering expression
Deprecated Value Members
- def =<(value: String): Bound
Filter based on a strict upper bound of dimension values, using lexicographic ordering.
Filter based on a strict upper bound of dimension values, using lexicographic ordering.
- returns
a bound filtering expression, with lexicographic ordering, specifying that the value of the dimension should be less than, or equal to the given number.
- Annotations
- @deprecated
- Deprecated
(Since version 2.4.0)
- def finalize(): Unit
- Attributes
- protected[lang]
- Definition Classes
- AnyRef
- Annotations
- @throws(classOf[java.lang.Throwable]) @Deprecated @deprecated
- Deprecated
(Since version ) see corresponding Javadoc for more information.