prestodb/presto

This system is a distributed SQL query engine that provides a unified interface for querying diverse data sources, including databases, object storage, and streaming platforms. It supports a wide range of connectors for data ingestion and export, such as Hive, Iceberg, Delta Lake, and various cloud storage services. The platform also includes robust benchmarking tools for performance testing and a modular architecture that allows for extensible function namespaces and caching strategies.

74 changes.

This period focused on modernizing the codebase's architecture and expanding data connectivity. The project introduced a new bytecode generation library, refactored the SQL parser and CLI output handling, and standardized the connector SPI across multiple data sources including Hive, Cassandra, and MongoDB. Additionally, the scope broadened to include new connectors for Google Sheets, Accumulo, and local files, alongside significant improvements to security, testing, and documentation.

98 changes.

This period focused on significantly expanding the connector ecosystem by adding support for SQL Server, Kudu, Pinot, and Elasticsearch, alongside deepening integrations with Druid, Hive, and Spark. Concurrently, the project established a robust benchmarking framework and introduced new data caching mechanisms to improve performance and testing capabilities.

77 changes.

This period focused on expanding the connector ecosystem with support for Delta Lake, Hudi, ClickHouse, and Prometheus, alongside significant refactoring of the Iceberg connector for V3 and native execution. Concurrently, the codebase advanced native execution capabilities through the Velox integration, gRPC-based function execution, and a dedicated native test suite. The work also established new infrastructure for session management, external authentication, and distributed tracing.

9 changes.

This period focused on enabling efficient data exchange and secure internal communication through the introduction of Apache Arrow-based federation via the FlightShim service and Arrow data conversion utilities. Concurrently, the codebase expanded its storage and connectivity capabilities by adding support for Lance datasets, Azure Blob Storage, and a generic Thrift codec toolkit. The release also established a new internal authentication mechanism using JWT and shared secrets to protect Presto's internal HTTP endpoints.

Introduces a new AWS security mapping system that allows Presto to map users to AWS IAM roles or basic access/secret keys via a configurable JSON file, supporting S3 and Lake Formation mapping types. Additionally, adds a new metrics publisher (AwsSdkClientStats) to track AWS SDK v2 client statistics such as request counts, retry counts, throttle exceptions, and call durations.

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

Users can now connect Presto to an Apache Accumulo data store. This change introduces the \presto-accumulo\ module, which provides a new connector that enables querying and writing to Accumulo tables. The implementation includes the core connector classes (such as \AccumuloConnector\, \AccumuloMetadata\, and \AccumuloClient\) and registers the connector via the \AccumuloPlugin\. This allows users to interact with Accumulo data sources using standard SQL queries.

presto-accumulo/src/main · high confidence

Introduces a new BlackHole connector that generates synthetic data for testing and development. The connector supports configurable table properties including split count, pages per split, rows per page, and field length. It also supports a page processing delay to simulate latency. The implementation includes all necessary components: connector, metadata, split manager, page source/sink providers, and handle classes.

presto-blackhole/src/main · high confidence

Introduces a new command-line interface for running benchmarks against a Presto cluster. The \PrestoBenchmarkDriver\ CLI accepts options for server address, user, catalog, schema, session properties, and query selection. It executes specified SQL queries from template files, measures wall time and CPU usage, and prints tabular benchmark results to the console.

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

The repository now includes a Dockerfile and associated build scripts (build.sh, entrypoint.sh) to construct the Presto Server and CLI Docker images. The image is based on CentOS Stream 9, bundles the Presto server and CLI, and includes the Prometheus JMX Exporter (v0.20.0) for metrics. The build script supports multi-architecture builds (amd64, arm64, ppc64le) and exposes port 8080 with a volume for data persistence.

docker · high confidence

Users can now connect Presto to Google Sheets. This change introduces a new 'gsheets' connector that allows querying Google Sheets as tables. The connector requires configuration of a credentials file path and a metadata sheet ID, and supports caching of sheet data with configurable expiration and size limits. It implements the standard Presto connector SPI, including metadata, split, and record set providers, enabling users to run SQL queries against their Google Sheets data.

(repo-wide) · high confidence

The benchmark runner now executes queries against a Presto cluster using a JDBC connection, configurable via \jdbc-url\ and \query-timeout\. This introduces a new \BenchmarkPrestoActionFactory\ that creates \JdbcPrestoAction\ instances, which handle query execution, progress monitoring, and exception classification for both cluster connection issues and standard Presto/Hive/JDBC/Thrift error codes.

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

Presto now supports defining functions via JSON files. A new \JsonFileBasedFunctionNamespaceManager\ loads function metadata from a configured path (file or directory), allowing users to manage function definitions using JSON. The implementation supports variable-arity functions with 'any' typed tails and UDAF (User-Defined Aggregate Function) support, providing an alternative to SQL-based function registration.

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

The Presto Hive connector now supports S3 Select pushdown for JSON data, in addition to the existing CSV support. This change introduces new classes in the \com.facebook.presto.hive.s3select\ package, including \S3SelectJsonRecordReader\ and \S3SelectCsvRecordReader\, which handle input and output serialization for their respective formats. A new \S3SelectDataType\ enum and \S3SelectSerDeDataTypeMapper\ map Hive SerDe classes (such as \JsonSerDe\) to the corresponding S3 Select data types. The \S3SelectPushdown\ class defines the rules for enabling pushdown, and the \S3SelectRecordCursor\ handles the resulting data. This allows queries against S3 objects to be filtered and projected at the storage layer, improving performance.

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

Added new SQL benchmark scripts for Presto/Kafka, including count.sql for total row counts and count\column\\*.sql files that count rows across 1, 10, and 100 columns (bigint, double, and varchar types).

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

Users can now connect to Apache Kudu clusters using the new Kudu connector. This includes support for Kerberos authentication, allowing secure connections to protected Kudu clusters. The connector also enables schema emulation, where Presto catalogs can be mapped to Kudu tables using configurable prefixes, and provides configuration options for timeouts, statistics, and schema emulation behavior.

presto-kudu · high confidence

Users can now connect to MongoDB databases using the new \presto-mongodb\ connector. This feature introduces a full-featured connector implementation including configuration for TLS/SSL connections (keystore/truststore paths and passwords), read preference tags, and case-sensitive name matching. The connector supports reading and writing data, with specific handling for various data types including ObjectIds, JSON, and complex nested structures.

presto-mongodb · high confidence

Users can now connect to MySQL databases using the new MySQL JDBC connector. This feature introduces the \MySqlClient\, \MySqlConfig\, and \MySqlPlugin\ classes, enabling read and write operations, mixed-case identifier support, and specific type mappings (e.g., \REAL\ to \float\, \TIMESTAMP\ to \datetime(6)\). The connector also supports credential passthrough and configurable connection properties like auto-reconnect and connection timeouts.

presto-mysql · high confidence

The benchmark runner now supports loading benchmark suites and queries from a MySQL database. This change introduces a new data source layer (AbstractJdbiBenchmarkSuiteSupplier, BenchmarkSuiteDao, and related mappers) that queries MySQL tables for suite definitions and SQL queries, allowing users to manage benchmark configurations in a database rather than static files or memory.

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

Introduces a new MySQL-based function namespace manager, enabling users to store and manage SQL-invoked functions and user-defined types in a MySQL database. This includes the \MySqlFunctionNamespaceManager\ and supporting classes for database connectivity, data access, and configuration, allowing Presto to persist function metadata in MySQL.

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

Users can now detect whether Myanmar text uses the Zawgyi or Unicode font encoding and normalize Zawgyi text to standard Unicode. The new \myanmar\_font\_encoding\ function returns 'zawgyi' or 'unicode' based on the input string, while \myanmar\_normalize\_unicode\ converts Zawgyi-encoded strings to their Unicode equivalents, handling multi-line inputs. These functions are provided by the new \I18nFunctionsPlugin\ in the \presto-i18n-functions\ module.

presto-i18n-functions · high confidence

A new OpenLineage event listener plugin has been added to Presto, enabling automatic emission of OpenLineage events for query lifecycle and column lineage. The plugin supports HTTP and console transports, allows configuration of namespaces, query types, and disabled facets, and includes a format interpolator for customizing job names. Tests verify column lineage emission, including direct and indirect transformations.

presto-openlineage-event-listener · high confidence

Presto now includes an OpenTelemetry plugin that provides distributed tracing capabilities. The new \OpenTelemetryPlugin\ registers a \TracerProvider\ that supports context propagation via the B3 single-header format, with a fallback to W3C trace context propagation. This enables users to trace requests across their Presto instances using OpenTelemetry standards.

presto-open-telemetry · high confidence

The Presto Pinot connector is introduced as a new plugin, registering the \PinotConnectorFactory\ and exposing the \PinotFunctions\ class. This includes a new SQL function, \pinot\_binary\_decimal\_to\_double\, which converts binary data representing a decimal number into a double-precision floating-point value, with configurable radix, scale, and null-handling behavior.

presto-pinot · high confidence

A new abstract class, PreparedQuery, has been added to the analyzer package. This class encapsulates formatted SQL and prepare SQL strings, and provides methods to inspect statement types, including rollback, transaction control, and explain type validation. This serves as a base for analyzing SQL statements within the query analyzer.

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

Added the Presto logo files (including \FB\_Presto\_Logo\_PRINT\_DarkBG.ai\ and \FB\_Presto\_Logo\_PRINT\_LightBG.ai\) and a design diagram (\design.graffle\) to the \presto-docs/src/main/resources\ directory. These assets are now available for use in Presto's documentation.

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

A new proxy service has been added to the Presto proxy component, allowing clients to securely access a remote Presto server without direct access. The proxy natively understands the Presto protocol and rewrites the 'nextUri' in response payloads to point to the proxy rather than the remote server. It supports generating JWT access tokens containing the principal from the TLS client certificate, enabling secure environments without explicit username and principal validation. Configuration options include the remote Presto URI, a shared secret file for authenticating URIs, and an async timeout. The implementation includes a REST endpoint for proxying requests, handling GET, POST, and DELETE operations, and forwarding the X-Forwarded-For header. Tests verify configuration mapping and server functionality.

presto-proxy · high confidence

Users can now connect Presto to a Prometheus instance to query time-series metrics. The new connector supports TLS-encrypted communication with the Prometheus server, configurable query chunking and caching durations, and an optional case-sensitive identifier matching mode. The connector exposes three columns per table: labels (map), timestamp (timestamp with time zone), and value (double).

presto-prometheus · high confidence

