L'alias table è una cattiva pratica?

Ricordo di aver imparato a farlo in un corso DBMS per studenti del Master of Information Services. Per salvarti un po 'di digitazione, puoi digitare:

SELECT t1.id, t2.stuff 
FROM 
              someTable    t1 
   INNER JOIN otherTable   t2 
      ON t1.id=t2.id
;

Ma ... Perché questo è accettabile nelle procedure memorizzate e simili? Sembra che tutto ciò che fa è danneggiare la leggibilità della dichiarazione risparmiando un tempo estremamente ridotto. C'è qualche motivo funzionale o logico per farlo? Sembra aggiungere ambiguità piuttosto che rimuoverlo; l'unica ragione accettabile che posso vedere per l'utilizzo di questo formato è se si aggiungesse un alias semanticamente significativo, ad esempio, FROM someTable idsTablequando il nome della tabella non è abbastanza descrittivo.

L'alias delle tabelle è una cattiva pratica o è solo un uso improprio di un sistema utile?

L'aliasing della tabella è una pratica comune e utile.

• Ti consente di risparmiare sequenze di tasti quando fai riferimento a colonne in qualsiasi punto della query.
• Migliora la leggibilità del tuo SQL quando fai riferimento a molte tabelle. Gli alias ti consentono di assegnare a quelle tabelle un nome breve più un piccolo significato sul modo in cui vengono utilizzate.
• È anche richiesto quando si unisce un tavolo a se stesso o quando si unisce alla stessa tabella più volte. In questo modo lo Strumento per ottimizzare le query sa a quale tabella si fa riferimento quando si menziona una colonna.

Il seguente estratto di report illustra bene tutti i punti precedenti:

INSERT INTO reporting.txns_extract
SELECT 
    -- 30+ columns snipped
    -- 
    -- Would you want to type out full table names for each 
    -- column here?
FROM 
    -- ... and in the JOIN conditions here?
                billing.financial_transactions  ft_cdi   -- alias required here
    INNER JOIN  
                billing.cash_application_links  cal
            ON  ft_cdi.key_num = cal.applied_ft_key_num
    INNER JOIN  
                billing.financial_transactions  ft_pmt   -- alias required here
            ON  cal.owner_key_num = ft_pmt.key_num
    LEFT OUTER JOIN
                billing.invoice_lines           invl
            ON  ft_cdi.key_num = invl.invoice_key_num
    LEFT OUTER JOIN
                billing.charges                 chrg
            ON  invl.creator_key_num = chrg.key_num
    LEFT OUTER JOIN
                billing.customer_services       cs
            ON  chrg.cs_key_num = cs.key_num
    INNER JOIN
                billing.billers                 bil
            ON  ft_cdi.biller_account_key_num = bil.biller_account_key_num
    INNER JOIN
                billing.formal_entities         fe
            ON  bil.frml_key_num = fe.key_num
WHERE
    -- ... and in the WHERE conditions here?
        ft_cdi.transaction_type <> 'Payment'   -- alias tells me this table is not for payments
    AND ft_cdi.status = 'Approved'
    AND ft_pmt.transaction_type =  'Payment'   -- alias tells me this table is for payments
    AND ft_pmt.status = 'Approved'
    AND ft_cdi.last_user_date >   ft_last_user_date_begin
    AND ft_cdi.last_user_date <=  ft_last_user_date_end
;

Penso che l'uso degli alias aiuti la leggibilità di una query se i nomi delle tabelle sono lunghi o simili tra loro che qualcuno che li legge rapidamente potrebbe confonderli. Pensi che questo ...

SELECT Really_long_table_name.ID,
       Even_longer_table_name_than_before.Name,
       Even_longer_table_name_than_before.Description,
       Even_longer_table_name_than_before.State
FROM   Really_long_table_name
       INNER JOIN Even_longer_table_name_than_before
               ON Really_long_table_name.ID = Even_longer_table_name_than_before.ID
WHERE  Really_long_table_name.Department = 'Whatever' 

è più leggibile di così?

SELECT a.ID,
       b.Name,
       b.Description,
       b.State
FROM   Really_long_table_name a
       INNER JOIN Even_longer_table_name_than_before b
               ON a.ID = b.ID
WHERE  a.Department = 'Whatever' 

A seconda di ciò che usi come alias di tabella, può rendere la query molto più semplice da leggere e comprendere per una persona.

L'aliasing della tabella (per motivi di nomi di tabella più brevi) non è una cattiva pratica.

Di solito lo uso quando i tablename sono lunghi e quindi uso solo l'alias che ha senso:

SELECT tTable.stuff FROM track_table tTable;

Se vuoi migliorare la leggibilità, puoi usare la ASparola chiave:

SELECT tTable.stuff FROM track_table AS tTable;

Ma, quando ti abitui alla sintassi, non è necessario.

Puoi utilizzarlo per aumentare in modo significativo la leggibilità delle tue query. Invece di usare un breve alias, usa il tuo alias per descrivere i dati a cui ti stai unendo, per esempio

SELECT
    transaction.unique_id,
    authorisingUser.name AS authorising_user_name,
    requestingUser.name AS requesting_user_name
FROM transactions AS transaction
JOIN users AS authorisingUser
    ON authorisingUser.user_id = txn.authorising_user_id
JOIN users AS requestingUser
    ON requestingUser.user_id = txn.request_user_id

Mentre l'utilizzo di alias estremamente brevi (come ao t1) può rendere difficile la lettura di una query in quanto è necessario andare a trovare l'alias per cercare cosa significa l'alias, un alias ben definito può spesso rendere una query più leggibile rispetto al semplice utilizzo della tabella nomi.

Questa è una domanda sulla "cattiva pratica". Le risposte sembrano riguardare "Salvare i tasti".

Personalmente, la mia velocità di codifica è limitata dalla mia velocità di pensiero, non dalla mia velocità di battitura. Trovo che il codice con molti alias di tabella sia molto più difficile da leggere rispetto al codice che utilizza i nomi delle tabelle stessi. Gli alias di tabella aggiungono un altro livello di riferimento indiretto.

Tuttavia, la maggior parte dei programmatori utilizza gli alias di tabella (anche se non lo faccio). Alcuni "ambienti di sviluppo SQL" lo rendono molto semplice e alcuni insegnanti insegnano automaticamente gli alias di tabella, specialmente durante l'apprendimento della sintassi "Join".

L'uso degli alias delle tabelle non è una cattiva pratica, ma a volte devo passare attraverso il codice e sostituire gli alias con i nomi delle tabelle originali per capire cosa sta succedendo.