All Classes and Interfaces
Class
Description
This interface defines an object that generates
WhereFilters to apply as ACLs to tables based upon a
UserContext and potentially a namespace and table name.A support object to assist in the creation of Row and column ACLs.
This auth wiring only allows users marked as administrators for the query to perform console operations.
This auth wiring only allows users marked as administrators for the query to perform console operations.
An
FixedPartitionedEnterpriseTableLocationKey that simply wraps an enterprise
TableLocationKeyBase implementation for DnD components to log binary rows via LAS.
A
ColumnRegion backed by a buffer of some sort.The basic implementation for a
BufferedColumnRegion.ColumnRegionByte implementation for regions that support fetching primitive bytes from a
FileDataBufferStore.ColumnRegionChar implementation for regions that support fetching primitive chars from a
FileDataBufferStore.ColumnRegionDouble implementation for regions that support fetching primitive doubles from a
FileDataBufferStore.ColumnRegionFloat implementation for regions that support fetching primitive floats from a
FileDataBufferStore.ColumnRegionInt implementation for regions that support fetching primitive ints from a
FileDataBufferStore.ColumnRegionLong implementation for regions that support fetching primitive ints from a
FileDataBufferStore.ColumnRegionLongWithLength implementation for regions that support fetching primitive longs from a
FileDataBufferStore.ColumnRegionShort implementation for regions that support fetching primitive shorts from a
FileDataBufferStore.Adapts a Legacy ColumnRegionByte to a Core ColumnRegionByte.
Adapts a Legacy ColumnRegionChar to a Core ColumnRegionChar.
Implementors provide a method to adapt an Enterprise
WritableChunk into a Community
WritableChunk.A collection of
WhereFilters by group and column.A
ColumnRegionByte that supports querying its length.A
ColumnRegionLong that supports querying its length.ColumnRegionObjectCached<T,ATTR extends Values,OFFSET_LOOKUP_CACHE extends OffsetLookupCache<T,ChunkSource.FillContext>>
Column region interface for regions that support fetching objects.
ColumnRegionObjectCached.CacheFactory<T,OFFSET_LOOKUP_CACHE extends OffsetLookupCache<T,ChunkSource.FillContext>>
A
ColumnRegion for non-primitive types that have a fixed size.A
ColumnRegion for non-primitive types that have a variable size.A Column region for objects that is backed by a dictionary of values.
A
ColumnRegionObject implementation for Deephaven format StringSet columns where stringsets are
stored as a bitmask and dictionary columnAn adapter from Community
ColumnSource to Enterprise ColumnSource geared
towards supporting Table.where().A Filter generator that provides a means to apply separate
AclFilterGenerator sets based on a users groups.A class specifically for completing table names; to be called after the completer has discovered the name of the
table.
A class specifically for completing table namespaces; to be called after the completer has discovered the name of the
namespace.
A concrete implementation of the replay configuration for one table.
Configure replay persistent queries.
AclFilterGenerator for combining the results of multiple AclFilterGenerators conjunctively, i.e.A
Table that wraps a Barrage subscription, but can gracefully handle upstream query state changes.Implementations of this interface provide parameters for a
ConnectionAwareRemoteTable to maintain a
subscription to a remote table.Implementations of this interface can be used to construct a new
ConnectionAwareRemoteTableParams.Gets groovy scripts over the network via controller client.
A lazy provider of the singleton controller client for queries.
A
RemoteTableStateWatcher that uses a PersistentQueryControllerClient to produce tokens backed by
PersistentQueryInfoMessages.A
RemoteTableStateWatcher.StateToken backed by a PersistentQueryInfoMessageThis class adapts a Legacy Enterprise TableLocationProvider into a Core TableLocationProvider.
Core+ ImportState for lastBy DIS instances.
LocalTableMap with an associated LiveTableRefreshCombiner.
A session factory that knows how to associate a barrage session and its managed channel; the session is created
authenticated to a DHE authentication service client.
This interface presents a view of the data store for the system in both Live, and Historical versions.
This class exists as an adapter shim between the Community implementation of
DatabaseInternal and the enterprise version.Custom autocomplete results for DHE.
A basic implementation of the
Database interface.This partial interface defines methods that we need to include in
Database
for various reasons, but are not intended for use by client code.An object that maintains connections to Deephaven services on a remote cluster.
A tagging interface for Deephaven formatted table locations.
An
UncoalescedTable that will apply row and column ACLs when it is coalesced.A clock impl with a delta adjustment and a speed factor.
A clock impl with a delta adjustment and a speed factor.
Note this class is only to be used by the DerivedPartitionTableWriterImpl.
This interface is used internally by the PartitionedTable DerivedTableWriter.
Persist data from a
Table to Deephaven storage using an in-worker DataImportServer.Represents Options for ingesting a table to a DIS partition.
Represents options for partitioned table ingestion.
An
AuthContext containing a single UserContext for Enterprise authentication.The authentication hook for enterprise clients to DnD workers.
The authorization provider for access to the worker.
A container for the configuration parameters of an Iceberg
discovery.The interface for constructing a
DiscoveryConfig.The result of an Iceberg table
discovery.The implementation of a
DiscoveryResultAclFilterGenerator for combining the results of multiple AclFilterGenerators disjunctively, i.e.Despite class name, this class doesn't extend the Groovy class loader, but rather handles getting Groovy script
resources.
A basic gRPC connection to a DnD worker.
A session on a Persistent Query used to access tables using Barrage
A factory class for creating
barrage sessions.Adapts a Legacy ColumnRegionDouble to a Core ColumnRegionDouble.
A implementation of
EdgeAclProvider that stores immutable maps of group to ACL definition.Objects that implement this interface provide ACLs for tables based on the requesting user at request time, as
opposed to
SourceAclProvider which applies ACLS to the table when it is fetched from the data source.A Builder to construct a set of ACLs to apply to a table based on the user fetching it.
Provides DnD engine table logger implementations that will write DHE binary rows.
An
SourceAclProvider that converts acls derived from Enterprise PermissionFilterProvider into
Community equivalents.This dagger module provides the authorization bindings into the dagger context.
An adapter from
enterprise filters to community filters.A light wrapper around an Enterprise
Filter.
This is the root component definition for DnD workers.
The root builder for the DnD jetty component.
A
TableKey implementation for addressing Deephaven Enterprise Tables.A basic Enterprise format
TableKey.Provides utility methods to read and write individual Deephaven format Tables.
Protobuf type
io.deephaven.proto.pivot.ErrorResponseProtobuf type
io.deephaven.proto.pivot.ErrorResponseImplementations of this internal interface are used to create appropriate
TableLocationProvider instances for
various extended table types.Implementations of this create
ExtendedStorageProviders based on the inputs.The service for loading
ExtendedStorageProviders that provide special storage backends for the database.An adapter FillContext for use when an Enterprise chunk must be filled by a Community source.
This class represents an instance of a legacy style Deephaven table where there are two fixed partitions, the column
partition and the internal partition
Adapts a Legacy ColumnRegionFloat to a Core ColumnRegionFloat.
An
AclFilterGenerator that provides full access to everyone.A Transformer for handling ACLs on generic objects.
A thin wrapper around a
ScriptSession so that we can invalidate the controller class loader cache before
evaluating scripts.A provider for group membership information for users of the system.
A
TicketTransformer that handles transformation of HierarchicalTables to apply ACLs at the edge.The provider for the coreplus:hive format, where tables are stored in the Apache Hive layout.
The factory class for creating this provider.
A
TableLocationKeyFinder that discovers Deephaven and parquet
format tables that are laid out in Apache Hive style on disk.A
TableLocationKeyFinder that uses a table of file names, sizes, and partitioning columns to provide table
locations.A
TableLocationFactory for resolving Hive style keys to locations.A
PropertyInputStreamLoader that loads files via HTTP GET requests to the specified hostA
TableLocation backed by a TableLocationMetadataIndex.LocationSnapshot that does not refresh and
tries to avoid creating the actual location until it is truly needed.Contains the configuration parameters needed to connect to an Iceberg
Catalog and
fetch Iceberg Tables.This interface provides an adapter layer between type specific data instructions and JSON serialization for
IcebergEndpoint.The factory interface for injecting implementations using
ServiceLoader.The complete configuration required to locate an Iceberg table within a
Catalog
and then fetch the Iceberg table into Deephaven.A Builder object for construction of a
IcebergEndpoint.An
IcebergEndpoint that is also named.An
ExtendedStorageProvider for the coreplus:iceberg type.The factory class for creating this provider.
An implementation of
IcebergDataInstructions used to serialize and deserialize S3Instructions for
fetching tables from an S3 store.A deserializer for
S3Instructions.The factory instance.
A serializer for
S3Instructions that only writes values that do not match the deephaven default values.Common utilities for loading Iceberg tables as Deephaven
TablesFor the CompositeImportState we need to have a well-defined order.
An import state details provides the class, constructor arguments, and key columns for an ImportState.
Tool to convert Legacy input tables into new Core+ input tables.
Tool to snapshot specified Core+ input tables.
Handles the targeting and reporting of Core+ executions on multiple input tables.
An extension of
InputTableUpdater that is a LivenessReferent and
allows materializing the resulting Table.Adapts a Legacy ColumnRegionInt to a Core ColumnRegionInt.
A
SecretsProvider that sources secrets from a file on disk in Property format.A factory to create a
JsonFilesSecretsProvider from an XML Element.The KafkaTableWriter creates a Deephaven Core KafkaIngester that persists the data to disk and serves it to other
queries using an in-worker instance of the DataImportServer.
A builder class containing the options for Kafka ingestion.
The LastByPartitionedTableFactory attaches to an Enterprise
DataImportServer and produces a Core
PartitionedTable with one constituent entry per partition for a given namespace and table name.Protobuf type
io.deephaven.proto.pqworker.ListenErrorRequestProtobuf type
io.deephaven.proto.pqworker.ListenErrorRequestProtobuf type
io.deephaven.proto.pqworker.ListenErrorResponseProtobuf type
io.deephaven.proto.pqworker.ListenErrorResponseAdapts a Legacy ColumnRegionLong to a Core ColumnRegionLong.
An object that produces a
ManagedChannel given host, port and max message size.A
TableLocationProvider that will perform a mark/sweep of active
locations on refresh.A
TableLocationKeyFinder that uses the Enterprise TableLocationMetadataIndex to find locations.An exception thrown when a
TableDefinition can not
be loaded from disk.A
TableLocationKey in Deephaven columnar format, located on a locally accessible filesystem.A
TableLocationKeyFinder for locating tables stored in Legacy
Deephaven Enterprise structured database.A
TableLocationKey marking tables stored in a Deephaven Enterprise database in the Parquet format.A
TableLocationFactory for resolving NestedPartitionedUnresolvedTableLocationKey to either a
OnDiskDeephavenTableLocation or ParquetTableLocation based on the data on disk.An
EnterpriseTableLocationKey is an extension of FileTableLocationKey that defers the creation of the
actual location key until the data is needed by the NestedPartitionedTableLocationFactory.An
AclFilterGenerator that provides no access to anyonne.Exception thrown when an operation expects a System schema, but was passed a non-system schema.
Tools for getting Files and Folders out of the Web IDE notebooks that are stored in DbInternal.WorkspaceData.
A record class that represents a file or folder.
An exception thrown when a Notebook is not found.
Protobuf type
io.deephaven.proto.pqworker.ObjectAccessRequestProtobuf type
io.deephaven.proto.pqworker.ObjectAccessRequestProtobuf type
io.deephaven.proto.pqworker.ObjectAccessResponseProtobuf type
io.deephaven.proto.pqworker.ObjectAccessResponseThis class adapts the DHE
ObjectCodec to the DHC
ObjectCodec.A
ChunkSource.GetContext for Deephaven Format ColumnRegionObject implementations containing
ChunkSource.GetContexts for the offset, dictionary and bitmask regions.Tools for reading offsets from existing partitions for use with in an Ingester.
The
ColumnLocation implementation for OnDiskDeephavenTableLocation locations.A
TableLocation for reading Deephaven format tables from a local
filesystem.A
TableDataService implementation that expects data to be located on
a local filesystem.A Mutable adapter for converting
OrderedKeys into a RowSequence.An
ExtendedStorageProvider implementation for parquet: types, including `flat` and `metadata`.The factory class for creating this provider.
Builder class that accepts inputs as setters and uses said inputs to get a map of performance analysis tables and
plots.
Implementations of this interface provide a client that can communicate with the Persistent Query Controller to query
and manage the state of Persistent Queries.
An object that will be notified of changes to the state of the Controller.
A basic
PersistentQueryControllerClient.Observer implementation with do-nothing methods.Implementations of this class provide a way to access script code and paths for execution.
A simple test adapter for using an
InMemoryPermissionFilterProvider as an
IrisGroupProvider for testing.Factory to handle Barrage DoExchange subscription requests.
We have not created a service, but rather make a request using the oneof message; and reply using the corresponding
message in the PivotPluginResponse.
We have not created a service, but rather make a request using the oneof message; and reply using the corresponding
message in the PivotPluginResponse.
Protobuf type
io.deephaven.proto.pivot.PivotPluginResponseProtobuf type
io.deephaven.proto.pivot.PivotPluginResponseA pivot table is a display-only object that aggregates using a list of row by-columns and column by-columns,
presenting the aggregated value for each combination of row and column by-column as a single cell.
A pivot snapshot contains three logical tables (represented as parallel definitions and chunks) that can be
assembled into a view on the screen:
Rows: The rows "table" contain the values of the row keys, their depth, and expanded state.
Opaque interface for objects used to cache snapshot state across multiple invocations of
PivotTable.snapshot(SnapshotState, Table, Table, ColumnName, ColumnName, Collection, RowSequence, RowSequence)Protobuf type
io.deephaven.proto.pivot.PivotTableApplyRequestProtobuf type
io.deephaven.proto.pivot.PivotTableApplyRequestProtobuf type
io.deephaven.proto.pivot.PivotTableApplyResponseProtobuf type
io.deephaven.proto.pivot.PivotTableApplyResponseProtobuf type
io.deephaven.proto.pivot.PivotTableCreationRequestProtobuf type
io.deephaven.proto.pivot.PivotTableCreationRequestProtobuf type
io.deephaven.proto.pivot.PivotTableCreationResponseProtobuf type
io.deephaven.proto.pivot.PivotTableCreationResponseProtobuf type
io.deephaven.proto.pivot.PivotTableDescriptorMessageProtobuf type
io.deephaven.proto.pivot.PivotTableDescriptorMessage
the first object is the pivot table
the first object is the pivot table
Protobuf type
io.deephaven.proto.pivot.PivotTableDescriptorResponseProtobuf type
io.deephaven.proto.pivot.PivotTableDescriptorResponse
the first object is the pivot table
the first object is the pivot table
the first object is the result rows expansion table
the second object is the result columns expansion table
the first object is the result rows expansion table
the second object is the result columns expansion table
Constants for interpreting Arrow schemas from io.deephaven.pivot.PivotTable instances.
Utilities for creating schemas from
PivotTable instances.
the first object is the pivot table
the first object is the pivot table
the first object is the result source table
the first object is the result source table
A
TicketTransformer that handles transformation of PivotTables to apply ACLs at
the edge.Server-side "view" object representing a client's snapshot target for HierarchicalTable data.
An ExchangeMarshaller for
PivotTableView.Protobuf type
io.deephaven.proto.pivot.PivotTableViewExpansionsMessageProtobuf type
io.deephaven.proto.pivot.PivotTableViewExpansionsMessageProtobuf type
io.deephaven.proto.pivot.PivotTableViewRequestProtobuf type
io.deephaven.proto.pivot.PivotTableViewRequestProtobuf type
io.deephaven.proto.pivot.PivotTableViewResponseProtobuf type
io.deephaven.proto.pivot.PivotTableViewResponseTool that manages an active subscription to a
PivotTableView.A data header describing the shared memory layout of a "record" or "row"
batch for a ticking barrage table.
A
UriResolver specifically for resolving requests for tables from persistent
queries by serial or name.A stub to allow clients to do synchronous rpc calls to service PQWorkerApi.
A stub to allow clients to do ListenableFuture-style rpc calls to service PQWorkerApi.
Base class for the server implementation of the service PQWorkerApi.
A stub to allow clients to do asynchronous rpc calls to service PQWorkerApi.
Static accessor for this worker's process information ID.
A
SecretsProvider that loads secrets from Configuration.The factory for creating a
SecretsProvider that loads secrets from configuration.A
PropertyInputStreamLoader that loads the property input stream from resources only.An interface for creating
TableDataProtocolDriver instances for use with RemoteTableDataService and
RemoteTableLocationImplThe PushSessionChangeListener creates a ScriptSession.Listener when enabled that tracks changes to the query scope
and sends them to the Controller to update a query state.
A hook that is called from the session monitor to delete our persistent query when we are complete.
Sets up the QueryLogs Query which supplies access to log tables for the web client.
An adapter class to map a Community
WhereFilter.RecomputeListener onto
the Enterprise SelectFilter.RecomputeListener.Minor utility methods used by column region and
RegionedColumnSource implementations.A
TableLocation implementation for remote table subscriptions discovered by a
io.deephaven.enterprise.tabledataservice.RemoteTableDataService.A Builder class for creating reliable subscriptions to remote tables.
An interposed interface that forces users to authenticate with the remote system before they can call any
subscription methods.
A
TableDataService implementation that uses Enterprise's TableDataProtocol to locate tables.A Factory class for creating
sessions for a ConnectionAwareRemoteTable to connect to.An Observable interface for
ConnectionAwareRemoteTable to monitor the state of a remote table.An Observer of state changes for this watcher.
A Token representing the state of the remote table object.
An interface for providing
TableReplayConfigurations by namespace and table name.A holder for TableReplayConfigurations, that allows the configurations to be accessed by namespace and tablename.
The ReplayDatabase wraps another Database implementation; applying
ClockFilters to liveTables before
returning them to the user.An
ArrayBackedOffsetLookupCache that allows for forward and backwards lookups of values.A Mutable adapter for converting
RowSequence into an OrderedKeys.Given a Core RowSet.Iterator present it as a Legacy OrderedKeys.Iterator.
The SchemaHelper assists query-builders with creating and validating Deephaven Enterprise schemas from a Core+
KafkaTableWriter.Options instance.Indicates that a requested schema was not found / does not exist.
Implementations provide access to secrets.
Implementations create instances of
SecretsProviders.The service for loading
SecretsProviders to be used with various authentication methods.This auth wiring explicitly denies the newSession and refreshSession calls as they are deprecated on the upstream
This class contains static methods and fields that help in converting serialized non-shadowed enterprise types into
their shadowed packages before they're classloaded
Enterprise makes extensive use of Java serialization through WObjectOutput/InputStream.
Enterprise makes extensive use of Java serialization through WObjectOutput/InputStream.
An
ObjectCodec implementation for Serializable object that internally uses a
ShadowingObjectInputStream to automatically replace detected shadowed classes in the object stream with their
shadowed versions.Adapts a Legacy ColumnRegionShort to a Core ColumnRegionShort.
An
AclFilterGenerator that simply applies the specified WhereFilters in Disjunctive Normal FormA simple immutable location snapshot.
A
TableLocation backed by a TableLocationMetadataIndex.TableLocationSnapshot that does not refresh and tries to avoid creating
the actual location until it is truly needed.An Exception thrown when there is a problem completing a Snapshot
An
EnterpriseTableLocationKey implementation which is backed by a
TableLocationMetadataIndex.LocationSnapshot instanceA provider object for creating row and column ACLs from the data source.
Protobuf type
io.deephaven.proto.pqworker.StringListProtobuf type
io.deephaven.proto.pqworker.StringListAn Exception thrown when there is a problem completing a subscription
Implementations of this interface provide parameters for a
ConnectionAwareRemoteTable to maintain a
subscription to a remote table.Implementations of this interface can be used to construct a new
SubscriptionOptions.Utility to log
Table objects to System tables via the Log Aggregator Server.Options for writing a system table using a logger.
The standard factory for creating
TableDataService instances using a DataRoutingService instanceA compatibility class for converting enterprise
TableDefinition into community
TableDefinitionAn helper for
TableLocationProvider implementations that can mark and sweep table locations based on if they
have been visited in the current cycle.This class adapts an enterprise
TableLocationState into a Community formatted
TableLocationState for use for Table data subscriptionsUnchecked exception that is decorated with the namespace and table was being operated on.
A collection of options that control the construction of a
live tableA Builder object for
TableOptionsThe replay configuration for one table.
A
TicketTransformer that handles transformation of Tables to apply ACLs at the edge.Holder for a TableWriter and the processor for use in implementing an ingester.
This class can be used to generate identical tables in memory to the ones stored in the resources for this project.
Protobuf type
io.deephaven.proto.pqworker.ThreadDumpRequestProtobuf type
io.deephaven.proto.pqworker.ThreadDumpRequestProtobuf type
io.deephaven.proto.pqworker.ThreadDumpResponseProtobuf type
io.deephaven.proto.pqworker.ThreadDumpResponseImplementations of this interface provide transformations of values before they are returned as
Exports to clients.Create functions for generating column partitions from an epoch timestamp.
Utilities for converting types from Core to Enterprise for use in ingesters.
An
UncoalescedTable implementation that wraps another uncoalesced table.We would like to be able to put all of the test data files in one package and reuse them.
This module injects the
PQUriResolver into the URI Resolver set for the worker.An
EnterpriseTableLocationKey implementation which provides a URI to back a
keyed locationDefines a
EnterpriseTableLocationKey which is backed by both a URI location
and a
TableLocationMetadataIndex.LocationSnapshotUnchecked exception representing issues with Core+ user input tables.
Unchecked exception representing an incompatible user table definition.
Unchecked exception representing a failure in deleting part or all of a user table.
Unchecked exception representing a failure in IO, e.g.
Unchecked exception representing a missing user table definition.
Unchecked exception representing a user table operation specifying a system namespace.
Unchecked exception representing insufficient access permissions to a user table operation.
Unchecked exception representing a preexisting user table definition.
Unchecked exception representing an incompatible table storage type.
Unchecked exception representing a failure in writing part or all of a user table.
A filter generator that specifies a set table, and a list of match expressions (FilteredColumn=SetColumn), to apply a
TableOperations.whereIn(Object, String...) operation to the filtered table.A Simple
GroupProvider that wraps the Enterprise implementation IrisGroupProviderInterface for writing tables to persistent Deephaven storage.
A
ReplayDatabase that also wraps a WritableDatabase.