Skip to content
CAI
Software that uses CAICheck a score

prestodb/presto

45.0

Weak · 13 November 2026

920.2k

lines of production code

Java

with C++

7

measurements over time

CAI band scale
CAI trend line
CAI lens gauges

What this system is

Features

Add BlackHole connector for testing and development

Introduces the BlackHole connector, a lightweight in-memory connector designed for testing and development. It simulates table scans by generating synthetic data (similar to /dev/zero) and supports configurable table properties such as split count, pages per split, rows per page, field length, and page processing delay. The connector implements the full connector SPI, including metadata management, split generation, and page source/sink providers, allowing users to test query plans and execution without requiring external data sources.

presto-blackhole/src/main · high confidence

Add DWRF encryption support and directory listing cache to Hive connector

The Hive connector now supports encryption for DWRF (Dwrf) files, introducing classes like AbstractDwrfEncryptionInformationSource and DwrfEncryptionMetadata to handle read and write encryption keys. Additionally, a new directory listing cache (CachingDirectoryLister) has been added to improve performance by caching file status results, with a corresponding system procedure (system.invalidate\_directory\_list\_cache) to allow manual cache invalidation.

presto-hive/src/main/java/com/facebook/presto/hive · high confidence

Add Hive Ranger security plugin for access control

This change introduces a new Ranger-based access control implementation for the Hive connector. It adds a new \RangerBasedAccessControl\ module that integrates with Apache Ranger to enforce authorization policies, including fetching service policies, user groups, and user roles from the Ranger REST API. The implementation includes configuration options for the Ranger HTTP endpoint, service name, basic authentication credentials, and policy refresh period, along with a custom HTTP client filter for basic auth. This allows Presto to delegate authorization decisions to an existing Ranger security infrastructure.

presto-hive/src/main/java/com/facebook/presto/hive/security/ranger · high confidence

Add JDBC-based Presto query execution to benchmark runner

The benchmark runner now supports executing queries against a Presto cluster via JDBC. This change introduces a new \prestoaction\ package containing a \PrestoActionFactory\ and \JdbcPrestoAction\ implementation that connects using a configurable JDBC URL and query timeout. It includes a \PrestoExceptionClassifier\ to distinguish between cluster connection errors and standard query errors, and integrates with the existing retry utilities to automatically retry transient network failures during query execution.

presto-benchmark-runner/src/main/java/com/facebook/presto/benchmark/prestoaction · high confidence

Add JSON support for Hive connector with S3 Select pushdown

The Hive connector now supports S3 Select pushdown for JSON data in addition to the existing CSV support. This change introduces new record readers for both CSV and JSON formats, a data type enum, and a SerDe mapper that routes LazySimpleSerDe to CSV and JsonSerDe to JSON. The pushdown logic also disables S3 Select when the query does not filter data, avoiding the overhead of S3 Select for full-table scans.

presto-hive/src/main/java/com/facebook/presto/hive/s3select · high confidence

Add Pinot plugin with binary decimal conversion function

The presto-pinot connector now includes a new plugin that registers the Pinot connector factory and a set of SQL functions. Specifically, it adds the \pinot\_binary\_decimal\_to\_double\ function, which converts binary decimal data stored in Pinot into double-precision floating-point numbers, enabling users to query and process this specific data type directly through Presto.

presto-pinot · high confidence

Add Presto logo and design diagram assets

Added design diagrams and logo files to the documentation resources. This includes a new OmniGraffle design diagram (\design.graffle\) and Adobe Illustrator/PDF logo assets for print (\logo/print/dark/\ and \logo/print/light/\), providing visual materials for Presto documentation.

presto-docs/src/main/resources · high confidence

Add Redis connector for querying Redis data stores

Introduces a new Redis connector that allows Presto to query Redis data sources. The connector supports multiple Redis data types (STRING, HASH, SET, ZSET) and various data formats (JSON, CSV, Avro, Raw) via a pluggable decoder architecture. It includes configuration for cluster nodes, TLS encryption, password authentication, and case-sensitive name matching, enabling users to treat Redis keys and values as relational tables.

presto-redis · high confidence

Add Redis-based History-Based Optimization statistics provider

Introduces a new Redis plugin that stores and retrieves historical plan statistics for use by the optimizer. The provider serializes statistics using Thrift, supports both standalone and cluster Redis modes, and exposes configurable timeouts, TTLs, and credential loading via properties files.

redis-hbo-provider · high confidence

Add Redshift connector

Users can now connect Presto to Amazon Redshift using the new Redshift connector. This change introduces the RedshiftClient, which extends the JDBC client to handle Redshift-specific behaviors such as case-insensitive identifier normalization, custom table renaming logic, and mapping the 'binary varying' type to VARBINARY. The connector is registered via RedshiftPlugin and RedshiftClientModule, enabling standard JDBC-based querying against Redshift data warehouses.

(repo-wide) · high confidence

Add SQL Server connector

This change introduces a new SQL Server connector for Presto, allowing users to query and manage data in Microsoft SQL Server databases. The implementation includes the SqlServerPlugin, SqlServerClient (handling specific operations like table/column renaming via sp\_rename and case-sensitive identifier normalization), and the necessary Guice module for dependency injection. It also provides a test harness (SqlServerQueryRunner) and integration tests verifying the new connector's functionality, including the support for the system.execute procedure for DDL/DML operations.

presto-sqlserver · high confidence

Add Spark 2 and 3 classloader interfaces for native execution sorted exchange

This change introduces the \classloader\_interface\ packages for both Spark 2 and Spark 3, providing the necessary Java bindings to support native execution sorted exchanges. The diff adds \MutablePartitionId\ and \MutablePartitionIdOrdering\ to handle partition identification and sorting, alongside \PrestoSparkNativeExecutionShuffleManager\ which implements the Spark \ShuffleManager\ interface to bypass standard Java shuffle writers/readers in favor of C++ native execution. It also includes \PrestoSparkUtils\ and \ScalaUtils\ to manage Scala/Java interoperability, with specific adaptations for Spark 2 (using \JavaConversions\) versus Spark 3 (using \JavaConverters\ and updated method signatures).

presto-spark-classloader-spark2, presto-spark-classloader-spark3 · high confidence

Add TLS and Basic Authentication support for Druid connector

The Druid connector now supports TLS encryption and HTTP Basic authentication when connecting to Druid clusters. Users can enable TLS by configuring truststore paths and passwords, and can switch the authentication type to Basic to provide username and password credentials for Druid API requests. The module also retains support for Kerberos authentication and no-authentication modes, wiring the appropriate HTTP client filters and TLS configurations based on the selected authentication type.

presto-druid/src/main/java/com/facebook/presto/druid/authentication · high confidence

Add TPC-DS Presto native connector

Introduces a new native TPC-DS connector that generates benchmark data in-memory, exposing schemas for scale factors from 0.01 (tiny) up to 100,000. The connector includes metadata, split management, and record set providers, with a configuration option \tpcds.use-varchar-type\ to ensure compatibility with native execution, and supports table statistics for query optimization.

presto-tpcds · high confidence

Add Teradata date and string functions

The Teradata functions plugin now includes date and string manipulation capabilities. Users can format and parse timestamps using \to\_char\, \to\_date\, and \to\_timestamp\ with support for Teradata-style format tokens (e.g., \yyyy/mm/dd hh24:mi:ss\) and timezone handling. Additionally, string functions \INDEX\ (finding substring position), \SUBSTRING\ (alias for \substr\), and \CHAR2HEXINT\ (converting strings to hexadecimal UTF-16BE representation) are available.

presto-teradata-functions · high confidence

Add TestingPrestoServerLauncher for launching test servers

Introduces a new command-line launcher (TestingPrestoServerLauncher) that allows users to start a TestingPrestoServer instance with specified plugins and catalog configurations via --plugin and --catalog arguments.

presto-testing-server-launcher · high confidence

Add Thrift connector documentation and service schema

Added the \PrestoThriftService.thrift\ file to the documentation includes, defining the Thrift interface and data structures (such as table metadata, column definitions, and value sets) used by the Thrift connector. This provides the necessary schema reference for users implementing or configuring the connector.

presto-docs/src/main/sphinx/include · high confidence

Add configuration and initialization support for Azure Blob Storage (WASB) and ADLS Gen2 (ABFS/ABFSS)

The Hive connector now includes the necessary configuration classes and initialization logic to support Azure storage backends. Users can configure WASB (legacy Azure Blob Storage) and ABFS/ABFSS (Azure Data Lake Storage Gen2) via new properties such as \hive.azure.wasb-storage-account\, \hive.azure.abfs-storage-account\, and associated access keys or OAuth credentials. The \HiveAzureConfigurationInitializer\ registers the corresponding Hadoop filesystem implementations (e.g., \NativeAzureFileSystem\, \AzureBlobFileSystem\) and applies required Hadoop configuration settings, enabling Presto to read from and write to these Azure storage systems.

presto-hive/src/main/java/com/facebook/presto/hive/azure · high confidence

Add gRPC UDF testing server

A new testing server module has been added to support gRPC-based User Defined Functions (UDFs). This includes a \TestingGrpcUdfServer\ that starts a gRPC server on port 50051 and an \EchoFirstInputGrpcUdfService\ implementation that acts as a test UDF by echoing the first input page received from Presto.

presto-grpc-testing-udf-server · high confidence

Add infinite and percentile-based TTL providers and infinite node TTL fetcher

This change introduces new plugin modules for managing time-to-live (TTL) configurations. In the cluster TTL providers, it adds an 'infinite' provider that returns an infinite TTL and a 'percentile' provider that calculates the cluster TTL based on a configurable percentile of node TTLs. In the node TTL fetchers, it adds an 'infinite' fetcher that returns an infinite TTL for all nodes. These components are registered as Presto plugins, enabling users to configure these specific TTL strategies.

presto-cluster-ttl-providers, presto-node-ttl-fetchers · high confidence

Add internal ZIP parsing library for Druid segment loading

The Druid connector now includes a custom ZIP parsing implementation in the \com.facebook.presto.druid.zip\ package to handle segment archives. This addition introduces classes for reading ZIP central directory records, end-of-central-directory structures, and Zip64 extensions, along with utilities for byte-level manipulation and entry metadata. This enables the connector to parse ZIP-based Druid data segments without relying on external or standard library constraints that may not support the specific segment formats or large-file requirements.

presto-druid/src/main/java/com/facebook/presto/druid/zip · high confidence

Add local file connector for reading HTTP request logs

Introduces a new \localfile\ connector that exposes local log files as a Presto table in the \logs\ schema. The connector reads HTTP request logs (configured via \presto-logs.http-request-log.location\ and an optional glob pattern \presto-logs.http-request-log.pattern\) and exposes columns for the server address and timestamp, allowing users to query local log data using standard SQL.

presto-local-file · high confidence

Add release notes collection script

A new shell script (src/release/release-notes.sh) has been added to automate the collection of release notes. The script downloads the presto-release-tools executable (version 0.14 by default) and executes it with provided GitHub credentials to generate the release notes.

src/release · high confidence

Add session configuration for join reordering and distribution

A new SQL benchmark script, session\_set\_cbo\_flags.sql, has been added to configure the query optimizer's join reordering strategy and join distribution type via session variables.

presto-benchto-benchmarks/src/main/resources/sql/presto · high confidence

Added Kafka benchmark SQL queries for row and column counts

New SQL benchmark scripts have been added to the Presto Kafka benchmark suite to measure query performance on row counts and specific column aggregations. The new files include \count.sql\ for total row counts, \count\_column\_1.sql\ for aggregating three columns, and \count\_column\_10.sql\ and \count\_column\_100.sql\ for aggregating 10 and 100 columns respectively (bigint, double, and varchar types). These queries allow users to benchmark the cost of scanning and counting data across varying numbers of columns in Kafka tables.

presto-benchto-benchmarks/src/main/resources/sql/presto/kafka · high confidence

Added SQL translation utilities for JDBC operators

The JDBC connector now includes new utility classes in the optimization function package to support the translation of specific SQL operators. JdbcTranslationUtil provides helper methods for formatting infix operations and extracting bound variables, while OperatorTranslators defines scalar function mappings for addition, subtraction, equality, inequality, and logical NOT, enabling the generation of corresponding SQL expressions for these operations.

presto-base-jdbc/src/main/java/com/facebook/presto/plugin/jdbc/optimization/function · high confidence

Added TPC-DS benchmark SQL queries

Added a suite of TPC-DS benchmark SQL queries (q01 through q23\_2) to the Presto benchmarking resources, providing standardized SQL workloads for performance testing.

presto-benchto-benchmarks/src/main/resources/sql/presto/tpcds · high confidence

Added bytecode control-flow statement classes

The \presto-bytecode\ module now includes a new \control\ package containing classes that represent structured control-flow constructs for bytecode generation. This adds support for \IfStatement\ (with optional true/false branches), \WhileLoop\ and \DoWhileLoop\, \ForLoop\ (with initialize, condition, update, and body blocks), \SwitchStatement\ (using lookup switches with a builder API), and \TryCatch\ blocks. These classes implement the \FlowControl\ interface and generate the corresponding JVM bytecode instructions via ASM \MethodVisitor\ calls, enabling more structured and readable bytecode construction for these patterns.

presto-bytecode/src/main/java/com/facebook/presto/bytecode/control · high confidence

Added distributed sort benchmark queries

New SQL benchmark scripts have been added to the Presto Benchto benchmarks suite to evaluate distributed sort performance. These include a session configuration script to toggle the distributed sort flag, and two query scripts that perform sorting on the TPC-H lineitem table—one ordering by a single column (orderkey) and another by six columns (orderkey, partkey, suppkey, linenumber, quantity, extendedprice).

_presto-benchto-benchmarks/src/main/resources/sql/presto/distributed\sort · high confidence

Added zone-index.properties for time zone ID mapping

A new \zone-index.properties\ file has been added to \presto-common\ to provide a fixed numeric ID for every supported time zone ID. This resource ensures consistent mapping between time zone identifiers and their numeric representations, which is required because Presto uses both \java.util.TimeZone\ and the Joda time library during execution.