Introduces a new REST-based implementation for managing and executing SQL-invoked functions. This includes a \RestBasedFunctionNamespaceManager\ that fetches function metadata from a configurable REST server, a \RestSqlFunctionExecutor\ that routes function calls to that server, and the associated Guice modules and configuration classes. This enables users to store and retrieve function definitions via a REST API rather than relying solely on the default SQL-based namespace manager.

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

Users can now configure the Hive connector to enforce authorization policies from Apache Ranger. This change introduces a new \RangerBasedAccessControl\ implementation that fetches policies and user/group mappings from the Ranger REST API, allowing administrators to manage fine-grained access control for Hive tables and columns through Ranger's centralized policy engine.

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

Introduces a new Redis-based implementation for storing and retrieving historical plan statistics. The change adds a complete plugin (RedisProviderPlugin) and supporting classes (RedisPlanStatisticsProvider, RedisProviderConfig, etc.) that allow Presto to persist and fetch plan statistics from a Redis cluster or standalone instance. This enables the use of historical statistics for query optimization by storing execution metrics in Redis, with configuration options for server URI, timeouts, TTL, and cluster mode.

redis-hbo-provider · high confidence

Users can now connect to Microsoft SQL Server databases using the new SQL Server connector. This adds a new plugin that registers the \SqlServerClient\ and \SqlServerPlugin\, enabling SQL Server as a supported JDBC data source. The implementation includes specific handling for SQL Server's \sp\_rename\ stored procedures for table and column renaming, and supports the \system.execute\ procedure for running arbitrary SQL statements.

presto-sqlserver · high confidence

A new SQL file, session\_set\_cbo\_flags.sql, was added to the Presto benchmarks to configure session variables for cost-based optimization, specifically setting join\_reordering\_strategy and join\_distribution\_type.

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

The Druid connector now supports TLS configuration and HTTP Basic authentication. Users can enable TLS by setting the truststore path and password, and can configure HTTP Basic authentication by providing a username and password. The authentication module conditionally binds either no authentication, Basic authentication, or Kerberos authentication based on the DruidConfig settings.

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

Introduces a new TPC-DS connector for Presto, enabling users to query TPC-DS benchmark data. The connector includes metadata, split management, and record set providers, along with support for table and column statistics to improve query planning. Configuration options allow users to specify the number of splits per node and choose between char or varchar data types, with a specific requirement to use varchar types for native execution.

presto-tpcds · high confidence

Presto now supports Teradata-compatible date and string functions, including to\_char, to\_date, to\_timestamp, index, substring, and char2hexint. Users can format and parse timestamps using custom date format strings, locate substrings, and convert strings to hexadecimal representations.

presto-teradata-functions · high confidence

The presto-thrift-testing-udf-server module was introduced, providing a standalone Thrift server for testing UDFs. The server implements the ThriftUdfService interface, specifically the EchoFirstInputThriftUdfService, which returns the first input parameter as the result. It supports both Presto serialized Page format and PrestoThriftPage formats, handling deserialization and serialization of page data. The server is configured via config.properties (defaulting to port 7779) and uses Airlift for bootstrapping with DriftNettyServerModule.

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

A new Thrift service definition file (PrestoThriftService.thrift) has been added to the documentation sources. This file defines the data structures and enums used by the Presto Thrift connector, including metadata for schemas, tables, columns, and various value sets (e.g., integer, double, varchar, json). This provides the interface specification for the connector's external communication.

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

Introduces a new database-backed implementation for managing session properties in Presto. This change adds a new module containing the \DbSessionPropertyManager\ and its associated components (including a \SessionPropertiesDao\ for database interactions and a \RefreshingDbSpecsProvider\ for periodic spec loading). The implementation supports configuration via \session-property-manager.db.url\, \session-property-manager.db.driver-name\, and \session-property-manager.db.refresh-period\ properties, enabling dynamic session property overrides stored in a database.

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

The Docker image now includes default configuration files to support immediate usage. This includes example settings for the coordinator (config.properties.example), JVM options for Java 17 (jvm.config.example), node identity and environment settings (node.properties), and pre-configured connectors for JMX, memory, TPC-DS, and TPC-H (catalog/\*.properties).

docker/etc · high confidence

The Presto Router now includes an example custom scheduler plugin (presto-router-example-plugin-scheduler) that demonstrates how to implement a metrics-based scheduling strategy. This new plugin, consisting of the \RouterSchedulerPlugin\, \MetricsBasedSchedulerFactory\, and \MetricsBasedScheduler\ classes, selects the destination cluster by choosing the one with the fewest active and queued queries. The change also adds a corresponding unit test to verify the scheduler's selection logic.

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

Users can now authenticate against a local file or an LDAP server. The new file-based authenticator reads a password file (format: username:hash) and supports BCrypt and PBKDF2 password hashing algorithms, with configurable refresh periods and cache sizes. The LDAP authenticator allows binding to an LDAP server for user authentication and optional group authorization checks, requiring LDAPS connections. Both plugins are registered via the new PasswordAuthenticatorPlugin, which exposes the 'file' and 'ldap' authenticator factories to the system.

presto-password-authenticators · high confidence

Presto now supports two cluster TTL providers: an 'infinite' provider that returns an indefinite TTL, and a 'percentile' provider that calculates the cluster TTL based on a configurable percentile of node TTLs. Additionally, an 'infinite' node TTL fetcher is introduced, which returns an indefinite TTL for each node. These components are registered via new plugin classes in the presto-cluster-ttl-providers and presto-node-ttl-fetchers modules.

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

Introduces a new local file connector that allows querying local log files (such as HTTP request logs) as tables within Presto. The connector supports glob patterns to match file names within a directory, caches file listings for 10 seconds, and maps log fields to columns including server address and timestamp. It provides a straightforward way to analyze local log data using SQL.

presto-local-file · high confidence

The presto-ml module now includes aggregation functions to train Support Vector Machine (SVM) models for classification and regression tasks. Users can use learn\_classifier and learn\_regressor to train models, with support for both numeric and string labels. The update also introduces evaluate\_classifier\_predictions to assess model accuracy, precision, and recall. Additionally, feature transformations such as unit normalization are now available for preprocessing data before training.

presto-ml · high confidence

The presto-native-sql-invoked-functions-plugin now includes new SQL-invoked scalar functions for array and map operations. Users can use array\_least\_frequent, array\_n\_least\_frequent, array\_top\_n, map\_top\_n\_keys, and map\_top\_n\_values, which are registered via the NativeSqlInvokedFunctionsPlugin.

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

New classes were added to the Presto-Spark classloader interface for both Spark 2 and Spark 3, including a custom shuffle manager (PrestoSparkNativeExecutionShuffleManager) that intercepts Spark's shuffle workflow to support native execution. The implementation registers and captures shuffle metadata, providing APIs for the native execution runtime to access this information. Utility classes (PrestoSparkUtils, ScalaUtils) and ordering classes (MutablePartitionId, MutablePartitionIdOrdering) were also added to support these changes.

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

The Hive connector now supports writing to and reading from encrypted DWRF (Data Warehouse Reference Format) files. This feature allows users to store sensitive data in Hive tables with encryption at rest, ensuring that the data is protected while stored on the underlying file system. The implementation includes new classes to handle encryption information and integrate with the ORC/DWRF writer, enabling secure data storage for users who require encrypted table formats.

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

The Presto Hive connector now supports authenticating with Google Cloud Storage using client-provided OAuth2 access tokens. This change introduces a new configuration option, hive.gcs.use-access-token, which, when enabled, allows Presto to use an external OAuth2 token for GCS access, providing an alternative to service account key files.

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

The Hive connector now supports reading data from Amazon S3, enabling users to query tables stored in S3 buckets. This change introduces the necessary infrastructure and tests to facilitate S3-based Hive table access.

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

Added new classes in the presto-common-arrow module to support Apache Arrow data exchange, including ArrowBatchSource, ArrowBlockBuilder, and BlockArrowWriter. These components handle the conversion between Presto internal block formats and Apache Arrow VectorSchemaRoot structures, enabling efficient data transfer for connector federation scenarios.

presto-common-arrow · high confidence

Users can now query system uptime and reboot history via the new 'atop' connector. This connector reads data from the 'atop' executable, supporting configuration for executable path, timezone, read timeout, and security settings (none or file-based access control). The implementation includes all necessary SPI components: metadata, split management, page sourcing, and handle resolution, enabling Presto to treat atop data as standard tables.

presto-atop/src/main · high confidence

The Presto ClickHouse connector now includes a suite of new classes in the \optimization\ package to handle query plan optimization and SQL generation. This includes \ClickHouseComputePushdown\ for pushing down filters and aggregations, \ClickHouseQueryGenerator\ to generate ClickHouse-compatible SQL, and various expression converters (\ClickHouseFilterExpressionConverter\, \ClickHouseProjectExpressionConverter\, \ClickHouseFilterToSqlTranslator\) that translate internal Presto expressions into ClickHouse SQL syntax. These changes enable more efficient query execution by delegating more processing to the ClickHouse database.

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

A new static RTree implementation named Flatbush is now available in the geospatial toolkit. It uses a Hilbert curve index to sort and pack spatial data into a flat array, providing a low-memory, high-performance alternative for spatial indexing that cannot be modified after construction.

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

A new service provider file has been added to register the Presto Spark service factory, enabling the framework to locate and instantiate the specific Presto Spark implementation via the Java Service Provider Interface.

presto-spark · high confidence

Added SQL query files (q01.sql through q23\_2.sql) for the TPC-DS benchmark suite, providing a comprehensive set of complex analytical queries for performance testing.

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

A new testing server has been added to the codebase, providing a Thrift-based interface to the TPCH (Tech Power House) dataset. This server exposes schema and table metadata, supports standard split generation, and implements index-based lookups for optimized data retrieval. The implementation includes the core server logic, configuration files, and a dedicated record set for handling indexed data lookups, all designed to facilitate testing of the Thrift connector.

presto-thrift-testing-server · high confidence

The Presto Hive common library now includes new classes to support Z-Order curve operations on integer data. Specifically, \ZOrder\ provides functions to encode and decode integer columns into a single dimensional z-address, with support for both positive-only and signed integers. Additionally, \ZAddressRange\ and \ZValueRange\ classes have been introduced to manage address ranges and value ranges respectively, enabling more efficient data locality preservation for multidimensional queries.

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

The presto-bytecode module now includes new classes for generating control flow in bytecode: CaseStatement, DoWhileLoop, ForLoop, IfStatement, SwitchStatement, TryCatch, and WhileLoop, along with the FlowControl interface. These classes provide a structured way to generate loops, conditionals, and try-catch blocks in the bytecode, enabling more complex control flow structures in generated code.

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

