使用SQL变量和子查询的利弊是什么？

Question

I'm wondering there is a difference between SQL variables and subqueries. Whether one uses more processing power, or one is quicker, or even if one merely is more readable.

For (a very basic) example, I like to use variables to hold polygon and transformations in PostGIS:

WITH region_polygon AS (
    SELECT ST_Transform(wkb_geometry, %(fishnet_srid)d) geom
    FROM regions
    LIMIT 1
), raster_pixels AS (
    SELECT (ST_PixelAsPolygons(rast)).*
    FROM test_regions_raster
    LIMIT 1
)
SELECT x, y
FROM raster_pixels a, region_polygon b
WHERE ST_Within(a.geom, b.geom)

But would it be better in any way to use subqueries?

SELECT x, y
FROM (
    SELECT ST_Transform(wkb_geometry, %(fishnet_srid)d) geom
    FROM regions
    LIMIT 1
) a, (
    SELECT (ST_PixelAsPolygons(rast)).*
    FROM test_regions_raster
    LIMIT 1
) b
WHERE ST_Within(a.geom, b.geom)

Note that I'm using PostgreSQL.

Answer 1

There's an important syntactic advantage of common table expressions over derived tables when it comes to reuse. Consider the following, equivalent examples using self-joins:

Using common table expressions

WITH a(v) AS (SELECT 1 UNION SELECT 2)
SELECT *
FROM a AS x, a AS y

Using derived tables

SELECT *
FROM (SELECT 1 UNION SELECT 2) x(v),
     (SELECT 1 UNION SELECT 2) y(v)

As you can see, using common table expressions, the view (SELECT 1 UNION SELECT 2) can be reused multiple times in your query. With derived tables, you will have to repeat your view declaration. In my example, this is still OK. In your own example, this starts getting a bit more hairy.

It's all about scope

Views in SQL are all about scoping. There are essentially four levels of declaring views:

• As derived tables. They can be consumed exactly once.
• As common table expressions. They can be consumed several times, but only in one query.
• As views. They can be consumed several times in several queries.
• As materialized views. Same as views, but the data is pre-calculated.

Some databases (in particular PostgreSQL) also know table-valued functions. From a mere syntax perspective, they're just like views - parameterised views.

Performance

Note that these thoughts only focus on syntax, not query planning. The different approaches may have very different performance implications, depending on the database vendor.

Answer 2

Those aren't variables, they're common table expressions ( cte ). In your query above, the execution plans are likely identical, because the optimizer should recognize they are equivalent queries. I prefer to use cte 's because I think they're easier to read than subqueries, but that's it.

Edit: Upon further reading it looks like PostgreSQL does treat common table expressions differently than other databases, you can't update a cte in PostgreSQL, for instance. I'll leave my answer here because I believe for your query there won't be a difference, but I'm not terribly familiar with PostgreSQL.

Answer 3

As pointed out this construct is called Common Table Expression , not a variable.

I prefer to use CTE, rather than subquery, because it is way easier to read and write for me, especially when you have several nested CTEs.

You can write CTE once and refer to it several times in the rest of the query. With subquery you'll have to repeat the code several times.

Important difference of PostgreSQL from other databases (at least from MS SQL Server) is that PostgreSQL evaluates each CTE only once.

A useful property of WITH queries is that they are evaluated only once per execution of the parent query, even if they are referred to more than once by the parent query or sibling WITH queries. Thus, expensive calculations that are needed in multiple places can be placed within a WITH query to avoid redundant work. Another possible application is to prevent unwanted multiple evaluations of functions with side-effects. However, the other side of this coin is that the optimizer is less able to push restrictions from the parent query down into a WITH query than an ordinary sub-query. The WITH query will generally be evaluated as written, without suppression of rows that the parent query might discard afterwards. (But, as mentioned above, evaluation might stop early if the reference(s) to the query demand only a limited number of rows.)

MS SQL Server would inline each reference of CTE into the main query and optimize the whole result, but PostgreSQL doesn't. In some sense PostgreSQL is more flexible here. If you want the subquery to be evaluated only once, put it in CTE. If you don't want, put it in subquery and repeat the code. In SQL Server you'd have to use temporary table explicitly.

Your example in the question is too simple and most likely both variants are equivalent - check the execution plan.

---

Official docs mention it, as I quoted above, but Nick Barnes gave a link to a good article explaining it in more details and I thought it is worth putting it in an answer, rather that comment.

When optimising queries in PostgreSQL (true at least in 9.4 and older), it's worth keeping in mind that – unlike newer versions of various other databases – PostgreSQL will always materialise a CTE term in a query.

This can have quite surprising effects for those used to working with DBs like MS SQL :

• A query that should touch a small amount of data instead reads a whole table and possibly spills it to a tempfile;
• and You cannot UPDATE or DELETE FROM a CTE term, because it's more like a read-only temp table rather than a dynamic view.

So, there is no definite answer whether CTE is better than subquery in PostgreSQL. In some cases it can be faster, in some cases it can be slower. But, IMHO, in most cases CTE is easier to write, read and maintain.

And, obviously, there is a case when you have no other option, but to use so-called recursive CTE (recursive queries are typically used to deal with hierarchical or tree-structured data).