presto-common/src/main/resources · high confidence

Enable remote UDF execution via Thrift with configurable page formats

Users can now execute SQL functions remotely using the Thrift protocol. This change introduces the ThriftSqlFunctionExecutor, which handles remote invocation, automatic retry logic for transient failures, and serialization of input data. It supports two page formats—PRESTO\_THRIFT and PRESTO\_SERIALIZED—allowing administrators to choose between native Thrift block encoding or serialized Presto pages via the thrift-page-format configuration. The module also includes context-aware address selection for routing requests to the correct UDF service instances.

presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace/execution/thrift · high confidence

Establishes repository governance, coding standards, and CI infrastructure

This change introduces foundational repository configuration files that define how the project is maintained and built. It adds a CODEOWNERS file to assign review responsibilities for specific modules (such as Presto core, connectors, and native execution) to designated teams and individuals, and a .pre-commit-config.yaml to enforce code formatting and linting (via clang-format, ruff, yamllint, etc.) before commits. It also includes a new Jenkinsfile to automate Maven builds, Docker image creation, and artifact publishing to AWS S3/ECR, alongside supporting configuration files like .clang-format, .gitignore, and .mailmap to standardize development workflows and environment setup.

(repo-wide) · high confidence

Extract benchmarking code into a dedicated presto-benchmark module

Benchmarking logic has been extracted from the main engine into a new, standalone presto-benchmark module. This change introduces a structured benchmarking framework with abstract base classes (AbstractBenchmark, AbstractOperatorBenchmark, AbstractSqlBenchmark) and a BenchmarkSuite that orchestrates a wide range of performance tests—including aggregation, join, filter, and array comparison benchmarks—against a local TPCH data set. Users can now run these standardized benchmarks to evaluate engine performance, with results output in JSON, CSV, and ODS formats.

presto-benchmark/src/main · high confidence

File-based resource group configuration with dynamic naming and selector enhancements

The file-based resource group manager now loads its configuration from a JSON file (configured via \resource-groups.config-file\), enabling easier management of resource groups without requiring a database. This update introduces dynamic resource group naming through templates (e.g., \${user}\), allowing selectors to match and create groups based on runtime context. Additionally, selectors can now route queries based on resource estimates (execution time, CPU time, peak memory), query type, client tags, client info, schema, and principal, providing more granular control over query routing and resource allocation.

presto-resource-group-managers · high confidence

Hive metastore module refactoring and new type support

The metastore logic has been moved into the new presto-hive-metastore module, introducing new core classes for handling Hive table handles, bucket properties, storage formats, and column encryption. This change adds support for UUID and Geometry types in Hive tables, enables DWRF encryption via new table properties, and introduces a native Presto bucket function type alongside the existing Hive-compatible mode.

presto-hive-metastore · high confidence

Initial Cassandra connector implementation

Adds a new Cassandra connector to Presto, providing the core infrastructure to read from and write to Cassandra clusters. This includes the connector factory, session management with configurable TLS and authentication, client configuration for timeouts and consistency levels, and support for clustering key predicate pushdown.

presto-cassandra/src/main · high confidence

Initial Delta Lake connector integration

Adds a new Delta Lake connector to Presto, enabling users to query Delta Lake tables stored in S3, GCS, and Azure Blob Storage/ADLS Gen2. This change introduces the core connector components (including DeltaClient, DeltaMetadata, and DeltaConnector) to read Parquet-based Delta tables, supporting features such as partition pruning, column mapping, and time-travel queries via snapshot IDs or timestamps.

presto-delta/src/main · high confidence

Initial Presto Docker configuration and catalog setup

The Docker image now includes default configuration files for Presto, enabling immediate usage with standard catalogs. New files in docker/etc/catalog define connectors for JMX, memory, TPC-DS, and TPC-H. A new node.properties file initializes the node ID using the HOSTNAME environment variable and sets the environment to 'test'. Example configuration files (config.properties.example, jvm.config.example) are provided, with the JVM config tailored for Java 17+ using G1GC and specific module opens.

docker/etc · high confidence

Initial Presto on Spark package assembly and distribution structure

This change introduces the build infrastructure for the Presto on Spark distribution package. It adds the Maven assembly descriptor (presto.xml) which configures the packaging of the server runtime, including specific plugin directories for connectors such as HANA, Hive, MySQL, PostgreSQL, Kafka, MongoDB, Pinot, Redis, Redshift, SQL Server, and TPCH/TPCDS, as well as session property managers. The package also bundles necessary third-party license notices (NOTICE file) and a README with installation instructions, providing the foundational artifact structure for deploying Presto on Spark.

presto-spark-package · high confidence

Initial Presto on Spark service factory registration

This change introduces the initial configuration for running Presto on Spark by registering the \PrestoSparkServiceFactory\ implementation via the Java Service Provider Interface (SPI). This allows the Presto runtime to discover and instantiate the specific factory class required to manage the Spark execution environment.

presto-spark · high confidence

Initial release of the Presto Druid connector

This change introduces the Druid connector, enabling Presto to query and ingest data from Apache Druid. The implementation includes the core connector infrastructure (DruidConnector, DruidClient, DruidConfig), metadata handling via DruidMetadata, and split management through DruidSplitManager. It supports reading data from the Druid broker via DruidBrokerPageSource and writing data via DruidPageSinkProvider. Key features include configurable schema names, basic authentication, TLS support, and query pushdown capabilities for filters and aggregations, allowing complex queries to be executed directly in Druid for improved performance.

presto-druid/src/main/java/com/facebook/presto/druid · high confidence

Initial release of the Presto JDBC driver

This change introduces the \presto-jdbc\ module, providing a new JDBC driver for connecting to Presto. The implementation includes core components such as \PrestoDriver\, \PrestoConnection\, \PrestoStatement\, and \PrestoResultSet\, along with support for connection properties (SSL, proxies, Kerberos, external authentication), \DatabaseMetaData\ for schema introspection, and type mapping for SQL data types.

presto-jdbc · high confidence

Initial support for ingesting data into Druid via Presto CTAS

This change introduces the core components for writing data from Presto into Druid tables using Create Table As Select (CTAS). It adds a new ingestion pipeline where Presto pages are serialized into gzip-compressed JSON files on deep storage (via DruidPageWriter), and a corresponding ingestion task is submitted to Druid (via DruidIngestTask and DruidClient) to load that data. The implementation supports local and HDFS input sources and maps Presto column types to Druid dimensions and timestamps.

presto-druid/src/main/java/com/facebook/presto/druid/ingestion · high confidence

Introduce AWS Security Mapping and SDK v2 Metrics

This change adds a new AWS Security Mapping feature to the Hive connector, allowing administrators to configure user-to-IAM-role or user-to-credentials mappings via a JSON file (configurable via hive.aws.security-mapping.type, config-file, and refresh-period). It also introduces AwsSdkClientStats to expose AWS SDK v2 metrics (request count, retries, throttling, call durations) as JMX stats, supporting the broader SDK v2 migration.

presto-hive-common/src/main/java/com/facebook/presto/hive/aws · high confidence

Introduce Alluxio-based local data caching for Presto

This change adds a new Alluxio-based local cache implementation for Presto, allowing users to enable and configure local caching to improve query performance. The new feature includes configuration options for cache size, eviction policies (LRU, LFU, FIFO, or Unevictable), timeout handling, and cache quota management. It also introduces data validation to detect corrupted cache entries and supports shadow caching for gradual rollout. Users can now leverage Alluxio's local caching capabilities directly within Presto's Hive connector without requiring a separate Alluxio cluster.

presto-cache/src/main/java/com/facebook/presto/cache/alluxio · high confidence

Introduce Apache Accumulo connector

Adds a new Apache Accumulo connector to Presto, enabling users to query and write data in Accumulo tables. The implementation includes the connector factory, metadata management, split generation, and I/O providers, along with configuration for session and table properties.

presto-accumulo/src/main · high confidence

Introduce Apache Arrow FlightShim service for connector federation

This change adds the \presto-flight-shim\ module, a standalone service that runs an Apache Arrow Flight server to enable connector federation with C++ workers. It includes the server implementation (\FlightShimServer\), a plugin manager for loading connectors dynamically (\FlightShimPluginManager\), and configuration classes (\FlightShimConfig\) for settings like server port, SSL, and batch sizes. The module also provides the necessary Guice bindings (\FlightShimModule\) and test infrastructure (\AbstractTestArrowFederationNativeQueries\) to validate federated query execution.

presto-flight-shim · high confidence

Introduce Arrow Flight connector plugin

Adds a new Arrow Flight connector plugin that enables Presto to query data via the Arrow Flight protocol. This change introduces the core connector components, including the plugin factory, metadata handling for schema and table discovery, split management for distributed scanning, and a page source provider that reads data from Arrow Flight streams. It also includes configuration support for SSL/TLS and mTLS authentication, as well as options for case-sensitive name matching.

presto-base-arrow-flight/src/main, presto-mysql, presto-prometheus · high confidence

Introduce Atop connector for querying system performance data

Adds a new Atop connector that allows users to query historical system performance metrics collected by the \atop\ utility. The connector exposes tables such as reboots and other system statistics, configurable via \atop.security\ (supporting 'none' or 'file' based access control), \atop.executable-path\, \atop.time-zone\, and \atop.max-history-days\. It integrates with Presto's connector SPI, including metadata, split management, and page sourcing, to read data from the \atop\ executable process.

presto-atop/src/main · high confidence

Introduce BingTile type and 2D KDB-tree spatial indexing

This change adds a new BingTile type (with serialization, QuadKey conversion, and parent/child navigation) and a 2-dimensional KDB-tree implementation (including JSON serialization utilities) to the Presto geospatial toolkit. These components provide the foundation for spatial indexing and Bing map tile integration, supporting more efficient spatial queries and tile-based operations.

presto-geospatial-toolkit/src/main/java/com/facebook/presto/geospatial · high confidence

Introduce Druid metadata model classes for segment and table information

Added new Java model classes (DruidColumnInfo, DruidColumnType, DruidSegmentIdWrapper, DruidSegmentInfo, DruidTableInfo) in the metadata package to represent Druid catalog structures. These classes provide Jackson-annotated serialization for parsing segment metadata (including deep storage paths for S3, HDFS, GCS, and local) and column/table definitions, enabling the connector to correctly interpret Druid's JSON metadata format.

presto-druid/src/main/java/com/facebook/presto/druid/metadata · high confidence

Introduce Elasticsearch connector with AWS IAM and password authentication

The Presto Elasticsearch connector is now available, enabling queries against Elasticsearch clusters. It supports two authentication modes: AWS IAM (configured via \elasticsearch.aws.access-key\, \elasticsearch.aws.secret-key\, \elasticsearch.aws.region\, and \elasticsearch.aws.use-instance-credentials\) and standard username/password (configured via \elasticsearch.username\ and \elasticsearch.password\). The connector exposes a \system.nodes\ table for cluster visibility, supports passthrough queries via the \$query\ suffix, and includes configuration for TLS, timeouts, and node refresh intervals.

presto-elasticsearch/src/main · high confidence

Introduce Flatbush Hilbert R-Tree for geospatial indexing

The geospatial toolkit now includes a new static, low-memory R-Tree implementation called Flatbush. This change adds the \Flatbush\ class, which stores tree data in a flat array for improved performance and reduced object creation, alongside supporting classes \HilbertIndex\ for spatial sorting and the \HasExtent\ interface for defining spatial bounds. Users can now leverage this efficient indexing structure for geospatial queries within the \presto-geospatial-toolkit\.

presto-geospatial-toolkit/src/main/java/com/facebook/presto/geospatial/rtree · high confidence

Introduce HDFS caching infrastructure and quota controls

This change adds the core data structures and caching mechanisms for HDFS file access in Presto. It introduces new classes to manage cache quotas and scopes (CacheQuota, CacheQuotaScope, CacheQuotaRequirement) and provides a provider interface (CacheQuotaRequirementProvider) to enforce these limits. The update also adds a new HdfsContext to carry session and table metadata during file operations, and introduces a new HiveFileContext to track file-level details like size, modification time, and cache eligibility. To support these features, the codebase now includes a new BlockLocation class for block metadata, a HiveFileInfo class for file status, and an ExtendedFileSystem abstraction with a Hadoop implementation (HadoopExtendedFileSystem) and a dedicated cache (HadoopExtendedFileSystemCache). Finally, it adds a CacheStatsMBean to expose cache performance metrics via JMX.

presto-hdfs-core · high confidence

Introduce Hive data caching with Alluxio and file-merge backends

This change adds a new caching layer for the Hive connector, allowing users to cache data to improve query performance. The implementation introduces a \CachingFileSystem\ abstraction and a \CacheFactory\ that instantiates either an Alluxio-based caching file system or a file-merge caching file system, depending on the \cache.type\ configuration. Users can enable caching via \cache.enabled\, specify the base storage directory with \cache.base-directory\, and configure quota management using \cache.cache-quota-scope\ and \cache.default-cache-quota\. Additional controls include \cache.validation-enabled\ to ensure cached data matches the source and \cache.last-modified-time-check-enabled\ to handle file updates. The module also exposes \CacheStats\ via JMX for monitoring hits, misses, and quota exceedances.

presto-cache/src/main/java/com/facebook/presto/cache · high confidence

Introduce Hive function namespace support

Adds a new \hive-functions\ function namespace that allows Presto to discover and execute Hive UDFs and aggregation functions. This change introduces the \HiveFunctionNamespaceManager\ and \HiveFunctionNamespacePlugin\ to register the namespace, along with supporting classes like \FunctionRegistry\ (which statically maps Hive function names to their Java implementations), \HiveFunction\ (the SPI representation of a Hive function), and \HiveAccumulatorInvoker\ (which handles the execution of Hive aggregation buffers). Users can now query and use Hive functions directly within Presto queries via this new namespace.

presto-hive-function-namespace · high confidence

Introduce HiveS3Config and modular S3 filesystem support

