Class DruidQuery

    • Field Detail


        public static final java.util.List<DruidSqlOperatorConverter> DEFAULT_OPERATORS_LIST
        Provides a standard list of supported Calcite operators that can be converted to Druid Expressions. This can be used as is or re-adapted based on underline engine operator syntax.
      • intervals

        final<org.joda.time.Interval> intervals
      • rels

        final<RelNode> rels
      • converterOperatorMap

        final java.util.Map<SqlOperator,​DruidSqlOperatorConverter> converterOperatorMap
        This operator map provides DruidSqlOperatorConverter instance to convert a Calcite RexNode to Druid Expression when possible.
      • VALID_SIG

        private static final java.util.regex.Pattern VALID_SIG

        private static final java.lang.String EXTRACT_COLUMN_NAME_PREFIX
        See Also:
        Constant Field Values

        private static final java.lang.String FLOOR_COLUMN_NAME_PREFIX
        See Also:
        Constant Field Values

        protected static final java.lang.String DRUID_QUERY_FETCH
        See Also:
        Constant Field Values
    • Constructor Detail

      • DruidQuery

        protected DruidQuery​(RelOptCluster cluster,
                             RelTraitSet traitSet,
                             RelOptTable table,
                             DruidTable druidTable,
                             java.util.List<org.joda.time.Interval> intervals,
                             java.util.List<RelNode> rels,
                             java.util.Map<SqlOperator,​DruidSqlOperatorConverter> converterOperatorMap)
        Creates a DruidQuery.
        cluster - Cluster
        traitSet - Traits
        table - Table
        druidTable - Druid table
        intervals - Intervals for the query
        rels - Internal relational expressions
        converterOperatorMap - mapping of Calcite Sql Operator to Druid Expression API.
    • Method Detail

      • isValidSignature

        static boolean isValidSignature​(java.lang.String signature)
        Returns whether a signature represents an sequence of relational operators that can be translated into a valid Druid query.
      • extendQuery

        public static DruidQuery extendQuery​(DruidQuery query,
                                             java.util.List<org.joda.time.Interval> intervals)
        Extends a DruidQuery.
      • needUtcTimeExtract

        private static boolean needUtcTimeExtract​(RexNode rexNode)
        Check if it is needed to use UTC for DATE and TIMESTAMP types.
      • toDruidColumn

        protected static Pair<java.lang.String,​ExtractionFunction> toDruidColumn​(RexNode rexNode,
                                                                                       RelDataType rowType,
                                                                                       DruidQuery druidQuery)
        rexNode - leaf Input Ref to Druid Column
        rowType - row type
        druidQuery - druid query
        Pair of Column name and Extraction Function on the top of the input ref or of(null, null) when can not translate to valid Druid column
      • isValidLeafCast

        private static boolean isValidLeafCast​(RexNode rexNode)
        rexNode - rexNode
        true if the operand is an inputRef and it is a valid Druid Cast operation
      • extractColumnName

        protected static java.lang.String extractColumnName​(RexNode rexNode,
                                                            RelDataType rowType,
                                                            DruidQuery query)
        rexNode - Druid input ref node
        rowType - rowType
        query - Druid Query
        Druid column name or null when not possible to translate.
      • format

        public static java.lang.String format​(java.lang.String message,
                                              java.lang.Object... formatArgs)
        Equivalent of String.format(Locale.ENGLISH, message, formatArgs).
      • isValid

        public boolean isValid​(Litmus litmus,
                               RelNode.Context context)
        Description copied from interface: RelNode
        Returns whether this relational expression is valid.

        If assertions are enabled, this method is typically called with litmus = THROW, as follows:

        assert rel.isValid(Litmus.THROW)

        This signals that the method can throw an AssertionError if it is not valid.

        Specified by:
        isValid in interface RelNode
        isValid in class AbstractRelNode
        litmus - What to do if invalid
        context - Context for validity checking
        Whether relational expression is valid
      • copy

        public RelNode copy​(RelTraitSet traitSet,
                            java.util.List<RelNode> inputs)
        Description copied from interface: RelNode
        Creates a copy of this relational expression, perhaps changing traits and inputs.

        Sub-classes with other important attributes are encouraged to create variants of this method with more parameters.

        Specified by:
        copy in interface RelNode
        copy in class AbstractRelNode
        traitSet - Trait set
        inputs - Inputs
        Copy of this relational expression, substituting traits and inputs
      • getTableScan

        public TableScan getTableScan()
      • getTopNode

        public RelNode getTopNode()
      • getTable

        public RelOptTable getTable()
        Description copied from interface: RelNode
        If this relational expression represents an access to a table, returns that table, otherwise returns null.
        Specified by:
        getTable in interface RelNode
        getTable in class AbstractRelNode
        If this relational expression represents an access to a table, returns that table, otherwise returns null
      • getDruidTable

        public DruidTable getDruidTable()
      • getIntervalCostMultiplier

        private double getIntervalCostMultiplier()
      • getQueryTypeCostMultiplier

        private double getQueryTypeCostMultiplier()
      • register

        public void register​(RelOptPlanner planner)
        Description copied from interface: RelNode
        Registers any special rules specific to this kind of relational expression.

        The planner calls this method this first time that it sees a relational expression of this class. The derived class should call RelOptPlanner.addRule(org.apache.calcite.plan.RelOptRule) for each rule, and then call super.register.

        Specified by:
        register in interface RelNode
        register in class AbstractRelNode
        planner - Planner to be used to register additional relational expressions
      • getElementType

        public java.lang.Class<java.lang.Object[]> getElementType()
        Description copied from interface: Typed
        Gets the type of the element(s) that are returned in this collection.
        Specified by:
        getElementType in interface ArrayBindable
        Specified by:
        getElementType in interface Typed
      • bind

        public Enumerable<java.lang.Object[]> bind​(DataContext dataContext)
        Description copied from interface: Bindable
        Executes this statement and returns an enumerable which will yield rows. The environment parameter provides the values in the root of the environment (usually schemas).
        Specified by:
        bind in interface Bindable<java.lang.Object[]>
        dataContext - Environment that provides tables
        Enumerable over rows
      • getQueryType

        public QueryType getQueryType()
      • getQueryString

        public java.lang.String getQueryString()
      • computeFilter

        private static DruidJsonFilter computeFilter​(@Nullable
                                                     Filter filterRel,
                                                     DruidQuery druidQuery)
        Translates Filter rel to Druid Filter Json object if possible. Currently Filter rel input has to be Druid Table scan
        filterRel - input filter rel
        druidQuery - Druid query
        DruidJson Filter or null if can not translate one of filters
      • computeProjectAsScan

        protected static Pair<java.util.List<java.lang.String>,​java.util.List<VirtualColumn>> computeProjectAsScan​(@Nullable
                                                                                                                         Project projectRel,
                                                                                                                         RelDataType inputRowType,
                                                                                                                         DruidQuery druidQuery)
        Translates list of projects to Druid Column names and Virtual Columns if any We can not use[], Object[]), since size can be different
        projectRel - Project Rel
        druidQuery - Druid query
        Pair of list of Druid Columns and Expression Virtual Columns or null when can not translate one of the projects.
      • computeProjectGroupSet

        protected static Pair<java.util.List<DimensionSpec>,​java.util.List<VirtualColumn>> computeProjectGroupSet​(@Nullable
                                                                                                                        Project projectNode,
                                                                                                                        ImmutableBitSet groupSet,
                                                                                                                        RelDataType inputRowType,
                                                                                                                        DruidQuery druidQuery)
        Computes the project group set.
        projectNode - Project under the Aggregates if any
        groupSet - Ids of grouping keys as they are listed in projects list
        inputRowType - Input row type under the project
        druidQuery - Druid Query
        A list of DimensionSpec containing the group by dimensions, and a list of VirtualColumn containing Druid virtual column projections; or null, if translation is not possible. Note that the size of lists can be different.
      • computeDruidJsonAgg

        protected static java.util.List<DruidQuery.JsonAggregation> computeDruidJsonAgg​(java.util.List<AggregateCall> aggCalls,
                                                                                        java.util.List<java.lang.String> aggNames,
                                                                                        Project project,
                                                                                        DruidQuery druidQuery)
        Translates aggregate calls to Druid DruidQuery.JsonAggregations when possible.
        aggCalls - List of AggregateCalls to translate
        aggNames - List of aggregate names
        project - Input project under the aggregate calls, or null if we have TableScan immediately under the Aggregate
        druidQuery - Druid Query Rel
        List of valid Druid DruidQuery.JsonAggregations, or null if any of the aggregates is not supported
      • computeSort

        private DruidQuery.JsonLimit computeSort​(@Nullable
                                                 java.lang.Integer fetch,
                                                 java.util.List<java.lang.Integer> collationIndexes,
                                                 java.util.List<RelFieldCollation.Direction> collationDirections,
                                                 ImmutableBitSet numericCollationIndexes,
                                                 java.util.List<java.lang.String> queryOutputFieldNames)
        fetch - limit to fetch
        collationIndexes - index of fields as listed in query row output
        collationDirections - direction of sort
        numericCollationIndexes - flag of to determine sort comparator
        queryOutputFieldNames - query output fields
        always an non null Json Limit object
      • writeField

        protected static void writeField​(com.fasterxml.jackson.core.JsonGenerator generator,
                                         java.lang.String fieldName,
                                         java.lang.Object o)
      • writeFieldIf

        protected static void writeFieldIf​(com.fasterxml.jackson.core.JsonGenerator generator,
                                           java.lang.String fieldName,
                                           java.lang.Object o)
      • writeArray

        protected static void writeArray​(com.fasterxml.jackson.core.JsonGenerator generator,
                                         java.util.List<?> elements)
      • writeObject

        protected static void writeObject​(com.fasterxml.jackson.core.JsonGenerator generator,
                                          java.lang.Object o)
      • metadataQuery

        static java.lang.String metadataQuery​(java.lang.String dataSourceName,
                                              java.util.List<org.joda.time.Interval> intervals)
        Generates a JSON string to query metadata about a data source.
      • getTimestampFieldIndex

        protected int getTimestampFieldIndex()
        index of the timestamp ref or -1 if not present