The Presto Hive connector now supports Azure Blob Storage (WASB) and ADLS Gen2 (ABFS/ABFSS) filesystems. New configuration options allow users to specify storage accounts, access keys, and OAuth2 credentials for ABFS, while the \HiveAzureModule\ registers the necessary filesystem implementations and configuration initializers to enable these storage backends.

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

Added example configuration files for various data connectors, including access-control.properties, and catalog configurations for blackhole, delta, druid, example, hana, hive, hudi, iceberg, jmx, localfile, memory, mysql, pinot, postgresql, prometheus, singlestore, sqlserver, tpcds, and tpch. These files provide default settings for each connector, enabling users to quickly set up and test connections to different data sources.

presto-main · high confidence

The Presto client now supports external authentication flows. This change introduces a new \ExternalAuthenticator\ that handles OAuth2-style redirects and token polling. Users can now authenticate via a desktop browser, system opener, or by printing a URL to the console, depending on the configured \ExternalRedirectStrategy\. The implementation includes a \CompositeRedirectHandler\ to manage multiple redirect strategies and an \HttpTokenPoller\ to handle the polling loop for obtaining tokens.

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

A new gRPC-based user-defined function (UDF) testing server has been introduced, featuring an 'EchoFirstInput' service that returns the first input row from a Presto page. This server, which listens on port 50051, is designed to facilitate testing of gRPC UDFs by providing a simple, echo-style implementation for validation purposes.

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

The Presto Druid connector now includes a new \com.facebook.presto.druid.zip\ package containing classes to parse ZIP file structures (Central Directory, End of Central Directory, Zip64 headers, and entry metadata). This enables the connector to read compressed Druid segment files directly from storage without external ZIP libraries, supporting both standard and Zip64 formats for segment loading.

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

Introduced new Java classes (DruidColumnInfo, DruidColumnType, DruidSegmentIdWrapper, DruidSegmentInfo, DruidTableInfo) in the presto-druid metadata package to handle Druid segment and table information, including JSON serialization/deserialization and S3 path resolution for segments.

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

A new shell script, src/release/release-notes.sh, has been added to automate the collection of release notes. This script downloads the Presto release tools and executes the release-notes command using a GitHub user and access token, streamlining the release process.

src/release · high confidence

The repository now includes a comprehensive set of configuration and governance files to standardize development and community interaction. This includes a \.clang-format\ file for C++ code formatting, a \.gitattributes\ file to mark generated files, and an expanded \.gitignore\ that excludes IDE-specific files, build artifacts, and native execution build directories. A \.gitmodules\ file was added to manage the Velox submodule. The project now enforces code ownership through a \CODEOWNERS\ file, which assigns specific teams and individuals to review changes in various modules. Additionally, the repository now contains \ADDITIONAL\_OWNERS\ (implied by the CODEOWNERS structure), \code of conduct\, \contributing guidelines\, \function guidelines\, and an \ARCHITECTURE.md\ document that outlines the project's mission, technical architecture, and long-term vision. These changes provide new contributors with clear instructions on how to submit code, adhere to style guides, and understand the project's structure.

(repo-wide) · high confidence

New Python scripts have been added to the \presto-benchto-benchmarks/generate\_schemas\ directory to generate Hive schemas for TPC-DS and TPC-H benchmarks. The \generate-tpcds.py\ script creates schemas for TPC-DS data across various sizes (10GB, 100GB, 1TB) in ORC format. The \generate-tpch.py\ script generates schemas for TPC-H data, supporting both ORC and TEXTFILE formats for different data sizes. These scripts automate the creation of tables and schemas required for running these specific benchmark suites.

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

Users can now insert data into Druid tables using CTAS or INSERT statements. This change introduces the core ingestion components in the presto-druid module: a new DruidIngestTask model to define the ingestion job, a DruidIngestionTableHandle to track table metadata, and a DruidPageSink/DruidPageWriter pipeline that writes incoming data as compressed JSON files (GZIP) to deep storage before submitting the ingestion task to Druid.

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

The presto-grpc-api module now supports executing SQL functions remotely over gRPC. This change introduces a new configuration class (GrpcSqlFunctionExecutionConfig) and a corresponding Guice module (GrpcSqlFunctionExecutionModule) that wires up the gRPC-based function executor. A new executor (GrpcSqlFunctionExecutor) handles the remote invocation, including retry logic and page serialization/deserialization utilities (GrpcUtils). The underlying protocol is defined in a new proto file (GrpcUdfInvoke.proto) which specifies the service interface and message structures for function invocation and results.

presto-grpc-api · high confidence

Presto now supports executing remote scalar functions using the Thrift protocol. This change introduces a new execution path for UDFs, allowing function calls to be dispatched over the network to remote services. The implementation includes a Thrift-based client, configuration for page formats (PrestoThrift and PrestoSerialized), and retry logic for transient failures. Users can now configure and utilize remote UDFs through the Thrift interface, enhancing distributed function execution capabilities.

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

The documentation template now includes a sidebar navigation that provides quick access to view the page source, edit the current page, create documentation or project issues on GitHub, and join the PrestoDB community on Slack. This adds new interactive elements to the doc pages, improving user engagement and feedback channels.

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

The benchmarking code has been extracted from the main Presto codebase into a dedicated \presto-benchmark\ module. This change introduces a new set of abstract base classes (such as \AbstractBenchmark\, \AbstractOperatorBenchmark\, and \AbstractSqlBenchmark\) that standardize how benchmarks are structured, warmed up, and executed. It also includes specific benchmark implementations for operations like array aggregation, SQL queries, and hash joins, allowing for more modular and reusable benchmarking tools.

presto-benchmark/src/main · high confidence

A new file-based session property manager has been introduced, allowing Presto to load session and catalog properties from a JSON configuration file. The implementation includes a plugin, factory, and manager classes that read session match specifications from a specified config file, enabling users to define property overrides and default values via file-based configuration rather than database or memory-only sources.

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

The Iceberg connector has been refactored to support Iceberg format version 3, including the addition of a CatalogType enum to distinguish between Hadoop, Hive, Nessie, and REST catalogs. New classes such as ColumnIdentity, CommitTaskData, and ExpressionConverter have been introduced to handle V3 type attributes, commit task data, and expression conversion, while FileContent and FileFormat enums are used to map Iceberg file types and formats. These changes lay the groundwork for native execution with Velox and improve metadata handling for Iceberg tables.

presto-iceberg · medium confidence

The Delta connector is introduced, enabling users to query Delta Lake tables stored in HDFS or cloud storage (S3, GCS, Azure Blob, ADLS Gen2). This initial release supports reading Delta tables, handling partition pruning, and managing table metadata through the Hive metastore, providing a foundation for Delta Lake integration.

presto-delta/src/main · high confidence

The geospatial toolkit now includes a new 2-dimensional K-D-B tree (KdbTree) and supporting classes (Rectangle, GeometryType, GeometryUtils, SphericalGeographyUtils) to improve spatial query performance. This change adds the core data structures and utilities required for spatial indexing and spherical distance calculations, enabling more efficient spatial joins and containment checks.

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

Added new configuration and implementation files for Alluxio caching, including \AlluxioCacheConfig\ with settings for metrics, async writes, max cache size, eviction policy (FIFO, LFU, LRU, UNEVICTABLE), timeout duration and threads, eviction retries, cache quota, shadow cache, and TTL. The \AlluxioCachingConfigurationProvider\ maps these settings to Alluxio client configuration. \AlluxioCachingFileSystem\ implements the caching logic, using SHA-256 hashes for cache identifiers and supporting last-modified-time checks. A new \CacheValidatingInputStream\ validates cached data against the source, and \PrestoCacheContext\ passes Hive file context and quota information to Alluxio.

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

A new standalone FlightShim service has been added to enable connector federation via the Apache Arrow Flight protocol. This includes the core server implementation (FlightShimServer, FlightShimProducer), configuration classes (FlightShimConfig), and plugin management (FlightShimPluginManager) that loads connectors and catalogs. The module also provides the necessary test infrastructure (AbstractTestArrowFederationNativeQueries, AbstractTestFlightShimJdbcPlugins) to validate the federation behavior.

presto-flight-shim · high confidence

Adds the foundational Java classes for the Arrow Flight connector, including the connector implementation, factory, and module wiring. This change enables users to configure and connect to Arrow Flight data sources, with support for mTLS authentication via client SSL certificates and keys, and case-sensitive name matching.

presto-base-arrow-flight/src/main · high confidence

The \presto-product-tests\ directory now provides a complete, self-contained environment for running end-to-end product tests using Docker and Docker Compose. This change introduces a new test execution workflow that spins up Hadoop, Presto, and various external services (such as MySQL, PostgreSQL, Cassandra, Kafka, and LDAP) in isolated containers. Developers can now run the full test suite or specific test groups against these containerized environments using the new \run\_on\_docker.sh\ script and \compose.sh\ wrappers, which handle container lifecycle, logging, and cleanup. The framework supports multiple test profiles including single-node, multi-node, TLS-encrypted, and Kerberos-secured configurations.

presto-product-tests · high confidence

The Presto Elasticsearch connector is now available, enabling queries against Elasticsearch clusters. The connector supports authentication via AWS IAM credentials or explicit username/password, and allows passthrough of raw Elasticsearch queries. It exposes system tables for node information and provides built-in columns for document ID, source, and score. Configuration options include timeouts, retry limits, and TLS settings.

presto-elasticsearch/src/main · high confidence

Added a new PageFile storage format for Hive, enabling the writing and reading of serialized pages with support for multiple compression codecs (Snappy, LZ4, GZIP, ZSTD, and none). The implementation includes new classes for writing (PageFileWriter, PageWriter) and reading (PageFilePageSource, PageFilePageReader) data, along with footer handling (PageFileFooterOutput/Reader) and adapter classes for compression. This change allows Hive tables to be stored in this new format, which supports configurable stripe sizes and compression, improving storage efficiency and read performance for Hive-based workloads.

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

Adds a new PostgreSQL connector to the Presto/Trino ecosystem, enabling users to query and write to PostgreSQL databases. The implementation includes the PostgreSqlClient, module, and plugin classes, along with comprehensive test suites (including case-sensitive and case-insensitive name mapping tests, distributed query tests, and integration smoke tests). The connector supports reading and writing various data types including JSON/JSONB, UUID, geometry/geography, and varbinary, and handles schema/table name resolution and metadata operations specific to PostgreSQL.

presto-postgresql · high confidence

Users can now deploy a new \presto-plan-checker-router-plugin\ that routes queries to either native or Java clusters based on plan compatibility. The plugin evaluates each query using \EXplain (type validate)\ to determine if the native cluster can handle it; if the query is incompatible or fails, the plugin can automatically retry or fall back to a Java cluster. Configuration properties allow enabling Java cluster fallback (\enable-java-cluster-fallback\), enabling cross-cluster query retry (\enable-java-cluster-query-retry\), and specifying the URIs for plan checker clusters, Java routers, and native routers.

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

