Show your appreciation for Deephaven by starring us on GitHub.

  • Docs
  • Blog
  • ContactRequest Demo
Try Sandbox
Core EngineUI & DashboardsPlottingEnterprise
  • Introduction
  • Deephaven Overview
      • Quickstart
      • Jupyter Quickstart
      • Python Client Quickstart
      • Crash Course Overview
      • Get Started
      • Architecture Overview
      • Create Tables
      • Table Operations
      • Query Strings
      • Python Integrations
      • Real-time Plots
      • Data I/O
      • Configure your Instance
      • Wrapping Up
      • Docker
      • pip
      • Source code
      • Production application
      • Deephaven's design
      • Incremental update model
      • Live DAG
      • Table types
      • Core API design
        • Static tables
        • Ring tables
        • Time tables
        • Input tables
        • Write data to a real-time table
        • Generate tables with Python functions
        • Import CSV files
        • Export CSV files
        • Import HTML files
        • Export HTML files
      • Arrow Flight
      • Iceberg
        • Kafka Overview
        • Basic terms
        • Connect to a Kafka stream
        • Supported Parquet formats
        • Import Parquet files
        • Export to Parquet
      • PyArrow
        • SQL queries in Deephaven
      • URI
      • Table data service
      • Table listeners
      • Table iterators
      • Replay
      • Metadata
      • Select and create columns
      • Drop, move, and rename columns
      • Format columns
      • Filter
      • Sort
      • Merge
        • Single aggregation
        • Multi-aggregation
        • Group and ungroup data
        • update_by
        • Cumulative, rolling, and moving statistics
        • Other rolling utilities
        • Exact and Relational Joins
        • Inexact, time-series, and range joins
      • Partition
      • Snapshot
        • Work with calendars
        • Work with time
        • Downsample data
      • Built-in query language functions
      • Arrays
      • Formulas and filters
      • Nulls, infs, and NaNs
      • Objects
      • Strings
      • Ternary-if
      • User-defined functions
      • Query Scope
      • Generate query strings with Python
      • Python classes in query strings
      • Python data types
      • PyObjects
      • Deephaven's Python package
      • Read Javadocs
      • User-defined functions
      • Variables in query strings
        • jpy
        • Numba
        • NumPy
        • pandas
        • Workflows
        • deephaven.learn
        • PyTorch
        • SciKit-Learn
        • TensorBoard
        • TensorFlow
        • Execution Context
        • Liveness scope
        • Systemic Object Marking
      • Jupyter
      • How to plot real-time data
      • Deephaven Express
      • Matplotlib and Seaborn
      • Plot without writing queries
      • Built-in API
        • Navigate the GUI
        • Set date-time format
        • Set table density
        • Create and organize notebooks
        • Markdown widgets
          • deephaven.ui
          • Format tables in the UI
          • Filter without writing queries
          • Clickable links
            • Rollup tables
            • Tree tables
        • Custom themes
        • IFrames
        • 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
        • Overview
        • Getting started
        • Resource management
        • Data I/O
        • Fluent interface
        • Overview
        • Fetch tables
        • Import tables
        • Create input tables
        • Run scripts
        • Table operations
        • Overview
        • Building blocks of the Deephaven R client
        • Real-time data analysis
        • Powerful table operations
        • Aggregations
        • Moving operations
      • Flight SQL
        • Excel Client
        • Protobuf and RPC
      • Install and use plugins
      • Create your own plugin
      • Copilot extension
      • Think like a Deephaven ninja
        • Use performance tables
        • Dial down the update frequency of ticking tables
        • Data Indexes
        • Parallelization
        • Synchronization and locking
        • Python-Java boundary
        • Run Garbage Collection
        • Barrage metrics
        • Interpret Barrage metrics
        • Troubleshoot query performance
        • Triage errors in queries
        • Decipher Python errors
        • Debugging with PyCharm
        • Retrieve logs
        • Get version information
      • Update Deephaven
        • Anonymous
        • Keycloak
        • mTLS
        • Pre-shared key
        • Username/password
        • Docker data volumes
        • Adjust heap size
        • Deephaven console service
        • Deephaven Docker application
          • Application Mode
          • Application Mode libraries
          • Application Mode scripts
        • Install packages
        • Python packages
        • Install and use Java packages
        • Production application
        • Deephaven configuration files
        • Web Defaults
        • Custom environmental variables
        • Periodic Update Graph configuration
      • AWS EC2
      • GCP
    • Ultimate cheat sheet
    • Choose Python packages
      • Simple table constructors
      • CSV
      • Kafka
      • Parquet
      • URI
    • Performance tables
    • Time operations
    • Python (client)
    • Python (server)
    • Java (client/server)
      • Javascript API Concepts
      • JavaScript
    • Go (client)
    • C++ (client)
    • C++ (examples)
    • R (client)
    • Barrage (communication)
    • gRPC (communication)
    • Protobuf (communication)
      • await_update
      • data_index
      • has_data_index
      • LivenessScope
      • liveness_scope
          • empty_table
          • new_table
          • time_table
          • input_table
          • ring_table
          • tree
          • rollup
          • with_attributes
          • without_attributes
          • 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
        • barrage_session
        • close
        • subscribe
        • snapshot
        • read_csv
        • write_csv
        • to_html
        • consume_to_partitioned_table
        • consume
        • produce
        • ColumnInstruction
        • read
        • write
        • read_sql
        • adbc.read_cursor
        • odbc.read_cursor
        • adapter
        • adapater_aws_glue
        • adapter_s3_rest
        • IcebergCatalogAdapter
        • IcebergReadInstructions
        • IcebergTable
        • IcebergTableAdapter
        • IcebergTableWriter
        • IcebergUpdateMode
        • IcebergWriteInstructions
        • InferenceResolver
        • SchemaProvider
        • SortOrderProvider
        • TableParquetWriterOptions
        • UnboundResolver
        • iter_dict
        • iter_tuple
        • iter_chunk_dict
        • iter_chunk_tuple
      • URI
        • attributes
        • columns
        • has_columns
        • is_blink
        • is_flat
        • is_refreshing
        • meta_table
        • size
        • table_diff
        • to_string
        • update_graph
        • 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
        • where
        • where_in
        • where_one_of
        • where_not_in
        • restrict_sort_to
        • reverse
        • sort
        • sort_descending
        • format_columns
        • format_column_where
        • format_row_where
        • merge
        • merge_sorted
          • group_by
          • ungroup
          • 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_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
        • update_by
        • cum_max
        • cum_min
        • cum_prod
        • cum_sum
        • cum_count_where
        • delta
        • DeltaControl
        • ema_tick
        • ema_time
        • emmax_tick
        • emmax_time
        • emmin_tick
        • emmin_time
        • ems_tick
        • ems_time
        • emstd_tick
        • emstd_time
        • forward_fill
        • OperationControl
        • 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
          • equals
          • not equals
          • icase in
          • icase not in
          • in
          • not in
      • Special variables and constants
        • Arrays
        • 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
      • garbage_collect
      • Application Mode configuration
      • Auto-imported functions
      • Backend Imports
    • Version support matrix
    • Deephaven example apps on GitHub
      • FAQ Overview
        • How can I find which Core version to which a feature or fix was added?
        • Is it possible to read a Parquet file from a remote location?
        • When does Deephaven load data into memory for Parquet reads?
        • Is docker compose required?
        • 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?
        • Does Deephaven have a built-in ATR?
        • How can I perform rolling operations without a fixed window size?
        • How do I extract data from a table?
        • Why do queries run faster the second time they are run?
        • How do I automatically execute Python code based on a Deephaven table column value?
        • When should I use `where_in` or `natural_join`?
        • Can I reset the Python kernel without restarting the Deephaven Docker container?
        • How do I solve a `hash table exceeds maximum size` error?
        • What's the best approach to monitor Deephaven server health?
        • How do I import one Python script into another in the Deephaven IDE?
        • Why am I getting an UpdateGraphConflictException?
        • Is there a way to find out how much memory a table is using?
        • Does it make any difference if I separate table operations or chain them together?
        • Why isn't `last_by` ticking?
        • How can I periodically write a ticking table to disk?
        • How can I manage the number of cores Deephaven can use?
        • Does `deephaven.stream.kafka` use the Confluent consumer under the hood?
        • How do I dynamically update a DataFrame from a table?
        • How do I get data out of a table?
        • How do I create unrollable columns in the Python IDE?
        • Is it possible to convert one or more columns of a Deephaven table to JSON?
        • How do I convert vector columns to primitive array columns?
        • How do I troubleshoot type hints?
        • How can I bin times to a specific time?
        • How can I convert year, day, and minute to an Instant?
        • Why are my table operations producing incorrect results?
        • Why aren't my date-time table operations working as expected?
        • How do I control what objects are displayed in the console?
        • Is there a utility to pretty print a table to log?
        • How do I control what objects are displayed in the console?
        • How efficient are my table selection operations?
        • Why are my table operations producing incorrect results?
        • How do I shift values in columns?
        • Where can I find the password for the Deephaven IDE?
        • How do I increase the maximum message size?
        • Why can't I read from S3?
        • How can I assume a specific role for S3?
    • Engage in GitHub discussions
    • File GitHub issues
    • Slack

FAQ Overview

Commonly asked questions about Deephaven Community Core.


General

Installation

Configuration

Table operations

Troubleshooting

Server-side APIs: General

Server-side APIs: Python

Server-side APIs: Groovy

Server-side APIs: Query language

Client APIs

Community Core

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

Enterprise

Enterprise SupportDocumentation

Social

BlogGithubSlackLinkedinYoutube

Company

AboutCareersNewsroomBrand AssetsContact

Copyright © 2025 Deephaven Data Labs LLC

Privacy PolicyTerms of Service