The Hive connector's S3 configuration is now centralized in a new \HiveS3Config\ class, exposing settings for path-style access, IAM role assumption, web identity authentication, and storage classes (including Intelligent Tiering). The \HiveS3Module\ has been updated to support multiple S3 filesystem implementations—Presto's native filesystem, Amazon EMRFS, and Hadoop's default configuration—allowing users to select the backend via \S3FileSystemType\. Additionally, the connector now supports configuring S3 upload ACLs and provides a dedicated client factory for S3 Select pushdown queries.

presto-hive/src/main/java/com/facebook/presto/hive/s3 · high confidence

Introduce Hudi connector for querying Apache Hudi tables

Users can now query Apache Hudi tables by configuring a new Hudi connector. This change adds the connector implementation, including metadata handling, split management, and page source providers, along with configuration options for metadata tables, size-based split weights, and split generation parallelism.

presto-hudi · high confidence

Introduce JSON-file-based function namespace manager

Presto now supports defining functions via JSON files through a new \json\_file\ namespace manager. Administrators can configure the \json-based-function-manager.path-to-function-definition\ setting to point to a JSON file or a directory (up to 4 levels deep) containing function definition files. The system loads these definitions at startup, allowing users to register scalar and aggregate functions defined in JSON, including support for variable-arity functions with an 'any' typed tail argument.

presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace/json · high confidence

Introduce JTS-based geometry serialization alongside Esri format

The geospatial toolkit now supports serializing and deserializing geometry data using the JTS (Java Topology Suite) library in addition to the existing Esri format. This change adds a new \JtsGeometrySerde\ class and a dedicated \GeometrySerializationType\ enum to handle the new binary format, allowing users to work with JTS-native geometry objects. The existing \EsriGeometrySerde\ is retained for backward compatibility, but the internal serialization logic has been refactored to use the new enum-based type system, and empty envelope serialization is now supported.

presto-geospatial-toolkit/src/main/java/com/facebook/presto/geospatial/serde · high confidence

Introduce MongoDB connector with TLS support and transactional API

Adds a new MongoDB connector to Presto, enabling users to query and write to MongoDB collections. The connector supports TLS encryption via keystore and truststore configuration, allows case-sensitive identifier matching, and implements the transactional API for write operations. It also supports reading MongoDB documents as map types and includes configuration for read preferences and connection pooling.

presto-mongodb · high confidence

Introduce Oracle connector with TLS, synonyms, and credential passthrough support

Users can now connect Presto to Oracle databases via the new Oracle connector. This connector supports configurable synonyms inclusion, customizable numeric default scales and rounding modes, and TLS/SSL encryption for secure connections. It also enables per-session credential passthrough, allowing users to authenticate using session-specific credentials rather than static catalog properties.

presto-oracle · high confidence

Introduce PageFile storage format with compression support

The Hive connector now supports a new PageFile storage format, enabling users to write and read data using a custom page-based layout. This change adds writers and readers for the format, including a footer that records stripe offsets and compression metadata. It also introduces adapters for Airlift compression codecs (Snappy, LZ4, GZIP, ZSTD) to allow compressed PageFile writes and reads, and integrates with the existing Hive file split and page source infrastructure to support splittable reads of these files.

presto-hive/src/main/java/com/facebook/presto/hive/pagefile · high confidence

Introduce Plan Checker Router Scheduler Plugin

Adds a new custom scheduler plugin for the Presto Router that routes queries to either native or Java clusters based on lightweight plan validation. The plugin uses \EXPLAIN (TYPE VALIDATE)\ to check if a query is compatible with the native engine; compatible queries are routed to the native cluster, while incompatible ones fall back to the Java cluster. It includes configuration options to enable fallback to Java clusters when plan checker clusters are unreachable (\enable-java-cluster-fallback\) and to automatically retry failed native queries on Java clusters (\enable-java-cluster-query-retry\). The plugin exposes MBeans for monitoring redirect counts and provides a dedicated \HttpRequestSessionContext\ to handle session header parsing.

presto-plan-checker-router-plugin · high confidence

Introduce PostgreSQL connector with support for JSON, UUID, and geometry types

Adds a new PostgreSQL connector plugin that enables querying PostgreSQL databases via JDBC. The connector supports reading JSON, JSONB, UUID, and PostGIS geometry/geography data types, and handles case-insensitive or case-sensitive name matching based on configuration. It also supports querying tables, views, materialized views, and foreign tables, while providing specific handling for PostgreSQL-specific features like bytea for varbinary and proper cleanup of temporary tables on errors.

presto-postgresql · high confidence

Introduce Presto Lance connector with type coercion and limit pushdown

This change adds the Presto Lance connector, enabling queries against Lance datasets via a new connector factory, metadata provider, and page source implementation. The connector supports reading data with automatic type coercion, specifically widening Float16 vectors to Float32 to ensure compatibility with the Arrow block builder, and handles array types containing Float16 by widening inner data vectors. It also includes a plan optimizer that pushes LIMIT clauses down into Lance scans to improve performance by reducing the number of fragments scanned and stopping scans early, while preserving exact LIMIT semantics in the execution plan.

presto-lance · high confidence

Introduce Presto Proxy service for secure remote access

This change adds a new Presto Proxy service that allows clients to access a remote Presto server through a firewall without direct connectivity. The proxy understands the Presto protocol, rewrites 'nextUri' links in responses to point to itself, and supports secure authentication by generating JWT access tokens from TLS client certificates. It also forwards the X-Forwarded-For header to preserve client IP information and includes configurable timeouts for reading responses from the coordinator.

presto-proxy · high confidence

Introduce Presto Router for multi-cluster query routing

Adds the Presto Router service, which sits in front of multiple Presto clusters to route incoming queries, collect cluster statistics, and display aggregated results via a web UI. The router supports configurable scheduling strategies (including random choice, round-robin, and weighted variants) and allows dynamic cluster membership updates through a JSON configuration file monitored by a file watch service. It exposes REST endpoints for query routing and cluster status, integrates with a plugin system for custom schedulers and authenticators, and provides a React-based UI for monitoring.

presto-router · high confidence

Introduce Presto Thrift Connector API

This change adds the \presto-thrift-api\ module, which defines the Thrift service interface and data structures required for the new Thrift Connector. It introduces the \PrestoThriftService\ interface with methods for listing schemas and tables, retrieving table metadata, and fetching data splits and rows. The module also includes Thrift-serializable value types for column metadata, domains, host addresses, page results, and split batches, along with utility classes for name validation and error handling, enabling external data sources to expose their data via the Thrift protocol.

presto-bigquery/src/main, presto-memory, presto-thrift-api · high confidence

Introduce Presto Verifier for query result equivalence validation

Adds the Presto Verifier tool, which allows users to verify the correctness of a new Presto version or the result equivalence of query pairs by comparing checksums between a control and a test cluster. The implementation includes a CLI entry point, a framework for managing verification stages (control, test, determinism analysis), and specific checksum validators for complex types such as arrays (including floating-point and string-as-double handling) and maps, ensuring accurate comparison of query outputs.

presto-verifier · high confidence

Introduce Presto benchmark runner entry point

Added a new command-line entry point for running Presto benchmarks. The \PrestoBenchmarkRunner\ class initializes an Airline CLI with a \benchmark\ command, which delegates to \PrestoBenchmarkCommand\. This command sets up the necessary Guice modules (including SQL parser and exception classification options) and executes the benchmark suite via the \AbstractBenchmarkCommand\ base class, providing a concrete, extensible way to launch benchmarks from the \presto-benchmark-runner\ module.

presto-benchmark-runner/src/main/java/com/facebook/presto/benchmark · high confidence

Introduce Presto-on-Spark classloader interface and execution abstractions

This change adds the \presto-spark-classloader-interface\ module, establishing the core API contracts and data structures for Presto-on-Spark execution. It introduces interfaces for service and task execution factories (\IPrestoSparkService\, \IPrestoSparkQueryExecutionFactory\), configuration management (\PrestoSparkConfiguration\), and native task processing (\PrestoSparkNativeTaskRdd\). The update also defines specific execution strategies for handling failures (such as disabling broadcast joins or increasing container size), standardizes row and shuffle data types (\PrestoSparkMutableRow\, \PrestoSparkShuffleStats\), and implements Kryo serialization registration to optimize data transfer between the driver and Spark executors.

presto-spark-classloader-interface · high confidence

Introduce Quick Stats for faster Hive table statistics collection

The Hive connector now supports a new 'Quick Stats' mechanism that allows it to fetch column-level statistics (row count, null count, min/max values) directly from file metadata (such as Parquet footers) when the Hive Metastore lacks accurate statistics. This feature, controlled by the \quickStatsEnabled\ session property, acts as a fallback to the standard metastore queries, enabling faster query planning and execution for tables with missing or stale metadata. The implementation includes new components like \QuickStatsProvider\ and \ParquetQuickStatsBuilder\ to handle background fetching, caching, and parsing of file-level statistics.

presto-hive/src/main/java/com/facebook/presto/hive/statistics · high confidence

Introduce REST-based Function Namespace Manager

Presto now supports a new REST-based function namespace manager that retrieves function signatures and executes SQL functions via an external REST server. This change adds a new 'rest' factory for function namespace managers, allowing users to configure a remote URL for function metadata and execution. The implementation includes a dedicated HTTP client with internal authentication, ETag-based caching for function lists, and a custom executor that serializes input pages and sends them to the remote server for processing, returning results as serialized pages.

presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace/mysql, presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace/rest · high confidence

Introduce RowExpression translation framework for connectors

Added a new translation layer in the \presto-expressions\ module that allows connectors to convert internal \RowExpression\ structures into target-specific representations. This includes the \FunctionTranslator\ for mapping scalar functions via annotations, the \RowExpressionTreeTranslator\ for traversing expression trees, and the \TranslatedExpression\ container to track translation results. This change enables connectors to implement custom logic for handling function calls and expressions during query execution.

presto-expressions/src/main/java/com/facebook/presto/expressions/translator · high confidence

Introduce Thrift UDF testing server

A new testing server for Thrift-based User-Defined Functions (UDFs) has been added to the Presto codebase. This server, implemented via \EchoFirstInputThriftUdfService\, listens on port 7779 and implements the \ThriftUdfService\ interface by returning the first input parameter block as the result. It supports both Presto Thrift page formats and serialized Presto pages, providing a concrete implementation for testing remote UDF execution capabilities.

presto-thrift-testing-udf-server · high confidence

Introduce Z-Order encoding and range search for integer columns

Added a new Z-Order library in the Hive common module that enables encoding and decoding of integer column values into Z-addresses to preserve data locality, supporting both positive-only and signed integer ranges. The implementation includes ZAddressRange and ZValueRange classes to define address and value bounds, allowing queries to search across multiple integer dimensions using Z-curve logic.

presto-hive-common/src/main/java/com/facebook/presto/hive/zorder · high confidence

Introduce benchmark runner framework with concurrent execution and event logging

This change adds the core framework for the Presto benchmark runner, enabling users to define and execute benchmark suites with configurable phases. It introduces a \BenchmarkRunner\ that orchestrates execution, supporting both sequential and concurrent query execution strategies via \ConcurrentPhaseExecutor\ (with configurable max concurrency). The runner captures detailed results for each query and phase, emitting structured events (\BenchmarkQueryEvent\, \BenchmarkPhaseEvent\, \BenchmarkSuiteEvent\) that can be logged to JSON files via the \JsonEventClient\. It also supports specifying session properties per query and configuring whether to continue on failure.

presto-benchmark-runner/src/main/java/com/facebook/presto/benchmark/framework · high confidence

Introduce case-sensitive name matching for the Kafka connector

The Kafka connector now supports case-sensitive matching of schema and table names. Users can enable this behavior via the new \case-sensitive-name-matching\ configuration property; when disabled (the default), names are matched case-insensitively using lowercase normalization.

presto-kafka · high confidence

Introduce common library for SQL-invoked function namespace management

This change adds the \presto-function-namespace-managers-common\ module, providing the foundational infrastructure for managing SQL-invoked functions. It introduces \AbstractSqlInvokedFunctionNamespaceManager\ as a base class for function namespace managers, handling caching of functions, metadata, and user-defined types, along with transaction support (currently no-op). The module also includes \JsonBasedUdfFunctionMetadata\ for parsing function definitions from JSON, configuration classes for cache expiration and supported languages, and a \SqlFunctionExecutors\ service to route function execution. Additionally, it provides a \NoopSqlFunctionExecutor\ for environments without a registered executor and an \InMemoryFunctionNamespaceManager\ for testing purposes.

presto-function-namespace-managers-common · high confidence

Introduce database-backed session property manager

Added a new \presto-db-session-property-manager\ module that allows Presto to fetch and override session properties from a relational database (MySQL or MariaDB). This feature introduces a JDBC-based configuration manager that automatically creates and manages the required \session\_specs\, \session\_client\_tags\, and \session\_property\_values\ tables, periodically refreshing property overrides from the database to apply them to user sessions.

presto-db-session-property-manager · high confidence

Introduce dedicated presto-analyzer module with new analysis data structures

This change establishes the core data structures for the new presto-analyzer module, introducing the Analysis class to track query metadata (such as column references, access control info, window functions, and materialized view states), the ExpressionAnalysis class to hold resolved types and coercions, and supporting classes like Field, FieldId, RelationId, and RelationType to model query relations and fields. It also adds the BuiltInQueryPreparer and BuiltInQueryAnalysis implementations, the FunctionAndTypeResolver interface for function and type resolution, and the ConstantExpressionVerifier to enforce constant expression rules, laying the foundation for the analyzer's internal state management.

presto-analyzer/src/main/java/com/facebook/presto/sql/analyzer · high confidence

Introduce file-based access control module in presto-plugin-toolkit

The presto-plugin-toolkit now includes a new security module that allows administrators to manage connector-level access control via a JSON configuration file. This feature introduces \FileBasedAccessControl\, which reads rules for schemas, tables, session properties, and procedures from a specified file, and supports optional periodic refreshing of these rules via the \security.refresh-period\ configuration. The module also provides \AllowAllAccessControl\ for permissive testing, \ReadOnlyAccessControl\ for restricting write operations, and forwarding wrappers (\ForwardingConnectorAccessControl\, \ForwardingSystemAccessControl\) to facilitate rule composition and dynamic reloading.