The presto-verifier module has been added to provide a new tool for verifying the correctness of a new Presto version or the result equivalence of query pairs. This includes the main entry point, command-line interface, and core verification logic such as checksum generation and column validation for array and floating-point types.

presto-verifier · high confidence

Added a new command-line entry point for running Presto benchmarks. The \PrestoBenchmarkRunner\ class provides the main method to launch the benchmark tool, while \PrestoBenchmarkCommand\ and \AbstractBenchmarkCommand\ define the command structure and execution logic, allowing users to execute benchmark suites via the CLI.

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

A new caching framework has been added to Presto, introducing a \CacheManager\ and \CacheFactory\ that support two caching strategies: \FILE\_MERGE\ and \ALLUXIO\. The \CacheConfig\ allows enabling caching, configuring the base directory, and enabling data validation. The \CachingModule\ wires up the cache manager, which can be either a \FileMergeCacheManager\ or a \NoOpCacheManager\ depending on the configuration. This provides the foundation for caching data in the Hive connector.

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

A new standalone function server is introduced, providing REST endpoints to list and execute functions. The server includes a FunctionPluginManager that dynamically loads plugins from directories or Maven artifacts, enabling extensibility. The FunctionResource exposes metadata about built-in scalar functions, including support for long variable constraints and schema-scoped filtering. This change adds the server entry point, dependency injection module, and plugin loading logic, shifting function execution and metadata exposure to a separate process.

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

Added new classes in the presto-expressions module to translate RowExpressions into a target representation. The change introduces FunctionTranslator, RowExpressionTranslator, RowExpressionTreeTranslator, TranslatedExpression, and TranslatorAnnotationParser, which together provide a visitor-based translation pipeline for scalar functions and other row expressions.

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

The Hive connector's S3 integration now supports multiple file system implementations via a new \S3FileSystemType\ configuration. Users can now configure the connector to use Amazon EMR's \EmrFileSystem\ or the default Hadoop S3A implementation alongside the native \PrestoS3FileSystem\. This is achieved by introducing \HiveS3Config\ to hold S3-specific settings, a \HiveS3Module\ to wire the appropriate \S3ConfigurationUpdater\ (Presto, EMRFS, or Hadoop Default), and new enums like \PrestoS3StorageClass\ and \PrestoS3AclType\ to manage S3 upload behaviors. This change allows users to switch between different S3 client implementations and storage classes without modifying core connector logic.

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

The presto-thrift-api module now includes a new Thrift service interface, PrestoThriftService, which defines the contract for remote UDF execution and connector interactions. This change adds a suite of Thrift-annotated data types in the connector package, including PrestoThriftPageResult, PrestoThriftSplit, PrestoThriftSplitBatch, and various metadata classes (e.g., PrestoThriftTableMetadata, PrestoThriftColumnMetadata). These classes facilitate the serialization and transmission of query results, split information, and schema details over the Thrift protocol, enabling the engine to interact with external data sources or UDF services via a standardized API.

presto-thrift-api · high confidence

Adds a new Thrift connector that enables integration with external storage systems via the Thrift RPC framework, allowing users to connect to non-Java storage systems or those with complex data models without writing a custom Presto connector. The implementation includes a configurable header provider to forward user identity, supports index joins and filter pushdown for native execution, and exposes page size distribution metrics for monitoring.

presto-thrift-connector · high confidence

A new pattern-matching library has been added to the codebase, providing a fluent API for matching objects against a hierarchy of patterns. The implementation includes core classes such as \Pattern\, \Matcher\, and \Match\, along with specific pattern types like \TypeOfPattern\, \WithPattern\, \CapturePattern\, \EqualsPattern\, and \FilterPattern\. This allows users to construct complex matching rules by chaining conditions on object types, properties, and predicates, and to capture matched values for further processing.

presto-matching · high confidence

Adds a new base JDBC connector implementation in the presto-base-jdbc module, providing a foundational layer for JDBC-based connectors. This includes the core client logic (BaseJdbcClient), configuration handling (BaseJdbcConfig), and connector factory/registration (JdbcConnector, JdbcConnectorFactory). This change enables JDBC connectors to leverage a standardized set of capabilities, including support for various SQL data types (such as UUID, DECIMAL, GEOMETRY, and TIMESTAMP), configurable case-sensitive name matching, and improved error handling and connection management.

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

The Presto benchmark runner now includes a new framework for executing benchmark suites, supporting both sequential and concurrent query execution strategies. Users can configure the runner via \BenchmarkRunnerConfig\, specifying event clients (such as JSON logging) to report results. The framework tracks phase and query events, handling failures by continuing or stopping based on configuration, and allows setting maximum concurrency for parallel query execution.

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

The Kafka connector now supports case-sensitive matching for schema and table names. By default, names are matched case-insensitively using lowercase normalization, but users can enable case-sensitive matching via the new 'case-sensitive-name-matching' configuration option.

presto-kafka · high confidence

The Druid connector now includes a new column reading layer in the \presto-druid\ module, introducing a \ColumnReader\ interface and specific implementations for \String\, \Double\, \Long\, \Float\, and \Timestamp\ types. This change adds the \SimpleReadableOffset\ helper class and establishes the foundation for reading Druid column data into Presto blocks.

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

A new \presto-function-namespace-managers-common\ module provides shared components for managing SQL-invoked functions, including an abstract base manager (\AbstractSqlInvokedFunctionNamespaceManager\) that handles caching of function metadata, implementations, and user-defined types. The change adds a \JsonBasedUdfFunctionMetadata\ class to parse and store function definitions from JSON, supporting variable arity, type constraints, and execution endpoints. It also introduces a \SqlFunctionExecutors\ abstraction to route function execution based on language, with a \NoopSqlFunctionExecutor\ fallback for environments without a registered executor. Additionally, an \InMemoryFunctionNamespaceManager\ is provided for testing purposes.

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

The presto-plugin-toolkit module now includes a new file-based access control implementation. This adds a \FileBasedAccessControl\ class that reads security rules from a JSON configuration file, supporting schema, table, session property, and procedure-level access control rules. The change also introduces helper utilities (\JsonUtils\, \JsonTypeUtil\) for parsing JSON configuration and a default \AllowAllAccessControl\ implementation that permits all operations. Administrators can now configure access control policies via external JSON files, with optional hot-reload support via a configurable refresh period.

presto-plugin-toolkit · high confidence

A new file-merge caching system has been added to the Presto cache module, introducing \FileMergeCacheConfig\, \FileMergeCacheManager\, \FileMergeCachingFileSystem\, and \FileMergeCachingInputStream\. This change enables caching of file reads for the Hive connector, allowing data to be stored in memory and on disk with configurable limits (max cached entries, TTL, and in-memory size). The implementation includes logic to handle cache hits/misses, enforce cache quotas, and validate cached data integrity.

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

Users can now configure resource groups using a JSON file instead of only database-backed or hardcoded configurations. The new \FileResourceGroupConfigurationManager\ reads group definitions, selectors, and CPU quota periods from a specified config file, enabling easier, non-persistent resource group management. This change adds the \FileResourceGroupConfig\, \FileResourceGroupConfigurationManager\, and related model classes (\ManagerSpec\, \ResourceGroupSpec\, \SelectorSpec\, etc.) to support this new configuration source.

presto-resource-group-managers · high confidence

Added a new \presto-spark-classloader-interface\ module containing core abstractions for running Presto on Spark. This includes the \ExecutionStrategy\ enum to define retry behaviors (such as disabling broadcast joins or increasing container size), along with interfaces like \IPrestoSparkService\ and \IPrestoSparkQueryExecution\ to manage the Spark execution lifecycle. The change also introduces key data structures such as \PrestoSparkConfiguration\ for managing Spark and Presto properties, \PrestoSparkMutableRow\ for handling row data, and \PrestoSparkNativeTaskRdd\ to support native task execution. Additionally, it provides a \PrestoSparkBootstrapTimer\ for tracking initialization durations and a \PrestoSparkConfInitializer\ to register Kryo classes for efficient serialization.

presto-spark-classloader-interface · high confidence

Adds a new internal authentication mechanism for Presto's internal HTTP communication. The \InternalAuthenticationManager\ generates and validates JWTs (when \internalJwtEnabled\ is true) or uses a shared secret for request filtering. This is wired into the \CommonInternalCommunicationModule\ via an \InternalAuthenticationFilter\ that protects endpoints marked with the \RoleType. internal\ role. Configuration is managed through \InternalCommunicationConfig\, which now includes settings for HTTPS keystores, cipher suites, Kerberos, and the new \internal-communication.jwt.enabled\ and \internal-communication.shared-secret\ properties. Tests verify the configuration mapping and defaults.

presto-internal-communication · high confidence

The Parquet reader has been refactored to support a new batch reading mechanism, introducing a \ColumnReader\ interface and a \ColumnReaderFactory\ to select between flat and nested batch readers for various data types. This change adds support for reading multiple rows in a single batch, which is expected to improve read performance. The implementation includes new classes for handling data pages, dictionary pages, and compression utilities, alongside a verification utility to ensure the new readers produce correct results.

presto-parquet · high confidence

The presto-bytecode module now includes a comprehensive set of new classes for generating bytecode expressions, including AndBytecodeExpression, ArithmeticBytecodeExpression, ArrayLengthBytecodeExpression, BytecodeExpression, BytecodeExpressions, CastBytecodeExpression, ComparisonBytecodeExpression, ConstantBytecodeExpression, GetElementBytecodeExpression, GetFieldBytecodeExpression, InlineIfBytecodeExpression, and InstanceOfBytecodeExpression. These classes provide a structured way to represent and generate Java bytecode for various operations such as arithmetic, comparison, casting, and field/element access.

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

The memory tracking framework has been refactored to support tagging memory allocations and prevent the recreation of operator localSystemMemoryContexts. This change introduces a new memory tracking structure that aggregates memory usage across operators, ensuring that memory limits are properly enforced and that broadcasted table memory updates are correctly tracked. The new framework also includes a mechanism to verify that aggregated contexts are not closed during updates, improving the reliability of memory management in Presto.

presto-memory-context · high confidence

The presto-record-decoder module has been refactored to use a new, extensible decoder framework. A new \DecoderModule\ registers factories for CSV, JSON, Avro, and dummy row decoders, which are dispatched via \DispatchingRowDecoderFactory\. Each format now has dedicated \RowDecoder\ and \ColumnDecoder\ implementations (e.g., \CsvRowDecoder\, \JsonRowDecoder\, \AvroRowDecoder\) that decode data into \FieldValueProvider\ instances. This change introduces a new \DecoderColumnHandle\ interface and \DecoderErrorCode\ for error handling, replacing previous ad-hoc decoding logic with a structured, pluggable system for parsing various record formats.

