All Classes and Interfaces
Class
Description
Abstract class for string-to-something conversions.
DeMuxExchange is opposite of MuxExchange.
Helps to run a query and await on the results.
Abstract base class for all JSON element parsers.
Represents table group scan with metadata usage.
AbstractGroupScanWithMetadata.GroupScanWithMetadataFilterer<B extends AbstractGroupScanWithMetadata.GroupScanWithMetadataFilterer<B>>
This class is responsible for filtering different metadata levels.
Base class for the runtime execution implementation of the Hash-Join and
Hash-SetOp operator
This holds information about the spilled partitions for the build and probe
side.
Abstract base class for Index collection (collection of Index descriptors)
Abstract base class for an Index descriptor
Describes an operator that expects more than one children operators as its input.
Multiplexing Exchange (MuxExchange) is used when results from multiple minor fragments belonging to the same
major fragment running on a node need to be collected at one fragment on the same node before distributing the
results further.
AbstractParquetGroupScan.RowGroupScanFilterer<B extends AbstractParquetGroupScan.RowGroupScanFilterer<B>>
This class is responsible for filtering different metadata levels including row group level.
Helper class responsible for creating and managing DrillFileSystem.
Abstract base class for file system based partition descriptors and Hive
partition descriptors.
Abstract base implementation of
PluginImplementor that can be used by
plugin implementors which can support only a subset of all provided operations.Parent class for all pojo readers.
Parent class for all pojo writers created for each field.
Base class-holder for the list of
RelDataTypeFields.Abstract base class for a resource manager.
Basic implementation of a row set for both the single and multiple
(hyper) varieties, both the fixed and extensible varieties.
Abstract implementation of
SchemaFactory, ensures that given schema
name is always converted is lower case.Base class for the projection-based and defined-schema-based
scan schema trackers.
Describes an operator that expects a single child operator as its input.
Implements an AbstractUnaryRecordBatch where the incoming record batch is
known at the time of creation
Base class for row sets backed by a single record batch.
To get good performance for most commonly used pattern matches
CONSTANT('ABC')
SqlPatternConstantMatcher
STARTSWITH('%ABC') SqlPatternStartsWithMatcher
ENDSWITH('ABC%') SqlPatternEndsWithMatcher
CONTAINS('%ABC%') SqlPatternContainsMatcher
we have simple pattern matchers.Abstract class for StorePlugin implementations.
Implements AbstractUnaryRecodBatch for operators that do not have an incoming
record batch available at creation time; the input is typically set up a few
steps after creation.
Base class for operators that have a single input.
Represents a projected column that has not yet been bound to a
table column, special column or a null column.
Represents an unresolved table column to be provided by the
reader (or filled in with nulls.) May be associated with
a provided schema column.
Wrapper around a
DataTunnel that tracks the status of batches sent to
to other Drillbits.Wrapper around a
UserClientConnection that tracks the status of batches
sent to User.Utility class that allows a group of receivers to confirm reception of a record batch as a single unit.
Evaluates if a query can be admitted to a ResourcePool or not by comparing query user/groups with the
configured users/groups policies for this selector.
AdjustOperatorsSchemaVisitor visits corresponding operators' which depending upon their functionality
adjusts their output row types.
Specialized aggregate function for SUMing the COUNTs.
A shim making an aircompressor (de)compressor available through the BytesInputCompressor
and BytesInputDecompressor interfaces.
Aliases table.
List aliases as a System Table
Representation of an entry in the System table - Aliases
Registry for public and user-owned aliases.
Class for obtaining and managing storage and table alias registries.
Target object type for which alias will be applied.
Implementation of
AnalyzeInfoProvider for file-based tables.Implementation of
AnalyzeInfoProvider for easy group scan tables.Interface for obtaining information required for analyzing tables such as table segment columns, etc.
Implementation of
AnalyzeInfoProvider for parquet tables.Complex selector whose value is list of other Simple or Complex Selectors.
Represents one level within array.
Parses a JSON array, which consists of a list of elements,
represented by a
ValueListener.Simple Map type data structure for storing entries of (int -> int) mappings where the max key value is below 2^16
to avoid hashing keys and use direct array index reference for retrieving the values.
Utilities commonly used with ASM.
Responsible for assigning a set of work units to the available slices.
Implementation of
DynamicFeature.Converts and writes all map children using provided
AvroColumnConverterFactory.MapColumnConverter.converters.Format plugin config for Avro data files.
Format plugin for Avro data files.
Utility class that provides methods to interact with Avro schema.
General mechanism for waiting on the query to be executed
Base field factor class which handles the common tasks for
building column writers and JSON listeners.
Common implementation for both the test and production versions
of the fragment context.
Basic reader implementation for json documents.
Implementation of
OperatorContext that provides services
needed by most run-time operators.This
OptionManager implements some the basic methods and should be
extended by concrete implementations.Implementation of
ParquetMetadataProvider which contains base methods for obtaining metadata from
parquet statistics.Base wrapper for algorithms that use sort comparisons.
Base implementation for a tuple model which is common to the "single"
and "hyper" cases.
Base class for code-generation-based tasks.
Build a set of writers for a single (non-hyper) vector container.
A JSON output class that generates standard JSON.
Basic reader builder for simple non-file readers.
Provides access to the row set (record batch) produced by an
operator.
Represents a group of batches spilled to disk.
Tool for printing the content of record batches to screen.
Base strategy for reading a batch of Parquet records.
Strategy for reading a record batch when all columns are
fixed-width.
Strategy for reading mock records.
Strategy for reading a record batch when at last one column is
variable width.
Holder class that contains batch naming, batch and record index.
Historically
BatchSchema is used to represent the schema of a batch.This class predicts the sizes of batches given an input batch.
A factory for creating
BatchSizePredictors.Helper class to assist the Flat Parquet reader build batches which adhere to memory sizing constraints
A container class to hold a column batch memory usage information.
Container class which holds memory usage information about a variable length
ValueVector;
all values are in bytes.Validate a batch of value vectors.
Helps to select a queue whose
QueryQueueConfig.getMaxQueryMemoryInMBPerNode() is nearest to the max memory
on a node required by the given query.Listener for JSON integer values.
Parquet value writer for passing decimal values
into
RecordConsumer to be stored as BINARY type.Function templates for Bit/BOOLEAN functions other than comparison
functions.
Utility class providing common methods shared between
DataClient and
ControlClientAdd a system table for listing connected users on a cluster
According to Putze et al.'s "Cache-, Hash- and Space-Efficient BloomFilter
Filters", see this paper
for details, the main theory is to construct tiny bucket bloom filters which benefit to
the cpu cache and SIMD opcode.
Listener for JSON Boolean fields.
A decorating accessor that returns null for indices that is beyond underlying vector's capacity.
Broadcast Sender broadcasts incoming batches to all receivers (one or more).
Represents the set of in-memory batches accumulated by
the external sort.
BufferedDirectBufInputStream reads from the
underlying InputStream in blocks of data, into an
internal buffer.Build the set of writers from a defined schema.
Build (materialize) as set of vectors based on a provided
metadata schema.
Evaluate a substring expression for a given value; specifying the start
position, and optionally the end position.
Modeled after
org.apache.hadoop.io.WritableUtils.Class loader for "plain-old Java" generated classes.
Wrapper around
PersistentStore to ensure all passed keys are
converted to lower case and stored this way.This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This file is generated with Freemarker using the template exec/java-exec/src/main/codegen/templates/CastEmptyStringVarTypesToNullableNumeric.java
This is a master class used to generate code for
HashTables.A CharSequence is a readable sequence of char values.
Evaluate a substring expression for a given UTF-8 value; specifying the start
position, and optionally the end position.
A ClassVisitor that verifies the required call sequence described in
http://asm.ow2.org/asm50/javadoc/user/org/objectweb/asm/ClassVisitor.html .
A MethodVisitor that verifies the required call sequence according to
http://asm.ow2.org/asm50/javadoc/user/org/objectweb/asm/MethodVisitor.html .
Implements the "plain Java" method of code generation and
compilation.
Selects between the two supported Java compilers: Janino and
the build-in Java compiler.
Represents a (Nullable)?(Type)Holder instance.
Plugin locator for the "classic" class-path method of locating connectors.
Build the original scanner based on the
RecordReader interface.Compiles generated code, merges the resulting class with the
template class, and performs byte-code cleanup on the resulting
byte codes.
Creates a deep copy of a LogicalExpression.
It allows setting the current value in the iterator and can be used once after
ClosingStreamIterator.next() callPluggable interface built to manage cluster coordination.
Global code compiler mechanism shared by all threads and operators.
Abstracts out the details of compiling code using the two available
mechanisms.
A code generator is responsible for generating the Java source code required
to complete the implementation of an abstract template.
Aggregate function which stores incoming fields into the map.
Aggregate function which collects incoming VarChar column values into the list.
Algorithms for building a column given a metadata description of the column and
the parent context that will hold the column.
Base class for any kind of column converter.
Converts and sets given value into the specific column writer.
Converts and writes array values using
ColumnConverter.ArrayColumnConverter.valueConverter
into ColumnConverter.ArrayColumnConverter.arrayWriter.Converts and writes dict values using provided key / value converters.
Does nothing, is used when column is not projected to avoid unnecessary
column values conversions and writes.
Converts and writes all map children using provided
ColumnConverter.MapColumnConverter.converters.Converts and writes scalar values using provided
ColumnConverter.ScalarColumnConverter.valueConverter.Deprecated.
it is never used.
Defines a column for the "enhanced" version of the mock data
source.
Columns that give information from where file data comes from.
Columns that give internal information about file or its parts.
Holds system / session options that are used for obtaining partition / implicit / special column names.
Core interface for a projected column.
Handles the special case in which the entire row is returned as a
"columns" array.
Parses the `columns` array.
Scan framework for a file that supports the special "columns" column.
Implementation of the columns array schema negotiator.
Schema negotiator that supports the file scan options plus access
to the specific selected columns indexes.
Represents the write-time state for a column including the writer and the (optional)
backing vector.
Primitive (non-map) column state.
Columns move through various lifecycle states as identified by this
enum.
Comparator type.
Comparison predicates for metadata filter pushdown.
Container that holds a complete work unit.
Visitor that moves non-
RexFieldAccess rex node from project below Uncollect
to the left side of the Correlate.Text reader, Complies with the RFC 4180 standard for text/csv files.
Implementation of
SqlVisitor that converts bracketed compound SqlIdentifier
to bracket-less compound SqlIdentifier (also known as DrillCompoundIdentifier)
to provide ease of use while querying complex types.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.CONCAT.Defines a storage connector: a storage plugin config along with the
locator which can create a plugin instance given an instance of the
config.
Locates storage plugins.
Populate metadata columns either file metadata (AKA "implicit
columns") or directory metadata (AKA "partition columns.") In both
cases the column type is nullable Varchar and the column value
is predefined by the projection planner; this class just copies
that value into each row.
Description of a constant argument of an expression.
For CSV files without headers, but with a provided schema,
handles the case where extra fields appear in the file beyond
the columns enumerated in the schema.
Abstract representation of a container of vectors: a row, a map, a
repeated map, a list or a union.
Implement "current_schema" function.
Implement "session_id" function.
Implement "user", "session_user" or "system_user" function.
Provides query context information (such as query start time, query user, default schema etc.) for UDFs.
Maintains connection between two particular bits.
Service that allows one Drillbit to communicate with another.
Defines how the Controller should handle custom messages.
A simple interface that describes the nature of the response to the custom incoming message.
Interface for defining how to serialize and deserialize custom message for consumer who want to use something other
than Protobuf messages.
Manages communication tunnels between nodes.
Purely to simplify memory debugging.
Holds metrics related to bit control rpc layer
ControlTunnel.ProtoSerDe<MSG extends com.google.protobuf.MessageLite>
This rule will convert " select count(*) as mycount from table "
or " select count(not-nullable-expr) as mycount from table " into
This rule is a logical planning counterpart to a corresponding ConvertCountToDirectScanPrule
physical rule
Rule which converts
Convert a VARCHAR column to an BIT column following the Java rules
for parsing Boolean values, then using 1 if the boolean is true, 0
if false.
Convert a VARCHAR column to an DATE column following the Java rules
for parsing a date time, optionally using the formatter provided in
the column schema.
Convert a VARCHAR column to an decimal column following the Java rules
for parsing integers (i.e.
Convert a VARCHAR column to a DOUBLE column following the Java rules
for parsing doubles (i.e.
Convert a VARCHAR column to an INT column following the Java rules
for parsing integers (i.e.
Convert a VARCHAR column to an INTERVAL column following the Java rules
for parsing a period.
Convert a VARCHAR column to an BIGINT column following the Java rules
for parsing longs (i.e.
Convert a VARCHAR column to an TIME column following the Java rules
for parsing a date time, optionally using the formatter provided in
the column schema.
Convert a VARCHAR column to an TIMESTAMP column following the Java rules
for parsing a date time, optionally using the formatter provided in
the column schema.
This class is used for backward compatibility when reading older query profiles that
stored operator id instead of its name.
This class is used internally for tracking injected countdown latches.
See
CountDownLatchInjection Degenerates to
PauseInjection.pause(), if initialized to zero count.A utility class that contains helper functions used by rules that convert COUNT(*) and COUNT(col)
aggregates (no group-by) to DirectScan
Generate a covering index plan that is equivalent to the original plan.
Handler for handling CREATE ALIAS statements.
Interface that provides the info needed to create a new table.
Generates and adds a CSRF token to a HTTP session.
All forms on site have a field with a CSRF token injected by server.
Holder for store version.
Manages a connection for each endpoint.
Holds metrics related to bit data rpc layer
Listener that keeps track of the status of batches sent, and updates the SendingAccountor when status is received
for each batch
Very simple date value generator that produces ISO dates
uniformly distributed over the last year.
Describes the default date output format to use for JSON.
Function to check if a varchar value can be cast to a date.
Parse local time dates.
A DbGroupScan operator represents the scan associated with a database.
Utility class to build a debug string for an object
in a standard format.
Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_ADD_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_AGGREGATE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_AVG_AGGREGATE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_CAST.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_DIV_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_MAX_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_MOD_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_SET_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_SUM_AGGREGATE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_SUM_SCALE.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DECIMAL_ZERO_SCALE.Non RM version of the parallelizer.
Helps to select the first default queue in the list of all the provided queues.
Represents a default resource manager for clusters that do not provide query
queues.
Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.DEFAULT.When selector configuration is absent for a ResourcePool then it is associated with a DefaultSelector.
Composite partition location corresponds to a directory in the file system.
Defines a single partition in a DFS table.
Base class for Java type-based conversion.
Encapsulates a Java expression, defined as anything that is
valid in the following code:
(expr)Reader index that points directly to each row in the row set.
Implementation of a single row set with no indirection (selection)
vector.
Distributed query queue which uses a Zookeeper distributed semaphore to
control queuing across the cluster.
Exposes a snapshot of internal state information for use in status
reporting, such as in the UI.
Describes an operator's endpoint assignment requirements.
Generates random field values uniformly distributed over
the range +-1 million, with any number of digits past
the decimal point.
Listener for the JSON double type.
Aggregate function interface.
Aggregation implemented in Drill.
Base class for logical and physical Aggregations implemented in Drill
Rule that converts an
LogicalAggregate to a DrillAggregateRel, implemented by a Drill "segment" operation
followed by a "collapseaggregate" operation.Drill logical node for "Analyze".
Starts, tracks and stops all the required services for a Drillbit daemon to work.
Implementation of the storage registry context which obtains the
needed resources from the
DrillbitContext.Interface to define the listener to take actions when the set of active drillbits is changed.
An InputStream that wraps a DrillBuf and implements the seekable interface.
Thin wrapper around byte array.
This class serves as a wrapper class for SqlAggFunction.
This class serves as a wrapper class for SqlBetweenOperator.
This class serves as a wrapper class for SqlFunction.
This class serves as a wrapper class for SqlOperator.
This class serves as a wrapper class for
SqlSumEmptyIsZeroAggFunction
with the same goal as DrillCalciteSqlAggFunctionWrapper
but extends SqlSumEmptyIsZeroAggFunction to allow using
additional Calcite functionality designated for SqlSumEmptyIsZeroAggFunction.This interface is meant for the users of the wrappers,
DrillCalciteSqlOperatorWrapper,
DrillCalciteSqlFunctionWrapper and DrillCalciteSqlAggFunctionWrapper, to access the wrapped Calcite
SqlOperator without knowing exactly which wrapper it is.This utility contains the static functions to manipulate
DrillCalciteSqlWrapper, DrillCalciteSqlOperatorWrapper
DrillCalciteSqlFunctionWrapper and DrillCalciteSqlAggFunctionWrapper.There's a bug in ASM's CheckClassAdapter.
Thin wrapper around a UserClient that handles connect/close and transforms
String into ByteBuf.
A delegating compression codec factory that returns (de)compressors based on
https://github.com/airlift/aircompressor when possible and falls back to
parquet-mr otherwise.
Drill's SQL conformance is SqlConformanceEnum.DEFAULT with a couple of deviations.
Convertlet table which allows to plug-in custom rex conversion of calls to
Calcite's standard operators.
Implementation of the DrillRelOptCost, modeled similar to VolcanoCost
Logical RelNode representing a
DirectGroupScan.Converts join with distinct right input to semi-join.
Stores distribution field index and field name to be used in exchange operators.
Custom ErrorHandler class for Drill's WebServer to have better error message in case when SPNEGO login failed and
what to do next.
Minus implemented in Drill.
DrillFileSystem is the wrapper around the actual FileSystem implementation.
In Drill file system all directories and files that start with dot or underscore is ignored.
Rule will transform item star fields in filter and replaced with actual field references.
Base class for logical and physical Filters implemented in Drill
Rule that converts a
LogicalFilter to a Drill "filter" operation.Wrapper around FSDataInputStream to collect IO Stats.
Represents the call of a function within a query and includes
the actual arguments and a reference to the function declaration (as a
"function holder.")
The base class of hash classes used in Drill.
Accessor class that extends the
ConstraintSecurityHandler to expose
protected method's for start and stop of Handler.Context for converting a tree of
DrillRel nodes into a Drill logical plan.Intersect implemented in Drill.
Interface which needs to be implemented by all the join relation expressions.
Logical Join implemented in Drill.
Base class for logical and physical Joins implemented in Drill.
Rule that converts a
LogicalJoin to a DrillJoinRel, which is implemented by Drill "join" operation.Base class for logical and physical Limits implemented in Drill
This rule converts a Sort that has either a offset and fetch into a Drill Sort and LimitPOP Rel
MergeFilterRule implements the rule for combining two
FiltersRule for merging two projects provided the projects aren't projecting identical sets of
input references.
Implementation of
SqlOperatorTable that contains standard operators and functions provided through
SqlStdOperatorTable, and Drill User Defined Functions.Utilities for Drill's planner.
Parquet currently supports a fixed binary type INT96 for storing hive, impala timestamp
with nanoseconds precision.
Parquet currently supports a fixed binary type, which is not implemented in Drill.
SQL parser, generated from Parser.jj by JavaCC.
Token literal values and constants.
Token Manager.
Helper methods or constants used in parsing a SQL query.
Project implemented in Drill.
Base class for logical and physical Project implemented in Drill
Rule that converts a
LogicalProject to a Drill "project" operation.When table support project push down, rule can be applied to reduce number of read columns
thus improving scan operator performance.
This rule implements the run-time filter pushdown via the rowkey join for queries with row-key filters.
Rule to reduce aggregates to simpler forms.
Relational expression that is implemented in Drill.
Contains factory implementation for creating various Drill Logical Rel nodes.
Utility class that is a subset of the RelOptUtil class and is a placeholder
for Drill specific static methods that are needed during either logical or
physical planning.
InputRefVisitor is a utility class used to collect all the RexInputRef nodes in a
RexNode.
Stores information about fields, their names and types.
RexFieldsTransformer is a utility class used to convert column refs in a RexNode
based on inputRefMap (input to output ref map).
LoginService used when user authentication is enabled in Drillbit.
Provider which injects DrillUserPrincipal directly instead of getting it
from SecurityContext and typecasting
Pretty-printing wrapper class around the ZK-based queue summary.
GroupScan of a Drill table.
Base class for logical/physical scan rel implemented in Drill.
Base class for logical and physical Screen implemented in Drill
Classes that can be put in the Distributed Cache must implement this interface.
Definition of a Drill function defined using the
@FunctionTemplate annotation of the class which
implements the function.Sort implemented in Drill.
Base class for logical and physical Sort implemented in Drill.
Rule that converts an
Sort to a DrillSortRel, implemented by a Drill "order" operation.Custom SpnegoAuthenticator for Drill
Custom implementation of DrillSpnegoLoginService to avoid the need of passing targetName in a config file,
to include the SPNEGO OID and the way UserIdentity is created.
SqlCall interface with addition of method to get the handler.
Sql parser tree node to represent statement:
{ DESCRIBE | DESC } tblname [col_name | wildcard ]
Drill SqlLine application configuration.
Customized
SqlParseException classSql parse tree node to represent statement:
RESET { <NAME> | ALL } .Sql parse tree node to represent statement:
SET <NAME> [ = VALUE ].Wraps the stats table info including schema and tableName.
Struct which contains the statistics for the entire directory structure
TableMacros must return a TranslatableTable
This class adapts the existing DrillTable to a TranslatableTable
Rule that converts a
LogicalUnion to a DrillUnionRel, implemented by a "union" operation.Union implemented in Drill.
Captures Drill user credentials and privilege's of the session user.
DrillUserPrincipal for anonymous (auth disabled) mode.Logical Values implementation in Drill.
Base class for logical and physical Values implemented in Drill.
Rule that converts a
LogicalValues to a Drill "values" operation.Give access to Drill version as captured during the build
Caution don't rely on major, minor and patch versions only to compare two
Drill versions.
Interface used by Drill components such as InformationSchema generator to get view info.
Base class for logical and physical Writer implemented in Drill.
Handler for handling DROP ALIAS statements.
Handler for handling DROP ALL ALIASES statements.
This and
DummyConvertTo class merely act as a placeholder so that Optiq
allows 'convert_to()' and 'convert_from()' functions in SQL.This and
DummyConvertFrom class merely act as a placeholder so that Optiq
allows 'convert_to()' and 'convert_from()' functions in SQL.This and
DummyConvertTo class merely act as a placeholder so that Optiq
allows the 'flatten()' function in SQL.Parse and ignore an unprojected value.
Used to ensure the param "batch" is a non-negative number.
Dynamically reads values from the given list of records.
An utility class that converts from
JsonNode
to DynamicPojoRecordReader during physical plan fragment deserialization.Wrapper around the default and/or distributed resource managers
to allow dynamically enabling and disabling queueing.
Loads schemas from storage plugins later when
CalciteSchema.getSubSchema(String, boolean)
is called.Unlike SimpleCalciteSchema, DynamicSchema could have an empty or partial schemaMap, but it could maintain a map of
name->SchemaFactory, and only register schema when the correspondent name is requested.
Projection filter based on the scan schema which typically starts as fully
dynamic, then becomes more concrete as the scan progresses.
Filter for a map, represented by a
TupleMetadata.Describes how to handle candidate columns not currently in the
scan schema, which turns out to be a surprisingly complex
question.
Filter for the top-level dynamic schema.
Dynamic credit based flow control:
The sender initially sends batch to the sender by the initial static credit (3).
Create the file scan lifecycle that manages the scan.
Base class for file readers.
Defines the static, programmer-defined options for this plugin.
Parser for a JSON element.
Query queue to be used in an embedded Drillbit.
Implementation of aliases table that doesn't hold or return information.
Represents a run of empty arrays for which we have no type information.
Represents an empty array: the case where the parser has seen only
[], but no array elements which would indicate the type.This class provided utility methods to encode and decode a set of user specified
SchemaPaths to a set of encoded SchemaPaths with the following properties.
EndpointAffinity captures affinity value for a given single Drillbit endpoint.
Presents an interface that describes the number of bytes for a particular work unit associated with a particular DrillbitEndpoint.
LeafPrel implementation that generates java code that may be executed to obtain results
for the provided plan part.ManagedReader implementation that compiles and executes specified code,
calls the method on it for obtaining the values, and reads the results using column converters.Implementation of
CredentialsProvider that obtains credential values from
environment variables.To avoid coupling the JSON structure parser with Drill's error
reporting mechanism, the caller passes in an instance of this
error factory which will build the required errors, including
filling in caller-specific context.
Visitor that generates code for eval
Extended variable descriptor ("holding container") for the variable
which references the value holder ("FooHolder") that stores the value
from a value vector.
Reads records from the RecordValueAccessor and writes into RecordWriter.
An abstraction used for dispatching store
events.Injection for a single exception.
Exchanges are fragment boundaries in physical operator tree.
This provides the resources required by an exchange operator.
Materializer visitor to remove exchange(s)
NOTE: this Visitor does NOT set OperatorId, as after Exchange removal all operators need renumbering
Use OperatorIdVisitor on top to set correct OperatorId
Tracks the simulated controls that will be injected for testing purposes.
The JSON specified for the
ExecConstants.DRILLBIT_CONTROL_INJECTIONS
option is validated using this class.Injects exceptions and pauses at execution time for testing.
The context that is used by a Drillbit in classes like the
FragmentExecutor.Utility class to enhance the Java
ExecutorService class functionalityExecutor task wrapper to enhance task cancellation behavior
A special type of concurrent map which attempts to create an object before returning that it does not exist.
Perform a schema projection for the case of an explicit list of
projected columns.
Condensed form of a Drill WHERE clause expression
node.
Represents a set of AND'ed expressions in Conjunctive Normal
Form (CNF).
Semanticized form of a Calcite relational operator.
An expression node with an unlimited set of children.
Represents a set of OR'ed expressions in Disjunctive Normal
Form (CNF).
Convert a logicalExpression to RexNode, notice the inputRel could be in an old plan, but newRowType is the newly built rowType
that the new RexNode will be applied upon, so when reference fields, use newRowType, when need cluster, plannerSetting, etc, use old inputRel
Writes JSON Output that will wrap Binary, Date, Time, Timestamp, Integer,
Decimal and Interval types with wrapping maps for better type resolution upon
deserialization.
Extended form of the mock record reader that uses generator class
instances to create the mock values.
Extends the original Option iterator.
Wrapper class for Extended Option Value
Based on
V1 of the Mongo extended type spec.
Names of Mongo extended types.
External sort batch: a sort batch which can spill to disk in
order to operate within a defined memory footprint.
This handler fails any request on the connection.
An
OptionManager which allows for falling back onto another
OptionManager when retrieving options.Describes a new field within an object.
Extensible mechanism to build fields for a JSON object (a Drill
row or Map).
Interface which all mock column data generators must
implement.
Creates a field parser given a field description and an optional field
listener.
This class manages the projection pushdown for a complex path.
Holder class to store field information (name and type) with the list of nodes this field is used in.
Replaces original node with provided in mapper, otherwise returns original node.
Describes one file within a scan and is used to populate implicit columns.
FileGroupScan operator represents all data which will be scanned from FileSystem by a given physical plan.
Specify the file name and optional selection root.
Collects file metadata for the given parquet file.
Represents projection column which resolved to a file metadata
(AKA "implicit") column such as "filename", "fqn", etc.
Definition of a file metadata (AKA "implicit") column for this query.
Parses the implicit file metadata columns out of a project list,
and marks them for special handling by the file metadata manager.
Implementation of
MetadataInfoCollector for file-based tables.Iterates over the splits for the present scan.
The file scan framework adds into the scan framework support for implicit
reading from DFS splits (a file and a block).
Iterates over the splits for the present scan.
Options for a file-based scan.
The file schema negotiator adds no behavior at present, but is
created as a placeholder anticipating the need for file-specific
behavior later.
Implementation of the file-level schema negotiator.
The file scan framework adds into the scan framework support for
reading from DFS splits (a file and a block) and for the file-related
implicit and partition columns.
The file schema negotiator provides access to the Drill file system
and to the file split which the reader is to consume.
Implementation of the file-level schema negotiator which holds the
file split which the reader is to process.
Jackson serializable description of a file selection.
Implements
CreateTableEntry interface to create new tables in FileSystem storage.Implementation of
MetadataProviderManager which uses file system providers and returns
builders for file system based TableMetadataProvider instances.Partition descriptor for file system based tables.
A Storage engine associated with a Hadoop FileSystem Implementation.
This is the top level schema that responds to root level path requests.
Helper class that provides methods to list directories or file or both statuses.
A visitor which visits a materialized logical expression, and build
FilterPredicate If a visitXXX method returns null, that means the
corresponding filter branch is not qualified for push down.
Evaluates information schema for the given condition.
Evaluates necessity to visit certain type of information_schema data using provided filter.
Evaluates necessity to visit certain type of information_schema data based
on given schema type.
Search through a LogicalExpression, finding all internal schema path references and returning them in a set.
Call-back (listener) implementation for a push-down filter.
Listener for a one specific group scan.
Generalized filter push-down strategy which performs all the tree-walking
and tree restructuring work, allowing a "listener" to do the work needed
for a particular scan.
A visitor class that analyzes a filter condition (typically an index condition)
and a supplied input collation and determines what the output collation would be
after applying the filter.
A visitor that is very similar to
FindLimit0SqlVisitor in that it looks for a LIMIT 0
in the root portion of the query tree for the sake of enabling optimisations but that is
different in the following aspects.Visitor that will identify whether the root portion of the RelNode tree contains a limit 0 pattern.
Reader for column names and types.
Parquet value writer for passing decimal values
into
RecordConsumer to be stored as FIXED_LEN_BYTE_ARRAY type.Layer above the
ResultSetLoader which handles standard conversions
for scalar columns where the schema is known up front (i.e.Foreman manages all the fragments (local and remote) for a single query where this
is the driving/root node.
Responsible for instantiating format plugins
Provides the ability to transform format location before creating
FileSelection if required.Similar to a storage engine but built specifically to work within a FileSystem context.
Provides the resources required by a non-exchange operator to execute.
This is the core Context which implements all the Context interfaces:
FragmentContext: A context provided to non-exchange
operators.
ExchangeFragmentContext: A context provided to exchange
operators.
RootFragmentContext: A context provided to fragment roots.
ExecutorFragmentContext: A context used by the Drillbit.
The interfaces above expose resources to varying degrees.Fragment context interface: separates implementation from definition.
Runs a single fragment on a single Drillbit.
A Physical Operator that can be the leaf node of one particular execution
fragment.
The Fragment Manager is responsible managing incoming data and executing a fragment.
OptionManager that holds options within FragmentContextImpl.Generic interface to provide different parallelization strategies for MajorFragments.
Describes the root operation within a particular Fragment.
Is responsible for submitting query fragments for running (locally and remotely).
Holds statistics of a particular (minor) fragment.
The status reporter is responsible for receiving changes in fragment state and propagating the status back to the
Foreman either through a control tunnel or locally.
Wrapper class for a major fragment profile.
WindowFramer implementation that supports the FRAME clause.
Maintains state while traversing a finite state machine described by
an FsmDescriptor.
Describes a finite state machine in terms of a mapping of tokens to
characters, a regular expression describing the valid transitions
using the characters, and an end state.
Is used to provide schema based on table location on file system
and default schema file name
SchemaProvider.DEFAULT_SCHEMA_NAME.FunctionalIndexInfo is to collect Functional fields in IndexDescriptor, derive information needed for index plan,
e.g.
Attributes of a function used in code generation and optimization.
Converts FunctionCalls to Java Expressions.
Holder class that contains:
function name
function signature which is string representation of function name and its input parameters
DrillFuncHolder associated with the function
Registry for functions.
To avoid the cost of initializing all functions up front, this class contains
all information required to initializing a function when it is used.
Function registry holder stores function implementations by jar name, function name.
An implementing class of FunctionResolver provide their own algorithm to choose a DrillFuncHolder from a given list of
candidates, with respect to a given FunctionCall
List functions as a System Table
Representation of an entry in the System table - Functions
Function scope is used to indicate function output rows relation:
simple / scalar (1 -> 1) or aggregate (n -> 1).
Estimates the average size of the output
produced by a function that produces variable length output
Return type enum is used to indicate which return type calculation logic
should be used for functions.
Binary form, returns the interval between `right` and `left`.
Unary form, subtracts `right` from midnight so equivalent to
`select age(current_date, right)`.
Binary form, returns the interval between `right` and `left`.
Binary form, returns the interval between `right` and `left`.
Binary form, returns the interval between `right` and `left`.
Unary form, subtracts `right` from midnight so equivalent to
`select age(current_date, right)`.
Binary form, returns the interval between `right` and `left`.
Binary form, returns the interval between `right` and `left`.
Binary form, returns the interval between `right` and `left`.
Unary form, subtracts `right` from midnight so equivalent to
`select age(current_date, right)`.
Binary form, returns the interval between `right` and `left`.
Binary form, returns the interval between `right` and `left`.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
This class merely act as a placeholder so that Calcite allows 'trunc('truncationUnit', col)'
function in SQL.
The code generator works with four conceptual methods which can
have any actual names.
A GroupScan operator represents all data which will be scanned by a given physical
plan.
Implementation of
CredentialsProvider that obtains credential values from
Configuration properties.Implementation of
FragmentParallelizer where fragment requires
running on a given set of endpoints.Describes a physical operator that has affinity to particular nodes.
Implement this interface if a Prel has distribution affinity requirements.
hash32 function definitions for numeric data types.
hash32 with seed function definitions for numeric data types.
Implements the runtime execution for the Hash-Join operator supporting INNER,
LEFT OUTER, RIGHT OUTER, and FULL OUTER joins
This calculator class is used when the Hash-Join_helper is not used (i.e., return size of zero)
This class is responsible for managing the memory calculations for the HashJoin operator.
The interface representing the
HashJoinStateCalculator corresponding to the
HashJoinState.BUILD_SIDE_PARTITIONING state.This class represents the memory size statistics for an entire set of partitions.
The interface representing the
HashJoinStateCalculator corresponding to the
HashJoinState.POST_BUILD_CALCULATIONS state.At this point we need to reserve memory for the following:
An incoming batch
An incomplete batch for each partition
If there is available memory we keep the batches for each partition in memory.
In this state, we need to make sure there is enough room to spill probe side batches, if
spilling is necessary.
A
HashJoinStateCalculator is a piece of code that compute the memory requirements for one of the states
in the HashJoinState enum.Overview
Contains utility methods for creating hash expression for either distribution (in PartitionSender) or for HashTable.
Interface for creating different forms of hash expression types.
Implements the runtime execution for the Hash-SetOp operator supporting EXCEPT,
EXCEPT ALL, INTERSECT, and INTERSECT ALL
Text output that implements a header reader/parser.
Wrapper around a representation of a "Holder" to represent that
Holder as an expression.
Define all attributes and values that can be injected by various Wrapper classes in org.apache.drill.exec.server.rest.*
Implementation of UserAuthenticator that reads passwords from an htpasswd
formatted file.
Implement HTTP Basic authentication for REST API access
Base reader builder for a hyper-batch.
Vector accessor used by the column accessors to obtain the vector for
each column value.
Read-only row index into the hyper row set with batch and index
values mapping via an SV4.
Implements a row set wrapper around a collection of "hyper vectors."
A hyper-vector is a logical vector formed by a series of physical vectors
stacked on top of one another.
Infer the schema for a hyperbatch.
Utilities for impersonation purpose.
Create RecordBatch tree (PhysicalOperator implementations) for a given
PhysicalOperator tree.
Manages the insertion of file metadata (AKA "implicit" and partition) columns.
Marks a column as implicit and provides a function to resolve an
implicit column given a description of the input file.
Marker for a file-based, non-internal implicit column that
extracts parts of the file name as defined by the implicit
column definition.
Partition column defined by a partition depth from the scan
root folder.
Manages the resolution of implicit file metadata and partition columns.
The result of scanning the scan output schema to identify implicit and
partition columns.
This class represents an implicit column in a dataset.
Manages implicit columns for files and partition columns for
directories.
Represents a wildcard: SELECT * when used at the root tuple.
Helper class to manage inbound impersonation.
Validator for impersonation policies.
Determines when a particular fragment has enough data for each of its receiving exchanges to commence execution.
An incoming batch of data.
The filter expressions that could be indexed
Other than SchemaPaths, which represent columns of a table and could be indexed,
we consider only function expressions, and specifically, CAST function.
Interface used to describe an index collection
Types of an index collections: NATIVE_SECONDARY_INDEX_COLLECTION, EXTERNAL_SECONDARY_INDEX_COLLECTION
Top level interface used to define an index.
Types of an index: PRIMARY_KEY_INDEX, NATIVE_SECONDARY_INDEX, EXTERNAL_SECONDARY_INDEX
IndexDefinition + functions to access materialized index(index table/scan, etc)
SchemaFactory of a storage plugin that can used to store index tables should expose this interface to allow
IndexDiscovers discovering the index table without adding dependency to the storage plugin.
IndexDiscoverBase is the layer to read index configurations of tables on storage plugins,
then based on the properties it collected, get the StoragePlugin from StoragePluginRegistry,
together with indexes information, build an IndexCollection
With this factory, we allow user to load a different indexDiscover class to obtain index information
Encapsulates one or more IndexProperties representing (non)covering or intersecting indexes.
An IndexGroupScan operator represents the scan associated with an Index.
IndexScanIntersectGenerator is to generate index plan against multiple index tables,
the input indexes are assumed to be ranked by selectivity(low to high) already.
IndexProperties encapsulates the various metrics of a single index that are related to
the current query.
IndexProperties encapsulates the various metrics of a single index that are related to
the current query.
Extension of the container accessor that holds an optional selection
vector, presenting the batch row count as the selection vector
count.
Reader index that points to each row indirectly through the
selection vector.
Single row set coupled with an indirection (selection) vector,
specifically an SV2.
Create Drill field listeners based on the observed look-ahead
tokens in JSON.
Builds a InfoSchemaFilter out of the Filter condition.
Generates records for POJO RecordReader by scanning the given schema.
Base class for tables in INFORMATION_SCHEMA.
Layout for the CATALOGS table.
Layout for the COLUMNS table.
Layout for the FILES table.
Layout for the PARTITIONS table.
Layout for the SCHEMATA table.
Layout for the TABLES table.
Layout for the VIEWS table.
The set of tables / views in INFORMATION_SCHEMA.
The base class for all types of injections (currently, pause and exception).
An Exception thrown when injection configuration is incorrect.
Key Deserializer for InjectionSite.
Is used to provide schema when passed using table function.
This is an
OptionManager that holds options in memory rather than in
a persistent store.An ASM ClassVisitor that strips class the access bits that are only possible
on inner classes (ACC_PROTECTED, ACC_PRIVATE, and ACC_FINAL).
The input batch group gathers batches buffered in memory before
spilling.
Constructs plan to be executed for inserting data into the table.
Parquet value writer for passing decimal values
into
RecordConsumer to be stored as INT32 type.Parquet value writer for passing decimal values
into
RecordConsumer to be stored as INT32 type.Drill-specific extension for a time interval (AKA time
span or time period).
Generates integer values uniformly randomly distributed over
the entire 32-bit integer range from
Integer.MIN_VALUE to Integer.MAX_VALUE.Exception for malformed connection string from client
An InvalidIndexDefinitionException may be thrown if Drill does not recognize the
type or expression of the index during the index discovery phase
Holder class that contains:
jar name
scan of packages, classes, annotations found in jar
unique jar classLoader
For the int type control,
the meaning of each bit start from lowest:
bit 0: intersect or not, 0 -- default(no intersect), 1 -- INTERSECT (DISTINCT as default)
bit 1: intersect type, 0 -- default (DISTINCT), 1 -- INTERSECT_ALL
Base class for MergeJoinPrel and HashJoinPrel
Maintain join state.
Merge Join implementation using RecordIterator.
Abstract implementation of StatisticsRecordWriter interface which exposes interface:
#writeHeader(List)
#addField(int,String)
to output the data in string format instead of implementing addField for each type holder.EVF based reader.
The two functions defined here convert_toJSON and convert_toEXTENDEDJSON are almost
identical.
Enhanced second-generation JSON loader which takes an input
source and creates a series of record batches using the
ResultSetLoader abstraction.Revised JSON loader that is based on the
ResultSetLoader abstraction.Extends the
JsonStructureOptions class, which provides
JSON syntactic options, with a number of semantic options enforced
at the JSON loader level.Interface through which UDFs, RecordWriters and other systems can write out a
JSON output.
Abstract implementation of RecordWriter interface which exposes interface:
#writeHeader(List)
#addField(int,String)
to output the data in string format instead of implementing addField for each type holder.Deprecated.
Deprecated.
EVF based JSON reader which uses input stream as data source.
Input to the JSON structure parser which defines guidelines
for low-level parsing as well as listeners for higher-level
semantics.
Parser for a subset of the jsonlines
format.
Parses an arbitrary JSON value (which can be a subtree of any
complexity) into a JSON string.
Contract between Lateral Join and any operator on right side of it consuming the input
from left side.
RecordBatch implementation for the lateral join operator.
LateralUnnestRowIDVisitor traverses the physical plan and modifies all the operators in the
pipeline of Lateral and Unnest operators to accommodate IMPLICIT_COLUMN.
Visitor for RelNodes which applies specified
RexShuttle visitor
for every node in the tree.Operator which specifically is a lowest level leaf node of a query plan
across all possible fragments.
Prel without children.
Represents the contents of a list vector.
Wrapper around the list vector (and its optional contained union).
Registry of Drill functions.
Local persistent store stores its data on the given file system.
A really simple provider that stores data in the local file system, one value per file.
A syncable local extension of the Hadoop FileSystem
A mock class to avoid NoClassDefFoundError after excluding Apache commons-logging from Hadoop dependency.
A simple Writer that will forward whole lines (lines ending with a newline) to
a Logger.
Responsible for breaking a plan into its constituent Fragments.
Extended version of a record reader which uses a size-aware batch mutator.
Extended version of a record reader which uses a size-aware batch mutator.
Exception thrown from the constructor if the data source is empty and
can produce no data or schema.
Basic scan framework for a "managed" reader which uses the scan schema
mechanisms encapsulated in the scan schema orchestrator.
Creates a batch reader on demand.
A visitor to compute memory requirements for each operator in a minor fragment.
Utility class which helps in parsing memory configuration string using the passed in pattern to get memory value in
bytes.
A join operator that merges two sorted streams using a record iterator.
Wrapper around the "MSorter" (in memory merge sorter).
Merges pre-sorted record batches from remote senders.
Optional custom parser for the portion of a JSON message that
surrounds the data "payload".
This is an utility class, holder for Parquet Table Metadata and
ParquetReaderConfig.A struct that contains the metadata for a column in a parquet file
Struct which contains the metadata for a single parquet file
A struct that contains the metadata for a parquet row group
A struct that contains the metadata for a column in a parquet file
Struct which contains the metadata for a single parquet file
Struct which contains the metadata for an entire parquet directory structure
A struct that contains the metadata for a parquet row group
A struct that contains the metadata for a column in a parquet file
Struct which contains the metadata for a single parquet file
A struct that contains the metadata for a parquet row group
A struct that contains the metadata for a column in a parquet file.
Struct which contains the metadata for a single parquet file
A struct that contains the metadata for a parquet row group
Implementation of
RelCollationImpl with field name.Class which provides information required for producing metadata aggregation when performing analyze.
Helper class for constructing aggregate value expressions required for metadata collecting.
Basic class for parquet metadata.
Resolved value for a metadata column (implicit file or partition column.) Resolution
here means identifying a value for the column.
A metadata context that holds state across multiple invocations of
the Parquet metadata APIs.
Terminal operator for producing ANALYZE statement.
Class which provides information required for storing metadata to the Metastore when performing analyze.
Represents direct scan based on metadata information.
Metadata runtime exception to indicate issues connected with table metadata.
Responsible for handling metadata returned by incoming aggregate operators
and fetching required metadata form the Metastore.
Class which provides information required for handling results of metadata aggregation when performing analyze.
Interface for obtaining information about segments, files etc which should be handled in Metastore
when producing incremental analyze.
Queries can contain a wildcard (*), table columns, or special
system-defined columns (the file metadata columns AKA implicit
columns, the `columns` column of CSV, etc.).
Util class that contains helper methods for converting paths in the table and directory metadata structures
Interface for retrieving and/or creating metadata given a vector.
Contains worker
Runnable classes for providing the metadata and related helper methods.Base interface for passing and obtaining
SchemaProvider, DrillStatsTable and
TableMetadataProvider, responsible for creating required
TableMetadataProviderBuilder which constructs required TableMetadataProvider
based on specified providersOperator which adds aggregate calls for all incoming columns to calculate
required metadata and produces aggregations.
Supported metadata versions.
Constructs plan to be executed for collecting metadata and storing it to the Metastore.
Implementation of
TableMetadataProvider which uses Drill Metastore for providing table metadata
for file-based tables.Implementation of
MetadataProviderManager which uses Drill Metastore providers.Implementation of
TableMetadataProvider which uses Drill Metastore for providing
table metadata for parquet tables.MethodAnalyzer<V extends org.objectweb.asm.tree.analysis.Value>
Analyzer that allows us to inject additional functionality into ASMs basic analysis.
Interface that defines a metric.
MinorFragmentEndpoint represents fragment's MinorFragmentId and Drillbit endpoint to which the fragment is
assigned for execution.
Builds the handler which provides values for columns in
an explicit project list but for which
the reader provides no values.
Each storage plugin requires a unique config class to allow
config --> impl lookups to be unique.
Describes a "group" scan of a (logical) mock table.
Describes a physical scan operation for the mock data source.
Structure of a mock table definition file.
Meta-data description of the columns we wish to create during a simulated
scan.
Describes one simulated file (or block) within the logical file scan
described by this group scan.
A tiny wrapper class to add required DrillTableSelection behaviour to
the entries list.
Generates a mock money field as a double over the range 0
to 1 million.
Parsers a binary.
Parses a Mongo date in the
V1 format:
In-memory sorter.
MurmurHash3 was written by Austin Appleby, and is placed in the public
domain.
A mutable form of a tuple schema.
Holder for a column to allow inserting and replacing columns within
the top-level project list.
Interface for the nested loop join operator.
This class abstracts the resources like cpu and memory used up by the operators.
Provides resources for a node in cluster.
WindowFramer implementation that doesn't support the FRAME clause (will
assume the default frame).
Generate a non-covering index plan that is equivalent to the original plan.
Indicates NonNullable nature
This managers determines when to run a non-root fragment node.
Implementation of
AliasRegistry that does nothing.An injector that does not inject any controls, useful when not testing (i.e.
Do-nothing implementation of the metadata manager.
Simple selector whose value is another Simple or Complex Selectors.
Old versions of Drill were writing a non-standard format for date.
Old versions of Drill were writing a non-standard format for date.
Manages null columns by creating a null column loader for each
set of non-empty null columns.
Create and populate null columns for the case in which a SELECT statement
refers to columns that do not exist in the actual table.
Parser for a field that contains only nulls.
A vector cache implementation which does not actually cache.
Parses nulls.
Do-nothing vector state for a map column which has no actual vector
associated with it.
Near-do-nothing state for a vector that requires no work to
allocate or roll-over, but where we do want to at least track
the vector itself.
A column specific equi-depth histogram which is meant for numeric data types
This class enables Drill to access file systems which use OAuth 2.0 for
authorization.
While a builder may seem like overkill for a class that is little more than small struct,
it allows us to wrap new instances in an Optional while using contructors does not.
Class for managing oauth tokens.
Parses a JSON object:
{ name : value ...Interface to track opening and closing of files.
Per-operator services available for operator implementations.
State machine that drives the operator executable.
Core protocol for a Drill operator execution.
Visitor to renumber operators - needed after materialization is done as some operators may be removed
using @ExtendedMaterializerVisitor
Registry of operator metrics.
Modular implementation of the standard Drill record batch iterator
protocol.
Interface for updating a statistic.
Utility methods, formerly on the OperatorContext class, that work with
operators.
Wrapper class for profiles of ALL operator instances of the same operator type within a major fragment.
This holds all the information about an option.
Wrapper class for OptionValue to add Status
Manager for Drill
options.Contains information about the scopes in which an option can be set, and an option's visibility.
Immutable set of options accessible by name or validator.
Validates the values provided to Drill options.
An
option value is used internally by an
OptionManager to store a run-time setting.Defines where an option can be configured.
This defines where an option was actually configured.
OrderedMuxExchange is a version of MuxExchange where the incoming batches are sorted
merge operation is performed to produced a sorted stream as output.
OrderedMuxExchangePrel is mux exchange created to multiplex the streams for a MergeReceiver.
Generates an ordered partition, rather than a random hash partition.
Class implementing OrderedPrel interface guarantees to provide ordered
output on certain columns.
Complex selector whose value is list of other Simple or Complex Selectors.
Describes the field will provide output from the given function.
Builds an output batch based on an output schema and one or more input
schemas.
Describes an input batch with a schema and a vector container.
Source map as a map schema and map vector.
Interface that allows a record reader to modify the current schema.
Return type calculation interface for functions that have return type set as with enum
FunctionTemplate.ReturnType.Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.CONCAT.OutputWidthExpressions are used to capture the information required to calculate the width of the output
produced by a variable-width expression.
Used to represent fixed-width values used in an expression.
FunctionCallExpr captures the details required to calculate the width of the output produced by a function
that produces variable-width output.
IfElseWidthExpr is uded to capture an
IfExpression.VarLenReadExpr captures the inputColumnName and the readExpression used to read a variable length column.
Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.PAD.Implement
UserAuthenticator based on Pluggable Authentication
Module (PAM) configuration.Implement
UserAuthenticator based on Pluggable Authentication
Module (PAM) configuration.Captures parallelization parameters for a given operator/fragments.
Collects/merges one or more ParallelizationInfo instances.
Interface to implement for passing parameters to
FragmentParallelizer.Marker annotation to determine which fields should be included as parameters
for the function.
Represents a single column read from the Parquet file by the record reader.
ByteBufferAllocator implementation that uses Drill's BufferAllocator to allocate and release
ByteBuffer objects.To properly release an allocated
DrillBuf, this class keeps track of it's corresponding ByteBuffer
that was passed to the Parquet library.Internal implementation of the Parquet file writer as a block container
Note: this is temporary Drill-Parquet class needed to write empty parquet files.
Note: this is temporary Drill-Parquet class needed to write empty parquet files.
Holds common statistics about data in parquet group scan,
including information about total row count, columns counts, partition columns.
Interface for providing table, partition, file etc.
Base interface for builders of
ParquetMetadataProvider.Abstract implementation of RecordWriter interface which exposes interface:
#writeHeader(List)
#addField(int,String)
to output the data in string format instead of implementing addField for each type holder.PartitionDescriptor that describes partitions based on column names instead of directory structure
Stores consolidated parquet reading configuration.
Utility class where we can capture common logic between the two parquet readers
For most recently created parquet files, we can determine if we have corrupted dates (see DRILL-4203)
based on the file metadata.
Utilities for converting from parquet INT96 binary (impala, hive timestamp)
to date time value.
Creates file system only if it was not created before, otherwise returns already created instance.
Mapping from the schema of the Parquet file to that of the record reader
to the schema that Drill and the Parquet reader uses.
Interface for providing table, partition, file etc.
Builder for
ParquetTableMetadataProvider.Utility class for converting parquet metadata classes to Metastore metadata classes.
This exception is thrown when parse errors are encountered.
The
parse_query function splits up a query string and returns a map of the key-value pairs.The
parse_url function takes an URL and returns a map of components of the URL.Used internally to keep track of partitions and frames.
Represents a partition column (usually dir0, dir1, ...).
Interface used to describe partitions.
Decorator class to hide multiple Partitioner existence from the caller since
this class involves multithreaded processing of incoming batches as well as
flushing it needs special handling of OperatorStats - stats since stats are
not suitable for use in multithreaded environment The algorithm to figure out
processing versus wait time is based on following formula: totalWaitTime =
totalAllPartitionersProcessingTime - max(sum(processingTime) by partitioner)
Helper interface to generalize functionality executed in the thread
since it is absolutely the same for partitionBatch and flushOutgoingBatches
protected is for testing purposes
Exposes partition information to UDFs to allow queries to limit reading
partitions dynamically.
Helps to perform limit in a partition within a record batch.
Interface to define a partition.
Class PathInExpr is to recursively analyze a expression trees with a map of
indexed expression collected from indexDescriptor, e.g.
Is used to provide schema using given schema file name and path.
Path serializer to simple String path.
A convenience class used to expedite zookeeper paths manipulations.
Injection for a single pause.
This represents a persisted
OptionValue.This deserializer only fetches the relevant information we care about from a store, which is the
value of an option.
Implementation of aliases table that updates its version in persistent store after modifications.
Implementation of
AliasRegistry that persists aliases tables
to the pre-configured persistent store.Stores and retrieve instances of given value type.
An abstraction for configurations that are used to create a
store.Defines operation mode of a
PersistentStore instance.A factory used to create
store instances.Implementation of
TokenRegistry that persists token tables
to the preconfigured persistent store.Implementation of tokens table that updates its version in persistent store after modifications.
Visitor class designed to traversal of a operator tree.
Returns RuleSet for concrete planner phase.
Helper class to return PlanFragments based on the query plan
or based on split query plan
As of now it is only invoked once per query and therefore cheap to create PlanSplitter object
on heap.
Aggregate implementation for Drill plugins.
The rule that converts provided aggregate operator to plugin-specific implementation.
Generalized interface for bootstraping or upgrading the plugin persistent
store.
Loads the set of bootstrap plugin configurations for new systems.
Abstract base class for a rule that converts provided operator to plugin-specific implementation.
PluginCost describes the cost factors to be used when costing for the specific storage/format plugin
An interface to check if a parameter provided by user is valid or not.
Class which checks whether the provided parameter value is greater than
or equals to a minimum limit.
Table implementation based on
DynamicDrillTable to be used by Drill plugins.Filter implementation for Drill plugins.
The rule that converts provided filter operator to plugin-specific implementation.
Represents a storage plugin, defined by a (name, config) pair.
Callback for the implementation process that checks whether a specific operator
can be converted and converts a tree of
PluginRel nodes into expressions
that can be consumed by the storage plugin.Prel used to represent a Plugin Conversion within an expression tree.
Join implementation for Drill plugins.
The rule that converts provided join operator to plugin-specific implementation.
Limit implementation for Drill plugins.
Represents a plugin-specific plan once children nodes have been pushed down into group scan.
Project implementation for Drill plugins.
The rule that converts provided project operator to plugin-specific implementation.
Provides a loose coupling of the plugin registry to the resources it needs
from elsewhere.
Relational expression that uses specific plugin calling convention.
Provides rules required for adding support of specific operator pushdown for storage plugin.
Sort implementation for Drill plugins.
The rule that converts provided sort operator to plugin-specific implementation.
Union implementation for Drill plugins.
The rule that converts provided union operator to plugin-specific implementation.
This class uses reflection of a Java class to construct a
RecordDataType.Reads values from the given list of pojo instances.
Pojo writer interface for writers based on types supported for pojo.
Pojo writer for boolean.
Pojo writer for decimal.
Pojo writer for double.
Pojo writer for Enum.
Pojo writer for float.
Pojo writer for int.
Pojo writer for long.
Pojo writer for Long.
Pojo writer for Boolean.
Pojo writer for Double.
Pojo writer for Float.
Pojo writer for Integer.
Pojo writer for Timestamp.
Pojo writer for String.
Cost estimates per physical relation.
A marker interface that means that this node should be finalized before execution planning.
Debug-time class that prints a PRel tree to the console for
inspection.
Contains worker
Runnable for creating a prepared statement and helper methods.Runnable that creates a prepared statement for given
UserProtos.CreatePreparedStatementReq and
sends the response at the end.This class rewrites all the project expression that contain convert_to/ convert_from
to actual implementations.
Manages a
PriorityQueueCopier instance produced from code generation.We've gathered a set of batches, each of which has been sorted.
Indicates private plugins which will be excluded from automatic plugin
discovery.
System table listing completed profiles
Base class for Profile Iterators
System table listing completed profiles as JSON documents
Wrapper class for a
query profile, so it to be presented through web UI.Implements callbacks to build the physical vectors for the project
record batch.
Enhanced form of a dynamic column which records all information from
the project list.
Utility class to check if a column is consistent with the projection
requested for a query.
Provides a variety of ways to filter columns: no filtering, filter
by (parsed) projection list, or filter by projection list and
provided schema.
Schema-based projection.
Compound filter for combining direct and provided schema projections.
Projection filter based on the (parsed) projection list.
Implied projection: either project all or project none.
Projection filter in which a schema exactly defines the set of allowed
columns, and their types.
Projection based on a non-strict provided schema which enforces the type of known
columns, but has no opinion about additional columns.
Converts a projection list passed to an operator into a scan projection list,
coalescing multiple references to the same column into a single reference.
Schema tracker for the "normal" case in which schema starts from a simple
projection list of column names, optionally with a provided schema.
ProjectMemoryManager(PMM) is used to estimate the size of rows produced by
ProjectRecordBatch.
A physical Prel node for Project operator.
Create a Drill field listener based on a provided schema.
Iterates over the set of batches in a result set, providing
a row set reader to iterate over the rows within each batch.
Protocol
Push-based result set reader, in which the caller obtains batches
and registers them with the implementation.
Represents one level of qualifier for a column.
Indicates that an external source has cancelled the query.
Per-compilation unit class loader that holds both caching and compilation
steps.
Packages a batch from the Screen operator to send to its
user connection.
Represents a batch of data with a schema.
Package that contains only a query ID.
Each Foreman holds its own QueryManager.
OptionManager that holds options within QueryContext.Parallelizes the query plan.
Interface which defines a queue implementation for query queues.
Exception thrown for all non-timeout error conditions.
The opaque lease returned once a query is admitted
for execution.
Exception thrown if a query exceeds the configured wait time
in the query queue.
Interface which defines an implementation for managing queue configuration of a leaf
ResourcePoolParses and initialize QueueConfiguration for a
ResourcePool.Manages resources for an individual query in conjunction with the
global
ResourceManager.Extends a
QueryResourceAllocator to provide queueing support.Model class for Query page
Model class for Results page
Encapsulates the future management of query submissions.
Query runner for streaming JSON results.
Is responsible for query transition from one state to another,
incrementing / decrementing query statuses counters.
Definition of a minor fragment that contains the (unserialized) fragment operator
tree and the (partially built) fragment.
Used to keep track of selected leaf and all rejected
ResourcePool for the provided query.Paralellizer specialized for managing resources for a query based on Queues.
Used in case of error while selecting a queue for a given query
Interface that defines all the implementation of a QueueSelectionPolicy supported by ResourceManagement
Factory to return an instance of
QueueSelectionPolicy based on the configured policy name.Randomly selects a queue from the list of all the provided queues.
A RangePartitionExchange provides the ability to divide up the rows into separate ranges or 'buckets'
based on the values of a set of columns (the range partitioning columns).
Provides the ability to divide up the input rows into a fixed number of
separate ranges or 'buckets' based on the values of a set of columns (the
range partitioning columns).
A batch buffer is responsible for queuing incoming batches until a consumer is ready to receive them.
Creates a batch reader on demand.
Row set index base class used when indexing rows within a row
set for a row set reader.
Computes the full output schema given a table (or batch)
schema.
Reader-level projection is customizable.
Manages the schema and batch construction for a managed reader.
Orchestrates projection tasks for a single reader within the set that the
scan operator manages.
Internal state for reading from a Parquet file.
A receiver is one half of an exchange operator.
A record batch contains a set of field values for a particular range of
records.
Describes the outcome of incrementing RecordBatch forward by a call to
RecordBatch.next().Holds the data for a particular record batch for later manipulation.
Holds record batch loaded from record batch message.
Logic for handling batch record overflow; this class essentially serializes overflow vector data in a
compact manner so that it is reused for building the next record batch.
Builder class to construct a
RecordBatchOverflow objectField overflow definition
Record batch definition
Given a record batch or vector container, determines the actual memory
consumed by each column, the average row, and the entire record batch.
This class is tasked with managing all aspects of flat Parquet reader record batch sizing logic.
Field memory quota
An abstraction to allow column readers attach custom field overflow state
Container object to hold current field overflow state
Container object to supply variable columns statistics to the batch sizer
Utility class to capture key record batch statistics.
Indicates whether a record batch is Input or Output
Helper class which loads contextual record batch logging options
Provides methods to collect various information_schema data.
Provides information_schema data based on information stored in
AbstractSchema.Provides information_schema data based on information stored in Drill Metastore.
Defines names and data types of columns in a static drill table.
RecordIterator iterates over incoming record batches one record at a time.
For new implementations please use new
ManagedReaderPojo object for a record in INFORMATION_SCHEMA.CATALOGS
Pojo object for a record in INFORMATION_SCHEMA.COLUMNS
Pojo object for a record in INFORMATION_SCHEMA.FILES
Pojo object for a record in INFORMATION_SCHEMA.PARTITIONS
Pojo object for a record in INFORMATION_SCHEMA.SCHEMATA
Pojo object for a record in INFORMATION_SCHEMA.TABLES
Pojo object for a record in INFORMATION_SCHEMA.VIEWS
Wrapper around VectorAccessible to iterate over the records and fetch fields within a record.
RecordWriter interface.
Utilities for converting SQL
LIKE and SIMILAR operators
to regular expressions.Fixed set of Drill relational operators, using well-defined
names.
Is responsible for remote function registry management.
It is necessary to start Drillbit.
Represents the internal state of a RepeatedList vector.
Repeated list column state.
Track the repeated list vector.
Class is responsible for generating record batches for text file inputs.
Vector state for a scalar array (repeated scalar) vector.
BasicValue with additional tracking information used to determine
the replaceability of the value (a holder, or boxed value) for scalar replacement purposes.
Plan-time properties of a requested column.
Represents one name element.
Represents the set of columns projected for a tuple (row or map.)
Each column may have structure: a set of referenced names or
array indices.
Represents an explicit projection at some tuple level.
Converts a
SqlNode representing: "ALTER ..Aliases table that fallback user aliases calls to public aliases
if alias not found in user aliases table.
A resolved column has a name, and a specification for how to project
data from a source vector to a vector in the final output container.
Represents a column which is implicitly a map (because it has children
in the project list), but which does not match any column in the table.
Projected column that serves as both a resolved column (provides projection
mapping) and a null column spec (provides the information needed to create
the required null vectors.)
Column that matches one provided by the table.
Drill rows are made up of a tree of tuples, with the row being the root
tuple.
Represents a map implied by the project list, whether or not the map
actually appears in the table schema.
Represents a map tuple (not the map column, rather the value of the
map column.) When projecting, we create a new repeated map vector,
but share the offsets vector from input to output.
Represents the top-level tuple which is projected to a
vector container.
Drillbit-wide resource manager shared by all queries.
Builds the proper resource manager and queue implementation for the configured
system options.
Interface which defines an implementation of ResourcePool configuration for
ResourcePoolTreeParses and initializes all the provided configuration for a ResourcePool defined in RM configuration.
Interface that defines implementation for selectors assigned to a ResourcePool.
Interface which defines the implementation of a hierarchical configuration for all the ResourcePool that will be
used for ResourceManagement
Parses and initializes configuration for ResourceManagement in Drill.
Responsible for setting configured
ExecConstants.HTTP_JETTY_SERVER_RESPONSE_HEADERS
to HttpServletResponse object.Copies rows from an input batch to an output batch.
Builds a result set (series of zero or more row sets) based on a defined
schema which may
evolve (expand) over time.
Implementation of the result set loader.
Read-only set of options for the result set loader.
Builder for the options for the row set loader.
Interface for a cache that implements "vector persistence" across
multiple result set loaders.
Manages an inventory of value vectors used across row batch readers.
An ASM ClassVisitor that allows for a late-bound delegate.
Return type calculation interface for functions that have return type set as with enum
FunctionTemplate.ReturnType.Rewrites an expression tree, replacing OR and AND operators with more than 2 operands with a chained operators
each with only 2 operands.
Rewrites an expression tree, replacing chained OR and AND operators with a single N-ary operator
e.g.
This class is an enhanced version for DrillOptiq,
1, it can convert expressions in one more layer(project that have expression) above project-scan,
while DrillOptiq can only convert expressions directly reference scan's row type,
2, it can record the generated LogicalExpression of each rexNode in the rexNode tree for future reference
this result can serve future rewrite that need to locate particular LogicalExpressions
Defines all the default values used for the optional configurations for ResourceManagement
Used in cases of any error with the ResourceManagement configuration
Marker interface describe the root of a query plan.
Node which is the last processing node in a query plan.
Provides services needed by the
FragmentExecutor.This managers determines when to run a root fragment node.
The root parsers are special: they must detect EOF.
Parser for data embedded within a message structure which is
encoded as an array of objects.
Parser for data embedded within a message structure which is encoded
as a single JSON object.
Parser for a compliant JSON data set which consists of an
array at the top level, where each element of the array is a
JSON object that represents a data record.
Parser for a jsonlines-style
data set which consists of a series of objects.
Extended version of a record reader used by the revised
scan batch operator.
Implementation of Calcite's ROW(col1, col2, ..., colN) constructor function.
Interface for a row key join
Enum for RowKeyJoin internal state.
A row set is a collection of rows stored as value vectors.
Single row set which is empty and allows writing.
Row set comprised of multiple single row sets, along with
an indirection vector (SV4).
Row set that manages a single batch of rows.
Fluent builder to quickly build up an row set (record batch)
programmatically.
Helper class to obtain string representation of RowSet.
Interface for writing values to a row set.
Implementation of the row set loader.
Reader for all types of row sets: those with or without
a selection vector.
Reader implementation for a row set.
Interface for writing values to a row set.
Implementation of a row set writer.
Define the validity of a row group against a filter
ALL : all rows match the filter (can not drop the row group and can prune the filter)
NONE : no row matches the filter (can drop the row group)
SOME : some rows only match the filter or the filter can not be applied (can not drop the row group nor the filter)
Contains rule instances which use custom RelBuilder.
A RuntimeFilterRecordBatch steps over the ScanBatch.
A reporter to send out the bloom filters to their receivers.
This class manages the RuntimeFilter routing information of the pushed down join predicate
of the partitioned exchange HashJoin.
This sink receives the RuntimeFilters from the netty thread,
aggregates them in an async thread, broadcast the final aggregated
one to the RuntimeFilterRecordBatch.
This visitor does two major things:
1) Find the possible HashJoinPrel to add a RuntimeFilterDef to it.
A binary wire transferable representation of the RuntimeFilter which contains
the runtime filter definition and its corresponding data.
Describes the field will provide output from the given function.
Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.SAME_IN_OUT_LENGTH.Base class for scalar field listeners
Reference list of classes we will perform scalar replacement on.
Parses
and simply passes the value token on to the listener.
true | false | null | integer | float | string |
embedded-objectand simply passes the value token on to the listener.
Parses
true | false | null | integer | float | string |
embedded-objectRecord batch used for a particular scan.
Row set mutator implementation provided to record readers created by
this scan batch.
Binds the scan lifeycle to the scan operator.
This visitor will walk a logical plan and record in a map the list of field references associated to each scan.
Parses and analyzes the projection list passed to the scanner.
Interface for add-on parsers, avoids the need to create
a single, tightly-coupled parser for all types of columns.
Identifies the kind of projection done for this scan.
/**
Basic scan framework for a set of "managed" readers and which uses the
scan schema tracker to evolve the scan output schema.
Gathers options for the
ScanLifecycle then builds a scan lifecycle
instance.Interface to the set of readers, and reader schema, that the scan operator
manages.
Implementation of the revised scan operator that uses a mutator aware of
batch sizes.
Parse the projection list into a dynamic tuple schema.
Builds the configuration given to the
ScanSchemaTracker.Performs projection of a record reader, along with a set of static
columns, to produce the final "public" result set (record batch)
for the scan operator.
Resolves a schema against the existing scan schema.
Indicates the source of the schema to be analyzed.
Computes scan output schema from a variety of sources.
Cost estimate for a scan.
Simple "tracker" based on a defined, fixed schema.
A reusable builder that supports the creation of BatchSchemas.
Contains information needed by
AbstractSchema implementations.Interface to implement to provide required info for
SchemaConfigHolder class that contains table name, schema definition and current schema container version.
Schema container version holder contains version in int representation.
Storage plugins implements this interface to register the schemas they provide.
Aggregate function which accepts VarChar column with string representations of
TupleMetadata
and returns string representation of TupleMetadata with merged schema.Aggregate function which infers schema from incoming data and returns string representation of
TupleMetadata
with incoming schema.Parent class for CREATE / DROP / DESCRIBE / ALTER SCHEMA handlers.
ALTER SCHEMA ADD command handler.
CREATE SCHEMA command handler.
DESCRIBE SCHEMA FOR TABLE command handler.
Wrapper to output schema in a form of table with one column named `schema`.
DROP SCHEMA command handler.
ALTER SCHEMA REMOVE command handler.
Empty batch without schema and data.
The operator for creating
SchemalessBatch instancesThe type of scan operator, which allows to scan schemaless tables (
DynamicDrillTable with null selection)Negotiates the table schema with the scanner framework and provides
context information for the reader.
Negotiates the table schema with the scanner framework and provides
context information for the reader.
Implementation of the schema negotiation between scan operator and
batch reader.
Implementation of the schema negotiation between scan operator and
batch reader.
Exposes partition information for a particular schema.
Provides mechanisms to manage schema: store / read / delete.
Factory class responsible for creating different instances of schema provider based on given parameters.
Implements a "schema smoothing" algorithm.
Exception thrown if the prior schema is not compatible with the
new table schema.
Tracks changes to schemas via "snapshots" over time.
Creates new schema trees.
Utility class for dealing with changing schemas
Set of schema utilities that don't fit well as methods on the column
or tuple classes.
Transfer batches to a user connection.
A ByteArrayInputStream that supports the HDFS Seekable API.
This class extends from
TableScan.A selection vector that fronts, at most, 64K values.
A sender is one half of an exchange node operations.
Account for whether all messages sent have been completed.
ServerAuthenticationHandler<S extends ServerConnection<S>,T extends com.google.protobuf.Internal.EnumLite>
Handles SASL exchange, on the server-side.
Contains worker
Runnable for returning server meta informationRunnable that creates server meta information for given
ServerMetaReq and
sends the response at the end.A enumeration of server methods, and the version they were introduced
it allows to introduce new methods without changing the protocol, with client
being able to gracefully handle cases were method is not handled by the server.
OptionManager that holds options within UserSession context.Converts a
SqlNode representing: "ALTER ..Representation of "SET property.name" query result.
Represents a layer of row batch reader that works with a
result set loader and schema manager to structure the data
read by the actual row batch reader.
Original show files command result holder is used as wrapper over new
Records.File holder
to maintain backward compatibility with ODBC driver etc.Describes the field will provide output from the given function.
Base class for scalar and object arrays.
An implementation of interface CharStream, where the stream is assumed to
contain only ASCII characters (without unicode processing).
Representation of a millisecond duration in a human-readable format
Parsers a Mongo extended type of the form:
Metadata provider which supplies only table schema and / or table statistics if available.
A message parser which accepts a path to the data encoded as a
slash-separated string.
The simple parallelizer determines the level of parallelization of a plan
based on the cost of the underlying operations.
Designed to setup initial values for arriving fragment accounting.
Abstract class for simple partition.
Builds a set of readers for a single (non-hyper) batch.
Wrap a VectorContainer into a record batch.
Rewrite RexNode with these policies:
1) field renamed.
This class go through the RexNode, collect all the fieldNames, mark starting positions(RexNode) of fields
so this information can be used later e,.g.
Produce a metadata schema from a vector container.
Sender that pushes all data to a single destination node.
Base class for a single vector.
State for a scalar value vector.
Special case for an offset vector.
State for a scalar value vector.
Uses this class to keep track # of Drill Logical Expressions that are
put to JBlock.
Resolve a table schema against the prior schema.
Implementation of
FragmentParallelizer where fragment has zero or
more endpoints with affinities.Rule that converts an
Sort to a physical SortPrel, implemented by a Drill "order" operation.Single-batch sorter using a generated implementation based on the
schema and sort specification.
Implementation of the external sort which is wrapped into the Drill
"next" protocol by the
ExternalSortBatch class.Return results for a single input batch.
Iterates over the final sorted results.
Computes the memory needs for input batches, spill batches and merge
batches.
Rule that converts a logical
DrillSortRel to a physical sort.This interface represents the metadata for a spilled partition.
Replaces "incoming" - instead scanning a spilled partition file
Holds a set of spilled batches, represented by a file on disk.
Represents the set of spilled batches, including methods to spill and/or
merge a set of batches to produce a new spill file.
Manages the spilling information for an operator.
This is a class that is used to do updates of the spilled state.
Generates the set of spill files for this sort session.
Wrapper around an input stream to collect the total bytes
read through the stream for use in reporting performance
metrics.
Wrapper around an output stream to collect the total bytes
written through the stream for use in reporting performance
metrics.
SimpleParallelizerMultiPlans class is an extension to SimpleParallelizer to
help with getting PlanFragments for split plan.
This implementation of RawBatchBuffer starts writing incoming batches to disk once the buffer size reaches a threshold.
Column-data accessor that implements JDBC's Java-null--when--SQL-NULL mapping.
SQL tree for ANALYZE statement.
Class responsible for managing:
parsing -
SqlConverter.parse(String)
validation - SqlConverter.validate(SqlNode)
conversion to rel - SqlConverter.toRel(SqlNode) (String)}
Enum which indicates type of CREATE statement.
Enum for metadata types to drop.
SQL Pattern Contains implementation
Sql parse tree node to represent statement:
REFRESH TABLE METADATA tblname
Parent class for CREATE, DROP, DESCRIBE, ALTER SCHEMA commands.
CREATE SCHEMA sql call.
DESCRIBE SCHEMA FOR TABLE sql call.
Enum which specifies format of DESCRIBE SCHEMA FOR table output.
DROP SCHEMA sql call.
Sql parse tree node to represent statement:
SHOW FILES [{FROM | IN} db_name] [LIKE 'pattern' | WHERE expr]
Sql parse tree node to represent statement:
SHOW {DATABASES | SCHEMAS} [LIKE 'pattern' | WHERE expr]
Sql parse tree node to represent statement:
SHOW TABLES [{FROM | IN} db_name] [LIKE 'pattern' | WHERE expr]
Sql parser tree node to represent
USE SCHEMA statement.Configures
SslContextFactory when https is enabled for Web UIFactory for standard conversions as outlined in the package header.
Definition of a conversion including conversion type and the standard
conversion class (if available.)
Indicates the type of conversion needed.
Base class for columns that take values based on the
reader, not individual rows.
Base class for columns that take values based on the
reader, not individual rows.
A
DrillTable with a defined schema
Currently, this is a wrapper class for SystemTable.The log2m parameter defines the accuracy of the counter.
The log2m parameter defines the accuracy of the counter.
The log2m parameter defines the accuracy of the counter.
The log2m parameter defines the accuracy of the counter.
Example input and output:
Schema of incoming batch:
Interface for collecting and obtaining statistics.
Reads records from the RecordValueAccessor and writes into StatisticsRecordCollector.
Visitor to collect stats such as cost and parallelization info of operators within a fragment.
Listener that keeps track of the status of batches sent, and updates the SendingAccountor when status is received
for each batch
Data Model for rendering /options on webUI
Interface for all implementations of the storage plugins.
Indicates an error when decoding a plugin from JSON.
Indicates the requested plugin was not found.
Plugin registry.
Helper class that can be used to obtain rules required for pushing down operators
that specific plugin supports configured using
StoragePluginRulesSupplier.StoragePluginRulesSupplierBuilder.Map of storage plugin *configurations* indexed by name.
Interface to the storage mechanism used to store storage plugin
configurations, typically in JSON format.
Concrete storage plugin (configuration) store based on the
PersistentStore abstraction.Storage plugin table scan rel implementation.
Holds storage properties used when writing schema container.
Model class for Storage Plugin and Credentials page.
Contains list of parameters that will be used to store path / files on file system.
An interface which supports storing a record stream.
A Store interface used to store and retrieve instances of given value type.
The Aggregator can return one of the following outcomes:
Stream the results of a query to a REST client as JSON, following the schema
defined by
QueryResult to maintain backward compatibility.64-bit integer (BIGINT) listener with conversions only from
numbers and strings.
32-bit integer (INT) listener with conversions only from
numbers and strings.
Return type calculation implementation for functions with return type set as
FunctionTemplate.ReturnType.STRING_CAST.Convert string to ASCII from another encoding input.
Returns the ASCII code of the first character of input string
Returns the char corresponding to ASCII code input.
Remove the longest string containing only characters from "from" from the start of "text"
Remove the longest string containing only character " " from the start of "text"
Remove the longest string containing only characters from "from" from the start of "text"
Remove the longest string containing only character " " from the start of "text"
Returns the input char sequences repeated nTimes.
Returns the reverse string for given input.
Fill up the string to length "length" by appending the characters 'fill' at the end of 'text'
If the string is already longer than length then it is truncated.
Fill up the string to length "length" by appending the characters ' ' at the end of 'text'
If the string is already longer than length then it is truncated.
Remove the longest string containing only characters from "from" from the end of "text"
Remove the longest string containing only character " " from the end of "text"
Return the string part at index after splitting the input string using the
specified delimiter.
Return the string part from start to end after splitting the input string
using the specified delimiter.
Generates a mock string field of the given length.
Abstract implementation of RecordWriter interface which exposes interface:
StringOutputRecordWriter.startNewSchema(BatchSchema)
StringOutputRecordWriter.addField(int,String)
to output the data in string format instead of implementing addField for each type holder.A SubScan operator represents the data scanned by a particular major/minor
fragment.
Removes
RelSubset nodes from the plan.Visit Prel tree.
OptionManager that holds options within
DrillbitContext.Indicates system plugins which will be dynamically initialized during storage
plugin registry init stage.
Locates system storage plugins.
An enumeration of all tables in Drill's system ("sys") schema.
This class creates batches based on the the type of
SystemTable.A "storage" plugin for system tables.
A namesake plugin configuration for system tables.
Definition of table parameters, contains parameter name, class type, type status (optional / required).
Describes table and parameters that can be used during table initialization and usage.
Simple selector whose value is a string representing a tag.
Defines a code generation "template" which consist of:
An interface that defines the generated class.
A template class which implements the interface to provide
"generic" methods that need not be generated.
A signature that lists the methods and vector holders used
by the template.
Text format plugin for CSV and other delimited text formats.
A byte-based Text parser implementation.
Global resource manager that provides basic admission control (AC) via a
configured queue: either the Zookeeper-based distributed queue or the
in-process embedded Drillbit queue.
Per-query resource manager.
Searches a fragment operator tree to find buffered within that fragment.
Allows parallel executions of tasks in a simplified way.
Drill-flavored version of a timestamp parser.
Drill-specific extension to allow times only.
Describes the input token stream.
Internal exception to unwind the stack when a syntax
error is detected within a record.
Token Manager Error.
Persistent Registry for OAuth Tokens
Operator Batch which implements the TopN functionality.
Adds non-trivial top project to ensure the final output field names are preserved.
Contains value vectors which are exactly the same
as the incoming record batch's value vectors.
An abstraction for storing, retrieving and observing transient (key, value) pairs in a distributed environment.
Represents an event created as a result of an operation over a particular (key, value) entry in a
store instance.Types of store events.
Factory that is used to obtain a
store instance.A listener used for observing
transient store events.Common interface to access a tuple backed by a vector container or a
map vector.
Common interface to access a column vector, its metadata, and its
tuple definition (for maps.) Provides a visitor interface for common
vector tasks.
Tuple-model interface for the top-level row (tuple) structure.
Accepts { name : value ...
Represents the loader state for a tuple: a row or a map.
Represents a map column (either single or repeated).
Represents a tuple defined as a Drill map: single or repeated.
State for a map vector.
Handles the details of the top-level tuple, the data row itself.
Declares a value vector field, providing metadata about the field.
Type functions for all types.
Unless explicitly changed by the user previously, the admin user
groups can only be determined at runtime
Unless explicitly changed by the user previously, the admin user
can only be determined at runtime
Validator that checks if the given DateTime format template is valid.
Validator that checks if the given value is included in a list of acceptable values.
Max width is a special validator which computes and validates
the maxwidth.
Defines the query state and shared resources available to UDFs through
injectables.
Wrapper store that delegates operations to PersistentStore.
Contains additional functions for union types in addition to those in
GUnionFunctions
Returns zero if the inputs have equivalent types.
Represents the contents of a union vector (or a pseudo-union for lists).
Union or list (repeated union) column state.
Vector wrapper for a union vector.
Placeholder for future unnest implementation that may require code generation.
Contains the actual unnest operation.
UnorderedDeMuxExchange is a version of DeMuxExchange where the incoming batches are not sorted.
UnorderedMuxExchange is a version of MuxExchange where the incoming batches are not sorted.
Unpivot maps.
Interface to provide various username/password based implementations for authentication.
Factory class which provides
UserAuthenticator implementation based on the BOOT options.Annotation for
UserAuthenticator implementation to identify the
implementation type.Interface for getting user session properties and interacting with user
connection.
While a builder may seem like overkill for a class that is little more than small struct,
it allows us to wrap new instances in an Optional while using contructors does not.
While a builder may seem like overkill for a class that is little more than small struct,
it allows us to wrap new instances in an Optional while using contructors does not.
Holds metrics related to bit user rpc layer
Utility class for User RPC
Implementations of this interface are allowed to increment queryCount.
Drill-specific extension to allow dates only, expressed in UTC
to be consistent with Mongo timestamps.
Per the
V1 docs:
In Strict mode, <date> is an ISO-8601 date format with a mandatory time zone field
following the template YYYY-MM-DDTHH:mm:ss.mmm<+/-Offset>.Description of a JSON value as inferred from looking ahead in
the JSON stream.
Description of JSON types as derived from JSON tokens.
Constructs a
ValueDef by looking ahead on the input stream.Represents a JSON scalar value, either a direct object field, or level
within an array.
Parses a JSON value.
Represents a declared variable (parameter) in a Drill function.
Physical Values implementation in Drill.
This class is responsible for formatting ValueVector elements.
Wraps a value vector field to be read, providing metadata about the field.
Value listener for JSON string values.
Parser which accepts all JSON values and converts them to actions on a
UNION vector writer.
Class which handles reading a batch of rows from a set of variable columns
Implements the
VarLenBulkInput interface to optimize data copyThis class is responsible for processing serialized overflow data (generated in a previous batch); this way
overflow data becomes an input source and is thus a) efficiently re-loaded into the current
batch ValueVector and b) subjected to the same batching constraints rules.
Implementation of
CredentialsProvider that obtains credential values from
Vault.Implement
UserAuthenticator
based on HashiCorp Vault.A wrapper around a VectorAccessible.
VectorAccessible is an interface.
Given a vector container, and a metadata schema that matches the container,
walk the schema tree to allocate new vectors according to a given
row count and the size information provided in column metadata.
Wraps a vector container and optional selection vector in an interface
simpler than the entire
RecordBatch.Deprecated.
Prototype mechanism to allocate vectors based on expected
data sizes.
Serializes vector containers to an output stream or from
an input stream.
Read one or more vector containers from an input stream.
Writes multiple VectorAccessible or VectorContainer
objects to an output stream.
Generic mechanism for retrieving vectors from a source tuple when
projecting columns to the output tuple.
Handles batch and overflow operation for a (possibly compound) vector.
Versioned store that delegates operations to PersistentStore and keeps versioning,
incrementing version each time write / delete operation is triggered.
Extension to the Store interface that supports versions
The vertex simply holds the child nodes but contains its own traits.
Overrides
Viewable to create a model which contains additional info of what control to display in menubar.Contains context information about view expansion(s) in a query.
Handler for Create View DDL command
Handler for Drop View [If Exists] DDL command.
Marker annotation to determine which fields should be included as parameters for the function.
Marker annotation to determine which fields should be included as parameters for the function.
Wrapper class around jetty based web server.
Holds various constants used by WebServer components.
Holds the resources required for Web User Session.
WebUserConnectionWrapper which represents the UserClientConnection between
WebServer and Foreman, for the WebUser submitting the query.Perform a wildcard projection.
Perform a wildcard projection with an associated output schema.
support for OVER(PARTITION BY expression1,expression2,...
Implementation of a table macro that generates a table based on parameters.
Manages the running fragments in a Drillbit.
Describes the field will provide output from the given function.
Stores the workspace related config.
Wrapper class that allows us to add additional information to each fragment
node for planning purposes.
A specialized version of record batch that can moves out buffers and preps
them for writing.
Writer physical operator
Write the RecordBatch to the given RecordWriter.
ZIP codec implementation which cna read or create single entry.
Defines the functions required by
ZKACLProviderDelegate to access ZK-ACL related informationThis class defines the methods that are required to specify
ACLs on Drill ZK nodes
This class hides the
ZKACLProvider from Curator-specific functions
This is done so that ACL Providers have to be aware only about ZK ACLs and the Drill ZKACLProvider interface
ACL Providers should not be concerned with the framework (Curator) used by Drill to access ZK.This factory returns a
ZKACLProviderDelegate which will be used to set ACLs on Drill ZK nodes
If secure ACLs are required, the ZKACLProviderFactory looks up and instantiates a ZKACLProviderDelegate
specified in the config file.Annotation for
ZKACLProviderDelegate implementation to identify the
implementation type.Manages cluster coordination utilizing zookeeper.
ZKDefaultACLProvider provides the ACLs for znodes created in a un-secure installation.
Deprecated.
will be removed in 1.7
use
ZookeeperPersistentStoreProvider instead.ZKSecureACLProvider restricts access to znodes created by Drill in a secure installation.
A namespace aware Zookeeper client.
Zookeeper based implementation of
PersistentStore.