presto-plugin-toolkit · high confidence

Introduce file-merge caching for Hive connector reads

Added a new file-merge cache implementation for the Hive connector that caches file chunks on disk to accelerate subsequent reads. The change introduces configuration options to control the maximum number of cached entries, the time-to-live for cache entries, and the maximum in-memory cache size. The caching logic integrates with the Hive file system to intercept reads, serving data from the local cache when available and respecting configured cache quotas.

presto-cache/src/main/java/com/facebook/presto/cache/filemerge · high confidence

Introduce native Iceberg catalog support with V3 protocol and file caching

The Iceberg connector now supports a native catalog type alongside existing Hadoop, Hive, Nessie, and REST catalogs, enabling direct integration with Iceberg's native metadata handling. This change introduces support for the Iceberg V3 protocol, including type-disambiguation attributes for complex nested types (UUID, FIXED) via the new ColumnIdentity class, and adds caching for manifest files to improve read performance. It also extends file content support to include deletion vectors and equality deletes, and provides a new $files system table for inspecting underlying data file metadata.

presto-iceberg · high confidence

Introduce new Docker image for Presto with remote function support

The repository now includes a new Dockerfile, build script, and entrypoint for building the Presto server image. The image is based on CentOS Stream 9 and uses Java 17. It includes the Presto CLI, a new remote function server (presto-function-server), and the Prometheus JMX Exporter (version 0.20.0). The build script supports multi-architecture builds (linux/amd64, linux/arm64, linux/ppc64le) and publishes images to a container registry. The entrypoint script runs the Presto launcher.

docker · high confidence

Introduce new SPI interfaces and classes for connector operations and metadata

The presto-spi module adds several new interfaces and classes to support advanced connector capabilities. This includes \BucketFunction\ for custom bucketing logic, \CatalogSchemaTableName\ for structured table identification, and \ClientRequestFilter\/\Factory\ for adding custom HTTP headers. New handle interfaces like \ConnectorDeleteTableHandle\, \ConnectorInsertTableHandle\, \ConnectorMergeTableHandle\, and \ConnectorDistributedProcedureHandle\ enable DELETE, INSERT, MERGE, and distributed procedure support. The \ConnectorPageSink\ and \ConnectorPageSource\ interfaces are expanded with methods for tracking bytes, files, memory usage, and validation CPU time. \ColumnMetadata\ is enhanced with support for derived columns and default values. Additionally, \ConnectorPlanOptimizer\ and \ConnectorPlanRewriter\ provide new hooks for connector-specific query plan optimization and transformation.

presto-spi · high confidence

Introduce new pattern-matching library for query plan analysis

The presto-matching module now includes a new pattern-matching framework that enables declarative matching and extraction of structured data, such as query plan nodes. This library provides core components including Pattern, Matcher, and Match classes, along with specific pattern types like TypeOf, Equals, Filter, Capture, and With. It also introduces Property and PropertyPattern classes for navigating object hierarchies and extracting values. The implementation includes a DefaultMatcher and DefaultPrinter for matching logic and debugging output. Test coverage includes examples with RelNode types (ScanNode, ProjectNode, FilterNode, JoinNode) demonstrating nested property matching and capture functionality.

presto-matching · high confidence

Introduce new session property and exception handling infrastructure

This change adds the foundational classes for managing new session properties and enforcing query limits. It introduces a \ClientRequestFilterManager\ to handle client request filters and a \CompressionCodec\ enum to standardize compression types. Additionally, it defines a suite of new exception classes (\ExceededCpuLimitException\, \ExceededIntermediateWrittenBytesException\, \ExceededMemoryLimitException\, \ExceededOutputSizeLimitException\, \ExceededScanLimitException\, \ExceededSpillLimitException\) to provide specific error handling for various resource constraints, alongside \FullConnectorSession\ and \SessionRepresentation\ to support richer session metadata and serialization.

presto-main-base · high confidence

Introduce pluggable error classification and execution strategies for Presto on Spark

The Presto on Spark runner now supports pluggable error classification and execution strategies, allowing connectors and administrators to define custom logic for handling failures and retry behaviors. This change introduces the \ErrorClassifier\ interface for categorizing exceptions and the \ExecutionStrategyValidator\ to enforce valid strategy configurations, alongside new configuration classes (\PrestoSparkConfig\, \PrestoSparkExecutionSettings\) and dependency injection modules (\PrestoSparkInjectorFactory\, \PrestoSparkModule\) to wire these components into the Spark execution context.

presto-spark-base · high confidence

Introduce pluggable record decoder framework for CSV, JSON, Avro, and raw formats

The presto-record-decoder module now provides a unified, extensible framework for decoding row data from various formats. Connectors can implement the DecoderColumnHandle interface to expose columns for decoding, and the system dispatches to specific decoders (CSV, JSON, Avro, Raw, and a Dummy decoder for debugging) based on the data format. This change introduces core abstractions like RowDecoder, FieldValueProvider, and DispatchingRowDecoderFactory, along with specific implementations that handle type conversions, validation, and error reporting for each format, enabling connectors to ingest structured and semi-structured data without embedding decoding logic directly.

presto-record-decoder · high confidence

Introduce presto-benchmark-driver CLI for benchmarking Presto clusters

Adds a new command-line benchmark driver tool that executes SQL queries against a Presto cluster and reports performance statistics. The driver supports configurable warm-up and run counts, session properties, schema and query selection via JSON suite configurations and regex patterns, SOCKS proxying, and configurable client request timeouts. Results are printed to standard output as tab-separated values including wall time, CPU time, and status, allowing users to easily integrate benchmark runs into their performance evaluation workflows.

presto-benchmark-driver/src/main · high confidence

Introduce presto-bytecode library for dynamic class generation

The presto-bytecode module has been added to provide a high-level API for generating Java bytecode at runtime. This library introduces a tree-based structure for defining classes, methods, and fields, utilizing the ASM framework under the hood. Key components include ClassDefinition for structuring generated classes, BytecodeBlock for composing instruction sequences, and ClassGenerator for compiling these definitions into loadable classes via a DynamicClassLoader. The module also includes utilities for handling annotations, array operations, and debug information, enabling the system to dynamically create and execute code.

presto-bytecode/src/main/java/com/facebook/presto/bytecode · high confidence

Introduce retryable client exceptions and new session configuration options

The client now distinguishes between retryable and non-retryable errors via the new ClientException class, which includes an isRetryable() flag to help clients handle transient failures more effectively. Additionally, ClientSession has been expanded to support new configuration options including client tags, trace tokens, resource estimates, custom headers, and a configurable client request timeout, allowing for more granular control over query execution and session behavior.

presto-client/src/main/java/com/facebook/presto/client · high confidence

Introduce standalone Presto Function Server with plugin support and REST API

This change introduces a new standalone Function Server component located in \presto-function-server/src/main\. It provides a REST API (\FunctionResource\) that exposes built-in scalar function metadata and supports executing functions via an execution endpoint. The server includes a \FunctionPluginManager\ that enables loading external plugins from directories, POM files, or Maven coordinates, registering their functions into the \FunctionAndTypeManager\. The server is bootstrapped via \FunctionServer\ and \FunctionServerModule\, which wire up the necessary dependencies including Jetty for HTTP serving and JAX-RS for the REST endpoints.

presto-function-server/src/main · high confidence

Introduce standalone Presto on Spark launcher CLI

Adds a new command-line launcher for Presto on Spark, allowing users to execute SQL queries directly via a CLI tool. The launcher accepts options for the SQL file, the Presto Spark package archive, configuration files, catalog directories, and optional native worker configurations. It handles the deployment of the package to the Spark cluster, loads catalog and session properties, and executes the provided SQL, printing the results to the console.

presto-spark-launcher · high confidence

Introduces JWT-based authentication for internal Presto service communication

This change adds a new internal authentication layer for HTTP-based communication between Presto components (such as the coordinator, workers, and resource manager). When enabled via the \internal-communication.jwt.enabled\ configuration, internal requests are secured using signed JSON Web Tokens (JWTs) containing the node ID, rather than relying solely on shared secrets or unauthenticated access. The \presto-internal-communication\ module now provides the \InternalAuthenticationManager\ to generate and validate these tokens, an \InternalAuthenticationFilter\ to enforce authentication on endpoints marked with the \INTERNAL\ role, and a \BasicPrincipal\ to represent the authenticated identity. This ensures that internal API calls are verified and authorized, enhancing the security posture of inter-node traffic.

presto-internal-communication · high confidence

Introduces new RowExpression tree traversal and canonicalization utilities

The presto-expressions module now includes a new set of classes to manage RowExpression trees: CanonicalRowExpressionRewriter for normalizing expressions (with an option to remove constants), DefaultRowExpressionTraversalVisitor as a base for tree walking, DynamicFilters for extracting and managing dynamic filter placeholders, LogicalRowExpressions for logical operations like AND/OR extraction, RowExpressionNodeInliner for substituting expression nodes, and the core RowExpressionRewriter and RowExpressionTreeRewriter infrastructure. These changes provide the underlying mechanics for expression canonicalization, dynamic filter handling, and tree rewriting within the query planner.

presto-expressions/src/main/java/com/facebook/presto/expressions · high confidence

Introduces new utility classes for Hive connector split handling and configuration

The presto-hive module adds several new utility classes to support advanced split management and configuration. This includes an AsyncQueue for thread-safe asynchronous data handling, ConfigurationUtils for managing Hadoop configuration copies and compression settings, and a suite of CustomSplitConverter implementations (HudiBootstrapBaseFileSplitConverter, HudiRealtimeBootstrapBaseFileSplitConverter, HudiRealtimeSplitConverter) to handle Hudi-specific file splits. Additionally, InternalHiveSplitFactory is introduced to centralize the creation of InternalHiveSplit objects, DecimalUtils handles Hive decimal decoding, FooterAwareRecordReader manages footer buffers for record reading, HiveFileIterator improves directory listing with empty file skipping, and MergingPageIterator supports sorted merging of pages.

presto-hive/src/main/java/com/facebook/presto/hive/util · high confidence

Introduction of PreparedQuery base class in analyzer package

A new abstract base class, PreparedQuery, has been added to the analyzer package to serve as a common structure for prepared queries. This class encapsulates formatted query text and prepare SQL statements, providing getter methods for these values and defining abstract or unsupported methods for query type, transaction control status, and statement classification, laying the groundwork for specific query implementations.

presto-common/src/main/java/com/facebook/presto/common/analyzer · high confidence

Introduction of the base JDBC connector framework

This change introduces the \presto-base-jdbc\ module, providing a foundational framework for building JDBC connectors. It includes the core \BaseJdbcClient\ for handling database interactions, \BaseJdbcConfig\ for connection and naming configuration, and a \ConnectionFactory\ abstraction that allows connectors to define custom connection sources. The framework also establishes the necessary SPI components, such as \JdbcConnector\ and \JdbcMetadata\, to integrate with the Presto connector lifecycle.

presto-base-jdbc/src/main/java/com/facebook/presto/plugin/jdbc · high confidence

JMX connector refactored to support historical data tables

The JMX connector now exposes a \history\ schema in addition to the existing \current\ schema, allowing users to query periodically sampled JMX metrics over time. This is implemented via a new \JmxHistoricalData\ component that stores sampled rows in an evicting queue, a \JmxPeriodicSampler\ that runs on a configurable \jmx.dump-period\ to capture live metrics, and a \JmxConnectorConfig\ that supports escaped commas in the \jmx.dump-tables\ configuration property. The connector's internal architecture has been updated to use the new \ConnectorContext\ and \TableLayout\ APIs, and it now uses \jakarta.inject\ for dependency injection.

presto-jmx · high confidence

Native expression optimization via sidecar

The sidecar plugin now offloads row expression optimization to the native sidecar, enabling faster constant folding and evaluation for scalar functions. The \NativeExpressionOptimizer\ collects expressions, resolves variables, and sends them in batch to the sidecar's \/v1/expressions\ endpoint along with session properties. The sidecar returns optimized expressions, which are then substituted back into the original query plan. This change introduces a new \NativeSidecarPlugin\ that registers the optimizer, a dedicated \NativeSidecarCommunicationModule\ for HTTP client and auth configuration, and robust retry handling via \SidecarRetryDriver\ with exponential backoff for transient failures. Failure information from the sidecar is mapped to Presto exceptions via \NativeSidecarFailureInfo\.

presto-native-sidecar-plugin · high confidence

Native sidecar function registry tool for worker function discovery

This change introduces a new tool that allows Presto workers to discover and register native (C++) UDFs by fetching their signatures from a sidecar service. The \NativeSidecarFunctionRegistryTool\ queries a sidecar node at startup (with configurable retry logic via \native-sidecar-registry-tool.num-retries\ and \native-sidecar-registry-tool.retry-delay-ms\) to retrieve a JSON-based function signature map, which is then converted into \SqlInvokedFunction\ objects for use by the query engine. This enables dynamic registration of native functions without requiring them to be compiled into the Presto binary.

presto-built-in-worker-function-tools · high confidence

New Arrow data conversion and batch source utilities for connector federation

Added core Java classes in presto-common-arrow to support Apache Arrow integration for connector federation: ArrowBatchSource reads Presto pages into Arrow VectorSchemaRoot batches, ArrowBlockBuilder converts Arrow vectors back to Presto Blocks (including dictionary-encoded blocks), and BlockArrowWriter maps Presto column metadata and types to Arrow schemas and vectors. The change also introduces ArrowException and ArrowErrorCode to handle Arrow-specific errors, along with comprehensive unit tests for primitive, date/time, and complex types.

presto-common-arrow · high confidence

New ClickHouse query optimization and pushdown framework