presto-record-decoder · high confidence

Added new interfaces and implementations for error classification and metadata storage in the Presto on Spark runner. The \ErrorClassifier\ interface allows for customizable handling of execution errors, while \PrestoSparkMetadataStorage\ and its \PrestoSparkLocalMetadataStorage\ implementation provide a mechanism for storing and retrieving metadata locally. These changes support more flexible error handling and metadata management within the Spark execution environment.

presto-spark-base · high confidence

A new \presto-native-tests\ module has been added to the project, providing a dedicated build system (CMakeLists.txt, Makefile) and Java test classes to run end-to-end queries against the native C++ Presto worker. This module enables testing the native execution engine with both Java and native sidecar configurations, supporting storage formats like PARQUET and DWRF, and includes test suites for aggregations, binary functions, custom functions, and geospatial operations.

presto-native-tests · high confidence

Added a new quick stats mechanism for the Hive connector that fetches column-level statistics directly from Parquet file footers, bypassing the Hive Metastore for missing or empty stats. This includes new classes such as \ColumnQuickStats\, \PartitionQuickStats\, and \QuickStatsProvider\ to handle parallel, cached, and timeout-managed background fetching of file metadata. The \MetastoreHiveStatisticsProvider\ now integrates this provider to merge or fallback to quick stats when traditional statistics are unavailable, improving query planning speed for tables with incomplete metadata.

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

Added new classes to support runtime metrics and error handling in presto-common, including RuntimeMetric, RuntimeStats, and RuntimeUnit for tracking performance data, as well as ErrorCode, ErrorType, and various exception classes (e.g., DataTypeMismatchException, GenericInternalException) to standardize error reporting and handling across the codebase.

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

The presto-bytecode module now includes a new package, com.facebook.presto.bytecode.instruction, which provides structured, type-safe wrappers for common bytecode operations. This includes classes for constant values (Constant), field access (FieldInstruction), method invocation (InvokeInstruction), control flow jumps (JumpInstruction), type operations (TypeInstruction), and variable access (VariableInstruction). These changes replace the previous flat or less-structured approach to bytecode generation, offering a more modular and maintainable API for constructing JVM bytecode instructions.

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

Users can now use the new In-Memory connector, which provides an in-memory data store for testing and development. The connector is configured via \memory.splits-per-node\ and \memory.max-data-per-node\ properties, allowing control over the number of splits per node and the maximum memory usage per node. The implementation includes a full connector lifecycle with metadata, split management, and page source/sink providers, all wired through the \MemoryModule\ and \MemoryPlugin\.

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

Users can now connect to and query Lance datasets via a new Presto connector. The change adds the core connector implementation (LanceConnector, LanceConfig, LanceModule), a page source that reads Lance fragments using Arrow/IPC, and handles type coercion (e.g., widening Float16 to Float32). It also includes a plan optimizer that pushes LIMITs down to the scanner, and configuration properties for batch sizes, caching, and namespace modes (dir/rest).

presto-lance · high confidence

The Presto Router is a new service that sits in front of Presto clusters, routing requests to them, collecting statistics, and providing a web UI. It supports multiple scheduling strategies (random choice, round-robin, weighted random choice, and weighted round-robin) and allows for custom scheduler plugins. The router also includes a plugin system for loading authenticators and schedulers, and exposes REST endpoints for cluster status and query information.

presto-router · high confidence

The presto-pinot-toolkit module now contains the complete implementation of the Pinot connector, including core classes such as PinotConnector, PinotConfig, PinotConnection, and PinotClusterInfoFetcher. This change introduces the new connector architecture, enabling users to connect Presto to Apache Pinot clusters, query data via the Pinot broker, and utilize session properties and configuration options specific to the Pinot integration.

presto-pinot-toolkit · high confidence

A new \presto-spark-launcher\ module has been added to provide a command-line interface for launching Presto on Spark. This module includes a main entry point, command-line argument parsing, and utilities for loading configuration and catalog properties. It supports passing user information, session properties, and SQL text or files for execution, enabling users to run queries against a Spark cluster with configurable session properties and access control.

presto-spark-launcher · high confidence

The ORC reader now utilizes a caching layer (CachingOrcDataSource, CachingStripeMetadataSource) to store frequently accessed file tails, stripe footers, and row group indices in memory. This change, alongside the introduction of the AbstractOrcDataSource base class, allows Presto to keep metadata and hot data in memory, reducing repeated disk I/O and improving read performance for ORC and DWRF files.

presto-orc · high confidence

A new \HiveCachingHdfsConfiguration\ class has been added to wrap the standard HDFS configuration, enabling the integration of a caching file system. This change introduces a \CachingJobConf\ inner class that delegates file system creation to a provided factory, allowing the system to utilize cached file systems when the cache is enabled via session properties.

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

Adds a new set of classes to the presto-expressions module to support advanced expression rewriting and canonicalization. This includes a RowExpressionRewriter base class and a RowExpressionTreeRewriter to facilitate tree traversal and modification, alongside specific rewriters like CanonicalRowExpressionRewriter for normalizing expressions. The change also introduces DynamicFilters for extracting and managing dynamic filter placeholders, LogicalRowExpressions for logical operations, and a RowExpressionNodeInliner for substitution, enabling more flexible query plan optimization and filter pushdown capabilities.

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

The presto-spi module adds the \BucketFunction\ interface, which allows connectors to define custom bucketing logic for data distribution. It also introduces \ClientRequestFilter\ and \ClientRequestFilterFactory\ interfaces, enabling connectors to inject custom HTTP headers into client requests. Additionally, \ColumnHandle\ is updated with new methods (\withRequiredSubfields\, \getRequiredSubfields\) to support subfield pruning for complex types, and \ColumnMetadata\ is introduced to represent column definitions including nullable, comment, and hidden status.

presto-spi · high confidence

Adds new exception classes (ExceededCpuLimitException, ExceededIntermediateWrittenBytesException, ExceededMemoryLimitException, ExceededOutputSizeLimitException, ExceededScanLimitException, ExceededSpillLimitException) to handle various query limit violations. Introduces FullConnectorSession and Session classes to manage connector-specific session properties and identity. Adds ClientRequestFilterManager and ClientRequestFilterModule to support pluggable client request filtering. Implements GroupByHashPageIndexer and PagesIndexPageSorter for page indexing and sorting operations.

presto-main-base · high confidence

The change adds a suite of new utility classes in the presto-hive package to support advanced data processing and split management. This includes a thread-safe AsyncQueue for concurrent operations, configuration utilities for Hadoop and compression settings, and specialized converters for Hudi table splits. Additionally, it introduces a FooterAwareRecordReader to handle file footers, a HiveFileIterator for directory traversal, and a MergingPageIterator for sorting and merging data pages.

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

This change introduces the \NativeSidecarFunctionRegistryTool\ and supporting classes (\WorkerFunctionRegistryTool\, \WorkerFunctionUtil\, and \NativeSidecarRegistryToolConfig\) that enable the Presto worker to dynamically discover and register native UDFs and RPC functions by fetching their signatures from a sidecar service. The tooling includes configuration for retry attempts and delays when fetching the sidecar node, and utility functions to convert JSON-based UDF metadata into \SqlInvokedFunction\ objects, ensuring that row field names are correctly handled for varchar and map types during function signature registration.

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

The presto-native-sidecar-plugin now provides a native expression optimizer that offloads row expression optimization to the sidecar, including support for passing session properties and handling failures via a new NativeSidecarFailureInfo structure. The plugin also registers a native function namespace manager to fetch UDF definitions from the sidecar, and exposes a native plan checker. These changes enable the engine to leverage native-sidecar capabilities for expression optimization and function resolution.

presto-native-sidecar-plugin · high confidence

The presto-common module introduces a new I/O abstraction layer with the DataOutput and DataSink interfaces, alongside an OutputStreamDataSink implementation. DataOutput defines a contract for writing data to a SliceOutput, while DataSink extends Closeable to manage batched writes of DataOutput objects, including methods for tracking size and retained memory. This change provides a standardized way to handle data output in Presto, replacing previous OutputStream-based approaches with a more structured interface.

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

The JDBC plugin introduces a new mapping framework that separates read and write logic into dedicated interfaces and mapping classes. This refactors how data is read from and written to JDBC result sets and prepared statements, providing a more modular and extensible way to handle type conversions for standard SQL types like booleans, integers, doubles, and slices.

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

The Hive connector now uses new \ParquetPageSource\ and \ParquetFileWriter\ classes to handle reading and writing Parquet files. The new page source (\ParquetPageSource\) and its factory (\ParquetPageSourceFactory\) manage data retrieval, including support for row index columns and subfield pruning. The new file writer (\ParquetFileWriter\) and its factory (\ParquetFileWriterFactory\) handle Parquet output, allowing configuration of compression and writer versions. Additionally, an \AggregatedParquetPageSource\ is introduced to support partial aggregation pushdown by reading metadata statistics directly. These changes replace the previous Parquet handling mechanisms in the Hive module, providing a more optimized and feature-rich Parquet integration.

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

Added a new RCFile page source implementation (HdfsRcFileDataSource, RcFilePageSource, and RcFilePageSourceFactory) to the Hive connector. This replaces the legacy RCFile reader with a more robust implementation that includes improved error handling for corrupt files, better memory tracking, and support for reading empty files. The new reader is integrated into the Hive connector's file format handling, allowing Presto to read RCFile-formatted data more reliably.

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

The Presto SQL engine gains a new plugin that registers a batch of SQL-invoked scalar functions. For arrays, this includes \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, new functions include \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 functions added are \replace\_first\, \trail\, and \split\_part\_reverse\. These are now available for use in SQL queries via the \presto-sql-invoked-functions-plugin\.

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

Added three new Sphinx extension modules (download.py, issue.py, pr.py) that introduce custom documentation roles. The download role generates links to Maven Central or GitHub releases for specific Presto artifacts (server, CLI, JDBC, verifier, benchmark-driver, spark-package, spark-launcher, router, and flight-shim). The issue and pr roles automatically link to corresponding GitHub issues and pull requests using the '\#' prefix. These roles enable authors to write concise references like :issue:\123\ or :pr:\456\ in the documentation, improving readability and maintainability of the docs.

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

