¿El alias de tabla es una mala práctica?

Recuerdo haber aprendido a hacer esto en un curso DBMS para estudiantes de Master of Information Services. Para ahorrarse algo de escritura, puede escribir:

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

Pero ... ¿Por qué es esto aceptable en procedimientos almacenados y tal? Parece que todo lo que hace es dañar la legibilidad de la declaración mientras ahorra una cantidad extremadamente pequeña de tiempo. ¿Hay alguna razón funcional o lógica para hacer esto? Parece agregar ambigüedad en lugar de eliminarla; La única razón aceptable que puedo ver para usar este formato es si estaba agregando un alias semánticamente significativo, por ejemplo, FROM someTable idsTablecuando el nombre de la tabla no es lo suficientemente descriptivo.

¿El alias de tablas es una mala práctica o es solo un mal uso de un sistema útil?

El alias de tabla es una práctica común y útil.

• Le ahorra pulsaciones de teclas cuando hace referencia a columnas en cualquier parte de su consulta.
• Mejora la legibilidad de su SQL cuando hace referencia a muchas tablas. Los alias le permiten dar a esas tablas un nombre corto más un pequeño significado de cómo se están utilizando.
• Incluso es necesario cuando une una tabla a sí mismo o cuando se une a la misma tabla varias veces. Esto es para que el optimizador de consultas sepa a qué tabla hace referencia cuando menciona una columna.

El siguiente extracto de informes ilustra muy bien todos los puntos anteriores:

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
;

Creo que el uso de alias ayuda a la legibilidad de una consulta si los nombres de las tablas son tan largos o similares entre sí que alguien que los lea rápidamente podría confundirlos. ¿Crees que esto ...

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' 

es más legible que esto?

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' 

Dependiendo de lo que use como alias de tabla, puede hacer que la consulta sea mucho más simple para que una persona la lea y comprenda.

El alias de tabla (en aras de nombres de tabla más cortos) no es una mala práctica.

Normalmente lo uso cuando los nombres de las tablas son largos y luego solo uso el alias que tiene sentido:

SELECT tTable.stuff FROM track_table tTable;

Si desea mejorar la legibilidad, puede usar la ASpalabra clave:

SELECT tTable.stuff FROM track_table AS tTable;

Pero, a medida que se acostumbra a la sintaxis, no es necesario.

Puede usar esto para aumentar significativamente la legibilidad de sus consultas. En lugar de usar un alias corto, use su alias para describir los datos a los que se está uniendo, por ejemplo

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

Si bien el uso de alias extremadamente cortos (como ao t1) puede hacer que una consulta sea difícil de leer, ya que necesita ir y encontrar el alias para buscar lo que significa el alias, un alias bien nombrado a menudo puede hacer que una consulta sea más legible que simplemente usar la tabla nombres

Esta es una pregunta sobre "mala práctica". Las respuestas parecen ser sobre "Guardar pulsaciones de teclas".

Personalmente, mi velocidad de codificación está limitada por mi velocidad de pensamiento, no por mi velocidad de escritura. Encuentro que el código con muchos alias de tabla es mucho más difícil de leer que el código que usa los nombres de las tablas. Los alias de tabla agregan otro nivel de indirección.

Sin embargo, la mayoría de los programadores usan alias de tabla (aunque yo no). Algunos "entornos de desarrollo de SQL" hacen que esto sea muy fácil de hacer, y algunos maestros enseñan alias de tabla automáticamente, especialmente como parte del aprendizaje de la sintaxis "Join".

Usar alias de tabla no es una mala práctica, pero a veces tengo que pasar por el código y reemplazar los alias con los nombres de las tablas originales para comprender lo que está sucediendo.