The ClickHouse connector now includes a new optimization layer in the \optimization\ package that enables pushing down filters, aggregations, and project expressions to the ClickHouse database. This change introduces a suite of new classes including \ClickHouseComputePushdown\ (the main \ConnectorPlanOptimizer\), \ClickHouseQueryGenerator\ (to build the final SQL), and specialized converters like \ClickHouseFilterExpressionConverter\ and \ClickHouseProjectExpressionConverter\ to translate Presto expressions into ClickHouse-compatible SQL. The \ClickHousePlanOptimizerProvider\ registers these optimizers, allowing the connector to generate more efficient execution plans by delegating computation to the database.

presto-clickhouse/src/main/java/com/facebook/presto/plugin/clickhouse/optimization · high confidence

New FunctionNamespaceManagerPlugin registers REST, JSON, and MySQL backends

The presto-function-namespace-managers module now includes a new plugin, FunctionNamespaceManagerPlugin, which registers three function namespace manager factories: RestBasedFunctionNamespaceManagerFactory, JsonFileBasedFunctionNamespaceManagerFactory, and MySqlFunctionNamespaceManagerFactory. This enables users to manage Presto function namespaces via REST APIs, JSON files, or MySQL databases, providing flexible storage options for function metadata.

presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace · high confidence

New Kudu connector for Presto

Adds a new Kudu connector that enables Presto to query and write to Apache Kudu tables. The connector supports Kerberos authentication, configurable schema emulation, and exposes table properties such as the number of replicas in SHOW CREATE TABLE output. Docker Compose scripts are included to run single- and three-node Kudu clusters for integration testing.

presto-kudu · high confidence

New ML plugin with SQL-based model training and evaluation aggregations

The presto-ml module now provides a set of SQL aggregation functions for machine learning workflows. Users can train Support Vector Machine (SVM) models directly in queries using \learn\_classifier\ and \learn\_regressor\ (which accept feature maps and optional parameters) and \learn\_libsvm\_classifier\/\learn\_libsvm\_regressor\ (which allow explicit parameter strings). The plugin also introduces \evaluate\_classifier\_predictions\ to compute accuracy, precision, and recall metrics by comparing truth and prediction values. Internally, the plugin manages model serialization, feature normalization (via \FeatureUnitNormalizer\ and \FeatureVectorUnitNormalizer\), and state handling for these aggregations.

presto-ml · high confidence

New OpenLineage event listener plugin for Presto

This change introduces the \presto-openlineage-event-listener\ plugin, which enables Presto to emit OpenLineage run events for query lifecycle tracking. The plugin registers as a Presto \EventListener\ and supports configurable transports (Console or HTTP) with optional API key authentication, custom headers, URL parameters, and GZIP compression. It captures query context and metadata facets (including user, source, client IP, query ID, and plan) and emits column lineage information, mapping both direct and indirect column transformations (such as aggregation, filter, join, and group-by operations) into OpenLineage input field transformations. The plugin is configured via properties like \openlineage-event-listener.transport.type\, \openlineage-event-listener.namespace\, and \openlineage-event-listener.job.name-format\, and includes a \FormatInterpolator\ to resolve placeholders like \$QUERY\_ID\ and \$USER\ in job names.

presto-openlineage-event-listener · high confidence

New OpenTelemetry distributed tracing plugin

Presto now includes an OpenTelemetry plugin that enables distributed tracing via the OpenTelemetry SDK. The plugin registers a tracer provider that supports context propagation using the B3 single-header format (with W3C propagation defined but currently throwing an error if used), exports spans to an OTLP gRPC endpoint specified by the OTEL\_EXPORTER\_OTLP\_ENDPOINT environment variable, and propagates baggage headers. This allows users to integrate Presto traces with external OpenTelemetry-compatible observability backends.

presto-open-telemetry · high confidence

New Parquet reader and writer implementation in Hive connector

The Hive connector now includes a new, optimized Parquet reader and writer implementation. The reader (ParquetPageSource) supports advanced features such as subfield pruning, row-index columns, and partial aggregation pushdown (reading min/max/count directly from Parquet metadata). The writer (ParquetFileWriter) allows writing Parquet files with configurable block/page sizes and compression. These components are wired together via new factories (ParquetPageSourceFactory, ParquetFileWriterFactory) and data sources (HdfsParquetDataSource), providing a more efficient and feature-rich Parquet experience for Hive tables.

presto-hive/src/main/java/com/facebook/presto/hive/parquet · high confidence

New QueryType enum for resource group classification

A new QueryType enum has been added to the resource groups module to classify query operations. This enum defines specific types including DATA\_DEFINITION, DELETE, DESCRIBE, EXPLAIN, ANALYZE, INSERT, SELECT, CONTROL, UPDATE, MERGE, and CALL\_DISTRIBUTED\_PROCEDURE, enabling more granular resource management and scheduling for these distinct query categories.

presto-common/src/main/java/com/facebook/presto/common/resourceGroups · high confidence

New RCFile reader implementation for Hive connector

The Hive connector now uses a new RCFile reader implementation (HdfsRcFileDataSource, RcFilePageSource, and RcFilePageSourceFactory) to read RCFile data. This new reader supports both binary and text RCFile formats, handles column projection, and provides better error handling for corrupted files. It replaces the previous legacy RCFile reader, offering improved performance and reliability for queries involving RCFile tables.

presto-hive/src/main/java/com/facebook/presto/hive/rcfile · high confidence

New SQL-invoked functions for arrays, maps, and strings

The presto-sql-invoked-functions-plugin now registers a new set of SQL-invoked scalar functions. For arrays, users gain array\_intersect, array\_average, array\_split\_into\_chunks, array\_frequency, array\_duplicates, array\_has\_duplicates, array\_least\_frequent, array\_max\_by, array\_min\_by, array\_sort\_desc, remove\_nulls, array\_top\_n, and array\_transpose. For maps, the plugin adds map\_normalize, map\_keys\_by\_top\_n\_values, map\_key\_exists, map\_top\_n, map\_top\_n\_keys, map\_top\_n\_values, map\_remove\_null\_values, all\_keys\_match, any\_keys\_match, any\_values\_match, no\_keys\_match, no\_values\_match, map\_int\_keys\_to\_array, and array\_to\_map\_int\_keys. String handling includes replace\_first, trail, and split\_part\_reverse. Additionally, a key\_sampling\_percent function is provided for deterministic sampling based on string hashing. These functions are exposed via the SqlInvokedFunctionsPlugin implementation.

presto-sql-helpers/presto-sql-invoked-functions-plugin · high confidence

The documentation build system now includes custom Sphinx extensions that allow authors to insert direct download links for Presto artifacts (such as the server, CLI, JDBC driver, and benchmark driver) and to automatically generate clickable links to GitHub issues and pull requests within the documentation.

presto-docs/src/main/sphinx/ext · high confidence

New TestNG listeners for Jackson constraints, test duration logging, and multi-threading safety

The presto-testng-services module now registers three new TestNG listeners to improve test reliability and diagnostics. JacksonStreamConstraintsListener lifts Jackson 2.18+'s default 50,000-character JSON property-name limit before tests run, preventing failures on large property names. LogTestDurationListener tracks and logs durations for individual tests and test classes, and dumps thread information if the test suite appears to hang or the JVM fails to shut down after completion. ReportMultiThreadedBeforeOrAfterMethod validates that test classes using @BeforeMethod or @AfterMethod are correctly annotated with @Test(singleThreaded=true) when running in parallel, failing fast if mutable state is detected in a multi-threaded context.

presto-testng-services · high confidence

New Thrift connector for external storage integration

The Presto Thrift connector is now available, allowing integration with external storage systems via the Thrift protocol without requiring a custom connector implementation. Users can configure the connector to point to Thrift servers that implement the \PrestoThriftService\ interface to provide metadata, splits, and data. The connector includes support for index joins, configurable retry behavior for async failures, and the ability to forward user identity via Thrift headers. It also exposes page size distribution metrics and supports filter pushdown for native execution when enabled.

presto-thrift-connector · high confidence

New analyzer utility classes for SQL statement analysis

Added four new utility classes in the analyzer package to support SQL analysis: \AnalyzerUtil\ for converting analyzer options into parsing options, \MetadataUtils\ for constructing qualified object names from session context, \ParameterExtractor\ for collecting parameter nodes from SQL statements, and \ParameterUtils\ for mapping parameters to their values. Additionally, \StatementUtils\ was introduced to map SQL statement types to query types (such as SELECT, INSERT, DELETE, DATA\_DEFINITION, and CONTROL) using a static registry, enabling consistent classification of statement categories during analysis.

presto-analyzer/src/main/java/com/facebook/presto/sql/analyzer/utils · high confidence

New array utilities and big-array implementations added to presto-common

The presto-common module now includes a new com.facebook.presto.common.array package containing high-performance, segment-based 'BigArray' implementations for primitive types (boolean, byte, double, int, long) and objects, along with utility classes like Arrays for capacity management, ByteArrayUtils for unsafe byte operations, and Long2IntOpenHashMap. These classes provide efficient memory management and access patterns for large datasets, with specific implementations like AdaptiveLongBigArray optimizing for CPU cache locality and BlockBigArray tracking reference counts for Block objects.

presto-common/src/main/java/com/facebook/presto/common/array · high confidence

New common classes for authentication, error handling, and query tracing

This change introduces several new classes to presto-common to support internal communication security, extensible error handling, and query performance tracing. AuthClientConfigs provides a configuration structure for internal sidecar HTTP clients, including key/trust store paths and JWT settings. ErrorCode and ErrorType are added to the common module to support the new catchableByTry flag for TRY error handling and to decouple error types from the SPI. QueryTracer, RuntimeMetric, and RuntimeMetricEvent are introduced to enable detailed query tracing and runtime statistics, allowing users to track span durations and metric aggregates across query execution stages.

presto-common/src/main/java/com/facebook/presto/common · high confidence

New documentation for authorization, system access control, and authentication methods

Added comprehensive documentation for Presto security features, including HTTP endpoint authorization with role-based access control, built-in system access control plugins (allow-all, read-only, and file-based with catalog/schema rules), and detailed guides for configuring Kerberos, LDAP, OAuth2, and password-file authentication. The new docs also cover secure internal node communication via SSL/TLS and JWT, CLI Kerberos setup, and performance considerations for encrypted communication.

presto-docs/src/main/sphinx/security · high confidence

New example custom scheduler plugin for Presto Router

Added an example custom scheduler plugin (\presto-router-example-plugin-scheduler\) that demonstrates how to implement a \RouterPlugin\ for Presto Router. The example includes a \MetricsBasedScheduler\ which selects the destination cluster based on the lowest total of running and queued queries, along with the necessary factory and plugin registration classes to integrate it into the router.

presto-router-example-plugin-scheduler · high confidence

New external authentication implementation in presto-client

The presto-client now includes a new \com.facebook.presto.client.auth.external\ package that implements the mechanics for external authentication. This adds an \ExternalAuthenticator\ (acting as both an OkHttp \Authenticator\ and \Interceptor\) to handle Bearer token challenges by extracting token and redirect URIs, and an \HttpTokenPoller\ to repeatedly poll for the token with retry logic. It also introduces a strategy-based redirect system (\ExternalRedirectStrategy\) with handlers for opening a desktop browser, using the system default opener, or printing the URL to the console, coordinated by a \CompositeRedirectHandler\. Token state is managed via \KnownToken\ implementations (local or memory-cached with thread-safe locking) to support the authentication flow.

presto-client/src/main/java/com/facebook/presto/client/auth · high confidence

New file-based and LDAP password authenticator plugins

This location introduces the \PasswordAuthenticatorPlugin\ which registers two new authentication backends: a file-based authenticator and an LDAP authenticator. The file-based authenticator reads user credentials from a configurable file, supporting both BCrypt and PBKDF2 password hashing (with a fallback for deprecated PBKDF2WithHmacSHA1 hashes), and includes caching for performance. The LDAP authenticator connects to an LDAPS server to validate user credentials and optionally check group membership, requiring a user bind search pattern and supporting a configurable cache TTL. Both authenticators are implemented as pluggable factories that can be enabled via configuration.

presto-password-authenticators · high confidence

New file-based session property manager plugin

Introduces a new \presto-file-session-property-manager\ module that allows configuring session properties via a JSON file. This plugin registers a \FileSessionPropertyManagerFactory\ which reads match specifications (user, source, tags, etc.) and applies corresponding default or override session properties and catalog properties. The implementation includes robust error handling for JSON parsing and fixes a potential NullPointerException when \catalogSessionProperties\ is not configured in a match spec.

presto-file-session-property-manager, presto-session-property-managers-common · high confidence

New generic Thrift codec toolkit for Presto connectors

The presto-thrift-connector-toolkit module now provides a reusable infrastructure for Thrift-based serialization in connectors. It introduces a GenericThriftCodec that wraps the Drift ThriftCodecManager to handle arbitrary Java types, a ThriftCodecProvider that implements ConnectorCodecProvider to supply codecs for standard connector handles (such as splits, table layouts, and transaction handles), and utility methods for binary serialization. Tests confirm that these components correctly serialize and deserialize connector handle types via Thrift.

presto-thrift-connector-toolkit · high confidence

New i18n plugin for Myanmar text encoding detection and normalization

The presto-i18n-functions module introduces a new plugin that registers two SQL scalar functions for handling Myanmar text. The \myanmar\_font\_encoding\ function analyzes input strings to determine whether they use Zawgyi or Unicode encoding, returning the detected type. The \myanmar\_normalize\_unicode\ function automatically converts Zawgyi-encoded text to normalized Unicode while leaving already-Unicode text unchanged, supporting multi-line inputs. These functions are provided via the \I18nFunctionsPlugin\ and rely on the \google.myanmartools\ library for detection and transliteration.

presto-i18n-functions · high confidence

New modular authentication framework for Hive and HDFS

The Hive connector now uses a new authentication module structure in \presto-hive/src/main/java/com/facebook/presto/hive/authentication\ that cleanly separates configuration and dependency injection for HDFS and Hive Metastore authentication. Users can now explicitly configure Kerberos credentials for the Hive Metastore client (\hive.metastore.client.principal\, \hive.metastore.client.keytab\) and the HDFS client (\hive.hdfs.presto.principal\, \hive.hdfs.presto.keytab\) via dedicated config classes. The system supports multiple authentication modes including no-auth, simple impersonation, and Kerberos (with or without impersonation) for both HDFS and the Metastore, wired together via \HiveAuthenticationModule\ and \AuthenticationModules\. Kerberos authentication is now cached via \CachingKerberosHadoopAuthentication\ to reduce ticket refresh overhead, and the Metastore client supports both Kerberos and token-based SASL authentication.