The presto-testng-services module now includes three new TestNG listeners: JacksonStreamConstraintsListener, which lifts Jackson 2.18+'s default 50,000-character JSON property-name limit; LogTestDurationListener, which logs warnings for slow tests and detects hung tests; and ReportMultiThreadedBeforeOrAfterMethod, which fails tests that use @BeforeMethod or @AfterMethod in parallel execution unless annotated with @Test(singleThreaded=true). These changes improve test reliability, performance visibility, and safety for parallel test execution.

presto-testng-services · high confidence

Added four new utility classes in the analyzer package: AnalyzerUtil, MetadataUtils, ParameterExtractor, and StatementUtils. These provide helper methods for creating parsing options from analyzer options, constructing qualified object names with catalog and schema resolution, extracting parameters from SQL statements, and mapping SQL statement types to query types (such as SELECT, INSERT, DELETE, DATA\_DEFINTION, and CONTROL).

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

Users can now configure function namespaces using three new storage backends: a JSON file-based manager, a MySQL-based manager, and a REST-based manager. These are registered via the new FunctionNamespaceManagerPlugin, which exposes the corresponding manager factories to the Presto plugin system, allowing administrators to choose how function metadata is persisted or retrieved.

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

Added a new \presto-thrift-connector-toolkit\ module containing a generic Thrift codec implementation (\GenericThriftCodec\) and a \ThriftCodecProvider\ that supplies \ConnectorCodec\ instances for standard connector handle types (splits, transactions, table handles, etc.). This provides a reusable utility for serializing and deserializing Thrift-based objects within the Presto connector framework.

presto-thrift-connector-toolkit · high confidence

A new \PlanCanonicalizationStrategy\ enum is introduced, defining four distinct strategies (DEFAULT, CONNECTOR, IGNORE\_SAFE\_CONSTANTS, and IGNORE\_SCAN\_CONSTANTS) that control how query plans are normalized. These strategies progressively relax constraints on constants and scan nodes, enabling more flexible plan matching for history-based optimizations and fragment result caching.

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

Added comprehensive documentation for Presto security features, including a new Authorization guide covering role-based access control and configuration-based authorizers. Introduced a Built-in System Access Control page detailing the allow-all, read-only, and file-based access control plugins. Added guides for securing internal node communication via SSL/TLS and JWT, and documentation for Kerberos, LDAP, OAuth2, and password-file authentication methods.

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

The Presto on Spark distribution package has been updated to include the HANA connector, allowing users to query SAP HANA databases. Additionally, the package now bundles the file and database session property managers, enabling users to configure and manage Presto session properties via file or database storage. The package assembly also includes standard license and notice files for third-party dependencies.

presto-spark-package · high confidence

The presto-bytecode library, previously removed, has been restored and reorganized into a dedicated module. This change brings back core bytecode generation utilities, including the \BytecodeBlock\ and \ClassGenerator\ for dynamic class generation, and introduces new classes such as \Access\, \AnnotationDefinition\, and \CallSiteBinder\ to support code generation for scalar functions and interface generation.

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

Presto now supports executing Hive functions through a dedicated 'hive-functions' namespace. This change introduces a new \HiveFunctionNamespaceManager\ and associated infrastructure (including \HiveFunction\, \HiveFunctionHandle\, and \StaticHiveFunctionRegistry\) that maps Hive's UDFs and UDAs to Presto's function execution model. Users can now invoke supported Hive functions directly in their queries, with the system handling the translation between Presto and Hive type systems and managing the function registry.

presto-hive-function-namespace/src/main · high confidence

The Hive connector's base classes have been refactored and moved into the new \presto-hive-common\ module. This introduces new shared types such as \BaseHiveColumnHandle\, \BaseHiveTableHandle\, and \BaseHiveTableLayoutHandle\ to standardize handle structures. Configuration and session properties are now centralized in \HiveCommonClientConfig\ and \HiveCommonSessionProperties\, exposing settings for ORC/Parquet reading, writer validation, and affinity scheduling. Additionally, utility classes like \MetadataUtils\ and error/warning code enums are consolidated in this common layer to support both Hive and Iceberg connectors.

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

The SQL analyzer logic has been extracted from the main engine into a new \presto-analyzer\ module. This change introduces a pluggable \QueryPreparer\ interface (implemented by \BuiltInQueryPreparer\) and a new \Analysis\ class to hold query metadata, types, and access control references. The refactoring also adds a \ConstantExpressionVerifier\ to validate expressions and introduces new classes like \Field\, \FieldId\, \RelationId\, and \RelationType\ to represent query structure. This modularization separates the analysis phase from the rest of the engine, allowing for potential future extensibility of the analyzer.

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

The type system in presto-common has been refactored by introducing new abstract base classes—AbstractType, AbstractPrimitiveType, AbstractIntType, AbstractLongType, and AbstractVariableWidthType—which consolidate common logic for block handling, hashing, and comparison. This structural change reorganizes the type hierarchy, moving shared implementations into these new classes to reduce duplication across specific type implementations like BooleanType, BigintType, and CharType.

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

Added JdbcTranslationUtil and OperatorTranslators classes to handle the translation of SQL operators (addition, subtraction, equality, inequality, and logical NOT) into JDBC-compatible expressions, enabling the JDBC connector to push down these specific filter conditions to the database.

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

The ClickHouse connector now supports case-sensitive matching for schema and table names. Users can enable this behavior by setting the 'case-sensitive-name-matching' configuration property to true. Previously, the connector used case-insensitive matching by default, which could lead to conflicts with names differing only by case. This change allows users to preserve exact name casing in their queries and metadata operations.

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

New SQL benchmark files have been added to test distributed sort capabilities. This includes a session configuration file to enable the distributed sort flag, and two query files that perform sorting operations on the lineitem table, specifically targeting single-column and six-column sort scenarios.

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

A new 'review-presto-pr' skill has been added to the agents configuration, enabling code review capabilities. This is implemented by creating a symbolic link from \.agents/skills\ to \../.claude/skills\, which organizes and exposes the skill to the agent system.

.agents · low confidence

A new empty Java class, Dummy.java, was added to the presto-benchto-benchmarks module. This change ensures that a JAR file is generated for the module, which is required for deploying the module to the Nexus repository.

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

A new Java class, PrestoThriftSpecDummy, was added to the presto-thrift-spec module. This class is empty and serves to ensure that the module produces a JAR file, which is required for deploying the module to the Nexus repository.

presto-thrift-spec · high confidence

The presto-test-coverage module now includes a new Java class, Report, and its corresponding test, ReportTest. These empty placeholder classes were added to fix staging deployment issues related to test coverage metrics.

presto-test-coverage · medium confidence

The Presto client now includes a legacy hostname verification implementation (LegacyHostnameVerifier and DistinguishedNameParser) that allows SSL/TLS connections to succeed when a server certificate's Common Name (CN) is used for host matching, even if the certificate also contains Subject Alternative Names (SANs). This change relaxes strict hostname verification to maintain compatibility with older certificates that rely on the CN field, while still enforcing modern SAN-based verification as the primary method.

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

The native execution component has been updated to track the latest changes in the Velox library, incorporating new APIs, memory management improvements, and bug fixes. This includes updates to the HTTP client, shuffle operators, and task management, ensuring compatibility with the latest Velox features and resolving various stability issues.

presto-native-execution · medium confidence

The Cassandra connector has been refactored to use the DataStax Java Driver 4.x, introducing a configurable exponential backoff retry policy for unavailable hosts and configurable speculative execution. Client behavior is now governed by a new \CassandraClientConfig\ that exposes settings for timeouts, consistency levels, and TLS/SSL authentication. The connector also supports secure connect bundles for cloud deployments and allows users to override the native protocol version.

presto-cassandra/src/main · high confidence

The documentation site has been reorganized into a new table of contents structure, introducing dedicated sections for Administration, Cache, Clients, Connectors, Developer Guide, Ecosystem, Functions, Language, Migration, Optimizer, Plugins, Presto C++, REST API, Router, Security, SQL Statements, and Troubleshooting. This change updates the main index and all top-level category pages to reflect the new grouping of content, providing users with a more logical and navigable documentation structure.

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

The project now uses the Takari Smart Builder and concurrent local repository extension to parallelize Maven builds by default. This change increases memory allocation to 8192MB via the JVM configuration and sets the thread count to 1C (one thread per CPU core). Users should be aware that this parallelization can cause issues with the maven-release-plugin and may consume more resources than a typical laptop provides.

.mvn · high confidence

The example HTTP connector has been completely rewritten to implement the latest Connector SPI, introducing new classes such as ExampleClient, ExampleModule, and ExampleConnectorFactory. This update aligns the connector with current framework interfaces, ensuring compatibility with the latest Presto engine features and internal architecture.

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

The presto-hive-metastore module has been restructured with new internal classes to support metastore operations, including HdfsEnvironment for HDFS configuration and authentication, ColumnConverter for type conversion, and various utility classes like HiveBasicStatistics and HiveStorageFormat. These changes introduce new interfaces and implementations that underpin the Hive connector's interaction with the metastore, enabling features such as column encryption, bucketing, and statistics handling.

presto-hive-metastore · medium confidence

Remote UDF execution now provides better exception handling and error code mapping. A new ExceptionUtils class converts Thrift UDF service exceptions into Presto exceptions, mapping error codes and stack traces to ensure consistent error reporting. The SimpleAddressSqlFunctionExecutorsModule is updated to support multiple function languages and implementation types, allowing for more flexible UDF execution configurations.

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

Added new classes to support cache quota management and enhanced file context tracking in the HDFS connector. The change introduces \CacheQuota\, \CacheQuotaRequirement\, and \CacheQuotaScope\ to define and enforce data size limits for directory listing caches. A new \BlockLocation\ class replaces the raw Hadoop \BlockLocation\ with a structured, serializable representation. \HiveFileContext\ is expanded to include cache quota, file size, and runtime statistics, enabling more granular control over caching behavior. Additionally, \HiveFileInfo\ is updated to use the new \BlockLocation\ type and includes retained size calculation for memory management. A test is added to verify the Thrift serialization of \HiveFileInfo\.

presto-hdfs-core · high confidence

Added new Java classes in presto-spark-common to support the new query data model: PrestoSparkQueryData for serializing query results, PrestoSparkQueryStatusInfo for query status and metadata, and SparkErrorCode for standardized error handling. These changes enable storing query results in separate files and enriching update information in query info.

presto-spark-common · medium confidence

The JDBC connector now includes a new optimization layer that can push down filter predicates to the database. This is achieved through new classes in the \presto-base-jdbc\ module: \JdbcComputePushdown\ acts as the plan optimizer, \JdbcFilterToSqlTranslator\ converts Presto row expressions into SQL fragments, and \JdbcPlanOptimizerProvider\ registers these optimizers. As a result, qualifying filter conditions on table scans may be executed by the underlying database rather than in Presto, potentially improving query performance.

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

