transact - T-SQL-Alias ​​usando "=" versus "como"

transact sql examples

Question

¿Hay algún motivo en particular (de rendimiento u otro) para usar AS antes de = cuando se alias una columna?

Mi preferencia personal (por legibilidad) es usar esto:

select
alias1     = somecolumn
alias2     = anothercolumn
from
tables
etc...

en lugar de esto:

select
somecolumn as alias1
anothercolumn as alias2
from
tables
etc...

¿Me estoy perdiendo por alguna razón por la que no debería estar haciendo esto? ¿Cuáles son las preferencias de otras personas cuando se trata de formatear sus columnas?

Answer 1

"=" es simplemente ambiguo.

Si sangra para separar cada cláusula de selección ...

select
    alias1     = somecolumn,
    alias2     = anothercolumn,
    result     = column1 * column2
from
    table
....


select
    somecolumn as          alias1,
    anothercolumn as       alias2,
    column1 * column2 as   result
from
    tables
     ...

Answer 2

''='' no es válido ANSI SQL, por lo que tendrá dificultades si desea ejecutar su aplicación en un DBMS diferente.

(Es cuando se usa el formulario ANSI pero se omite el ''AS'' opcional. Los resultados me resultan difíciles de leer, personalmente).

Answer 3

** incluso prefiero usar ''como'' en lugar de ''=''. ''='' crea confusión en el código.

p.ej :

 column as alias1

Answer 4

= puede confundirse con la asignación y la igualdad; de hecho, la forma que realmente no me gusta es cuando se ve como una cadena (generalmente cuando hay espacios en juego):

somecolumn as ''alias 1''

o

''alias 1'' = somecolumn

Prefiero la notación alternativa:

somecolumn as [alias 1]

Answer 5

El formulario de alias postfix (con o sin el "AS") es consistente entre los alias de columnas y tablas. Personalmente, me gustaría una opción para hacer cumplir el uso de "AS", y entonces no tendrías la situación:

select
    columnA,
    columnB
    columnC
from
    table

produciendo un conjunto de resultados con dos columnas en lugar de las 3 esperadas.

También diría que con el prefijo "=", puede hacer que sea más difícil de leer si está mezclando obteniendo un conjunto de resultados y una asignación de variable:

select
    cA = columnA,
    @cB = columnB,
    cC = columnC
from
    table

Answer 6

Las tres formas que conozco de alias:

1. TableColumn AS MyAlias
2. TableColumn MyAlias
3. MyAlias ​​= TableColumn

Re: 1), prefiero esto ya que es el código más autodocumentado (IMO), y me permite buscar AS necesito encontrar alias.

Re: 2), esta es mi segunda opción, pero sin el AS , nunca estoy seguro de si esto es un error de cortar y pegar o no, especialmente en consultas largas, mal formateadas.

Re: 3), no me gusta esto porque a) parece una tarea, yb) se mezcla demasiado con las cláusulas ON y las declaraciones CASE

Entonces, mi voto es usar la palabra clave AS para sus alias.

Answer 7

Los alias de columna declarados por la sintaxis "=" están en desuso en SQL Server 2008 y no se admiten en la próxima versión. Ver el artículo de MSDN .

Answer 8

No lo usaría simplemente porque se parece demasiado a la operación de igualdad. ''AS'' es claro en la medida en que no es ambiguo para mí.

Es lo mismo que no usar mayúsculas en sql, me resulta más difícil de leer.

Answer 9

No tienes que usar ninguno

Suelta el AS y usa

SELECT originalname alias
FROM
   tablename

Answer 10

Para poner algo de contrapeso, prefiero usar =.

Si soy el consumidor de los resultados de la consulta de alguna manera, me parece más conveniente ver qué columnas puedo usar como consumidor.

prefiero esto

SELECT
      [ElementObligationID] = @MaxElementObligationID + eo.ElementObligationID
      , [ElementID] = eo.ElementID
      , [IsotopeID] = eo.IsotopeID
      , [ObligationID] = eo.ObligationID
      , [ElementWeight] = eo.ElementWeight * -1
      , [FissileWeight] = eo.FissileWeight * -1
      , [Items] = eo.Items * -1
      , [Comment] = eo.Comment
      , [AdditionalComment] = eo.AdditionalComment
      , [Aanmaak_userid] = @UserID
      , [Aanmaak_tijdstip] = GetDate()
      , [Laatste_wijziging_userid] = @UserID
      , [Laatste_wijziging_tijdstip] = GetDate()
FROM  dbo.KTM_ElementObligation eo
      INNER JOIN dbo.KTM_ElementObligationArticle eoa ON 
          eoa.ElementObligationID = eo.ElementObligationID

Más allá de esto

SELECT
      @MaxElementObligationID + eo.ElementObligationID AS [ElementObligationID]
      , eo.ElementID AS [ElementID]
      , eo.IsotopeID AS [IsotopeID]
      , eo.ObligationID AS [ObligationID]
      , eo.ElementWeight * -1 AS [ElementWeight]
      , eo.FissileWeight * -1 AS [FissileWeight]
      , eo.Items * -1 AS [Items]
      , eo.Comment AS [Comment]
      , eo.AdditionalComment AS [AdditionalComment]
      , @UserID AS [Aanmaak_userid]
      , GetDate() AS [Aanmaak_tijdstip]
      , @UserID AS [Laatste_wijziging_userid]
      , GetDate() AS [Laatste_wijziging_tijdstip]