presto-hive/src/main/java/com/facebook/presto/hive/authentication · high confidence

New plan canonicalization strategies for history-based optimization

A new \PlanCanonicalizationStrategy\ enum has been introduced to support history-based optimization (HBO) by defining how query plans are normalized for comparison. The enum includes four strategies: \DEFAULT\ (minimal changes for basic nodes, used for fragment result caching), \CONNECTOR\ (connector-specific canonicalization for table scans, used for HBO), \IGNORE\_SAFE\_CONSTANTS\ (removes non-impacting constants like those in ProjectNodes but preserves FilterNode constants), and \IGNORE\_SCAN\_CONSTANTS\ (further relaxes canonicalization by ignoring constants in non-partitioned scan predicates). These strategies allow the optimizer to match historical execution plans more flexibly by ignoring irrelevant constant values while preserving those that affect plan statistics.

presto-common/src/main/java/com/facebook/presto/common/plan · high confidence

New plugin for native SQL-invoked array and map functions

A new plugin, NativeSqlInvokedFunctionsPlugin, has been added to the presto-sql-helpers directory to register SQL-invoked scalar functions for array and map operations. This plugin exposes functions such as array\_least\_frequent, array\_n\_least\_frequent, array\_top\_n (with a comparator), map\_top\_n\_keys, and map\_top\_n\_values, allowing users to perform frequency-based and sorted top-N selections on arrays and maps directly via SQL.

presto-sql-helpers/presto-native-sql-invoked-functions-plugin · high confidence

New segment reading infrastructure for Druid connector

The Druid connector now includes a new set of classes in the segment package to handle reading Druid data segments. This includes \DruidSegmentReader\ for batching and reading column data, \PrestoQueryableIndex\ as a wrapper for Druid's queryable index, and various sources like \HdfsDataInputSource\, \ZipIndexFileSource\, and \SmooshedColumnSource\ to access segment files from deep storage (HDFS, ZIP). The \V9SegmentIndexSource\ implements the logic to load and parse V9 format Druid segments, enabling the connector to read data from these specific segment structures.

presto-druid/src/main/java/com/facebook/presto/druid/segment · high confidence

New utility classes for backoff logic and safe MBean registration added to presto-common

The presto-common module now includes two new utility classes: Backoff, which provides configurable retry logic with exponential backoff delays and failure tracking for HTTP clients, and RebindSafeMBeanServer, a thread-safe wrapper around the JMX MBeanServer that prevents registration errors by returning existing instances when a duplicate registration is attempted. These utilities support more robust error handling and stability in components that rely on retry mechanisms and JMX metrics exposure.

presto-common/src/main/java/com/facebook/presto/common/util · high confidence

Partial aggregation pushdown for ORC files

The Hive connector now supports pushing down partial aggregation operations (COUNT, MIN, MAX) directly into the ORC file reader. This allows Presto to compute aggregate results by reading only the file footer statistics instead of scanning the full data, significantly reducing I/O and improving query performance for aggregation-heavy workloads on ORC tables.

presto-hive/src/main/java/com/facebook/presto/hive/orc · high confidence

Presto CLI output formatting and display overhaul

The Presto CLI now supports multiple output formats including aligned tables, vertical lists, JSON, CSV, and TSV, allowing users to choose the presentation style that best fits their workflow via the --output-format option. The new aligned table printer intelligently handles multi-line values and renders byte arrays as hex dumps for better readability. Additionally, the CLI introduces a tab-completion system for SQL commands and table names, a configurable pager for long result sets, and improved warning display with optional color coding on real terminals.

presto-cli/src/main · high confidence

Restored and expanded bytecode expression library

The presto-bytecode module has been restored to the main codebase, bringing back a comprehensive set of bytecode expression classes (such as And, Arithmetic, Cast, and Comparison) that enable the generation of Java bytecode for logical, arithmetic, and type-casting operations. This update also introduces new utility methods in BytecodeExpressions, including defaultValue for ParameterizedType and array constructor support, expanding the capabilities for generating default values and array operations.

presto-bytecode/src/main/java/com/facebook/presto/bytecode/expression · high confidence

Scaffolding for JDBC plan pushdown optimization

The JDBC connector now includes the initial implementation scaffolding for pushing down compute operations to the database. This change introduces the \JdbcComputePushdown\ optimizer, which translates filter predicates into SQL expressions via \JdbcFilterToSqlTranslator\, and registers this optimizer through the new \JdbcPlanOptimizerProvider\. While the logical plan optimizer list is currently empty, the physical plan optimizer is configured to apply these pushdown rules, laying the groundwork for improved query performance by offloading filtering to the underlying JDBC source.

presto-base-jdbc/src/main/java/com/facebook/presto/plugin/jdbc/optimization · high confidence

Support for MySQL-backed benchmark suite and query storage

The benchmark runner now supports sourcing benchmark suites and queries from a MySQL database. This change introduces a new MySQL-based supplier that uses Jdbi to read suite definitions, individual queries, and associated session properties from configurable database tables, allowing users to manage benchmark content externally via MySQL rather than relying on embedded or file-based sources.

presto-benchmark-runner/src/main/java/com/facebook/presto/benchmark/source · high confidence

Support for client-provided OAuth tokens in GCS access

Users can now authenticate with Google Cloud Storage using a client-provided OAuth access token instead of relying solely on service account JSON key files. This is enabled by setting the new \hive.gcs.use-access-token\ configuration option to true and providing the token via the \hive.gcs.oauth\ extra credential. When enabled, the system bypasses service account authentication and uses the provided token for GCS operations, offering an alternative authentication path for environments where service account keys are not preferred or available.

presto-hive/src/main/java/com/facebook/presto/hive/gcs · high confidence

Support for executing SQL functions via gRPC UDFs

The presto-grpc-api module now includes the infrastructure to execute SQL functions remotely as gRPC User-Defined Functions (UDFs). This change introduces a new gRPC service definition (GrpcUdfInvoke.proto) for invoking functions, a configuration class (GrpcSqlFunctionExecutionConfig) to set the gRPC address and page format, and a new executor (GrpcSqlFunctionExecutor) that handles the serialization of Presto pages, manages gRPC channels, and implements retry logic for remote function calls. A Guice module (GrpcSqlFunctionExecutionModule) wires these components together, binding the executor when gRPC UDF support is enabled.

presto-grpc-api · high confidence

TransactionId class added to presto-common with Thrift and JSON serialization support

The TransactionId class has been introduced in the presto-common module, providing a wrapper around UUIDs that supports both Thrift serialization (via @ThriftStruct, @ThriftConstructor, and @ThriftField annotations) and JSON serialization (via @JsonCreator and @JsonValue annotations). This enables TransactionId instances to be seamlessly transmitted over Thrift RPCs and serialized/deserialized in JSON payloads, facilitating interoperability between components that use different serialization protocols.

presto-common/src/main/java/com/facebook/presto/common/transaction · high confidence

Architecture

Function execution context and operator definitions moved to presto-common

The \OperatorType\ enum, \SqlFunctionProperties\ configuration class, and \SqlFunctionResult\ container have been moved from \presto-spi\ to \presto-common\. This centralizes the definitions for built-in operators (such as arithmetic and comparison operators) and the properties passed to SQL functions (including session settings like time zone, locale, and legacy behavior flags), making these core function execution components available to common modules rather than being isolated in the SPI layer.

presto-common/src/main/java/com/facebook/presto/common/function · high confidence

Hive connector security model refactored into pluggable modules

The Hive connector's security implementation has been restructured into a modular, pluggable architecture. The previous monolithic security logic is now split into distinct access control implementations—Legacy, File-based, Read-only, SQL-standard, and Ranger—which are registered via the new HiveSecurityModule. Administrators can now select the active security system using the hive.security configuration property (defaulting to legacy), allowing for easier migration to SQL-standard or Ranger-based access controls while maintaining backward compatibility with existing legacy configurations.

presto-hive/src/main/java/com/facebook/presto/hive/security · high confidence

Introduce presto-pinot-toolkit as a shared library for Pinot connector internals

The \presto-pinot-toolkit\ module is introduced to house shared implementation details for the Pinot connector, including core classes such as \PinotConnector\, \PinotConfig\, \PinotClusterInfoFetcher\, \PinotBrokerPageSource\, and various column and metadata handling utilities. This refactoring consolidates common logic—such as cluster info fetching, broker page sourcing, and type mapping—into a reusable library, enabling better modularity and separation of concerns for the Pinot connector's internal components.

presto-pinot-toolkit · high confidence

Predicate package moved to presto-common

The predicate package, including core classes like TupleDomain, Domain, ValueSet, and FilterFunction, has been moved to presto-common. This refactoring centralizes predicate logic, making it available as a shared component for other Presto modules.

presto-common/src/main/java/com/facebook/presto/common/predicate · high confidence

Refactored Hive connector base classes into presto-hive-common

The Hive connector's core abstractions have been consolidated into the new presto-hive-common module to support shared implementations across Hive and Iceberg. This change introduces base handle classes (BaseHiveTableHandle, BaseHiveColumnHandle, BaseHiveTableLayoutHandle) that standardize how table metadata, column definitions, and split layouts are represented. It also includes a new HiveCommonClientConfig and HiveCommonSessionProperties to centralize configuration for ORC and Parquet readers, as well as utility classes like MetadataUtils and PartitionSet to improve partition handling and metadata query optimization.

presto-hive-common/src/main/java/com/facebook/presto/hive · high confidence

Refactored type system with new abstract base classes

The type implementation hierarchy in presto-common has been restructured to improve code reuse and maintainability. New abstract base classes—AbstractType, AbstractPrimitiveType, AbstractIntType, AbstractLongType, AbstractVariableWidthType, and AbstractVarcharType—have been introduced to consolidate common logic for type signatures, block building, hashing, and comparison operations. Concrete types like BigintType, BooleanType, and CharType now extend these abstractions, reducing duplication across the type system.

presto-common/src/main/java/com/facebook/presto/common/type · high confidence

Behavioural changes

2105 commits (339 fixes) modifying presto-native-execution

