Show your appreciation for Deephaven by starring us on GitHub.

  • Docs
  • Blog
  • ContactRequest Demo
Try Demo
Core EngineUI & DashboardsPlottingEnterprisePlugins
  • Introduction
  • Deephaven Overview
  • Getting Started
    • Quickstart
    • Jupyter quickstart
    • Python client quickstart
      • Overview
      • Get Started
      • Architecture Overview
      • Create Tables
      • Table Operations
      • Time and Calendars
      • Query Strings
      • Recipes, not loops!
      • Python Integrations
      • Real-time Plots
      • deephaven.ui
      • Data I/O
      • Configure your Instance
      • Wrapping Up
      • Docker
      • pip
      • Source code
      • Version support matrix
  • User Guide
      • Patterns of use
      • Table types
      • Incremental update model
      • Live DAG
      • Initialization and updates
      • Column types
        • Static tables
        • Ring tables
        • Time tables
        • Input Tables
        • Convert add- and append-only tables to blink tables
        • Write data to a real-time table
        • Generate tables with Python functions
      • Replay
      • Arrow Flight
      • Arrow/Barrage schema
        • Read CSV files
        • Write CSV files
        • Read HTML files
        • Convert tables to HTML
      • Iceberg
        • Overview
        • Basic terms
        • Connect to a stream
        • Write a custom parser
        • Supported formats
        • Read Parquet files
        • Write Parquet files
      • PyArrow
      • SQL queries in Deephaven
      • Table data service
      • URI
      • Overview
      • Metadata
      • Select and create columns
      • Drop, move, and rename columns
      • Format columns
      • Filter
      • Sort
      • Keyed row selection
      • Keyed transpose
      • Merge
        • Group and ungroup data
        • Single aggregation
        • Multi-aggregation
        • Rolling aggregations
        • Rollup tables
        • Tree tables
        • Exact and relational joins
        • Inexact, time-series, and range joins
      • Partition
      • Synchronize tables
      • Snapshot
        • Work with time
        • Work with calendars
        • Downsample data
        • Table listeners
        • Table iterators
        • Extract table values
      • Overview
      • Data types
      • Nulls, infs, and NaNs
      • Arrays
      • Strings
      • Java classes & objects
        • Boolean & numeric
        • String & char
        • Date-time
        • Formulas
        • Filters
        • Operators
        • Casting
        • Ternary-if
        • Constants
        • Variables
        • Functions
        • Query Scope
        • Variables
        • Functions
        • Classes & objects
        • PyObjects
      • Deephaven's Python package
      • Generate query strings
      • Read Javadocs
      • Jupyter
        • jpy
        • Numba
        • NumPy
        • pandas
        • Workflows
        • deephaven.learn
        • PyTorch
        • scikit-learn
        • TensorBoard
        • TensorFlow
        • Execution Context
        • Liveness Scope
        • Systemic Object Marking
      • How to plot real-time data
      • Deephaven Express
      • Matplotlib and Seaborn
      • Plot without writing queries
      • Built-in API
      • deephaven.ui
        • Navigate the GUI
        • Upload a table from a file
        • Set date-time format
        • Set table density
        • Create and organize notebooks
        • Markdown widgets
        • Format tables in the UI
        • Filter without writing queries
        • Clickable links
        • Custom themes
        • IFrames
        • Overview
        • Getting started
        • Resource management
        • Data I/O
        • Fluent interface
        • Overview
        • Fetch tables
        • Import tables
        • Create Input Tables
        • Run scripts
        • Table operations
      • Extract data with a Java client
      • JS API
        • Overview
        • Initialize
        • Binding to a table
        • Execute a query on a table
        • Sort a table
        • Filter a table
        • Query objects
        • Join two tables
        • Perform aggregations on table
        • Convert a PyArrow table to a Deephaven table
        • Execute a script server side
        • Subscribe to a ticking table
        • Error handling
        • Capture Python client tables
        • Stream data with Input Tables
        • Overview
        • Building blocks
        • Real-time data analysis
        • Powerful table operations
        • Aggregations
        • Moving operations
      • Flight SQL
      • Protobuf and RPC
      • Install and use plugins
      • Create your own plugin
      • Create a JavaScript plugin
      • MCP
      • Copilot extension
      • Think like a Deephaven ninja
      • Vectorization and the recipe paradigm
        • Use performance tables
        • Dial down the update frequency of ticking tables
        • Data Indexes
        • Predicate Pushdown filtering
        • Parallelization
        • Synchronization and locking
        • Formulas and threads
        • Track processing time
        • Python-Java boundary
        • Run garbage collection
        • Barrage metrics
        • Interpret Barrage metrics
        • Troubleshoot query performance
        • Triage errors in queries
        • Decipher Python errors
        • Retrieve logs
        • Get version information
        • Overview
        • Docker
        • pip
        • Source
        • Embedded server
        • Common problems
      • Deephaven's design
      • The Table API
      • Core API design
      • Servers & clients
      • What is Barrage?
      • Deephaven Vectors
  • Deploy and administer
    • Install the production application
    • Update Deephaven
      • AWS EC2
      • GCP
      • Anonymous
      • Keycloak
      • mTLS
      • Pre-shared key
      • Username/password
      • Docker data volumes
      • Adjust heap size
      • Deephaven console service
      • Deephaven Docker application
      • Install packages
      • Python packages
      • Install and use Java packages
      • Configure the production application
      • Deephaven configuration files
      • Configuration properties
      • Web defaults
      • JS plugins
      • Custom environment variables
      • Periodic Update Graph configuration
      • Query table configuration
        • Overview
        • Libraries
        • Scripts
        • Configuration
  • Reference
      • Python (client)
      • Python (server)
      • C++ (client)
      • C++ (examples)
      • Go (client)
      • Java (client/server)
        • JavaScript API concepts
        • JavaScript
      • R (client)
      • Barrage (communication)
      • gRPC (communication)
      • Protobuf (communication)
      • await_update
      • data_index
      • garbage_collect
      • has_data_index
      • liveness_scope
      • LivenessScope
          • empty_table
          • new_table
          • time_table
          • input_table
          • ring_table
          • bool_col
          • byte_col
          • char_col
          • datetime_col
          • double_col
          • float_col
          • InputColumn
          • int_col
          • jobj_col
          • long_col
          • pyobj_col
          • short_col
          • string_col
        • add_only_to_blink
        • blink_to_append_only
        • function_generated_table
        • DynamicTableWriter
        • TablePublisher
        • remove_blink
        • TableReplayer
        • TableDefinitionLike
        • read_feather
        • to_arrow
        • to_table
        • read_csv
        • write_csv
      • to_html
        • adapter
        • adapter_aws_glue
        • adapter_s3_rest
        • IcebergCatalogAdapter
        • IcebergReadInstructions
        • IcebergTable
        • IcebergTableAdapter
        • IcebergTableWriter
        • IcebergUpdateMode
        • IcebergWriteInstructions
        • InferenceResolver
        • SchemaProvider
        • SortOrderProvider
        • TableParquetWriterOptions
        • UnboundResolver
        • consume_to_partitioned_table
        • consume
        • produce
        • ColumnInstruction
        • read
        • write
        • write_partitioned
        • read_sql
        • adbc.read_cursor
        • odbc.read_cursor
      • URI
        • barrage_session
        • close
        • subscribe
        • snapshot
        • publish
        • publish_table
        • fetch
        • fetch_table
        • attributes
        • columns
        • has_columns
        • is_blink
        • is_flat
        • is_refreshing
        • meta_table
        • size
        • table_diff
        • to_string
        • update_graph
        • with_attributes
        • with_keys
        • with_unique_keys
        • without_attributes
        • drop_columns
        • flatten
        • lazy_update
        • move_columns
        • move_columns_down
        • move_columns_up
        • rename_columns
        • select
        • select_distinct
        • update
        • update_view
        • view
        • head
        • head_pct
        • slice
        • slice_pct
        • tail
        • tail_pct
        • TailInitializationFilter
        • where
        • where_in
        • where_one_of
        • where_not_in
        • restrict_sort_to
        • reverse
        • sort
        • sort_descending
        • format_columns
        • format_column_where
        • format_row_where
        • layout_hints
        • keyed_transpose
        • merge
        • merge_sorted
          • group_by
          • ungroup
          • abs_sum_by
          • avg_by
          • count_by
          • first_by
          • head_by
          • last_by
          • max_by
          • median_by
          • min_by
          • std_by
          • sum_by
          • tail_by
          • var_by
          • weighted_avg_by
          • weighted_sum_by
          • agg_by
          • partitioned_agg_by
          • abs_sum
          • agg_all_by
          • avg
          • count_
          • count_distinct
          • count_where
          • distinct
          • first
          • formula
          • group
          • last
          • max_
          • median
          • min_
          • partition
          • pct
          • sorted_first
          • sorted_last
          • std
          • sum_
          • unique
          • var
          • weighted_avg
          • weighted_sum
        • rollup
        • tree
        • update_by
        • delta
        • DeltaControl
        • forward_fill
        • OperationControl
          • cum_count_where
          • cum_max
          • cum_min
          • cum_prod
          • cum_sum
          • ema_tick
          • ema_time
          • emmax_tick
          • emmax_time
          • emmin_tick
          • emmin_time
          • ems_tick
          • ems_time
          • emstd_tick
          • emstd_time
          • rolling_avg_tick
          • rolling_avg_time
          • rolling_count_tick
          • rolling_count_time
          • rolling_count_where_tick
          • rolling_count_where_time
          • rolling_formula_tick
          • rolling_formula_time
          • rolling_group_tick
          • rolling_group_time
          • rolling_max_tick
          • rolling_max_time
          • rolling_min_tick
          • rolling_min_time
          • rolling_prod_tick
          • rolling_prod_time
          • rolling_std_tick
          • rolling_std_time
          • rolling_sum_tick
          • rolling_sum_time
          • rolling_wavg_tick
          • rolling_wavg_time
        • aj
        • exact_join
        • full_outer_join
        • join
        • left_outer_join
        • multi_join
        • natural_join
        • raj
        • range_join
        • partition_by
        • filter
        • from_constituent_tables
        • from_partitioned_table
        • get_constituent
        • keys
        • Metadata methods
        • partitioned_transform
        • merge
        • sort
        • proxy
        • transform
        • snapshot
        • snapshot_when
        • time_window
          • dh_now
          • dh_time_zone
          • dh_today
          • simple_date_format
          • time_zone_alias_add
          • time_zone_alias_rm
          • to_date
          • to_datetime
          • to_j_duration
          • to_j_instant
          • to_j_local_date
          • to_j_local_time
          • to_j_period
          • to_j_time_zone
          • to_j_zdt
          • to_np_datetime64
          • to_np_timedelta64
          • to_pd_timestamp
          • to_pd_timedelta
          • to_time
          • to_timedelta
          • add_calendar
          • calendar
          • calendar_name
          • calendar_names
          • remove_calendar
          • set_calendar
        • iter_dict
        • iter_tuple
        • iter_chunk_dict
        • iter_chunk_tuple
      • Special variables and constants
        • equals
        • not equals
        • icase in
        • icase not in
        • in
        • not in
        • Arrays
        • Barrier
        • ConcurrencyControl
        • date-time
        • Durations
        • Casting
        • NaNs
        • Nulls
        • Objects
        • Periods
        • Strings
    • Data types
      • dh_null_to_nan
      • to_numpy
      • to_table
      • to_np_busdaycalendar
      • to_pandas
      • to_table
      • one_click
      • one_click_partitioned_table
      • plot_cat
      • plot_cat_hist
      • plot_ohlc
      • plot_pie
      • plot_style
      • plot_treemap
      • plot_xy
      • plot_xy_hist
      • SelectableDataSet
      • Backend imports
        • Overview
        • Basic
        • Math
        • Time
        • Logic
        • Parse
        • Sort
        • Search
        • GUI
        • Constants
        • Java
        • Data types
  • Cheat sheets
    • Ultimate cheat sheet
    • Choose Python packages
    • Performance tables
    • Time operations
      • Simple table constructors
      • CSV
      • Kafka
      • Parquet
      • URI
  • Help and more
      • Overview
        • How can I find which Core version to which a feature or fix was added?
        • Is docker compose required?
        • Why do ticking tables stall on WSL 2?
        • How do I configure Deephaven to use another port?
        • What's the minimum amount of memory I should allocate to a Deephaven server?
        • Is it possible disable the Deephaven console?
        • How do I set the default timezone?
        • How can I manage the number of cores Deephaven can use?
        • Where can I find the password for the Deephaven IDE?
        • How do I increase the maximum message size?
        • Can I integrate custom data sources with Deephaven?
        • Is it possible to read a Parquet file from a remote location?
        • When does Deephaven load data into memory for Parquet reads?
        • How do I extract data from a table?
        • How can I periodically write a ticking table to disk?
        • Does `deephaven.stream.kafka` use the Confluent consumer under the hood?
        • How do I dynamically update a DataFrame from a table?
        • Is it possible to convert one or more columns of a Deephaven table to JSON?
        • Does Deephaven have a built-in ATR?
        • How can I perform rolling operations without a fixed window size?
        • How do I delete historical data?
        • How do I extract a list of distinct dates from a table?
        • How do row keys and positional indices behave during table operations?
        • How do I create a partitioned blink table?
        • How do I automatically execute Python code based on a Deephaven table column value?
        • When should I use `where_in` or `natural_join`?
        • How can I capture the first row of the last N updates?
        • Does it make any difference if I separate table operations or chain them together?
        • Why isn't `last_by` ticking?
        • How do I convert vector columns to primitive array columns?
        • How do I shift values in columns?
        • How do I get the ISO week number from a datetime?
        • How do I filter by time of day across all dates?
        • How can I bin times to a specific time?
        • How can I convert year, day, and minute to an Instant?
        • Why aren't my date-time table operations working as expected?
        • How can I convert an integer date to a formatted string?
        • Can I reset the Python kernel without restarting the Deephaven Docker container?
        • How do I import one Python script into another in the Deephaven IDE?
        • How do I create unrollable columns in the Python IDE?
        • How do I control what objects are displayed in the console?
        • Why do queries run faster the second time they are run?
        • How does memory work in the JVM?
        • What's the best approach to monitor Deephaven server health?
        • Is there a way to find out how much memory a table is using?
        • How do I solve a `hash table exceeds maximum size` error?
        • Why am I getting a "Java class not found" error when starting deephaven-server?
        • Why am I getting an UpdateGraphConflictException?
        • How do I troubleshoot type hints?
        • Why does my function with type hints throw an error on null values?
        • Why are my table operations producing incorrect results?
        • How do I run Deephaven behind AWS ALB?
        • Why can't I read from S3?
        • How can I assume a specific role for S3?
    • Deephaven example apps on GitHub
    • Engage in GitHub discussions
    • File GitHub issues
    • Slack

FAQ overview

Commonly asked questions about Deephaven Community Core.


Install and upgrade

Configure the server

Import and export data

Table operations

Dates and times

Console and IDE

Performance and memory

Troubleshoot errors

Run on AWS

Community Core

DocumentationCommunity questionsOpen-core LicensePydoc clientPydoc serverJavadoc client/serverGodoc clientC++ client

Enterprise

Enterprise SupportDocumentation

Social

BlogGithubSlackLinkedinYoutube

Company

AboutCareersNewsroomBrand AssetsContact

Copyright © 2026 Deephaven Data Labs LLC

Privacy PolicyTerms of Service