The JMX connector has been refactored to implement the new Connector SPI interfaces, including the TableLayout API and transactional API. This introduces a new 'history' schema that stores periodic snapshots of JMX data, allowing users to query historical JMX metrics over time. The connector now supports escaped commas in the 'jmx.dump-tables' configuration property, enabling table names with commas. Additionally, the plugin is now extracted as a standalone module, and the connector's behavior is updated to support multiple object names per table and case-insensitive configuration properties.

presto-jmx · high confidence

The Presto JDBC driver has been refactored to use a new \AbstractConnectionProperty\ base class and a centralized \ConnectionProperties\ registry, simplifying how connection parameters (such as SSL, proxy, Kerberos, and session properties) are defined, validated, and accessed. This change introduces a more robust and extensible way to manage JDBC connection parameters, including support for external authentication, custom headers, and query interceptors. Additionally, the \PrestoConnection\ class has been updated to utilize this new property system, and the \PrestoDriver\ now registers itself with the \DriverManager\ using the new HTTP client setup.

presto-jdbc · high confidence

The SQL parser and SQL formatter have been completely rewritten. The grammar (SqlBase.g4) and all associated Java classes (including SqlFormatter, ExpressionFormatter, and QueryUtil) have been replaced with new implementations. This change introduces support for a wide range of new SQL syntaxes, including MERGE INTO, CREATE/ALTER/DROP for tables, views, schemas, functions, and roles, as well as various SHOW and EXPLAIN commands. The new parser and formatter also support new data types, window functions, and other SQL features, while removing support for approximate queries.

presto-parser · high confidence

The RebindSafeMBeanServer utility class, which wraps a JMX MBeanServer to safely handle duplicate registrations, has been moved from its previous location into the presto-common module. This change improves code organization by placing the utility in the shared common library, making it more accessible to other Presto modules.

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

The \presto-common\ module now includes the \com.facebook.presto.common.array\ package, containing utility classes for array management and large array implementations (such as \IntBigArray\, \LongBigArray\, \BooleanBigArray\, and \Arrays\ for capacity management). This move consolidates array handling logic previously scattered or located in other modules, making these core data structures directly available to all Presto components without cross-module dependencies.

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

The Hive connector now includes new plan optimizer rules that enable filter pushdown, requested column propagation, Parquet dereference pushdown, and partial aggregation pushdown for ORC/Parquet/DWRF file formats. These changes allow the Hive connector to push down more query logic to the storage layer, potentially improving query performance by reducing data read and processing overhead.

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

A new \QueryType\ enum has been added to the \presto-common\ module under \com/facebook/presto/common/resourceGroups\. This enum defines specific query categories—including DATA\_DEFINITION, DELETE, DESCRIBE, EXPLAIN, ANALYZE, INSERT, SELECT, CONTROL, UPDATE, MERGE, and CALL\_DISTRIBUTED\_PROCEDURE—each mapped to a numeric value for serialization via Thrift. This change provides a centralized, serializable representation of query types used for resource group management.

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

The RCFile module now includes a new compression codec factory (AircompressorCodecFactory) that uses the Airlift compress library for Snappy, LZO, LZ4, and GZIP codecs, alongside a new buffered output implementation (BufferedOutputStreamSliceOutput, ChunkedSliceOutput) to improve memory management and performance for RCFile read/write operations.

presto-rcfile · high confidence

The presto-common module now includes the OperatorType enum, which defines arithmetic, comparison, and other SQL operators, including support for dynamic filter comparison operators. Additionally, SqlFunctionProperties has been moved to this module and extended with fields for extra credentials, canonicalized JSON extract output, try/catchable error codes, and legacy ST\_Equals behavior, enabling more granular control over SQL function execution and error handling.

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

The CLI now uses a new OutputPrinter interface and dedicated printer classes (AlignedTablePrinter, CsvPrinter, JsonPrinter, etc.) to handle result formatting. This change introduces FormatUtils for consistent number, time, and progress bar formatting, and AbstractWarningsPrinter for standardized warning display. The Console class has been updated to use these new components, improving how query results and warnings are rendered to the user.

presto-cli/src/main · medium confidence

The Presto geospatial toolkit now supports serialization and deserialization for both Esri and JTS geometry formats. A new \GeometrySerializationType\ enum defines the wire format codes, while \EsriGeometrySerde\ and \JtsGeometrySerde\ handle the specific logic for each library. This change allows the system to correctly read and write spatial data using either format, improving compatibility and robustness in handling geometry types like empty envelopes and geometry collections.

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

The Druid connector's segment reading logic has been refactored to use a new internal segment API. This introduces new classes such as DruidSegmentReader, HdfsDataInputSource, and V9SegmentIndexSource, which handle reading and parsing Druid segment files (including ZIP-based storage). This change aligns the connector with the updated Druid 35.0.1 API, where SimpleQueryableIndex became abstract, requiring a custom PrestoQueryableIndex implementation.

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

The Hive connector's authentication logic has been restructured into a new \presto-hive/authentication\ package, introducing a modular, injectable architecture for HDFS and Hive Metastore authentication. This change enables flexible authentication strategies (such as Kerberos, simple, or no authentication) to be selected at runtime based on configuration, and adds support for cross-realm Kerberos authentication and HDFS wire encryption. Users benefit from improved security, better configurability, and the ability to impersonate users when accessing HDFS.

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

The Hive connector's filter pushdown and subfield extraction logic has been refactored into new classes: \BaseSubfieldExtractionRewriter\ and \FilterPushdownUtils\. These changes restructure how filters are evaluated and pushed down to the storage layer, potentially affecting query performance and the handling of subfields in Hive tables.

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

The ORC reading logic in the Hive connector has been refactored to improve code structure and maintainability. A new \AggregatedOrcPageSource\ class was introduced to handle partial aggregation pushdown, allowing the engine to read aggregated results directly from ORC file metadata. Additionally, the existing \OrcPageSource\ and its associated factories have been renamed to \OrcBatchPageSource\ and \OrcBatchPageSourceFactory\ respectively, clarifying their role in batch processing. The refactoring also includes moving shared utility methods into \OrcPageSourceFactoryUtils\ and ensuring proper resource management for ORC data sources.

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

The block classes in presto-common have been refactored to use new abstract base classes (AbstractArrayBlock, AbstractMapBlock, AbstractRowBlock, etc.) that provide standardized implementations for size calculation, region copying, and null handling. This change improves code reuse and consistency across different block types, enabling more efficient memory usage and faster serialization by leveraging common logic for operations like copyPositions, getRegion, and size estimation.

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

The client module introduces a new ClientException class to represent client-side errors, and refactors the error handling model by introducing a structured FailureInfo class that includes error location, stack traces, and suppressed exceptions. Additionally, type signature handling is updated with a new ClientTypeSignature class that supports generic parameters and legacy server compatibility, while Column and other data models are updated to use the new type signature structure. Utility classes for interval parsing (IntervalDayTime, IntervalYearMonth) and JSON data fixing (FixJsonDataUtils) are added to improve data consistency and parsing.

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

The predicate package has been refactored and moved into presto-common, introducing new classes such as AllOrNoneValueSet, DiscreteValues, Domain, EquatableValueSet, FilterFunction, Marker, NullableValue, Primitives, Range, Ranges, SortedRangeSet, and TupleDomain. This change consolidates predicate-related logic into the common module, making these components available for reuse across the codebase.

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

The Hive connector's security implementation has been refactored into a modular architecture. The \HiveSecurityModule\ now dynamically loads one of several access control implementations based on the \hive.security\ configuration: \legacy\ (the previous default), \sql-standard\ (SQL standard privileges), \file\, \read-only\, or \ranger\. This change isolates the legacy security behavior into its own \LegacySecurityModule\ and \LegacyAccessControl\ class, while introducing a new \SqlStandardAccessControl\ for SQL-standard role and privilege management. A \SystemTableAwareAccessControl\ wrapper ensures that queries against system tables are correctly mapped to their underlying source tables for permission checks. Users can now configure the security model via the \hive.security\ property, with the default remaining the legacy mode to preserve existing behavior.

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

The TPC-H connector has been rewritten to implement the new Connector SPI, introducing new classes such as TpchMetadata, TpchSplitManager, and TpchRecordSet. This refactor enables table layout-based query planning, allowing the optimizer to push down predicates and partition data across worker nodes more effectively. The connector now supports configurable column naming (STANDARD or SIMPLIFIED) and exposes partitioning and predicate pushdown settings, improving query performance and flexibility for users running TPC-H benchmarks.

presto-tpch · high confidence

The TransactionId class has been moved to the presto-common module, making it available for broader use across the Presto codebase. The class now includes annotations (@ThriftStruct, @ThriftConstructor, @ThriftField) and Jackson annotations (@JsonCreator, @JsonValue) to support Thrift and JSON serialization, enabling easier integration with distributed systems and API endpoints that rely on these formats.

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

The Maven wrapper configuration has been updated to use Apache Maven 3.9.12, ensuring that the project uses a consistent and up-to-date build tool version across all development environments.

.mvn/wrapper · high confidence

The TPC-H benchmark SQL queries in the Presto benchmark suite have been updated to include a configurable table name prefix (e.g., \${prefix}lineitem\), ensuring consistency with the TPC-DS benchmark structure. Additionally, the logic for query 2 (Q2) has been corrected to return the first 100 rows as specified by the TPC-H v3.0.1 standard, and a syntax error in the query set (using \substr\ instead of \substring\) has been fixed.

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

The zone-index.properties file in presto-common has been updated with the 2025b timezone data, adding support for new timezones such as America/Nuuk, Pacific/Kanton, Europe/Kyiv, America/Ciudad\_Juarez, and Asia/Qostanay, ensuring compatibility with both java.util.TimeZone and the Joda time library.

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

The \presto-common\ module now includes a vendored copy of the Base32 encoding and decoding classes (\Base32.java\, \BaseNCodec.java\, \StringUtils.java\) from the Apache Commons Codec library. This change removes the external dependency on \org.apache.commons.codec\ for these specific utilities, keeping the \presto-common\ dependency graph simpler and self-contained. Users will see these encoding capabilities available within the \com.facebook.presto.common.type.encoding\ package without needing to manage the Apache Commons Codec library as a transitive dependency.

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

Corrects a bug in multi-coordinator environments where the system allowed more concurrent queries than configured limits. The fix ensures that the last running query is stamped to all parent resource groups and updates the resource manager cache to prevent stale state from allowing excess queries to run.

presto-tests · high confidence

