# JOIN

JOIN is a SQL operation that combines rows from tables according to a condition specifying which rows are paired.

This is one page of public article previews, not the complete archive. Follow Next page to continue. Summaries are not the original full articles.

## Your CRM Stage Probabilities Were Made Up - Calibrate Them in an Afternoon

DevFeed: [Your CRM Stage Probabilities Were Made Up - Calibrate Them in an Afternoon](<https://devfeed.tech/articles/your-crm-stage-probabilities-were-made-up-calibrate-them-in-an-afternoon-147254.md>)

Original publisher: [Read original article](<https://hackernoon.com/your-crm-stage-probabilities-were-made-up-calibrate-them-in-an-afternoon?source=rss>)

Author: Malek Damiri

Published: 2026-11-21T03:02:10Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [Finance](<https://devfeed.tech/topics/finance.md>), [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [business](<https://devfeed.tech/tags/business.md>), [crm](<https://devfeed.tech/tags/crm.md>), [data-analytics](<https://devfeed.tech/tags/data-analytics.md>), [forecast](<https://devfeed.tech/tags/forecast.md>), [forecasting](<https://devfeed.tech/tags/forecasting.md>), [pipeline](<https://devfeed.tech/tags/pipeline.md>), [revops](<https://devfeed.tech/tags/revops.md>), [sales-forecasting](<https://devfeed.tech/tags/sales-forecasting.md>), [sales-operations](<https://devfeed.tech/tags/sales-operations.md>), [sales-pipeline](<https://devfeed.tech/tags/sales-pipeline.md>), [snapshots](<https://devfeed.tech/tags/snapshots.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

CRM stage probabilities can substantially overstate quarterly pipeline: in the example, CRM weighting forecast about $4.6 million per quarter against roughly $2 million actually closed, while rates measured from earlier quarters came within about 10%. Calibrate using deals open on each quarter's first day, then compare eventual wins with wins in that same quarter; these answer different questions. The article's SQL groups outcomes by stage and tests rates learned on the first four quarters against the last four, avoiding evaluation on the training data. It recommends updating CRM probabilities to eventual win rates, keeping same-quarter rates in a warehouse table for quarterly forecasts, and recalculating quarterly. Reliable calibration requires historical snapshots; account for stage or process changes and reopened deals, and pool quarters or combine stages when counts are small. The figures are a simulated example, not a claim about every company.

### Source excerpt

Malek Damiri shows how to calibrate CRM stage probabilities from pipeline snapshots in SQL, and why weighted pipeline is often 2x too high.

## MetaSieve: Faster Relational Deep Learning through SQL-Based Metapath Selection

DevFeed: [MetaSieve: Faster Relational Deep Learning through SQL-Based Metapath Selection](<https://devfeed.tech/articles/metasieve-faster-relational-deep-learning-through-sql-based-metapath-selection-142283.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2608.25903>)

Author: Fahim Shahriar Khan, Ashraf Aboulnaga

Published: 2026-11-19T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>), [arXiv: Machine Learning](<https://devfeed.tech/sources/arxiv-machine-learning.md>)

Topics: [Machine learning](<https://devfeed.tech/topics/machine-learning.md>), [rdbms](<https://devfeed.tech/topics/rdbms.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Neural Network](<https://devfeed.tech/topics/neural-network.md>), [Deep neural networks](<https://devfeed.tech/topics/deep-neural-networks.md>), [Artificial Intelligence](<https://devfeed.tech/topics/ai.md>)

Tags: [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [deep-learning](<https://devfeed.tech/tags/deep-learning.md>), [evaluation](<https://devfeed.tech/tags/evaluation.md>), [faster](<https://devfeed.tech/tags/faster.md>), [gnn](<https://devfeed.tech/tags/gnn.md>), [relational-databases](<https://devfeed.tech/tags/relational-databases.md>), [selection](<https://devfeed.tech/tags/selection.md>), [sql](<https://devfeed.tech/tags/sql.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

MetaSieve reduces the subgraphs used to train relational graph neural networks by pruning metapaths that appear uninformative, aiming to cut training time while maintaining accuracy. For each candidate metapath extension, it uses SQL joins and aggregations to calculate statistics, then scores the candidate for low cost and informativeness; extensions below a threshold are pruned. The selection layer relies on database statistics and task labels, not GNN parameters, and is designed to work with different GNN architectures for classification and regression. On RelBench with multiple GNN backbones, the authors report large per-epoch training-time reductions while maintaining and often improving accuracy.

### Source excerpt

arXiv:2608.25903v2 Announce Type: replace Abstract: Relational Deep Learning (RDL) is an effective approach to machine learning over multi-table relational databases. In RDL, a database is modeled as a graph in which each row is a node and each foreign-key relation is an edge, and a graph neural network (GNN) is trained on this graph. Training a GNN requires sampling a subgraph around every seed node in the training set, and the cost of training is largely determined by the size of these subgraphs. This paper aims to reduce subgraph size by leveraging the join and aggregation capabilities of relational database systems. We observe that sampled subgraphs are obtained by following metapaths composed of foreign-key links, and that many of these metapaths can be pruned without loss of accuracy. We present MetaSieve, a metapath selection layer that determines which metapaths to retain and which to prune. For each candidate metapath extension, MetaSieve computes statistics via SQL join and aggregation queries and evaluates the extension based on a novel scoring function that prefers lightweight but informative candidates. Metapaths whose scores fall below a threshold are deemed uninformative and pruned. Metapath selection in MetaSieve is lightweight since it relies only on database statistics and task labels, and it is independent of GNN parameters, so it integrates with diverse GNN architectures for classification and regression. Our evaluation on the RelBench benchmark with multiple GNN backbones shows that MetaSieve consistently reduces per-epoch training time by large margins while maintaining and often improving accuracy.

## Reading Postgres EXPLAIN ANALYZE when the planner expects 300 rows and gets 15,000

DevFeed: [Reading Postgres EXPLAIN ANALYZE when the planner expects 300 rows and gets 15,000](<https://devfeed.tech/articles/reading-postgres-explain-analyze-when-the-planner-expects-300-rows-and-gets-15-000-136913.md>)

Original publisher: [Read original article](<https://hackernoon.com/reading-postgres-explain-analyze-when-the-planner-expects-300-rows-and-gets-15000?source=rss>)

Author: Anatolii Zhadan

Published: 2026-11-17T06:40:19Z

Content type: article

Language: en

Sources: [HackerNoon](<https://devfeed.tech/sources/hackernoon.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>), [groupby](<https://devfeed.tech/topics/groupby.md>), [test](<https://devfeed.tech/topics/test.md>)

Tags: [amd](<https://devfeed.tech/tags/amd.md>), [amd-epyc](<https://devfeed.tech/tags/amd-epyc.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [arm](<https://devfeed.tech/tags/arm.md>), [b-tree](<https://devfeed.tech/tags/b-tree.md>), [backend](<https://devfeed.tech/tags/backend.md>), [backend-development](<https://devfeed.tech/tags/backend-development.md>), [batch](<https://devfeed.tech/tags/batch.md>), [batches](<https://devfeed.tech/tags/batches.md>), [cache](<https://devfeed.tech/tags/cache.md>), [clock](<https://devfeed.tech/tags/clock.md>), [cloud](<https://devfeed.tech/tags/cloud.md>), [cost](<https://devfeed.tech/tags/cost.md>), [count](<https://devfeed.tech/tags/count.md>), [database](<https://devfeed.tech/tags/database.md>), [epyc](<https://devfeed.tech/tags/epyc.md>), [explain](<https://devfeed.tech/tags/explain.md>), [explain-analyze](<https://devfeed.tech/tags/explain-analyze.md>), [node](<https://devfeed.tech/tags/node.md>), [performance](<https://devfeed.tech/tags/performance.md>), [plan](<https://devfeed.tech/tags/plan.md>), [planner](<https://devfeed.tech/tags/planner.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [programming](<https://devfeed.tech/tags/programming.md>), [query-optimization](<https://devfeed.tech/tags/query-optimization.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

Start at the lowest plan node where estimated and actual rows diverge: in the example, PostgreSQL expected 300 Lisbon users but found 15,000, leading to 15,000 index lookups and a sort spill. That Nested Loop was faster in memory (159 ms versus 344 ms for a Hash Join) but slower from disk (2.15 s versus 455 ms), showing why plain queries should be timed warm and cold before comparing plans. Read plans bottom-up, account for per-loop row and time averages by multiplying by loops, and subtract child times to locate work. `Buffers` read counts mean pages requested from the OS, not necessarily disk; `track_io_timing` can show read waits. `Disk:` and multi-batch hashes indicate spills, whose cost depends on the serving machine and memory settings. `EXPLAIN ANALYZE` adds measurement overhead: in the reported tests it slowed `count(*)` 2.4-3.0 times, while `TIMING OFF` retains rows, loops and buffers but still has overhead. Wrap analyzed writes in a transaction and roll them back; their work and sequence increments can persist.

### Source excerpt

A bad plan starts at the lowest node where expected and actual rows split, and every node above it is built on that wrong number.

## Analyze Anthropic usage, spend, and access with AWS Glue, Amazon S3 Tables, and AWS Quick

DevFeed: [Analyze Anthropic usage, spend, and access with AWS Glue, Amazon S3 Tables, and AWS Quick](<https://devfeed.tech/articles/analyze-anthropic-usage-spend-and-access-with-aws-glue-amazon-s3-tables-and-aws-quick-136178.md>)

Original publisher: [Read original article](<https://aws.amazon.com/blogs/big-data/analyze-anthropic-usage-spend-and-access-with-aws-glue-amazon-s3-tables-and-aws-quick/>)

Author: Daniyal Alam

Published: 2026-11-16T20:09:24Z

Content type: tutorial

Language: en

Sources: [AWS Big Data Blog](<https://devfeed.tech/sources/aws-big-data-blog.md>)

Topics: [AWS Glue](<https://devfeed.tech/topics/aws-glue.md>), [Amazon S3 Tables](<https://devfeed.tech/topics/amazon-s3-tables.md>), [Apache Iceberg](<https://devfeed.tech/topics/apache-iceberg.md>), [Claude](<https://devfeed.tech/topics/claude.md>), [Amazon S3](<https://devfeed.tech/topics/amazon-s3.md>), [anthropic](<https://devfeed.tech/topics/anthropic.md>), [Amazon Web Services](<https://devfeed.tech/topics/aws.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [data ownership](<https://devfeed.tech/topics/data-ownership.md>), [AWS IAM](<https://devfeed.tech/topics/aws-iam.md>)

Tags: [advanced-300](<https://devfeed.tech/tags/advanced-300.md>), [ai](<https://devfeed.tech/tags/ai.md>), [amazon](<https://devfeed.tech/tags/amazon.md>), [amazon-athena](<https://devfeed.tech/tags/amazon-athena.md>), [amazon-s3](<https://devfeed.tech/tags/amazon-s3.md>), [amazon-s3-tables](<https://devfeed.tech/tags/amazon-s3-tables.md>), [analyze](<https://devfeed.tech/tags/analyze.md>), [anthropic](<https://devfeed.tech/tags/anthropic.md>), [apache](<https://devfeed.tech/tags/apache.md>), [apache-iceberg](<https://devfeed.tech/tags/apache-iceberg.md>), [apache-iceberg-tables](<https://devfeed.tech/tags/apache-iceberg-tables.md>), [api](<https://devfeed.tech/tags/api.md>), [api-key](<https://devfeed.tech/tags/api-key.md>), [athena](<https://devfeed.tech/tags/athena.md>), [aws](<https://devfeed.tech/tags/aws.md>), [aws-glue](<https://devfeed.tech/tags/aws-glue.md>), [aws-quick](<https://devfeed.tech/tags/aws-quick.md>), [s3](<https://devfeed.tech/tags/s3.md>), [s3-tables](<https://devfeed.tech/tags/s3-tables.md>), [tables](<https://devfeed.tech/tags/tables.md>), [technical-how-to](<https://devfeed.tech/tags/technical-how-to.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

AWS Glue's native Anthropic connector can load usage, cost, users, workspaces, and API key data into an AWS lakehouse without custom integration code. The walkthrough stores API keys in Secrets Manager, uses separate Admin and workspace connections for their different data scopes, and writes raw and curated Apache Iceberg tables to Amazon S3 Tables. AWS Glue materialized views join that data with business unit, outcome, and employee reference data; Athena queries the results, and AWS Quick can build dashboards directly from the views. The example surfaces spending by business unit, cost per outcome, and recently used keys created by former employees for ownership review--not automatic evidence of misuse. The article notes API rate limits, recommends bounded incremental reads, and specifies Glue materialized view requirements including Glue 5.1 or later, iam:PassRole, deterministic definitions, and inline subqueries because WITH-based views failed to refresh in its testing.

### Source excerpt

The new AWS Glue connector for Anthropic reads Claude usage, cost, and API key data into AWS without custom code. This post shows how to land it in Amazon S3 Tables as Apache Iceberg tables, join it with your business data, query it with Amazon Athena, and visualize AI spend and governance in AWS Quick.

## MEM-SQL: Memory-Empowered Text-to-SQL

DevFeed: [MEM-SQL: Memory-Empowered Text-to-SQL](<https://devfeed.tech/articles/mem-sql-memory-empowered-text-to-sql-135446.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.18338>)

Author: Xiaoqi Wang, Wenqi Pei, Shizheng Hou, Yilai Liu, Han Chen, Boyan Li, Yuyu Luo, Hongyang Du

Published: 2026-11-16T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [text2sql](<https://devfeed.tech/topics/text2sql.md>), [AI for SQL query generation](<https://devfeed.tech/topics/ai-for-sql-query-generation.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [benchmarks](<https://devfeed.tech/tags/benchmarks.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [database](<https://devfeed.tech/tags/database.md>), [databases](<https://devfeed.tech/tags/databases.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [domain](<https://devfeed.tech/tags/domain.md>), [edits](<https://devfeed.tech/tags/edits.md>), [execution](<https://devfeed.tech/tags/execution.md>), [generation](<https://devfeed.tech/tags/generation.md>), [history](<https://devfeed.tech/tags/history.md>), [join](<https://devfeed.tech/tags/join.md>), [language-models](<https://devfeed.tech/tags/language-models.md>), [latency](<https://devfeed.tech/tags/latency.md>), [layer](<https://devfeed.tech/tags/layer.md>), [linking](<https://devfeed.tech/tags/linking.md>), [mappings](<https://devfeed.tech/tags/mappings.md>), [memory](<https://devfeed.tech/tags/memory.md>), [queries](<https://devfeed.tech/tags/queries.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

MEM-SQL uses verified query history to improve Text-to-SQL accuracy while reducing generation cost. Its HARE benchmark contains 1,600 requests derived from 823 verified queries across four datasets, with annotations distinguishing whole-query adaptation from partial reuse. MEM-SQL stores query templates, reusable SQL blocks, and mappings from domain concepts to schema elements; it uses a layer only when all its assigned requirements match above a threshold. On-demand Schema Linking consults the schema when no layer qualifies or retrieved evidence seems insufficient. Across six language models on HARE, mean execution accuracy rose from 37.1% for direct generation without history to 50.0%, while input tokens fell 76.6% and latency 68.8% on average. Reusing several queries remains difficult: accuracy fell from 56.7% to 29.7%, especially when components must be reorganized or combined around a shared join. OSL reduced generation cost for three other memory designs, but its accuracy effect depended on the design.

### Source excerpt

arXiv:2611.18338v1 Announce Type: new Abstract: Text-to-SQL systems translate natural language questions into SQL queries over increasingly complex databases. However, widely used benchmarks evaluate questions independently, overlooking settings where earlier queries over the same database can supply joins or calculations for a new question. We introduce HARE (History-AwaRe Text-to-SQL BEnchmark) to measure the accuracy and cost of adapting historical SQL. HARE comprises 1,600 requests derived from a fixed pool of 823 verified queries across four datasets. Annotations record which components each request preserves and which edits it requires, distinguishing whole-query adaptation from partial reuse. Our method, MEM-SQL (Memory-EMpowered Text-to-SQL), stores whole-query templates, reusable SQL blocks, and mappings from domain concepts to schema elements. MEM-SQL uses a layer only if every requirement assigned to it has a match above that layer's threshold. With On-demand Schema Linking (OSL), MEM-SQL consults the schema only when no layer qualifies or the generator judges retrieved evidence insufficient. Across six language models on HARE, mean execution accuracy rises from 37.1% for Direct Generation without history to 50.0% for MEM-SQL, with 76.6% fewer input tokens and 68.8% lower latency on average. Further analysis shows that requests reusing several verified queries remain a bottleneck, with accuracy falling from 56.7% to 29.7%, most sharply when reused components must be placed in a new query structure or combined with a shared join. Applying OSL to three other memory designs consistently reduces generation cost, while its accuracy benefit depends on the memory design. Verified history can thus make generation both more accurate and cheaper, but its value depends on the evidence retained and when the system consults the schema.

## Hippasus: Accurate and Cost-Efficient Feature Augmentation over Relational Tables

DevFeed: [Hippasus: Accurate and Cost-Efficient Feature Augmentation over Relational Tables](<https://devfeed.tech/articles/hippasus-accurate-and-cost-efficient-feature-augmentation-over-relational-tables-132667.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2602.02025>)

Author: Serafeim Papadias, Kostas Patroumpas, Dimitrios Skoutas

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [Feature Engineering](<https://devfeed.tech/topics/feature-engineering.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [rdbms](<https://devfeed.tech/topics/rdbms.md>), [llm-reasoning](<https://devfeed.tech/topics/llm-reasoning.md>), [Predictive AI](<https://devfeed.tech/topics/predictive-ai.md>), [Plover](<https://devfeed.tech/topics/plover.md>)

Tags: [adaptive](<https://devfeed.tech/tags/adaptive.md>), [analysis](<https://devfeed.tech/tags/analysis.md>), [challenges](<https://devfeed.tech/tags/challenges.md>), [complex](<https://devfeed.tech/tags/complex.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cross](<https://devfeed.tech/tags/cross.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [cs-lg](<https://devfeed.tech/tags/cs-lg.md>), [data](<https://devfeed.tech/tags/data.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [efficiency](<https://devfeed.tech/tags/efficiency.md>), [execution](<https://devfeed.tech/tags/execution.md>), [experiments](<https://devfeed.tech/tags/experiments.md>), [exploration](<https://devfeed.tech/tags/exploration.md>), [exploring](<https://devfeed.tech/tags/exploring.md>), [feature](<https://devfeed.tech/tags/feature.md>), [feature-selection](<https://devfeed.tech/tags/feature-selection.md>), [features](<https://devfeed.tech/tags/features.md>), [framework](<https://devfeed.tech/tags/framework.md>), [hybrid](<https://devfeed.tech/tags/hybrid.md>), [tables](<https://devfeed.tech/tags/tables.md>)

### AI overview

Hippasus augments a base table with predictive features from related tables while controlling the cost of exploring join paths. It ranks candidate paths before running joins, using lightweight statistical signals and adaptive semantic analysis that calls an LLM only when needed. Multi-way joins and cross-path feature consolidation support execution; hybrid feature selection combines statistical relevance with semantic refinement. Across 13 real-world datasets, the authors report up to 15.7% average predictive-performance improvement over state-of-the-art methods, runtime on par with the fastest methods, and low LLM token cost. These claims are limited to the abstract; it does not provide details on datasets, metrics, or evaluation conditions.

### Source excerpt

arXiv:2602.02025v3 Announce Type: replace Abstract: ML models critically depend on feature quality, yet in real-world settings, useful features are often distributed across multiple relational tables rather than a single dataset. Feature augmentation addresses this problem by automatically discovering and joining additional tables to enrich a base table with predictive features. However, scaling feature augmentation to complex schemas with many tables and multi-hop relationships is challenging. It requires exploring a large space of join paths, executing costly joins, and selecting useful features from noisy results. Existing approaches suffer from either limited effectiveness or efficiency. Restricting exploration to simple joins limits predictive performance, while more expressive methods rely on expensive training data, lack scalability, or fail to fully exploit schema-level semantics. We present Hippasus, a cost-aware, LLM-guided feature augmentation framework over relational schemas, that addresses these challenges. Hippasus ranks candidate join paths before executing any join, by combining lightweight statistical signals with adaptive semantic analysis, invoking an LLM only when necessary. It further introduces efficient multi-way join execution with cross-path feature consolidation, and a hybrid feature selection strategy that integrates statistical relevance with semantic refinement. Experiments on 13 real-world datasets show that Hippasus improves predictive performance by up to 15.7% on average over state-of-the-art methods, while running on par with the fastest of them and keeping its LLM token cost low.

## Probe-Based Routing for Join Optimizer Selection

DevFeed: [Probe-Based Routing for Join Optimizer Selection](<https://devfeed.tech/articles/probe-based-routing-for-join-optimizer-selection-132693.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2611.15263>)

Author: Vladimir Burlakov, Alena Rybakina, Sergey Kudashev, Ilgam Latypov, Konstantin Gilev, Alexander Demin, Denis Ponomaryov, Yuriy Dorn

Published: 2026-11-13T05:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>), [monte carlo tree search](<https://devfeed.tech/topics/monte-carlo-tree-search.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [algorithm](<https://devfeed.tech/tags/algorithm.md>), [alpha](<https://devfeed.tech/tags/alpha.md>), [cluster](<https://devfeed.tech/tags/cluster.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [cost](<https://devfeed.tech/tags/cost.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [dynamic-programming](<https://devfeed.tech/tags/dynamic-programming.md>), [features](<https://devfeed.tech/tags/features.md>), [information](<https://devfeed.tech/tags/information.md>), [job](<https://devfeed.tech/tags/job.md>), [join](<https://devfeed.tech/tags/join.md>), [monte-carlo](<https://devfeed.tech/tags/monte-carlo.md>), [monte-carlo-tree-search](<https://devfeed.tech/tags/monte-carlo-tree-search.md>), [ordering](<https://devfeed.tech/tags/ordering.md>), [random](<https://devfeed.tech/tags/random.md>), [router](<https://devfeed.tech/tags/router.md>), [routing](<https://devfeed.tech/tags/routing.md>), [selection](<https://devfeed.tech/tags/selection.md>), [size](<https://devfeed.tech/tags/size.md>), [spacing](<https://devfeed.tech/tags/spacing.md>), [time](<https://devfeed.tech/tags/time.md>)

### AI overview

The paper reports that routing join queries using probe-derived landscape features improves mean end-to-end time over PostgreSQL's relation-count rule on JOB and IMDb-CEB. The probe estimates tail spacing (α), describing gaps among the best sampled join orders, and crossover surprise (θ), measuring how a crossover child's cost differs from its parents' mean; it takes microseconds per query. The router clusters training queries by these features and relation count, assigns a solver only where it wins total end-to-end time by a margin, and otherwise keeps PostgreSQL's default choice. On IMDb-CEB, adding probe features nearly doubles the gain from relation count alone. The excerpt does not provide absolute timings or further benchmark details.

### Source excerpt

arXiv:2611.15263v1 Announce Type: new Abstract: In optimizers that choose a join-order solver by a size rule, join ordering is an algorithm-selection problem, because dynamic programming (DP), genetic search (GEQO), and Monte Carlo tree search (MCTS) each win on different queries. PostgreSQL nevertheless chooses among them by relation count alone, although queries with the same relation count can favor different solvers. This paper introduces two landscape features that a probe computes from random join orders in microseconds per query. The tail spacing $\alpha$ describes how the costs of the best sampled orders are spaced, and the crossover surprise $\theta$ describes how far the cost of a crossover child deviates from the mean cost of its parents. The router clusters training queries by these features and the relation count, assigns a solver to every cluster that this solver wins in total end-to-end time by a margin, and leaves all other queries to PostgreSQL's default rule. On JOB and IMDb-CEB, the router lowers mean end-to-end time relative to the default rule, and on IMDb-CEB the probe features nearly double the gain obtained from the relation count alone, so they carry information about the queries that the relation count lacks.

## Who is actually using your Snowflake MCP server?

DevFeed: [Who is actually using your Snowflake MCP server?](<https://devfeed.tech/articles/who-is-actually-using-your-snowflake-mcp-server-124191.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/who-is-actually-using-your-snowflake-mcp-server-683a6cb543d7?source=rss----34b6daafc07---4>)

Author: Ondřej Blaha

Published: 2026-11-09T15:01:04Z

Content type: article

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [MSP MCP](<https://devfeed.tech/topics/msp-mcp.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Access Control](<https://devfeed.tech/topics/access-control.md>), [ai observability](<https://devfeed.tech/topics/ai-observability.md>), [Single sign-on (SSO)](<https://devfeed.tech/topics/sso.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>)

Tags: [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [integration](<https://devfeed.tech/tags/integration.md>), [join](<https://devfeed.tech/tags/join.md>), [mcp](<https://devfeed.tech/tags/mcp.md>), [mcp-server](<https://devfeed.tech/tags/mcp-server.md>), [oauth](<https://devfeed.tech/tags/oauth.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>), [snowflake-cortex](<https://devfeed.tech/tags/snowflake-cortex.md>)

### AI overview

Snowflake does not record the MCP server name in query history, but it records the OAuth security integration used at login. Assigning a separate integration to each MCP server and joining QUERY_HISTORY.AUTHN_EVENT_ID to LOGIN_HISTORY.EVENT_ID lets teams attribute queries by integration, user, role, and time; a shared integration only identifies a group. The article explains how to configure OAuth integrations and build usage reports, while noting that login rows are not calls and that query counts can include procedure or dbt work and require filtering out Snowflake's automatic skills-list queries. PAT and key-pair sign-ins lack an integration name, so attribution is weaker. Cortex Analyst leaves tagged validation queries but does not execute returned SQL; Cortex Search activity generally cannot be tied to a user or channel in account usage. Query and login history are delayed, and some queries may be missing or sampled. The reported method is a workaround based on the author's internal October 2026 testing.

### Source excerpt

How to see who sends queries through MCP, how many and how often, using one join in account usageSnowflake has no column that tells you which MCP server a query came through. It does store the name of the OAuth security integration that every MCP client signs in with. Give each MCP server its own integration, join one column from query history to login history, and you have usage per server, user and day. This article shows how, and where the approach stops working. Setting up a Snowflake-managed MCP server takes a few minutes. A few weeks later, the same client usually comes back with a different question: is anyone using it? Which users, how often, and is it worth it? I get this question from clients regularly. The last one put it as a requirement: a model that contains only queries run by their reporting team through one specific MCP server, without the same people's Snowsight work, and with user, role, timestamp and volume. Two identical rows in query history My first thought was that a filter on query history would do it. It won't, because query history has no column that says "this came from MCP server X", and I did not find one anywhere else in account usage either. That client's reporting team works in Snowsight every day and has recently started asking Claude as well. When an analyst writes select region, sum(revenue) from sales in a worksheet and later asks Claude the same question, Claude sends the same SQL through the MCP server. QUERY_HISTORY then holds two rows with the same text, the same user, the same role and, if the warehouse is shared, the same warehouse.The two queries differ only in how the analyst signed in.The sign-in tells them apart An MCP client such as Claude Desktop, Claude Code or Cursor signs in through an OAuth security integration, while Snowsight uses SSO or a password. Snowflake stores the name of the integration with every login, and every query points to the login that opened its session, so all it takes is one join: select q.que

## Your LLM writes good SQL. That's not the same as safe SQL

DevFeed: [Your LLM writes good SQL. That's not the same as safe SQL](<https://devfeed.tech/articles/your-llm-writes-good-sql-that-s-not-the-same-as-safe-sql-118718.md>)

Original publisher: [Read original article](<https://www.infoworld.com/article/4244721/your-llm-writes-good-sql-thats-not-the-same-as-safe-sql.html>)

Author: Venkat Navneeth Burla

Published: 2026-11-05T09:00:00Z

Content type: opinion

Language: en

Sources: [InfoWorld](<https://devfeed.tech/sources/infoworld.md>)

Topics: [LLM security](<https://devfeed.tech/topics/llm-security.md>), [text2sql](<https://devfeed.tech/topics/text2sql.md>), [AI for SQL query generation](<https://devfeed.tech/topics/ai-for-sql-query-generation.md>), [least privilege](<https://devfeed.tech/topics/least-privilege.md>), [Large Language Model](<https://devfeed.tech/topics/llm.md>), [LLM observability](<https://devfeed.tech/topics/llm-observability.md>), [Benchmark](<https://devfeed.tech/topics/benchmark.md>), [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [analytics](<https://devfeed.tech/tags/analytics.md>), [analytics-artificial-intelligence-data-management-generative-ai-sql](<https://devfeed.tech/tags/analytics-artificial-intelligence-data-management-generative-ai-sql.md>), [artificial-intelligence](<https://devfeed.tech/tags/artificial-intelligence.md>), [benchmark](<https://devfeed.tech/tags/benchmark.md>), [cortex](<https://devfeed.tech/tags/cortex.md>), [customer](<https://devfeed.tech/tags/customer.md>), [data](<https://devfeed.tech/tags/data.md>), [data-management](<https://devfeed.tech/tags/data-management.md>), [engagement](<https://devfeed.tech/tags/engagement.md>), [english](<https://devfeed.tech/tags/english.md>), [field](<https://devfeed.tech/tags/field.md>), [fields](<https://devfeed.tech/tags/fields.md>), [filter](<https://devfeed.tech/tags/filter.md>), [finance](<https://devfeed.tech/tags/finance.md>), [generative-ai](<https://devfeed.tech/tags/generative-ai.md>), [healthcare](<https://devfeed.tech/tags/healthcare.md>), [hospitals](<https://devfeed.tech/tags/hospitals.md>), [hr](<https://devfeed.tech/tags/hr.md>), [ids](<https://devfeed.tech/tags/ids.md>), [ignore](<https://devfeed.tech/tags/ignore.md>), [it](<https://devfeed.tech/tags/it.md>), [language-en](<https://devfeed.tech/tags/language-en.md>), [llm](<https://devfeed.tech/tags/llm.md>), [sql](<https://devfeed.tech/tags/sql.md>), [storytype-feature](<https://devfeed.tech/tags/storytype-feature.md>)

### AI overview

The article argues that accurate text-to-SQL can still expose data to the wrong user, and recommends enforcing access rules in code before queries run. It proposes resolving each user's role, business unit, territory, and assigned accounts first, limiting the model's available tables and columns, and tagging sensitive fields in the metadata catalog. A policy layer should parse and rewrite generated SQL; validation should reject SELECT *, scope-crossing queries, oversized results, and risky joins, with execution through a narrow database account and an audit record of context, policy, SQL, and results. In a synthetic, de-identified 900-query benchmark, 40% ran unchanged; others needed row filters, masking, or join rewrites, while some were sent for review or blocked. The article reports up to about 80 unauthorized rows from plain text-to-SQL, leaks under static role-based access control, and none under its policy-aware approach, with about 6.5 ms added per query. These findings are limited to the stated benchmark.

### Source excerpt

A few years into working with data, I've learned that the hardest part of an AI system is rarely the model. Usually it's the question of who gets to ask what. That question came up for me while building an LLM analytics tool on Snowflake Cortex for healthcare engagement and field-performance data. The tool let people ask questions in plain English, and it cut recurring analytics turnaround from days to minutes. It also made me realize that a fast, accurate answer can still be the wrong answer. A correct query can still be the wrong one Most of us test text-to-SQL the same way. We ask a question, check that the query runs, and compare the output to what we expected. That works right up until the answer is correct for the wrong person. Picture a sales rep who types "quarterly sales for my hospitals" and gets every hospital in the region back. The SQL is clean. The result is still a problem, and the same thing can happen in a multi-tenant app, an HR system, or a finance tool. Start with who is asking The first change I'd make is to what the model is allowed to see. Before anything is generated, look up who is asking: their role, business unit, territory, and assigned accounts. Then give the model only the tables and columns that person can use. Sensitive fields such as customer IDs, contract terms, or salaries should be tagged in your metadata catalog so they are never offered in the first place. It sounds obvious, but it is easy to skip when a demo is working. A prompt is not a permission system It is tempting to add "only show my territory" to the system prompt and move on. I understand the appeal. But a prompt is a suggestion, and the model can ignore it, forget it, or misread it on a hard question. A better setup parses the generated SQL and rewrites it before anything runs, so the rules live in code that the model cannot talk its way around. In the benchmark behind this work, the most common fix across 900 test queries was adding a row filter to the WHERE clause (

## Before You Model a Single Table: Data Modelling Questions to Ask for AI Agents in Snowflake

DevFeed: [Before You Model a Single Table: Data Modelling Questions to Ask for AI Agents in Snowflake](<https://devfeed.tech/articles/before-you-model-a-single-table-data-modelling-questions-to-ask-for-ai-agents-in-snowflake-116418.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/before-you-model-a-single-table-data-modelling-questions-to-ask-for-ai-agents-in-snowflake-0ac71edf8172?source=rss----34b6daafc07---4>)

Author: Cesar Segura

Published: 2026-11-03T19:31:02Z

Content type: article

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [schema design](<https://devfeed.tech/topics/schema-design.md>), [semantic-layer](<https://devfeed.tech/topics/semantic-layer.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [text2sql](<https://devfeed.tech/topics/text2sql.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [AI Architecture](<https://devfeed.tech/topics/ai-architecture.md>)

Tags: [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [analyst](<https://devfeed.tech/tags/analyst.md>), [architect](<https://devfeed.tech/tags/architect.md>), [article](<https://devfeed.tech/tags/article.md>), [business](<https://devfeed.tech/tags/business.md>), [business-analyst](<https://devfeed.tech/tags/business-analyst.md>), [column](<https://devfeed.tech/tags/column.md>), [cortex](<https://devfeed.tech/tags/cortex.md>), [cortex-agent](<https://devfeed.tech/tags/cortex-agent.md>), [data](<https://devfeed.tech/tags/data.md>), [data-modelling](<https://devfeed.tech/tags/data-modelling.md>), [generative-ai-tools](<https://devfeed.tech/tags/generative-ai-tools.md>), [governance](<https://devfeed.tech/tags/governance.md>), [model](<https://devfeed.tech/tags/model.md>), [modelling](<https://devfeed.tech/tags/modelling.md>), [ontology](<https://devfeed.tech/tags/ontology.md>), [questions](<https://devfeed.tech/tags/questions.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>), [table](<https://devfeed.tech/tags/table.md>)

### AI overview

AI agents infer query logic from schemas, so ambiguous grain, joins, dates and metric meanings can produce incorrect SQL. The article recommends documenting and testing each fact table's grain, exposing clear business columns, defining relationships and metric logic explicitly, and using scoped Snowflake Semantic Views over curated data. It distinguishes the executable query and metric layer (Semantic Views) from governed business definitions (Business Ontology) and AI-inferred context (Cortex Sense); ontology formulas document meaning, while Cortex Analyst executes the Semantic View expression, so they must stay aligned. It also advises profiling performance under realistic workloads and repeatedly evaluating representative business questions, including join, double-counting, ambiguity and permission cases. Business Ontology and Cortex Sense are noted as preview features as of October 2026.

### Source excerpt

A Snowflake Architect's guide to designing data that AI agents can actually understand Questions prior to modelling in Snowflake for your agents Every few weeks someone asks me the same thing: "We want a Cortex Agent on top of our data. How should we model it?" The honest answer is that most of the questions behind that sentence are not about the agent. They are modelling questions we should have answered years ago, and an agent now exposes them in public. A business analyst carries a lot of tacit knowledge: which date really means "sale", which orders are cancelled, what "revenue" means for Finance versus Sales. An agent has none of that. It reads your schema, infers, and writes SQL. Every ambiguity becomes an inference, and every inference is a chance for a wrong join, filter or aggregation. In this article we will walk through the six questions I ask teams before they start modelling: grain, shape, semantic views, business meaning, performance and evaluation. We will close with a checklist you can take to your next design session. Index 1. Why agents change the rules 2. Question 1: What is the grain, and does every column mean one thing? 3. Question 2: Star, snowflake or wide table, and how many joins are too many? 4. Question 3: How big should a Semantic View be? 5. Question 4: Who owns the meaning of a metric? 6. Question 5: Does physical performance still matter? 7. Question 6: How will we know it works? The Big Picture Conclusions References About Me 1. Why agents change the rules The first thing I explain is that an agent solution is not one model; it is a stack of layers, each with a different job. Confusing them is the root of most disappointing proofs of concept. Curated physical model: tables, views, facts, dimensions, types, keys and quality tests. It represents the data faithfully and consistently. Semantic View: the executable semantic layer. It describes how to query a domain and how to calculate its metrics: logical tables, relationships, dimensions

## Optimizing Columnar Storage in Tanzu Greenplum, Part 2: Accelerating Hash Joins with Early Join Filtering

DevFeed: [Optimizing Columnar Storage in Tanzu Greenplum, Part 2: Accelerating Hash Joins with Early Join Filtering](<https://devfeed.tech/articles/optimizing-columnar-storage-in-tanzu-greenplum-part-2-accelerating-hash-joins-with-early-join-filtering-113403.md>)

Original publisher: [Read original article](<https://blogs.vmware.com/tanzu/optimizing-columnar-storage-in-tanzu-greenplum-part-2-accelerating-hash-joins-with-early-join-filtering/>)

Author: VMware Community

Published: 2026-11-03T05:29:30Z

Content type: article

Language: en

Sources: [VMware](<https://devfeed.tech/sources/vmware-blogs.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>)

Tags: [benchmark](<https://devfeed.tech/tags/benchmark.md>), [bloom](<https://devfeed.tech/tags/bloom.md>), [bloom-filter](<https://devfeed.tech/tags/bloom-filter.md>), [columnar](<https://devfeed.tech/tags/columnar.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [greenplum](<https://devfeed.tech/tags/greenplum.md>), [hash](<https://devfeed.tech/tags/hash.md>), [join](<https://devfeed.tech/tags/join.md>), [modern-apps](<https://devfeed.tech/tags/modern-apps.md>), [optimizing](<https://devfeed.tech/tags/optimizing.md>), [payload](<https://devfeed.tech/tags/payload.md>), [query](<https://devfeed.tech/tags/query.md>), [storage](<https://devfeed.tech/tags/storage.md>), [table](<https://devfeed.tech/tags/table.md>), [vmware](<https://devfeed.tech/tags/vmware.md>), [vmware-tanzu-greenplum](<https://devfeed.tech/tags/vmware-tanzu-greenplum.md>)

### AI overview

Tanzu Greenplum 7.9's Early Join Filtering (EJF) can reduce work on selective hash joins by using only join keys and a Bloom filter built from the join's build side to discard non-matching rows during scanning, before payload columns are read. The optimizer chooses EJF only when it estimates the path is cheaper than a standard hash join. Safeguards disable filtering when the Bloom filter is ineffective during build or probe. In the reported TPC-DS Scale 1000 results, EJF reduced total workload time by 14.83%; 91 of 99 queries improved, two were unchanged, and six regressed, with a maximum slowdown of 12.09%. These are benchmark results reported in the supplied excerpt.

### Source excerpt

This post walks through Early Join Filtering (EJF) in Tanzu Greenplum 7.9. This extends the "read less, decide early" architecture to hash joins as EJF filters out non-matching rows before payload columns are ever materialized, delivering the query speed of an indexed table without the maintenance overhead. The post Optimizing Columnar Storage in Tanzu Greenplum, ... Continued The post Optimizing Columnar Storage in Tanzu Greenplum, Part 2: Accelerating Hash Joins with Early Join Filtering appeared first on VMware Blogs.

## Tessera: Fast Join-Aggregates over Skewed Sparse Relations in Database Engines

DevFeed: [Tessera: Fast Join-Aggregates over Skewed Sparse Relations in Database Engines](<https://devfeed.tech/articles/tessera-fast-join-aggregates-over-skewed-sparse-relations-in-database-engines-108348.md>)

Original publisher: [Read original article](<https://arxiv.org/abs/2610.40620>)

Author: Gyuyeong Kim

Published: 2026-10-30T04:00:00Z

Content type: article

Language: en

Sources: [arXiv: Databases](<https://devfeed.tech/sources/arxiv-databases.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>), [database-optimization](<https://devfeed.tech/topics/database-optimization.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>)

Tags: [abstract](<https://devfeed.tech/tags/abstract.md>), [addition](<https://devfeed.tech/tags/addition.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [aggregates](<https://devfeed.tech/tags/aggregates.md>), [also](<https://devfeed.tech/tags/also.md>), [arxiv](<https://devfeed.tech/tags/arxiv.md>), [avoid](<https://devfeed.tech/tags/avoid.md>), [based](<https://devfeed.tech/tags/based.md>), [block](<https://devfeed.tech/tags/block.md>), [cells](<https://devfeed.tech/tags/cells.md>), [cpu](<https://devfeed.tech/tags/cpu.md>), [cs-db](<https://devfeed.tech/tags/cs-db.md>), [database](<https://devfeed.tech/tags/database.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [either](<https://devfeed.tech/tags/either.md>), [engine](<https://devfeed.tech/tags/engine.md>), [engines](<https://devfeed.tech/tags/engines.md>), [execution](<https://devfeed.tech/tags/execution.md>), [fast](<https://devfeed.tech/tags/fast.md>), [join](<https://devfeed.tech/tags/join.md>), [over](<https://devfeed.tech/tags/over.md>)

### AI overview

Tessera targets join-aggregate queries over skewed, sparse relations, where conventional plans can materialize billions of intermediate rows. It computes sparse matrix products directly from engine rows, emits only nonzero result cells, and prunes values that cannot meet the query threshold before multiplication. For sufficiently dense pairs of frequent values, it offloads that block to a CPU matrix accelerator. The abstract reports Tessera is 2.8x-18.8x faster than the fastest existing system and up to 1,802x faster than DuckDB execution plans; it does not provide further experimental details.

### Source excerpt

arXiv:2610.40620v1 Announce Type: new Abstract: Join-aggregate queries count or sum matching rows for each pair of values, often over skewed sparse relations in which a few values are frequent and most pairs of values never co-occur. Conventional execution plans materialize billions of intermediate join rows, taking minutes to tens of minutes per query. Recent matrix-based solutions reformulate these queries as matrix multiplication to reduce or avoid this materialization. However, they remain slow because they either store result cells for non-matching pairs or still materialize intermediate join rows for infrequent values. We present Tessera, a skew-aware join-aggregate operator for database engines that avoids both sources of overhead. Specifically, Tessera computes a sparse matrix product directly over the engine's rows, emits only nonzero cells as result rows, and prunes values that cannot meet the query's threshold before multiplication begins. It also offloads the dense block formed by pairs of the most frequent values to a CPU matrix accelerator when that block is dense enough. Experimental results show that Tessera is faster than the fastest existing system by 2.8x to 18.8x. In addition, Tessera outperforms DuckDB's execution plans by up to 1,802x.

## Before You Model a Single Table: Data Modelling Questions to Ask for AI Agents in Snowflake

DevFeed: [Before You Model a Single Table: Data Modelling Questions to Ask for AI Agents in Snowflake](<https://devfeed.tech/articles/before-you-model-a-single-table-data-modelling-questions-to-ask-for-ai-agents-in-snowflake-105583.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/before-you-model-a-single-table-data-modelling-questions-to-ask-for-ai-agents-in-snowflake-ad242d437d16?source=rss----34b6daafc07---4>)

Author: Cesar Segura

Published: 2026-10-28T21:01:01Z

Content type: article

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [schema design](<https://devfeed.tech/topics/schema-design.md>), [semantic-layer](<https://devfeed.tech/topics/semantic-layer.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Data Quality](<https://devfeed.tech/topics/data-quality.md>), [knowledge-engineering](<https://devfeed.tech/topics/knowledge-engineering.md>), [business logic](<https://devfeed.tech/topics/business-logic.md>), [AI Architecture](<https://devfeed.tech/topics/ai-architecture.md>)

Tags: [2](<https://devfeed.tech/tags/2.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agents](<https://devfeed.tech/tags/agents.md>), [aggregation](<https://devfeed.tech/tags/aggregation.md>), [ai](<https://devfeed.tech/tags/ai.md>), [ai-agent](<https://devfeed.tech/tags/ai-agent.md>), [ai-agents](<https://devfeed.tech/tags/ai-agents.md>), [analyst](<https://devfeed.tech/tags/analyst.md>), [architect](<https://devfeed.tech/tags/architect.md>), [article](<https://devfeed.tech/tags/article.md>), [business](<https://devfeed.tech/tags/business.md>), [business-analyst](<https://devfeed.tech/tags/business-analyst.md>), [data](<https://devfeed.tech/tags/data.md>), [data-modelling](<https://devfeed.tech/tags/data-modelling.md>), [generative-ai-tools](<https://devfeed.tech/tags/generative-ai-tools.md>), [governance](<https://devfeed.tech/tags/governance.md>), [model](<https://devfeed.tech/tags/model.md>), [modelling](<https://devfeed.tech/tags/modelling.md>), [questions](<https://devfeed.tech/tags/questions.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>), [snowflake-cortex](<https://devfeed.tech/tags/snowflake-cortex.md>), [table](<https://devfeed.tech/tags/table.md>)

### AI overview

Reliable Snowflake Cortex Agent answers depend on reducing ambiguity across the data model, semantic layer, business definitions and evaluation. The article recommends documenting and testing each fact table's grain, using explicit relationships and appropriate date roles, and exposing a simple query path; it favors star schemas as a starting point while allowing bounded wide tables and more complex models beneath a simplified layer. Semantic Views should be scoped by domain, describe business meaning, and define metrics and filters explicitly. Business Ontology can govern canonical terms and link them to assets, but its documented formulas do not execute: Cortex Analyst uses the Semantic View expression, so both must stay aligned and tested. The article also calls for realistic performance profiling and evaluations covering joins, double counting, ambiguity and access controls. It notes that Business Ontology, its Cortex Agents integration and Cortex Sense were in Private Preview for selected accounts as of October 2026.

### Source excerpt

A Principal Architect's guide to structuring tables, semantic views and business context so agents generate reliable SQLQuestions prior to modelling in Snowflake for your agents Every few weeks someone asks me the same thing: "We want a Cortex Agent on top of our data. How should we model it?" The honest answer is that most of the questions behind that sentence are not about the agent. They are modelling questions we should have answered years ago, and an agent now exposes them in public. A business analyst carries a lot of tacit knowledge: which date really means "sale", which orders are cancelled, what "revenue" means for Finance versus Sales. An agent has none of that. It reads your schema, infers, and writes SQL. Every ambiguity becomes an inference, and every inference is a chance for a wrong join, filter or aggregation. In this article we will walk through the six questions I ask teams before they start modelling: grain, shape, semantic views, business meaning, performance and evaluation. We will close with a checklist you can take to your next design session. Index 1. Why agents change the rules 2. Question 1: What is the grain, and does every column mean one thing? 3. Question 2: Star, snowflake or wide table, and how many joins are too many? 4. Question 3: How big should a Semantic View be? 5. Question 4: Who owns the meaning of a metric? 6. Question 5: Does physical performance still matter? 7. Question 6: How will we know it works? The Big Picture Conclusions References About Me 1. Why agents change the rules The first thing I explain is that an agent solution is not one model; it is a stack of layers, each with a different job. Confusing them is the root of most disappointing proofs of concept. Curated physical model: tables, views, facts, dimensions, types, keys and quality tests. It represents the data faithfully and consistently. Semantic View: the executable semantic layer. It describes how to query a domain and how to calculate its metrics: logical

## Snowflake Optima Planning: Cross-Query Performance

DevFeed: [Snowflake Optima Planning: Cross-Query Performance](<https://devfeed.tech/articles/snowflake-optima-planning-cross-query-performance-105584.md>)

Original publisher: [Read original article](<https://medium.com/snowflake/snowflake-optima-planning-cross-query-performance-1dda1871346d?source=rss----34b6daafc07---4>)

Author: Rudi Leibbrandt

Published: 2026-10-28T19:01:02Z

Content type: article

Language: en

Sources: [Snowflake Builders](<https://devfeed.tech/sources/snowflake-builders.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [analytics](<https://devfeed.tech/tags/analytics.md>), [cross](<https://devfeed.tech/tags/cross.md>), [data-engineering](<https://devfeed.tech/tags/data-engineering.md>), [database](<https://devfeed.tech/tags/database.md>), [feedback](<https://devfeed.tech/tags/feedback.md>), [first](<https://devfeed.tech/tags/first.md>), [fragment](<https://devfeed.tech/tags/fragment.md>), [hash](<https://devfeed.tech/tags/hash.md>), [healthcare](<https://devfeed.tech/tags/healthcare.md>), [healthcare-technology](<https://devfeed.tech/tags/healthcare-technology.md>), [join](<https://devfeed.tech/tags/join.md>), [matching](<https://devfeed.tech/tags/matching.md>), [operator](<https://devfeed.tech/tags/operator.md>), [performance](<https://devfeed.tech/tags/performance.md>), [plan](<https://devfeed.tech/tags/plan.md>), [planning](<https://devfeed.tech/tags/planning.md>), [production](<https://devfeed.tech/tags/production.md>), [queries](<https://devfeed.tech/tags/queries.md>), [query](<https://devfeed.tech/tags/query.md>), [query-optimization](<https://devfeed.tech/tags/query-optimization.md>), [question](<https://devfeed.tech/tags/question.md>), [repeat](<https://devfeed.tech/tags/repeat.md>), [snowflake](<https://devfeed.tech/tags/snowflake.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

Snowflake Optima Planning can reuse execution feedback across distinct queries when their optimizer plans contain a matching fragment or operator, such as a join. It hashes plan pieces after compilation, then uses feedback from a prior execution to improve cardinality estimates for a matching piece on a new query's first run. A match is only a candidate: Optima Planning withholds feedback when transferring it could over-generalize. This complements per-query feedback, which takes over after the query runs again. The excerpt reports a synthetic example improving from about 13 seconds to half a second, and a production 19-join query falling from almost two hours to 30 seconds. Customers can see Optima Planning use in Query Profile and QUERY_INSIGHTS, but the current insight does not distinguish fragment matches from whole-query matches.

### Source excerpt

TL;DR: Optima Planning already learns from repeated queries. It can now also learn across queries -- when a brand-new query shares a plan fragment or join with something that has already run, it reuses that feedback on the very first execution. In production, this turned a 19-join analytics query from almost two hours into 30 seconds. No manual configuration required. Optima Planning: One more question about a query In a production workload by a large U.S.-based healthcare technology company, cross-query feedback reduced a 19-join analytics query from almost two hours to 30 seconds. Here's how that's possible. Optima Planning has so far answered one question about a whole query: has this query, or a variation of it, run before? (Covered in our previous "Boosting Recurring Query Performance with Snowflake Optima Planning" blog.) Optima Planning can now also answer a complementary question about a piece of the plan inside a query -- a plan fragment, or an individual operator. Per-query feedback answers an important question: Has this query, or a variation of it, run before? Matching on a plan fragment or an individual operator answers a complementary question, about a piece of the plan rather than the whole query: Has this plan fragment, or this specific operator such as a join, appeared inside any other query that has already run? Together, they widen the population of queries Optima Planning can learn from, covering both queries that are the same and queries that repeat in shape but are not the same. How this works Today, Optima Planning can also match inside the query -- on a plan fragment, such as the join tree inside a shared view, or on an individual operator, such as a specific join -- at a finer grain than the whole query. At a high level: After a query compiles, Optima Planning computes a hash for each plan fragment and each individual operator in the plan, such as a specific join, over the optimizer's output for that piece of the plan, not the whole query's SQL

## The new cost-based join optimizer with reordering support for non-inner joins

DevFeed: [The new cost-based join optimizer with reordering support for non-inner joins](<https://devfeed.tech/articles/the-new-cost-based-join-optimizer-with-reordering-support-for-non-inner-joins-105721.md>)

Original publisher: [Read original article](<https://clickhouse.com/blog/the-new-cost-based-join-optimizer-with-reordering-support-for-non-inner-joins>)

Author: Fisnik Kastrati

Published: 2026-10-28T14:12:53Z

Content type: article

Language: en

Sources: [ClickHouse Blog](<https://devfeed.tech/sources/clickhouse-blog.md>)

Topics: [JOIN](<https://devfeed.tech/topics/join.md>), [Test-driven development](<https://devfeed.tech/topics/tdd.md>)

Tags: [000](<https://devfeed.tech/tags/000.md>), [17](<https://devfeed.tech/tags/17.md>), [2](<https://devfeed.tech/tags/2.md>), [2013](<https://devfeed.tech/tags/2013.md>), [3](<https://devfeed.tech/tags/3.md>), [about](<https://devfeed.tech/tags/about.md>), [actions](<https://devfeed.tech/tags/actions.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [algorithms](<https://devfeed.tech/tags/algorithms.md>), [all](<https://devfeed.tech/tags/all.md>), [based](<https://devfeed.tech/tags/based.md>), [clickhouse](<https://devfeed.tech/tags/clickhouse.md>), [cost](<https://devfeed.tech/tags/cost.md>), [exhaustive](<https://devfeed.tech/tags/exhaustive.md>), [join](<https://devfeed.tech/tags/join.md>), [plan](<https://devfeed.tech/tags/plan.md>), [safely](<https://devfeed.tech/tags/safely.md>), [semi](<https://devfeed.tech/tags/semi.md>), [support](<https://devfeed.tech/tags/support.md>), [with](<https://devfeed.tech/tags/with.md>)

### AI overview

ClickHouse's DPsub cost-based join optimizer can reorder inner, left/right/full outer, semi, and anti joins while preserving query results. A conflict detector uses join types, predicate references, and NULL behavior to reject invalid regroupings and admit valid ones; the article reports exhaustive validation with 2.8 million core plans, no invalid or missing plans, plus zero mismatches across 1,200 fuzzed queries. DPsub searches exhaustively up to 12 tables, though the default limit is 10; larger joins fall back to the greedy optimizer. The optimizer becomes the default in ClickHouse 26.10, with settings to select the algorithm and disable conflict detection.

### Source excerpt

ClickHouse's new exhaustive cost-based join optimizer safely reorders inner, outer, semi, and anti joins to find the cheapest valid plan.

## Shard design doesn't start from your tables

DevFeed: [Shard design doesn't start from your tables](<https://devfeed.tech/articles/shard-design-doesn-t-start-from-your-tables-98539.md>)

Original publisher: [Read original article](<https://planetscale.com/blog/shard-groups-the-unit-of-co-location>)

Author: Rohit Nayak

Published: 2026-10-23T00:00:00Z

Content type: article

Language: en

Sources: [PlanetScale](<https://devfeed.tech/sources/blog-planetscale.md>)

Topics: [table-partitioning](<https://devfeed.tech/topics/table-partitioning.md>), [schema design](<https://devfeed.tech/topics/schema-design.md>), [Transactions](<https://devfeed.tech/topics/transactions.md>), [rdbms](<https://devfeed.tech/topics/rdbms.md>), [JOIN](<https://devfeed.tech/topics/join.md>)

Tags: [64-bit](<https://devfeed.tech/tags/64-bit.md>), [aggregate](<https://devfeed.tech/tags/aggregate.md>), [algorithm](<https://devfeed.tech/tags/algorithm.md>), [atomic](<https://devfeed.tech/tags/atomic.md>), [best](<https://devfeed.tech/tags/best.md>), [can](<https://devfeed.tech/tags/can.md>), [catalog](<https://devfeed.tech/tags/catalog.md>), [change](<https://devfeed.tech/tags/change.md>), [clusters](<https://devfeed.tech/tags/clusters.md>), [column](<https://devfeed.tech/tags/column.md>), [commit](<https://devfeed.tech/tags/commit.md>), [concepts](<https://devfeed.tech/tags/concepts.md>), [copy](<https://devfeed.tech/tags/copy.md>), [cross](<https://devfeed.tech/tags/cross.md>), [customer](<https://devfeed.tech/tags/customer.md>), [design](<https://devfeed.tech/tags/design.md>), [engineering](<https://devfeed.tech/tags/engineering.md>), [key](<https://devfeed.tech/tags/key.md>), [neki](<https://devfeed.tech/tags/neki.md>), [postgres](<https://devfeed.tech/tags/postgres.md>), [queries](<https://devfeed.tech/tags/queries.md>), [tables](<https://devfeed.tech/tags/tables.md>), [transactions](<https://devfeed.tech/tags/transactions.md>)

### AI overview

Design shard groups around keys shared by important queries and transactions: co-locate related tables so joins and transactions stay on one shard. In Neki, matching shard keys and hashing place rows with the same key together; reference tables are copied to each listed shard, keeping joins local. Cross-shard transactions lack atomic commit and a shared snapshot. The article describes `xxhash` as its recommended index, `range` for direct integer ranges, and `modulo` as predictable but costly to change at scale. A global secondary index can support lookups by a non-shard key through two single-shard reads. MoveTables imports data and can create initial reference-table copies; Reshard changes shard keys or shard counts as query needs evolve.

### Source excerpt

Shard group design starts from your queries, not your tables. Find the key that your most important queries and transactions share, and put every table that carries that key in one group.

## Announcing DuckDB 2.0.0 LTS "Cinnamon Teal"

DevFeed: [Announcing DuckDB 2.0.0 LTS "Cinnamon Teal"](<https://devfeed.tech/articles/announcing-duckdb-2-0-0-lts-cinnamon-teal-92886.md>)

Original publisher: [Read original article](<https://duckdb.org/2026/10/21/announcing-duckdb-200.html>)

Author: The DuckDB team

Published: 2026-10-21T00:00:00Z

Content type: release

Language: en

Sources: [DuckDB](<https://devfeed.tech/sources/duckdb.md>)

Topics: [DuckDB](<https://devfeed.tech/topics/duckdb.md>), [Parser](<https://devfeed.tech/topics/parser.md>), [deprecated](<https://devfeed.tech/topics/deprecated.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Cryptography](<https://devfeed.tech/topics/cryptography.md>), [Deployment Strategies](<https://devfeed.tech/topics/deployment-strategies.md>), [Claude Code](<https://devfeed.tech/topics/claude-code.md>), [codex](<https://devfeed.tech/topics/codex.md>)

Tags: [2-0-0](<https://devfeed.tech/tags/2-0-0.md>), [agent](<https://devfeed.tech/tags/agent.md>), [agent-mode](<https://devfeed.tech/tags/agent-mode.md>), [announce](<https://devfeed.tech/tags/announce.md>), [asynchronous](<https://devfeed.tech/tags/asynchronous.md>), [duckdb](<https://devfeed.tech/tags/duckdb.md>), [feature](<https://devfeed.tech/tags/feature.md>), [i-o](<https://devfeed.tech/tags/i-o.md>), [lts](<https://devfeed.tech/tags/lts.md>), [protocol](<https://devfeed.tech/tags/protocol.md>), [release](<https://devfeed.tech/tags/release.md>), [sql](<https://devfeed.tech/tags/sql.md>), [triggers](<https://devfeed.tech/tags/triggers.md>), [type](<https://devfeed.tech/tags/type.md>), [version](<https://devfeed.tech/tags/version.md>)

### AI overview

DuckDB 2.0.0 is an LTS feature release supported until at least October 2027. Highlights include asynchronous Parquet and CSV reads for greater parallelism on remote storage; a fully integrated VARIANT type that shreds semi-structured data for columnar execution and Parquet; and a polished Quack client-server protocol with CONNECT and remote query pushdown for supported databases. The CLI's agent mode uses compact output, reports truncation and errors clearly, and can stop runaway queries. A PEG-based extensible parser becomes the default, and triggers can maintain audit tables or incrementally update aggregates, though some trigger combinations remain unsupported. Migration requires care: pre-2.0 versions cannot read database files created by 2.0, so the release recommends testing on a shadow system before production. It also requires a C++17 compiler, disables single-arrow lambda syntax by default, and schedules osx_amd64 support to end in 2.1. Client libraries and extensions may arrive after the initial release.

### Source excerpt

The DuckDB team is happy to announce that today we're releasing DuckDB version 2.0.0 LTS, codenamed "Cinnamon Teal" (Spatula cyanoptera). This is our biggest feature release so far, and it ships a polished version of the Quack protocol, asynchronous I/O, a first-class `VARIANT` type, agent mode, triggers, an extensible SQL parser and much more, built from close to 20,000 commits since DuckDB 1.5.

## Faster String Aggregations with Dimension Tables

DevFeed: [Faster String Aggregations with Dimension Tables](<https://devfeed.tech/articles/faster-string-aggregations-with-dimension-tables-63561.md>)

Original publisher: [Read original article](<https://duckdb.org/2026/10/02/dimension-tables.html>)

Author: DuckDB Team

Published: 2026-10-02T00:00:00Z

Content type: tutorial

Language: en

Sources: [DuckDB](<https://devfeed.tech/sources/duckdb.md>)

Topics: [Test-driven development](<https://devfeed.tech/topics/tdd.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [table-partitioning](<https://devfeed.tech/topics/table-partitioning.md>)

Tags: [aggregate](<https://devfeed.tech/tags/aggregate.md>), [data](<https://devfeed.tech/tags/data.md>), [datasets](<https://devfeed.tech/tags/datasets.md>), [join](<https://devfeed.tech/tags/join.md>), [query](<https://devfeed.tech/tags/query.md>), [table](<https://devfeed.tech/tags/table.md>), [using-duckdb](<https://devfeed.tech/tags/using-duckdb.md>)

### AI overview

This DuckDB tutorial shows how to speed up repeated aggregations on long, low-cardinality strings by assigning sorted, narrow integer keys in dimension tables, grouping on those keys, and joining the strings back after aggregation. It explains alternatives such as ENUM, handling new values, tradeoffs, and cases where encoding is unlikely to help. It also notes that encoding does not solve high-cardinality aggregation memory growth caused by per-thread group duplication.

### Source excerpt

When a query groups on long, repeated strings, move the strings into a small dimension table with sorted, narrow integer keys. Aggregate on the keys, then join the strings back in at the very end. The query works as before, though on small fixed-width integers instead of variable-length text.

## Quail: Speeding up AI-SQL by jointly optimizing query planner and inference engine

DevFeed: [Quail: Speeding up AI-SQL by jointly optimizing query planner and inference engine](<https://devfeed.tech/articles/quail-speeding-up-ai-sql-by-jointly-optimizing-query-planner-and-inference-engine-79924.md>)

Original publisher: [Read original article](<https://modal.com/blog/quail-billion-tpm>)

Author: Charles Frye; Shreya Shankar

Published: 2026-09-24T00:00:00Z

Content type: article

Language: en

Sources: [Modal](<https://devfeed.tech/sources/modal.md>)

Topics: [AI for SQL query generation](<https://devfeed.tech/topics/ai-for-sql-query-generation.md>), [performance-engineering](<https://devfeed.tech/topics/performance-engineering.md>), [AI Infrastructure](<https://devfeed.tech/topics/ai-infrastructure.md>), [SQL](<https://devfeed.tech/topics/sql.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [vllm](<https://devfeed.tech/topics/vllm.md>), [DuckDB](<https://devfeed.tech/topics/duckdb.md>)

Tags: [ai](<https://devfeed.tech/tags/ai.md>), [benchmarking](<https://devfeed.tech/tags/benchmarking.md>), [business-intelligence](<https://devfeed.tech/tags/business-intelligence.md>), [caching](<https://devfeed.tech/tags/caching.md>), [perf](<https://devfeed.tech/tags/perf.md>), [planner](<https://devfeed.tech/tags/planner.md>), [sql](<https://devfeed.tech/tags/sql.md>)

### AI overview

The article presents Quail, an inference engine that jointly optimizes SQL query plans and LLM inference for AI-SQL workloads. It describes query planning, KV-cache reuse and kernel optimizations, and reports over one billion tokens per minute per H100 GPU on one multi-join query, with 1.84x faster performance than a vLLM baseline averaged across the authors' benchmark tasks.

### Source excerpt

Maximizing perf on AI-SQL queries with the KV-optimal left-deep join

## From Raw Tables to Conversational Analytics in One Afternoon

DevFeed: [From Raw Tables to Conversational Analytics in One Afternoon](<https://devfeed.tech/articles/from-raw-tables-to-conversational-analytics-in-one-afternoon-80254.md>)

Original publisher: [Read original article](<https://dlthub.com/blog/bigquery-property-graph-dlt>)

Author: Roshni Melwani

Published: 2026-09-01T00:00:00Z

Content type: tutorial

Language: en

Sources: [DLT Hub](<https://devfeed.tech/sources/dlt-hub.md>)

Topics: [BigQuery](<https://devfeed.tech/topics/bigquery.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [AI Chat](<https://devfeed.tech/topics/ai-chat.md>), [Analytics Pipeline](<https://devfeed.tech/topics/analytics-pipeline.md>), [semantic-layer](<https://devfeed.tech/topics/semantic-layer.md>)

Tags: [bigquery](<https://devfeed.tech/tags/bigquery.md>), [database](<https://devfeed.tech/tags/database.md>), [dataset](<https://devfeed.tech/tags/dataset.md>), [gemini](<https://devfeed.tech/tags/gemini.md>), [gql](<https://devfeed.tech/tags/gql.md>), [graph](<https://devfeed.tech/tags/graph.md>), [models](<https://devfeed.tech/tags/models.md>), [ontology](<https://devfeed.tech/tags/ontology.md>), [tutorials](<https://devfeed.tech/tags/tutorials.md>)

### AI overview

The article demonstrates a workflow that loads the Chinook relational dataset into BigQuery with dlt, creates canonical views, declares a property graph, and queries it with GQL. It also tests BigQuery Conversational Analytics on a natural-language question, reporting a correct answer and generated query. The article argues that resolving business meaning in the canonical model helps the graph and conversational interface produce useful results.

### Source excerpt

We previously explained in detail how to build canonical models. This blog takes that further: declare a BigQuery property graph over those models, query it with GQL, then ask it questions in plain English. The ontology resolved in the first step is what makes the answers right at the end.

## From Homegrown to Flink: Migrating a Stateful Ad Event Join at Scale

DevFeed: [From Homegrown to Flink: Migrating a Stateful Ad Event Join at Scale](<https://devfeed.tech/articles/from-homegrown-to-flink-migrating-a-stateful-ad-event-join-at-scale-47506.md>)

Original publisher: [Read original article](<https://engineering.zalando.com/posts/2026/07/migrating-ad-event-processing-to-flink.html>)

Author: Aleksandr Birin

Published: 2026-07-23T22:00:00Z

Content type: article

Language: en

Sources: [Zalando](<https://devfeed.tech/sources/zalando-engineering-blog.md>)

Topics: [Apache Flink](<https://devfeed.tech/topics/apache-flink.md>), [stream-processing](<https://devfeed.tech/topics/stream-processing.md>), [Data pipelines](<https://devfeed.tech/topics/data-pipelines.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [real-time](<https://devfeed.tech/topics/real-time.md>), [Stateful](<https://devfeed.tech/topics/stateful.md>), [Apache Kafka](<https://devfeed.tech/topics/apache-kafka.md>), [Scalability](<https://devfeed.tech/topics/scalability.md>), [Java](<https://devfeed.tech/topics/java.md>)

Tags: [apache-flink](<https://devfeed.tech/tags/apache-flink.md>), [backend](<https://devfeed.tech/tags/backend.md>), [data-pipelines](<https://devfeed.tech/tags/data-pipelines.md>), [distributed](<https://devfeed.tech/tags/distributed.md>), [event](<https://devfeed.tech/tags/event.md>), [flink](<https://devfeed.tech/tags/flink.md>), [java](<https://devfeed.tech/tags/java.md>), [kafka](<https://devfeed.tech/tags/kafka.md>), [scale](<https://devfeed.tech/tags/scale.md>), [stateful](<https://devfeed.tech/tags/stateful.md>), [zalando](<https://devfeed.tech/tags/zalando.md>)

### AI overview

Zalando's Ad Platform team migrated a homegrown Java application that joined bid and interaction events from Kinesis and Nakadi streams to Apache Flink. The migration addressed partitioning and state-loss problems while halving infrastructure cost and eliminating in-memory state loss on restarts.

### Source excerpt

We replaced a homegrown in-memory stream join with Apache Flink, halved our infrastructure cost, and eliminated in-memory state loss on restarts.

## Astral to join OpenAI

DevFeed: [Astral to join OpenAI](<https://devfeed.tech/articles/astral-to-join-openai-82885.md>)

Original publisher: [Read original article](<https://astral.sh/blog/openai>)

Author: charlie@astral.sh (Charlie Marsh)

Published: 2026-03-19T00:00:00Z

Content type: news

Language: en

Sources: [Astral](<https://devfeed.tech/sources/astral.md>)

Topics: [codex](<https://devfeed.tech/topics/codex.md>), [Open Source](<https://devfeed.tech/topics/open-source.md>), [OpenAI](<https://devfeed.tech/topics/openai.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Self-organizing Team](<https://devfeed.tech/topics/self-organizing-team.md>)

Tags: [codex](<https://devfeed.tech/tags/codex.md>), [let](<https://devfeed.tech/tags/let.md>), [open-source](<https://devfeed.tech/tags/open-source.md>), [programming](<https://devfeed.tech/tags/programming.md>), [python](<https://devfeed.tech/tags/python.md>), [ruff](<https://devfeed.tech/tags/ruff.md>), [uv](<https://devfeed.tech/tags/uv.md>)

### AI overview

Astral says it has agreed to join OpenAI as part of the Codex team. The company plans to continue supporting and building its open source Python tools, including Ruff, uv, and ty, while exploring closer integration with Codex.

### Source excerpt

Astral has entered into an agreement to join OpenAI as part of the Codex team.

## pg\_plan\_advice: Plan Stability and User Planner Control for PostgreSQL?

DevFeed: [pg\_plan\_advice: Plan Stability and User Planner Control for PostgreSQL?](<https://devfeed.tech/articles/pg-plan-advice-plan-stability-and-user-planner-control-for-postgresql-33636.md>)

Original publisher: [Read original article](<https://rhaas.blogspot.com/2026/03/pgplanadvice-plan-stability-and-user.html>)

Author: Robert Haas (noreply@blogger.com)

Published: 2026-03-04T17:55:00Z

Content type: opinion

Language: en

Sources: [Robert Haas](<https://devfeed.tech/sources/robert-haas.md>)

Topics: [PostgreSQL](<https://devfeed.tech/topics/postgresql.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [modules](<https://devfeed.tech/topics/modules.md>), [Query (disambiguation)](<https://devfeed.tech/topics/query.md>)

Tags: [join](<https://devfeed.tech/tags/join.md>), [modules](<https://devfeed.tech/tags/modules.md>), [plan](<https://devfeed.tech/tags/plan.md>), [planner](<https://devfeed.tech/tags/planner.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [query](<https://devfeed.tech/tags/query.md>), [test](<https://devfeed.tech/tags/test.md>)

### AI overview

The article presents a proposed PostgreSQL 19 patch set introducing the pg_plan_advice, pg_collect_advice, and pg_stash_advice contrib modules. It demonstrates how pg_plan_advice can generate plan advice strings, preserve selected planner decisions, or vary advice to produce a different join plan.

### Source excerpt

I'm proposing a very ambitious patch set for PostgreSQL 19. Only time will tell whether it ends up in the release, but I can't resist using this space to give you a short demonstration of what it can do. The patch set introduces three new contrib modules, currently called pg_plan_advice, pg_collect_advice, and pg_stash_advice. Read more "

## Small improvement for pretty-printing in paste.depesz.com

DevFeed: [Small improvement for pretty-printing in paste.depesz.com](<https://devfeed.tech/articles/small-improvement-for-pretty-printing-in-paste-depesz-com-33672.md>)

Original publisher: [Read original article](<https://www.depesz.com/2026/01/06/improvement-for-pretty-printing-in-paste-depesz-com/>)

Author: depesz

Published: 2026-01-06T15:13:10Z

Content type: release

Language: en

Sources: [select \* from depesz;](<https://devfeed.tech/sources/select-from-depesz.md>)

Topics: [pretty printing](<https://devfeed.tech/topics/pretty-printing.md>), [JOIN](<https://devfeed.tech/topics/join.md>), [Command-line interface](<https://devfeed.tech/topics/cli.md>), [Script](<https://devfeed.tech/topics/script.md>)

Tags: [announce](<https://devfeed.tech/tags/announce.md>), [announcements](<https://devfeed.tech/tags/announcements.md>), [command-line](<https://devfeed.tech/tags/command-line.md>), [formatting](<https://devfeed.tech/tags/formatting.md>), [irc](<https://devfeed.tech/tags/irc.md>), [join](<https://devfeed.tech/tags/join.md>), [paste-depesz-com](<https://devfeed.tech/tags/paste-depesz-com.md>), [perl](<https://devfeed.tech/tags/perl.md>), [pg-prettify](<https://devfeed.tech/tags/pg-prettify.md>), [postgresql](<https://devfeed.tech/tags/postgresql.md>), [pretty](<https://devfeed.tech/tags/pretty.md>), [pretty-printing](<https://devfeed.tech/tags/pretty-printing.md>), [script](<https://devfeed.tech/tags/script.md>), [uncategorized](<https://devfeed.tech/tags/uncategorized.md>)

### AI overview

The article describes an improvement to the pretty printer on paste.depesz.com that produces better indentation for complex SQL join conditions. It also notes that the printer can be used from the command line or through a previously described script without storing content on the site.

### Source excerpt

As you maybe know, some time ago I made paste service, mostly to use for queries, or related text to share on IRC. One part of it is that it also has pretty printer of provided queries. Recently I realized that in case of complex join conditions, the output is, well, sub-optimal. For example: SELECT ... Continue reading "Small improvement for pretty-printing in paste.depesz.com"

[Next page](<https://devfeed.tech/topics/join.md?cursor=WyIyMDI2LTAxLTA2VDE1OjEzOjEwKzAwOjAwIiwgImFhOTU0YTBiLTkwNzktNDI3My04YWEwLTY1YzU3MTY0MWU0MCJd>)