2026 Performance improvements¶

Improved runtime pruning for expressions with TIMESTAMP_TZ data types. Snowflake now prunes micro-partitions more effectively for timestamp-based filter predicates.

Improves performance for time-series queries with timestamp filters by skipping significantly more irrelevant micro-partitions, reducing I/O and execution time.

Continued improvements to skew handling in hash joins, further reducing processing bottlenecks from unevenly distributed data.

Improves execution time for join queries with data skew by dynamically adjusting redistribution based on warehouse configuration.

Performance Explorer now applies granular access control, aligning visibility with your privileges on warehouses, databases, and Snowflake database roles.

More users can access Performance Explorer to identify and troubleshoot slow queries without requiring ACCOUNTADMIN privileges.

Dynamic table refresh boundaries with DYNAMIC_TABLE_REFRESH_BOUNDARY(). Decouples upstream and downstream dynamic table refreshes so each pipeline refreshes independently.

Avoids unnecessary cascaded refreshes, reducing compute cost and refresh latency for multi-stage dynamic table pipelines.

Task graph overlap policy. Tasks support ALLOW_CHILD_OVERLAP and ALLOW_ALL_OVERLAP policies that permit concurrent graph runs.

Increases throughput for task-based data pipelines by allowing parallel execution instead of serial-only scheduling.

Enhanced parallel scanning for queries accelerated by the Query Acceleration Service (QAS).

Cortex Search updates (General availability): Multi-index search and search service selection for agents, reducing latency and cost by querying one service instead of all.

Dynamic table SCHEDULER attribute (General availability). Set SCHEDULER = DISABLE for manual-only refresh; manual refreshes don’t cascade through the pipeline.

MIN_BY and MAX_BY functions are supported with dynamic table incremental refresh (General availability).

More dynamic table pipelines can stay on incremental refresh instead of falling back to less efficient full refresh paths.

Dynamically adjusts network message sizes based on the execution plan to optimize data transfer between processing nodes.

Improves execution time for interactive and latency-sensitive workloads by reducing network overhead. Particularly benefits short-running queries and high-concurrency scenarios.

Improves execution time for scan-heavy queries, especially on larger warehouses with high concurrency. Reduces CPU overhead during parallel scan coordination.

Identifies opportunities to push aggregations earlier in the query plan when common table expressions (CTEs) are present.

Improves execution time for complex queries with CTEs by reducing the volume of data processed in later stages of the query plan.

Improved extraction pushdown through view columns, enabling more efficient scan and metadata usage for subcolumns accessed through views.

Cortex Code CLI query optimizer skill (General availability). Use natural language to get AI-driven query optimization recommendations.

Helps users identify and fix slow queries by providing optimization suggestions through the Cortex Code command-line interface.

Faster pruning decisions during compilation and execution, especially for queries that scan tables with many micro-partitions.

Reduces both compilation and execution time for queries with range predicates by skipping more irrelevant micro-partitions.

More efficient aggregation processing when data fits on a single server node, avoiding unnecessary distributed processing overhead.

AI_FILTER (General availability). Includes query-engine optimization that routes qualifying AI_FILTER patterns through optimized execution paths.

AI_AGG and AI_SUMMARIZE_AGG (General availability). Set-based AI aggregation functions that process groups natively instead of row-by-row AI_COMPLETE calls.

Up to approximately 2x throughput for large aggregation workloads compared to equivalent row-wise AI_COMPLETE patterns.

Search optimization: Support for structured data types. Search optimization can improve performance of point lookup and substring queries on ARRAY, OBJECT, and MAP columns on standard and Apache Iceberg™ tables.

Improved query performance with Snowflake Optima Metadata, which continuously analyzes your workload patterns and creates metadata to optimize pruning of unused micro-partitions. Snowflake Optima is only available on Snowflake generation 2 standard warehouses (Gen2).

Improved pruning for join queries with inequality predicates. For example, the following join query uses the > operator in an inequality predicate:

SELECT *
  FROM employees e, managers m
  WHERE e.employee_id = m.employee_id AND
        e.salary > m.salary AND
        m.level = 'M5';

For this query, Snowflake prunes micro-partitions from the employees table where all salaries are below the lowest M5 manager salary.

Improves execution time for queries that parse JSON data. Queries with heavy JSON processing may see significant speedups.

Improved compilation performance for queries with deeply nested CASE expressions by keeping them in a simplified form throughout the compilation process.