“AS”在SQL中意味着什么？

Question

Below is the synopsis of SELECT from the PostgreSQL documentation . It seems to me that sometimes we write <expression> AS <name> and sometimes it's <name> AS <expression> . In ordinary English, I tend to think <expression> AS <name> is much more common (eg "Address her as. Doctor Smith, please. , and I'm having trouble understanding how to think about <name> AS <expression> .

1. How can we distinguish between where to use <name> AS <expression> and <expression> as <name> ?
2. What are minimal obvious examples of each?
3. Are there parallels of each kind in ordinary language, which would make it intuitively obvious when to use what?

 [ WITH [ RECURSIVE ] with_query [, ...] ] SELECT [ ALL | DISTINCT [ ON ( expression [, ...] ) ] ] * | expression [ [ AS ] output_name ] [, ...] [ FROM from_item [, ...] ] [ WHERE condition ] [ GROUP BY expression [, ...] ] [ HAVING condition [, ...] ] [ WINDOW window_name AS ( window_definition ) [, ...] ] [ { UNION | INTERSECT | EXCEPT } [ ALL | DISTINCT ] select ] [ ORDER BY expression [ ASC | DESC | USING operator ] [ NULLS { FIRST | LAST } ] [, ...] ] [ LIMIT { count | ALL } ] [ OFFSET start [ ROW | ROWS ] ] [ FETCH { FIRST | NEXT } [ count ] { ROW | ROWS } ONLY ] [ FOR { UPDATE | SHARE } [ OF table_name [, ...] ] [ NOWAIT ] [...] ] where from_item can be one of: [ ONLY ] table_name [ * ] [ [ AS ] alias [ ( column_alias [, ...] ) ] ] ( select ) [ AS ] alias [ ( column_alias [, ...] ) ] with_query_name [ [ AS ] alias [ ( column_alias [, ...] ) ] ] function_name ( [ argument [, ...] ] ) [ AS ] alias [ ( column_alias [, ...] | column_definition [, ...] ) ] function_name ( [ argument [, ...] ] ) AS ( column_definition [, ...] ) from_item [ NATURAL ] join_type from_item [ ON join_condition | USING ( join_column [, ...] ) ] and with_query is: with_query_name [ ( column_name [, ...] ) ] AS ( select | values | insert | update | delete ) TABLE [ ONLY ] table_name [ * ] 

Answer 1

I like the question.

Here is how I see it and how I explain it to people, hope it helps:

Let's start with <expression> as <name> . The simplest analogy from real life is an abbreviation. It was created to make the code cleaner, easier to read and simply shorter. Let's imagine a scenario: we have data on all students from the Massachusetts Institute of Technology as well as Massachusetts Department of Motor Vehicles in our database and we want to find students that have speeding tickets and how much they have paid.

SELECT
    government.SocialSecurityAdministration.FirstName,
    government.SocialSecurityAdministration.LastName,
    education.MasachusettsInstituteOfTechnology.Faculty
    government.DepartmentOfMotorVehiclesTickets.TicketTotal,
    government.SocialSecurityAdministration.SocialSecurityNumber
FROM
    education.MasachusettsInstituteOfTechnology
    INNER JOIN government.DepartmentOfMotorVehiclesTickets ON education.MasachusettsInstituteOfTechnology.SocialSecurityNumber = government.DepartmentOfMotorVehicles.SocialSecurityNumber
    INNER JOIN government.SocialSecurityAdministration ON government.DepartmentOfMotorVehicles.SocialSecurityNumber = government.SocialSecurityAdministration.SocialSecurityNumber

Looks ugly, doesn't it? In real life, we've abbreviated the Massachusetts Institute of Technology to be MIT and the Department of Motor Vehicles to be DMV . I'm not aware of the official abbreviation for Social Security Administration (but we can come up with one) though we say SSN when we mean Social Security Number . Let's implement this idea:

SELECT
        ssnAdm.FirstName,
        ssnAdm.LastName,
        ssnAdm.Faculty
        dmv.TicketTotal,
        ssnAdm.SocialSecurityNumber AS ssn
    FROM
        education.MasachusettsInstituteOfTechnology AS mit
        INNER JOIN government.DepartmentOfMotorVehiclesTickets AS dmv ON mit.SocialSecurityNumber = dmv.SocialSecurityNumber
        INNER JOIN government.SocialSecurityAdministration AS ssAdm ON dmv.SocialSecurityNumber = dmv.SocialSecurityNumber