1 commit adding/updating tests in presto-hive/src/test/resources/quick\_stats; Add Parquet write test utilities for array and map schema conversion; Added Delta Lake test fixtures for data reading and snapshotting; Added Docker-based integration test for Presto on Spark; Added Dockerized Hive and MinIO test containers; Added Hudi MOR partition update test fixtures; Added TestingPrestoServerLauncher for testing Presto server instances; Added benchmark tests for CPU counters, decimal aggregation, statistical digests, and inequality joins; Added benchmarks and tests for R-tree implementations; Added benchmarks and tests for geometry serialization; Added benchmarks and unit tests for type signature parsing and character handling; Added benchmarks for Hive file formats and optimizer rules; Added comprehensive tests for presto-common predicate classes; Added cost-based plan regression tests for TPC-DS and TPC-H benchmarks; Added integration and unit tests for the Elasticsearch connector; Added integration tests for Hudi table support; Added native test coverage for IP prefix and array scalar functions; Added test coverage for core Presto common classes; Added test data for the Presto example HTTP plugin; Added test infrastructure for the ClickHouse connector; Added test resources for Delta Lake column mapping and protocol features; Added test resources for Hudi integration testing; Added test resources for Hudi non-partitioned COPY-O-WRITE tables; Added test utilities for Cassandra driver compatibility; Added test utilities for the Presto benchmark runner; Added testing infrastructure for the Presto UI; Added tests for AWS S3 security mapping configuration; Added tests for Accumulo row serializers; Added tests for BlackHole metadata operations; Added tests for CLI output formatters and client options; Added tests for Hive common client configuration, HiveFileInfo serialization, metadata utilities, AWS security mapping, and Z-Ordering logic; Added tests for Hive connector utility classes; Added tests for Hive function namespace integration; Added tests for Hive statistics provider and quick stats components; Added tests for InMemoryCachingHiveMetastore; Added tests for JSON-file and REST-based function namespace managers; Added tests for MySQL and MariaDB function namespace managers; Added tests for Parquet predicate utility functions; Added tests for Presto block and block builder components; Added tests for REST function executor routing; Added tests for RegexTemplate and benchmarking resources; Added tests for S3 Select functionality; Added tests for S3 file system and configuration; Added tests for SqlFunctionProperties equality; Added tests for analyzer components; Added tests for benchmark runner retry and configuration; Added tests for bytecode expression generation; Added tests for bytecode utilities and class generation; Added tests for external authentication in the Presto client; Added tests for geometry utility functions and K-d tree spatial indexing; Added tests for legacy and SQL-standard access control implementations; Added tests for presto-common array utilities and data structures; Added tests for spatial join operations; Added tests for the AWS Glue Hive metastore integration; Added tests for the Delta Lake connector; Added tests for the File Merge Cache configuration and manager; Added tests for the Presto Apache Accumulo connector model classes; Added tests for the Presto benchmark runner's MySQL suite source; Added tests for the base JDBC connector; Added tests for the new Parquet reader implementation; Added tests for the reference REST function server; Added unit tests for Alluxio cache components; Added unit tests for Cassandra connector utilities; Added unit tests for Druid ingestion task serialization; Added unit tests for JDBC compute pushdown optimization; Added unit tests for Ranger-based access control configuration and enforcement; Added unit tests for cache configuration and testing utilities; Added unit tests for client-side data handling and serialization; Added unit tests for the Google Sheets connector; Added unit tests for the Presto benchmark runner framework; New test container abstractions for integration testing; New test infrastructure for Hive S3 and S3 Select JSON tests; Updated Hive integration tests for Hive 3.x compatibility; Updated Hudi test fixtures for Merge-on-Read tables.

This release updates dependencies across 128 manifests, including upgrades to Airlift, Netty, Log4j, and various connector-specific libraries. Several updates address security vulnerabilities, such as those in Netty, Log4j, and Jackson, while others resolve build or compatibility issues. These changes ensure the platform remains secure and stable.

(dependencies) · high confidence

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

• CAI 44 → 43 (-0.3)
• Rubric changed (rubric-2026.08.18 → rubric-2026.08.19) — scores are not directly comparable.

• Code Health 55 → 55 (-0.0)
• Architecture 99 → 99 (+0.6)
• Maturity 75 → 70 (-5.3)
• Readiness 44 → 44 (+0.0)
• Security 58 → 57 (-0.8)
• Accessibility 32 → 32 (+0.0)

• Boundary-crossing change coupling: InMemoryNodeManager.java ↔ PrestoSparkInternalNodeManager.java (presto-main-base/src/main/java/com/facebook/presto/metadata/InMemoryNodeManager.java)
• Boundary-crossing change coupling: PrestoSparkInjectorFactory.java ↔ PrestoSparkConfiguration.java (presto-spark-base/src/main/java/com/facebook/presto/spark/PrestoSparkInjectorFactory.java)
• Boundary-crossing change coupling: ReadOnlySystemAccessControl.java ↔ AccessControl.java (presto-main-base/src/main/java/com/facebook/presto/security/ReadOnlySystemAccessControl.java)
• Boundary-crossing change coupling: ReadOnlySystemAccessControl.java ↔ AllowAllAccessControl.java (presto-main-base/src/main/java/com/facebook/presto/security/ReadOnlySystemAccessControl.java)
• Boundary-crossing change coupling: ReadOnlySystemAccessControl.java ↔ DenyAllAccessControl.java (presto-main-base/src/main/java/com/facebook/presto/security/ReadOnlySystemAccessControl.java)
• Boundary-crossing change coupling: TrackingRemoteTaskFactory.java ↔ HttpRemoteTaskFactory.java (presto-main-base/src/main/java/com/facebook/presto/execution/TrackingRemoteTaskFactory.java)
• High CVE: [GHSA redacted] (presto-ui/src/yarn.lock)
• High CVE: [GHSA redacted] (presto-ui/src/yarn.lock)
• High vulnerability: [GHSA redacted] (presto-ui/src/yarn.lock)
• Hotspot: presto-main-base/src/main/java/com/facebook/presto/sql/planner/optimizations/PushdownSubfields.java (presto-main-base/src/main/java/com/facebook/presto/sql/planner/optimizations/PushdownSubfields.java)
• LLM evaluation failed
• Off-boarding risk: anonymized user #1
• Off-boarding risk: anonymized user #10
• Off-boarding risk: anonymized user #11
• Off-boarding risk: anonymized user #12
• Off-boarding risk: anonymized user #2
• Off-boarding risk: anonymized user #3
• Off-boarding risk: anonymized user #4
• Off-boarding risk: anonymized user #5
• Off-boarding risk: anonymized user #6
• …and 4 more

• Boundary-crossing change coupling: Metadata.java ↔ ClassLoaderSafeConnectorMetadata.java (presto-main-base/src/main/java/com/facebook/presto/metadata/Metadata.java)
• Boundary-crossing change coupling: Metadata.java ↔ ConnectorMetadata.java (presto-main-base/src/main/java/com/facebook/presto/metadata/Metadata.java)
• Boundary-crossing change coupling: PrestoSparkQueryExecutionFactory.java ↔ QueryCompletedEvent.java (presto-spark-base/src/main/java/com/facebook/presto/spark/PrestoSparkQueryExecutionFactory.java)
• Boundary-crossing change coupling: PrestoSparkServiceFactory.java ↔ PrestoSparkLauncherCommand.java (presto-spark-base/src/main/java/com/facebook/presto/spark/PrestoSparkServiceFactory.java)
• Boundary-crossing change coupling: QueryInfo.java ↔ QueryCompletedEvent.java (presto-main-base/src/main/java/com/facebook/presto/execution/QueryInfo.java)
• Boundary-crossing change coupling: QueryStateMachine.java ↔ QueryCompletedEvent.java (presto-main-base/src/main/java/com/facebook/presto/execution/QueryStateMachine.java)
• Duplicated block (5 lines × 2) (presto-main-base/src/main/java/com/facebook/presto/sql/analyzer/ExpressionAnalyzer.java)
• High CVE: [GHSA redacted] (presto-ui/src/yarn.lock)
• High CVE: [GHSA redacted] (presto-ui/src/yarn.lock)
• High CVE: [GHSA redacted] (presto-ui/src/yarn.lock)
• Hotspot: presto-cassandra/src/main/java/com/facebook/presto/cassandra/CassandraType.java (presto-cassandra/src/main/java/com/facebook/presto/cassandra/CassandraType.java)
• Medium IaC: CKV_DOCKER_3 (docker/Dockerfile)
• Medium IaC: CKV_DOCKER_3 (presto-native-execution/scripts/dockerfiles/centos-dependency.dockerfile)
• Medium IaC: CKV_DOCKER_3 (presto-native-execution/scripts/dockerfiles/prestissimo-runtime.dockerfile)
• Medium IaC: CKV_DOCKER_3 (presto-native-execution/scripts/dockerfiles/ubuntu-22.04-dependency.dockerfile)
• Medium IaC: CKV_DOCKER_9 (presto-native-execution/scripts/dockerfiles/ubuntu-22.04-dependency.dockerfile)
• Off-boarding risk: anonymized user #8
• Off-boarding risk: anonymized user #6
• Off-boarding risk: anonymized user #4
• Off-boarding risk: anonymized user #10
• …and 10 more

• 15 commits — 9 feature/other, 6 fixes

• presto-docs/src — 4 commits
• presto-iceberg/src — 3 commits
• presto-lance/src — 2 commits
• presto-main-base/src — 2 commits
• presto-native-execution/velox — 2 commits
• presto-parser/src — 1 commit
• presto-ui/src — 1 commit

• fix: fix(docs): Change brackets for array type hints (#28255)
• fix: fix(docs): Resolve duplicate function description warnings (#28253)
• fix: fix(docs): Resolve func reference target not found warnings (#28254)
• fix: fix(plugin-iceberg): Fix Iceberg ANALYZE failure when column names in metadata are not lowercase for Hive catalog (#28234)
• fix: fix(plugin-lance): List tables across all schemas when no schema is given (#28268)
• fix: fix: Properly delete Iceberg data files on DROP TABLE for S3 storage (#27938)
• change: chore(ci): Advance velox (#28257)
• change: chore(ci): Advance velox (#28260)
• change: chore(deps): Bump postcss from 8.5.13 to 8.5.23 in /presto-ui/src (#28226)
• change: feat!: Add scan-only raw input data size statistics (#28222)
• change: feat(analyzer): Reject non-deterministic functions in materialized views (#28220)
• change: feat(parser): Add support for ANSI SQL syntax in trim function (#28190)
• change: feat(plugin-iceberg): Add proxy support for Iceberg REST catalogs (#28217)
• change: feat(plugin-lance): Integrate lance-namespace API (#27481)
• change: refactor(docs): Refactor Deploying Presto page (#28258)

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

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.