FROM  dbo.KTM_ElementObligation eo
      INNER JOIN dbo.KTM_ElementObligationArticle eoa ON 
          eoa.ElementObligationID = eo.ElementObligationID

solo mi 2c.

Answer 11

Prefiero no usar ninguno de esos. Acabo de dar el nombre de la columna sin ninguna palabra clave en el medio

SELECT MAX(price_column) maximumprice FROM prices

Answer 12

Prefiero usar AS dado que = se usa en la instrucción where, y puede ser confuso en una consulta larga.

Answer 13

Si bien tengo una preferencia por usar AS, lo realmente importante aquí es tener un estándar corporativo y seguirlo. Si más personas usan AS de =, entonces todos deberían usarlo. Los estándares de codificación son lo que hace que sea más fácil mantener el código, no el estándar particular que elija. Si todos usan lo mismo, entonces su ojo se acostumbra a elegirlo.

Answer 14

me gusta el

SELECT
 column1 = table.column1
 ,column2 = table.colum2
FROM table

Encuentro AS no tan fácil de notar en comparación con el signo a = (puedo detectar = más rápido que AS)

Además, cuando uno solo hace SELECCIONAR alias de columna, a veces es confuso saber cuál es cuál :)

Answer 15

No soy tan afortunado como otros que han publicado aquí. El código con el que trabajo normalmente es escrito por otra persona y es raro que no existan sentencias CASE u otros cálculos, concatenaciones o lógica que provoquen que una sola entrada abarque varias filas de script T_SQL.

Usar un signo igual en lugar de ''AS'' es mucho más fácil de leer. Con un signo igual, sabrá que el nombre de alias que está buscando está en la primera posición de la fila. Cuando se usa ''AS'' y el T_SQL abarca varias líneas, el nombre del alias podría estar literalmente en cualquier lugar.

Es mucho, mucho, más fácil encontrar el alias ''Elementos'' cuando se usa igual que cuando se usa ''AS''.

    SELECT
        ElementObligationID = @MaxElementObligationID + eo.ElementObligationID
      , ElementID = eo.ElementID
      , IsotopeID = eo.IsotopeID
      , ObligationID = eo.ObligationID
      , ElementWeight = eo.ElementWeight * -1
      , FissileWeight = eo.FissileWeight * -1
      , Items = CASE WHEN eo.Items < 0 THEN eo.Items * -1
                     WHEN eo.Items > 0 THEN eo.Items
                     ELSE 0 END
      , Comment = eo.Comment
      , AdditionalComment = eo.AdditionalComment
      , Aanmaak_userid = @UserID
      , Aanmaak_tijdstip = GetDate()
      , Laatste_wijziging_userid = @UserID
      , Laatste_wijziging_tijdstip = GetDate()
FROM  dbo.KTM_ElementObligation eo
      INNER JOIN dbo.KTM_ElementObligationArticle eoa ON 
          eoa.ElementObligationID = eo.ElementObligationID

Ahora imagine tener más de 5 veces la cantidad de código que está aquí y la necesidad de encontrar el alias ''Elementos''.

SELECT
      @MaxElementObligationID + eo.ElementObligationID AS ElementObligationID
      , eo.ElementID AS ElementID
      , eo.IsotopeID AS IsotopeID
      , eo.ObligationID AS ObligationID
      , eo.ElementWeight * -1 AS ElementWeight
      , eo.FissileWeight * -1 AS FissileWeight
      , CASE WHEN eo.Items < 0 THEN eo.Items * -1
             WHEN eo.Items > 0 THEN eo.Items
             ELSE 0 END AS Items
      , eo.Comment AS Comment
      , eo.AdditionalComment AS AdditionalComment
      , @UserID AS Aanmaak_userid
      , GetDate() AS Aanmaak_tijdstip
      , @UserID AS Laatste_wijziging_userid
      , GetDate() AS Laatste_wijziging_tijdstip
FROM  dbo.KTM_ElementObligation eo
      INNER JOIN dbo.KTM_ElementObligationArticle eoa ON 
          eoa.ElementObligationID = eo.ElementObligationID

''AS'' vs ''='' no es una preferencia arbitraria y caprichosa. No estoy exagerando cuando digo que ha habido momentos en los que tomaría varios minutos encontrar el nombre de alias que busco porque el autor del guión que ahora estoy a cargo de mantener no utilizó el signo igual con su alias. No puedo pensar en una mayor pérdida de tiempo, dinero y recursos que pagarle a un profesional de TI para buscar nombres de alias en el código. Existe una respuesta correcta y incorrecta si le preocupa la facilidad de mantenimiento, la legibilidad y la eficiencia . ¡Tu trabajo es proporcionar valor comercial, no pasar el día buscando a Waldo!