A change to existing behaviour in presto-native-execution — 2105 commits (339 fixs), 861 files: “\[Native\] Replace deprecated node.ip with node.internal-address in NativeQueryRunner classes”; “\[native\] Assign createFinishTimeMs at point of task completion in prestoTask”; “\[native\] Advance velox and update memory code”; and 1855 more (refs \#28085, \#26353, \#27095, \#28292, \#25941, …).

presto-native-execution · medium confidence · unverified

The documentation sidebar now includes a direct link to the PrestoDB Slack community, allowing users to easily join the conversation. This change is implemented via a new table-of-contents template partial that also standardizes other sidebar actions like viewing page source, editing the page, and creating issues on GitHub.

_presto-docs/src/main/sphinx/\templates · high confidence

Added dummy class to ensure benchmark module jar creation

A new Dummy class was added to the presto-benchto-benchmarks module to force the creation of a JAR file, which is required for deploying the module to Nexus. This change ensures the module produces an artifact even if it contains no other code, supporting the build and publishing process.

presto-benchto-benchmarks/src/main/java · high confidence

Added legacy hostname verification support in Presto client

The Presto client now includes a \LegacyHostnameVerifier\ and \DistinguishedNameParser\ within the bundled OkHttp internals. This addition enables the client to verify SSL hostnames using legacy Common Name (CN) matching rules when a certificate lacks Subject Alternative Names (SANs), ensuring compatibility with servers that rely on older certificate configurations.

presto-client/src/main/java/okhttp · high confidence

ClickHouse connector adds case-sensitive name matching support

The ClickHouse connector now supports case-sensitive matching for schema and table names via the new \case-sensitive-name-matching\ configuration property. This feature allows users to preserve the exact casing of identifiers when querying ClickHouse, which is critical for databases containing names that differ only by case. The previous \clickhouse.case-insensitive\ configuration is now deprecated in favor of this new setting.

presto-clickhouse/src/main/java/com/facebook/presto/plugin/clickhouse · high confidence

Complete rewrite of the SQL parser and formatter using ANTLR 4

The presto-parser module has been replaced with a new implementation based on the ANTLR 4 grammar (SqlBase.g4). This change introduces a new AST structure and a dedicated SQL formatter (SqlFormatter) that handles the formatting of all supported statements, including DDL (CREATE/ALTER/DROP TABLE, SCHEMA, VIEW, FUNCTION, ROLE), DML (INSERT, UPDATE, DELETE, MERGE), and query operations. The new parser also supports advanced features such as window functions, prepared statements, and materialized views, while the formatter ensures consistent SQL output for these constructs.

presto-parser · high confidence

Enable parallel Maven builds with Smart Builder

The project now uses local Maven configuration to enable parallel builds by default. A new \.mvn/extensions.xml\ file adds the Takari Smart Builder and concurrent local repository extensions, while \.mvn/maven.config\ sets the thread count to \1C\ (one thread per core). Additionally, \.mvn/jvm.config\ increases the maximum heap size to 8GB to support the increased resource usage.

.mvn · high confidence

Example HTTP connector rewritten for new Presto SPI

The example-http connector has been completely rewritten to implement the latest Presto Service Provider Interface (SPI). This update introduces a new connector architecture using explicit handle classes (e.g., ExampleTableHandle, ExampleColumnHandle) and a dedicated handle resolver, replaces the generic getService pattern with specific manager providers, and adopts the TableLayout API for query planning. Additionally, the connector now supports lazy schema loading via an HTTP metadata endpoint and includes a shutdown hook for graceful lifecycle management.

presto-example-http/src/main · high confidence

Improved error handling and exception propagation for remote UDF execution

The remote UDF execution path now provides better visibility into failures by mapping Thrift service exceptions to Presto exceptions with preserved error codes and stack traces. A new ExceptionUtils class handles the conversion of Thrift UDF service errors, including suppressed exceptions and detailed stack trace elements, ensuring that users see meaningful error messages and debugging information when remote function calls fail.

presto-function-namespace-managers/src/main/java/com/facebook/presto/functionNamespace/execution · high confidence

Introduce DataSink and DataOutput abstractions for I/O operations

The presto-common module now provides new \DataSink\ and \DataOutput\ interfaces along with an \OutputStreamDataSink\ implementation to standardize how data is written to outputs. This change replaces the previous reliance on raw \OutputStream\ interfaces with a structured approach where data is batched via \DataOutput\ objects and written through a \DataSink\, enabling more flexible and consistent I/O handling across the system.

presto-common/src/main/java/com/facebook/presto/common/io · high confidence

Introduce Docker Compose-based product test environments

The product test execution model has shifted to use Docker Compose for managing infrastructure, replacing the previous manual or script-based container orchestration. This change introduces a standardized set of environment profiles (such as singlenode, multinode, multinode-tls, and various Kerberos/LDAP configurations) defined via reusable compose files and wrapper scripts. Users can now run tests against specific infrastructure setups using the new \compose.sh\ wrappers, which handle service discovery, container lifecycle, and environment-specific configurations like TLS keystores and Kerberos principals automatically.

presto-product-tests · high confidence

Introduce Presto on Spark query status and error code models

This change adds new data models to the Presto on Spark runtime to better expose query execution details and handle errors. PrestoSparkQueryStatusInfo now includes optional update information (UpdateInfo and updateCount) alongside standard query stats, allowing clients to see details for update operations. Additionally, a new PrestoSparkQueryData class is introduced to hold column and row data separately, and a SparkErrorCode enum defines specific error codes (such as executor OOM or storage errors) to provide more granular error reporting for Spark-specific failures.

presto-spark-common · high confidence

Introduce new memory tracking framework with tagged allocations and broadcast limits

The presto-memory-context module now uses a new memory tracking framework that requires allocation tags for memory reservations and enforces broadcast memory limits. This change introduces a hierarchical context structure (AggregatedMemoryContext, LocalMemoryContext, MemoryTrackingContext) to track user, revocable, and system memory separately, ensuring that queries are not blocked below a guaranteed memory threshold and that broadcast table memory usage is strictly limited during operations like lookup joins.

presto-memory-context · high confidence

Introduce typed column readers for the Druid connector

The Druid connector now uses a new set of column readers (StringColumnReader, DoubleColumnReader, FloatColumnReader, LongColumnReader, TimestampColumnReader) to read data from Druid segments. This change adds specific handling for VARCHAR, DOUBLE, REAL, BIGINT, and TIMESTAMP types, replacing previous generic or less structured reading logic. A SimpleReadableOffset helper is also added to support Druid's offset-based reading mechanism.

presto-druid/src/main/java/com/facebook/presto/druid/column · high confidence

Introduces caching layer for HDFS configurations

The Hive connector now uses a new \HiveCachingHdfsConfiguration\ implementation that wraps the standard HDFS configuration with a caching mechanism. This change introduces \CachingJobConf\ to reduce the overhead of creating Hadoop configuration objects and enables caching of file system instances, which can improve performance for repeated file access operations.

presto-hive/src/main/java/com/facebook/presto/hive/cache · high confidence

New Hive connector plan optimizer rules for filter, column, and aggregation pushdown

The Hive connector now includes a new set of plan optimizer rules in the \presto-hive/rule\ package to improve query performance. \HiveFilterPushdown\ pushes filter predicates down to the storage layer, while \HiveAddRequestedColumnsToLayout\ ensures only necessary columns are read. For Parquet tables, \HiveParquetDereferencePushDown\ optimizes access to nested fields, and \HivePartialAggregationPushdown\ pushes partial aggregation operations (like COUNT, MIN, MAX) to ORC, Parquet, and DWRF file formats. These optimizers are registered via \HivePlanOptimizerProvider\ and are disabled when native execution is enabled, as the native engine handles equivalent optimizations differently.

presto-hive/src/main/java/com/facebook/presto/hive/rule · high confidence

New JDBC read/write mapping infrastructure

The JDBC connector now uses a new mapping framework in the \presto-base-jdbc\ module to handle data conversion. This change introduces \ReadMapping\ and \WriteMapping\ classes along with specific function interfaces (such as \BooleanReadFunction\, \LongWriteFunction\, etc.) to define how data is read from and written to JDBC result sets and prepared statements. The \StandardColumnMappings\ class provides the default implementations for these mappings, establishing the foundation for how standard SQL types are translated to and from Presto types.

presto-base-jdbc/src/main/java/com/facebook/presto/plugin/jdbc/mapping · high confidence

New RCFile reader and writer implementations

The presto-rcfile module now uses new, standalone implementations for reading and writing RCFile format data, replacing the previous Hadoop-dependent code. This change introduces a new codec abstraction (RcFileCodecFactory) with implementations for both Hadoop codecs and the Airlift compress library, allowing for more flexible compression handling. The new reader and writer are designed to be independent of internal Presto representations and include improvements such as increased buffer sizes, better error categorization, and fixes for handling non-selected columns and old file headers.

presto-rcfile · high confidence

New batch-oriented Parquet reader with column pruning and compression support

The presto-parquet module introduces a new batch-oriented column reader architecture that significantly improves read performance and memory efficiency. This change adds support for reading Parquet files using batch readers for various data types (including Int32, Int64, Boolean, Binary, Decimal, and Timestamp), enabling subfield pruning and predicate pushdown optimizations. The implementation includes a new ColumnReader interface and factory, along with dedicated batch readers for flat and nested columns. Additionally, the module now supports LZ4 and ZSTD compression codecs, and introduces a new ParquetDataSource abstraction for file access. The reader also handles corrupted Parquet statistics more gracefully and includes optimizations for dictionary-based reads and page skipping using column indexes.

presto-parquet · high confidence

New query dispatch and memory management architecture

The query execution flow has been restructured to introduce a new \LocalDispatchQuery\ and \LocalDispatchQueryFactory\ that handle query prerequisites and state transitions before submission. Concurrently, the \MemoryRevokingScheduler\ has been updated to support per-query memory limits and configurable spilling strategies, while \SqlQueryManager\ now enforces limits on CPU time, scan bytes, output size, and intermediate written bytes via a dedicated management executor. These changes shift how queries are queued, tracked, and constrained, impacting query performance and resource utilization.

presto-main · high confidence

Presto documentation restructured with new theme and expanded content

The Presto documentation has been reorganized into a new, logical structure with dedicated sections for Administration, Clients, Connectors, Developer Guide, Functions, and more, replacing the previous layout. The build system has been upgraded to Sphinx 8.2.1 and the sphinx-immaterial theme (0.13.0), introducing a modern UI with dark mode support, copy buttons, and sticky TOC. This update also adds comprehensive documentation for Presto C++ (Prestissimo), including installation, features, and sidecar plugin details, while expanding coverage of SQL statements, security (OAuth2, LDAP), and various connectors.

presto-docs/src/main/sphinx · high confidence

Refactored Block implementations into new abstract base classes

The block implementations in presto-common have been restructured to use new abstract base classes (AbstractArrayBlock, AbstractMapBlock, AbstractRowBlock, and their single-value variants) to consolidate common logic for operations like copyPositions, getRegion, and size calculations. This change standardizes how array, map, and row blocks handle position selection, region extraction, and memory sizing, improving code reuse and consistency across the block hierarchy.

presto-common/src/main/java/com/facebook/presto/common/block · high confidence

Refactored Hive filter pushdown with new BaseSubfieldExtractionRewriter

The Hive connector's filter pushdown logic has been refactored to improve subfield extraction and warning handling. A new \BaseSubfieldExtractionRewriter\ class now centralizes the rewriting of filter and table scan plan nodes, handling the conversion of empty table scans to values nodes and managing unenforced constraints. Supporting utility methods have been moved to \FilterPushdownUtils\ to manage domain predicates and column name extraction for subfields. This change also improves the warning message when a TableScanNode is converted to a ValuesNode, providing clearer feedback for debugging query plans.

presto-hive-common/src/main/java/com/facebook/presto/hive/rule · high confidence

Refactored ORC reader and writer infrastructure with new caching and configuration abstractions

The ORC module has been restructured to improve memory management, caching, and configuration. A new \AbstractOrcDataSource\ and \CachingOrcDataSource\ provide a unified, cacheable interface for reading ORC file data, supporting lazy reads for small ranges and configurable buffer sizes. Stripe metadata is now managed via a \CachingStripeMetadataSource\ that caches footer slices, stream inputs, and row group indices to reduce redundant I/O. The writer configuration has been consolidated into a new \ColumnWriterOptions\ class, replacing previous scattered options, and the \DefaultOrcWriterFlushPolicy\ now explicitly manages stripe flushes based on row count, byte size, and dictionary fullness. Additionally, \ChunkedSliceOutput\ and \DecodeTimestampOptions\ introduce more efficient output buffering and precise microsecond timestamp decoding support.

presto-orc · high confidence

Restored bytecode instruction classes in presto-bytecode

The bytecode instruction classes in the presto-bytecode module (Constant, FieldInstruction, InvokeInstruction, JumpInstruction, LabelNode, TypeInstruction, and VariableInstruction) have been restored. These classes provide the core abstractions for generating JVM bytecode instructions, including loading constants, accessing fields, invoking methods and constructors, handling control flow with jumps and labels, managing object creation and casting, and manipulating local variables.

presto-bytecode/src/main/java/com/facebook/presto/bytecode/instruction · high confidence

Schema generation scripts moved to dedicated subdirectory

The TPC-DS and TPC-H schema generation scripts (generate-tpcds.py and generate-tpch.py) have been relocated into the presto-benchto-benchmarks/generate\_schemas subdirectory. This change reorganizes the benchmarking tooling structure without altering the functionality of the scripts, which continue to generate Hive schema and table creation statements for various data formats (ORC and TEXTFILE) and sizes.

_presto-benchto-benchmarks/generate\schemas · high confidence

The .agents/skills path is now a symbolic link pointing to ../.claude/skills, centralizing the location of agent skills within the .claude directory structure.

.agents · high confidence

TPC-H benchmark queries updated to v3.0.1 with standardized naming and table prefixes

The TPC-H benchmark suite in the Presto benchmarks module has been refreshed to align with the TPC-H v3.0.1 specification. Query files have been renamed to a consistent qXX format, and all table references now use a configurable prefix (e.g., ${prefix}lineitem) to support schema isolation. Additionally, specific queries have been corrected for compliance: Q02 now includes a LIMIT 100 clause as required by the standard, and Q22 uses the standard substr function instead of substring.

presto-benchto-benchmarks/src/main/resources/sql/presto/tpch · high confidence

TPC-H connector rewritten to use new Connector SPI with partitioning and statistics support

The TPC-H connector has been completely rewritten to implement the new Connector SPI, introducing support for table partitioning, predicate pushdown, and table statistics. Users can now configure column naming conventions (STANDARD or SIMPLIFIED) via the tpch.column-naming property, enable or disable partitioning and predicate pushdown via connector properties, and benefit from improved query planning through exposed table statistics and partition-aware split scheduling.

presto-tpch · high confidence

Updated Maven wrapper to version 3.9.12

The Maven wrapper configuration has been updated to use Maven distribution version 3.9.12 and the Maven Wrapper JAR version 3.2.0. This ensures that builds executed via the wrapper will consistently use these specific versions of the build tool and wrapper infrastructure, rather than relying on whatever version of Maven might be installed on the developer's machine.

.mvn/wrapper · high confidence

Test coverage

1 commit adding/updating tests in presto-hive/src/test/resources/quick\_stats; Add example data files for the HTTP example plugin; Add test coverage for Hive connector SSL, CTE execution, client operations, and table writability; Added Cassandra connector test infrastructure; Added Delta Lake test fixtures for checkpointing, complex types, and case-sensitive partitions; Added Docker-based end-to-end integration tests for Presto on Spark; Added Hive benchmarking infrastructure and optimizer performance tests; Added Parquet reader test suite and benchmarks; Added SQL test fixtures for Hive constraints, bucketing, and offline partitions; Added benchmark tests for CPU counters, decimal aggregation, statistical digests, and inequality joins; Added benchmarks and expanded tests for geometry serialization; Added benchmarks and unit tests for type signature parsing and type utilities; Added cost-based plan regression tests for TPC-DS and TPC-H workloads; Added empty Report class and corresponding test in presto-test-coverage module; Added integration and unit tests for the Presto Elasticsearch connector; Added integration tests for Hudi table support; Added integration tests for the Apache Accumulo connector; Added test containers for Hive with MinIO data lake and SSL/TLS support; Added test coverage for array and IP prefix scalar functions; Added test coverage for presto-common components; Added test fixtures for Delta Lake column mapping and protocol upgrades; Added test harness for Parquet schema conversion and writing; Added test infrastructure and coverage for the Arrow Flight connector; Added test infrastructure and test cases for the ClickHouse connector; Added test infrastructure for Hive S3 integration; Added test resources and documentation for Hudi integration testing; Added test resources for Hudi MOR partition path updates; Added test resources for Hudi Merge-on-Read Realtime table; Added test resources for non-partitioned Hudi Copy-On-Write table; Added test suite for the Atop connector; Added test utilities for benchmark runner setup; Added test utility for Cassandra driver compatibility; Added tests and benchmarks for the new Flatbush Hilbert RTree implementation; Added tests for AWS S3 security mapping configuration; Added tests for Accumulo row serializers; Added tests for BlackHole connector metadata operations; Added tests for File Merge Cache configuration and manager; Added tests for GeometryUtils and KdbTree spatial components; Added tests for Hive common configuration, AWS security mapping, and Z-Ordering; Added tests for Hive connector utility classes; Added tests for Hive quick statistics and partition sampling; Added tests for InMemoryCachingHiveMetastore cache behavior; Added tests for JSON-file and REST-based function namespace managers; Added tests for MySQL function namespace manager configuration and execution; Added tests for Parquet predicate utility functions; Added tests for Presto Accumulo connector model components; Added tests for Presto CLI output formatting and client options; Added tests for REST function executor routing; Added tests for Ranger-based access control configuration and enforcement; Added tests for RegexTemplate and benchmark test resources; Added tests for S3 Select pushdown and record reading components; Added tests for analyzer components; Added tests for benchmark runner JDBC action, configuration, and retry logic; Added tests for benchmark suite configuration and MySQL supplier; Added tests for cache configuration and utility functions; Added tests for external authentication in the Presto client; Added tests for legacy security configuration and access control implementations; Added tests for presto-client serialization and data handling; Added tests for presto-common array utilities; Added tests for presto-common predicate classes; Added tests for spatial join operations; Added tests for the Backoff utility class; Added tests for the Google Sheets connector; Added tests for the REST-based function server integration; Added tests for the benchmark runner framework; Added unit tests for AWS Glue metastore conversion and integration; Added unit tests for Alluxio cache configuration and file system behavior; Added unit tests for Cassandra connector utilities; Added unit tests for DruidIngestTask JSON serialization; Added unit tests for JDBC compute pushdown optimization; Added unit tests for SqlFunctionProperties equality; Added unit tests for bytecode utilities and class generation; Initial integration tests for the Delta Lake connector; Initial test suite for the Presto Druid connector; New Docker test container utilities for integration testing; New and updated integration test suites for aggregations, joins, and engine-only queries; New integration test infrastructure for Hive on Hadoop 2; New presto-native-tests module for end-to-end C++ validation; Presto UI testing infrastructure and component migration.

Dependencies

2713 commits updating dependencies (128 manifests)

A dependency / build maintenance change in (dependencies) — 2713 commits (243 fixs), 128 files: “Add unit test for learn aggregation”; “Prepare for next development iteration - 0.265-SNAPSHOT”; “chore: Address modernizer issues in presto-main-base (\#27874)”; and 2452 more (refs \#27874, \#27759, \#28043, \#27184, \#26931, …).

(dependencies) · high confidence · unverified

Vendor Base32 encoding implementation in presto-common

The presto-common module now includes a vendored copy of the Base32 codec (along with its BaseNCodec superclass and supporting utilities) extracted from Apache Commons Codec. This change removes the external dependency on the Apache Commons Codec library for Base32 operations, simplifying the dependency graph while providing RFC 4648-compliant encoding and decoding capabilities directly within the type encoding package.

presto-common/src/main/java/com/facebook/presto/common/type/encoding · high confidence

Housekeeping

Added dummy class to enable presto-thrift-spec module deployment

A new empty class, PrestoThriftSpecDummy, has been added to the presto-thrift-spec module. This change ensures that the module produces a JAR file, which is required to deploy the module to the Nexus repository.

presto-thrift-spec · high confidence

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

How this codebase got here

Score

  • CAI 40 → 45 (+5.1)
  • Rubric changed (rubric-2026.10.5 → rubric-2026.11.3) — scores are not directly comparable.

Lenses

  • Code Health 48 → 48 (-0.8)
  • Architecture 90 → 91 (+0.2)
  • Maturity 69 → 73 (+4.1)
  • Readiness 31 → 42 (+11.4)
  • Security 67 → 68 (+0.9)
  • Accessibility 33 → 36 (+3.0)
  • Performance 84 → 100 (+16.0)

Resolved (1181)

  • Boundary-crossing change coupling: PrestoSparkQueryExecutionFactory.java ↔ PrestoSparkRunner.java (presto-spark-base/src/main/java/com/facebook/presto/spark/PrestoSparkQueryExecutionFactory.java)
  • Boundary-crossing change coupling: SqlStandardAccessControl.java ↔ AccessControlManager.java (presto-hive/src/main/java/com/facebook/presto/hive/security/SqlStandardAccessControl.java)
  • Change coupling: SystemSessionProperties.java ↔ Expressions.java (presto-main-base/src/main/java/com/facebook/presto/SystemSessionProperties.java)
  • Change-coupling hub: IcebergUtil.java → IcebergFileWriterFactory.java, IcebergHiveMetadataFactory.java, IcebergPlanOptimizerProvider.java (presto-iceberg/src/main/java/com/facebook/presto/iceberg/IcebergUtil.java)
  • Change-coupling hub: OrcBatchPageSourceFactory.java → HiveSelectivePageSourceFactory.java, DwrfSelectivePageSourceFactory.java, OrcSelectivePageSourceFactory.java (presto-hive/src/main/java/com/facebook/presto/hive/orc/OrcBatchPageSourceFactory.java)
  • Change-coupling hub: PlanOptimizers.java → SystemSessionProperties.java, PlannerUtils.java, Patterns.java, Expressions.java (presto-main-base/src/main/java/com/facebook/presto/sql/planner/PlanOptimizers.java)
  • Dependency hygiene PARTLY measured — Maven/Gradle declarations read, no dependency graph resolved
  • Documentation: contradicts the code (presto-native-execution/presto_cpp/docs/README.md)
  • Duplicated block (10 lines × 2) (presto-hive-function-namespace/src/main/java/com/facebook/presto/hive/functions/gen/AccumulatorCompiler.java)
  • Duplicated block (10 lines × 2) (presto-iceberg/src/main/java/com/facebook/presto/iceberg/optimizer/IcebergMetadataOptimizer.java)
  • Duplicated block (10 lines × 3) (presto-main-base/src/main/java/com/facebook/presto/execution/AddColumnTask.java)
  • Duplicated block (11 lines × 2) (presto-hive-function-namespace/src/main/java/com/facebook/presto/hive/functions/gen/AccumulatorCompiler.java)
  • Duplicated block (11 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/operator/scalar/ArrayConcatFunction.java)
  • Duplicated block (11 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/type/DecimalOperators.java)
  • Duplicated block (11 lines × 2) (presto-pinot-toolkit/src/main/java/com/facebook/presto/pinot/auth/PinotBrokerAuthenticationProvider.java)
  • Duplicated block (11 lines × 6) (presto-parquet/src/main/java/com/facebook/presto/parquet/batchreader/BinaryNestedBatchReader.java)
  • Duplicated block (12 lines × 2) (presto-druid/src/main/java/com/facebook/presto/druid/DruidPlanOptimizer.java)
  • Duplicated block (12 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/execution/AddColumnTask.java)
  • Duplicated block (12 lines × 2) (presto-orc/src/main/java/com/facebook/presto/orc/reader/LongSelectiveStreamReader.java)
  • Duplicated block (13 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/server/GracefulShutdownHandler.java)
  • …and 1161 more

New (1989)

  • Boundary-crossing change coupling: StatsRecordingMetadataManager.java ↔ AstBuilder.java (presto-main-base/src/main/java/com/facebook/presto/metadata/StatsRecordingMetadataManager.java)
  • Change coupling: HiveSelectivePageSourceFactory.java ↔ OrcBatchPageSourceFactory.java (presto-hive/src/main/java/com/facebook/presto/hive/HiveSelectivePageSourceFactory.java)
  • Change coupling: IcebergFileWriterFactory.java ↔ IcebergUtil.java (presto-iceberg/src/main/java/com/facebook/presto/iceberg/IcebergFileWriterFactory.java)
  • Change coupling: IcebergUtil.java ↔ IcebergPlanOptimizerProvider.java (presto-iceberg/src/main/java/com/facebook/presto/iceberg/IcebergUtil.java)
  • Change coupling: OrcBatchPageSourceFactory.java ↔ OrcSelectivePageSourceFactory.java (presto-hive/src/main/java/com/facebook/presto/hive/orc/OrcBatchPageSourceFactory.java)
  • Change-coupling hub: PlanOptimizers.java → SystemSessionProperties.java, PlannerUtils.java, Patterns.java (presto-main-base/src/main/java/com/facebook/presto/sql/planner/PlanOptimizers.java)
  • ClassTooLong: DelegatingMetadataManager (presto-main-base/src/main/java/com/facebook/presto/metadata/DelegatingMetadataManager.java)
  • ClassTooLong: MaterializedViewColumnMappingExtractor (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/MaterializedViewColumnMappingExtractor.java)
  • Dependency hygiene PARTLY measured — Maven build resolved part of the dependency graph, currency reported but not scored
  • DropColumnTask.execute (cognitive 17) (presto-main-base/src/main/java/com/facebook/presto/execution/DropColumnTask.java)
  • Duplicated block (10 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java)
  • Duplicated block (11 lines × 2) (presto-iceberg/src/main/java/com/facebook/presto/iceberg/IcebergAbstractMetadata.java)
  • Duplicated block (11–12 lines × 3) (presto-main-base/src/main/java/com/facebook/presto/operator/scalar/MapFilterFunction.java)
  • Duplicated block (15–16 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/execution/AddColumnTask.java)
  • Duplicated block (24 lines × 6) (presto-parquet/src/main/java/com/facebook/presto/parquet/batchreader/BinaryNestedBatchReader.java)
  • Duplicated block (6 lines × 2) (presto-iceberg/src/main/java/com/facebook/presto/iceberg/IcebergAbstractMetadata.java)
  • Duplicated block (6 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/MaterializedViewColumnMappingExtractor.java)
  • Duplicated block (7 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java)
  • Duplicated block (7 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java)
  • Duplicated block (7 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/MaterializedViewColumnMappingExtractor.java)
  • …and 1969 more

Changes since last survey

  • 55 commits — 40 feature/other, 15 fixes

By area

  • presto-iceberg/src — 8 commits
  • presto-main-base/src — 8 commits
  • presto-native-execution/presto_cpp — 7 commits
  • presto-native-execution/velox — 6 commits
  • presto-docs/src — 5 commits
  • presto-ui/src — 5 commits
  • (root) — 3 commits
  • presto-native-execution/src — 3 commits
  • presto-main/src — 2 commits
  • presto-native-tests/src — 2 commits
  • presto-mysql/pom.xml — 1 commit
  • presto-native-execution/scripts — 1 commit
  • presto-parser/src — 1 commit
  • presto-spark-base/src — 1 commit
  • presto-spi/src — 1 commit
  • presto-verifier/src — 1 commit

Notable commits

  • fix: fix(native): Remove unused materialized output constant (#28790) (#28790)
  • fix: fix(native): Return stored row lineage values for projected columns (#28745)
  • fix: fix(plugin-iceberg): Fix V3 deletion-vector DML on transform-partitioned tables and multi-task deletes (#28727) (#28727)
  • fix: fix(plugin-iceberg): Fix _last_updated_sequence_number split pruning (#28747)
  • fix: fix(plugin-iceberg): Fix delete stats with row lineage predicates (#28744)
  • fix: fix(plugin-iceberg): Ignore row lineage stats in Parquet and ORC (#28746)
  • fix: fix(plugin-jdbc): Package geometry runtime dependencies (#28748)
  • fix: fix(scheduler): Preserve split scheduling order (#28657)
  • fix: fix(security): Bump fast-uri to 3.1.9 for fixing [CVE redacted], [CVE redacted], [CVE redacted], [CVE redacted] in presto-ui (#28713)
  • fix: fix(security): Set SameSite=Lax on OAuth2 web UI cookies (#28764)
  • fix: fix(security): Upgrade redshift-jdbc42 and commons-codec to address open high CVEs (#28792)
  • fix: fix(security): Upgrade snappy-java version to 1.1.10.12 to address CVEs (#28735)
  • fix: fix(testing): Fail explain verification on plan structure mismatches (#28757) (#28757)
  • fix: test(plugin-iceberg): Add V3 DV iceberg regression tests for Prestissimo PR #28182 (#28673)
  • fix: test: Add regression test for equality delete on column added by later split (#28445)
  • change: build(native): Use rapids-cmake to configure CUDA architectures for GPU builds (#27975)
  • change: build: Move presto-spark-classloader modules to always-active modules so release tooling bumps them (#27750) (#27750)
  • change: chore(ci): Advance velox (#28714)
  • change: chore(ci): Advance velox (#28715)
  • change: chore(ci): Advance velox (#28732)
  • …and 35 more

Architecture

  • Containers 0 added · 0 removed · contexts 0 added · 0 removed · edges 1 added · 33 removed

Added dependency edges (1)

  • redis-hbo-provider → presto-spi

Removed dependency edges (was a dependency, now gone) (33)

  • presto-accumulo → redis-hbo-provider
  • presto-analyzer → redis-hbo-provider (coupling)
  • presto-base-jdbc → redis-hbo-provider
  • presto-clickhouse → redis-hbo-provider
  • presto-common → redis-hbo-provider
  • presto-delta → redis-hbo-provider
  • presto-druid → redis-hbo-provider
  • presto-expressions → redis-hbo-provider
  • presto-function-namespace-managers-common → redis-hbo-provider (coupling)
  • presto-geospatial-toolkit → redis-hbo-provider
  • presto-hive → redis-hbo-provider (coupling)
  • presto-hive-common → redis-hbo-provider
  • presto-hive-function-namespace → redis-hbo-provider (coupling)
  • presto-hive-metastore → redis-hbo-provider (coupling)
  • presto-iceberg → redis-hbo-provider (coupling)
  • presto-jdbc → redis-hbo-provider
  • presto-kafka → redis-hbo-provider
  • presto-main → redis-hbo-provider (coupling)
  • presto-main-base → redis-hbo-provider (coupling)
  • presto-native-sidecar-plugin → redis-hbo-provider (coupling)
  • …and 13 more

Written by cca.canine.dev from the codebase's own history, inside the signed delivery this page is composed from.

Survey your own repository

prestodb/presto was measured the same way every project in this corpus was: the same rubric, at a pinned commit, with the result published in full. Point a surveyor at a repository you know and see whether you agree with it.

About this page

  • The score is its most recent published measurement, taken on 13 November 2026 at a pinned commit. It is not a live figure and does not change until the project is measured again.
  • Measured at commit 30c16358fc2626da721913a750ed0fbb96e1e34e — the exact code this score is about.
  • Scored under rubric-2026.11.3 — the same rubric and the same method as every other entry in this index.
  • Measured by Canine Code Analyzer (cca.canine.dev) using cca measure-2026.11.61+preprod-f3449e6eb431.