Looks better now, doesn't it?

Now to the <name> as <expression> portion of it. This is done to simplify the code as well as some performance optimizations but let's focus on simplification for now. Using the same example I've used above, you might want to get/ask the following: " For every MIT student that has received a ticket I need to know the last 4 digits of their SSN, their last name, the amount of money in their bank account and their last VISA transaction amount ". Yes, you work for CIA.

Let's write it:

SELECT
    RIGHT(4,ts.ssn) as LastFourDigitsSsn,
    ts.LastName,
    bad.TotalAmount,
    ISNULL(visa.TransactionAmt,'Student uses MasterCard') AS VisaTransaction
FROM
    (SELECT
        ssnAdm.FirstName,
        ssnAdm.LastName,
        ssnAdm.Faculty
        dmv.TicketTotal,
        ssnAdm.SocialSecurityNumber AS ssn
    FROM
        education.MasachusettsInstituteOfTechnology AS mit
        INNER JOIN government.DepartmentOfMotorVehiclesTickets AS dmv ON mit.SocialSecurityNumber = dmv.SocialSecurityNumber
        INNER JOIN government.SocialSecurityAdministration AS ssAdm ON dmv.SocialSecurityNumber = dmv.SocialSecurityNumber
    ) AS ts
    INNER JOIN business.BankAccountsData AS bad ON ts.ssn = bad.SocialSecurityNumber
    OUTER APPLY (SELECT TOP 1 TransactionAmt FROM business.VisaProcessingData vpd WHERE vpd.BankAccountID = bad.ID ORDER BY TransactionDateTime DESC) as visa

Well, looks ugly again. But what if we simplify it a bit and express certain things outside of the actual statement? That's when <name> as <expression> comes in. Let's do it:

WITH MitTicketedStudents AS (
    SELECT
        ssnAdm.LastName,
        ssnAdm.SocialSecurityNumber as ssn,
        RIGHT(4,ssnAdm.SocialSecurityNumber) as LastFourDigitsSsn
    FROM
        education.MasachusettsInstituteOfTechnology AS mit
        INNER JOIN government.DepartmentOfMotorVehiclesTickets AS dmv ON mit.SocialSecurityNumber = dmv.SocialSecurityNumber
        INNER JOIN government.SocialSecurityAdministration AS ssAdm ON dmv.SocialSecurityNumber = dmv.SocialSecurityNumber
),
LatestVisaTransactions AS (
    SELECT DISTINCT
        BankAccountID,
        FIRST_VALUE(TransactionAmt) OVER (PARTITION BY BankAccountId ORDER BY TransactionDateTime DESC) as TransactionAmt
    FROM
        business.VisaProcessingData
)

-- And let's use our expressions now

SELECT
    mts.LastFourDigitsSsn,
    mts.LastName,
    bad.TotalAmount,
    ISNULL(lvt.TransactionAmt,'Student uses MasterCard') AS VisaTransaction
FROM
    MitTicketedStudents mts
    INNER JOIN business.BankAccountsData AS bad ON mts.ssn = bad.SocialSecurityNumber
    LEFT OUTER JOIN LatestVisaTransactions lvt ON bad.ID = lvt.BankAccountID;

Looks better, doesn't it?

Conclusion: when you want to separate code you use <name> as <expression> , when you want to give something an alias to simplify code you use <expression> as <name> .

Answer 2

What matters is where it appears.

mytable:
mycolumn myothercolumn
----------------------
       1             a
       2             b

SELECT myrow.mycolumn * 2 AS mylabel
FROM (SELECT * FROM mytable) AS myrow
WHERE myrow.mycolumn > 1

mylabel
-------
      4

In SELECT, we refer to the value of an expression AS some output column name ("column alias"). In FROM, we refer to (a typical row of) the value of a table expression AS some name ("table alias", "correlation name").

(It turns out that because of details of the grammar typos are less problematic if we use AS in SELECT clauses but don't use AS in FROM clauses.)

There are other uses of AS. The context also determines what they mean, and they also correspond to using using a name to refer to something.

In technical contexts it turns out not to be helpful to try to make sense of what something means based on the everyday meanings of technical terms, including making sense of what a thing is based on its name. The SQL language designers [sic] didn't choose to always have either <expression> AS <name> or <name> AS <expression> . That is just how it is. That is just how you write stuff to get your program to do stuff to stuff. (Accepted but more modern principles of computer language design do suggest more regular notations.)