Enterprise
Deephaven empowers your team to build analyses, models, algos, reports, and dashboards quickly.
Contact SalesFast. Easy. Integrated.
Deephaven Enterprise has been battle-tested inside the demanding environment of hedge funds, stock exchanges and banks. It is a collection of enterprise-ready tools and exclusive add-ons to Deephaven Community that helps your team scale up quickly and benefit from the mutualization of enhancement requests. Professional services are available if you need more hands on deck.
Batteries included data management
Data Management
Systems for ingesting, storing, and disseminating data focus on throughput and efficiency. Utilities exist to support cleaning, validation, and transformation. Sophisticated control systems limit user or team access to source and derived data by directory and table, as well as granularly by row or column key.
Scale across 1000s of cores, PBs of data, and TBs of streams
Query & Compute
The Deephaven Enterprise platform comprises the machinery, operations, and workflows to develop and support applications and analytics at scale -- real-time and otherwise. It is readily deployed on commoditized cloud or physical Linux resources using modern techniques. Ingest, store, and compute scale independently.
Create and share applications and interactive dashboards quickly
UI & Tooling
Deephaven Enterprise has premiere experiences in Jupyter, Excel, R-Studio and classic IDE’s and its REPL, but it also includes a zero-time UX for launching, scheduling, and monitoring applications. These feed dependent enterprise apps and empower the quick configuration and sharing of real-time dashboards.
Built for Developers, loved by Data Scientists
Combine your static and real-time data sources
Join and merge Kafka streams with Parquet files. Use identical operations on batch and stream.
Join your time series and aggregate
Do as-of joins on data as it streams. Inherit high-performance, updating aggregations.
Streamline your data science
Move code to data. Combine custom functions with table operations.
Leverage gRPC and Arrow Flight Libraries
Work with standard data frameworks for fast data transport.
from deephaven import ConsumeKafka, ParquetTools, TableTools
from deephaven2.parquet import read_table
# data-ingestion integrations (Kafka, Parquet, and many more)
table_today_live = ConsumeKafka.consume(
{"bootstrap.servers": "kafka:9092"}, "metrics"
)
table_yesterday = ParquetTools.readTable("/data/metrics.parquet")
# merging dynamic with static is easy; the updating table will continue to update
table_merged = TableTools.merge(table_today_live, table_yesterday)
# operators can be used identically on dynamic and static tables (or merges of the two)
table_joined = table_today_live.sumBy("ProcessKey").naturalJoin(
table_yesterday.sumBy("ProcessKey"), "ProcessKey", "YestTotal = Metric"
)
bitcoin = ConsumeKafka.consume({"bootstrap.servers": "kafka:9092"}, "bitcoin")
ethereum = ConsumeKafka.consume({"bootstrap.servers": "kafka:9092"}, "ethereum")
# time series joins update as source tables update
priceRatio = (
bitcoin.aj(ethereum, "Timestamp", "SizeEth = Size, PriceEth = Price")
.update("Ratio = Price / PriceEth")
.renameColumns("SizeBtc = Size")
)
# time-bin by minute and aggregate accordingly
agg = priceRatio.update("TimeBin = upperBin(Timestamp, MINUTE)").by(
["TimeBin"],
[
AggAvg("Ratio"),
AggMin("MinRatio = Ratio"),
AggMax("MaxRatio = Ratio"),
AggSum("Size", "SizeBtc"),
AggWAvg("SizeBtc", "VwapBtc = Price"),
],
)
import numpy as np
from sklearn.linear_model import LinearRegression
# write a custom function
def computeBeta(value1, value2):
stat1 = np.diff(np.array(value1), n=1).reshape(-1, 1)
stat2 = np.diff(np.array(value2), n=1).reshape(-1, 1)
reg = LinearRegression(fit_intercept=True)
reg.fit(value1, value2)
return reg.coef_[0][0]
# filter, sort and do time-series joins on source tables
iot = source.where("MeasureName = `Example`").view(
"TimeInterval", "DeviceId", "MeasureValue"
)
iot_joined = iot.aj(iot.where("DeviceId = `Master`"), "TimeInterval", "Measure_Master")
# use the custom function within the deephaven object directly
# no client-server or copy
betas = (
iot_joined.by("DeviceId")
.select(
"DeviceId",
"Beta = (double) computeBeta.call(Measure_Master.toArray(), MeasureValue.toArray())",
)
.sort("DeviceId")
)
FlightSession session = newSession();
TableSpec trades = readQst("trades.qst");
TableSpec quotes = readCsv("quotes.csv");
TableSpec topTenTrades = trades
.aj(quotes, "Timestamp", "Mid")
.updateView("Edge=abs(Price-Mid)")
.sortDescending("Edge")
.head(100);
try (
final Export export = session.export(topTenTrades);
final FlightStream flightStream = session.getStream(export)) {
while (flightStream.next()) {
System.out.println(flightStream.getRoot().contentToTSVString());
}
}
from pydeephaven import Session
from pyarrow import csv
session = Session() # assuming DH is running locally with the default config
table1 = session.import_table(csv.read_csv("data1.csv"))
table2 = session.import_table(csv.read_csv("data2.csv"))
joined_table = table1.join(
table2, keys=["key_col_1", "key_col_2"], columns_to_add=["data_col1"]
)
df = joined_table.snapshot().to_pandas()
print(df)
session.close()
auto client = Client::connect(server);
auto manager = client.getManager();
auto trades = manager.fetchTable("trades");
auto quotes = manager.readCsv("quotes.csv");
auto topTenTrades = trades
.aj(quotes, "Timestamp", "Mid")
.updateView("Edge=abs(Price-Mid)")
.sortDescending("Edge")
.head(100);
std::cout << topTenTrades.stream(true) << '\n';
class TableView {
setFilter() {
this._filters = Array.prototype.slice.apply(arguments);
return this._table.applyFilter(this._filters);
}
addFilter(filter) {
this._filters.push(filter);
return this._table.applyFilter(this._filters);
}
// Use cloning when you want to create a new table
// to apply filters without modifying the existing table.
clone(name) {
if (!name) {
name = `${this._name}Clone`;
}
return this._table.copy().then((newTable) => new TableView(name, newTable));
}
}