sql - ejemplos - ¿Hay una diferencia entre Select*y Select

select sql server (18)

Esta pregunta ya tiene una respuesta aquí:

¿Cuál es más rápido / mejor? SELECCIONAR * o SELECCIONAR columna1, columna2, columna3, etc. 46 respuestas

Estoy usando MS SQL Server 2005. ¿Hay alguna diferencia, entre el motor SQL, entre

SELECT * FROM MyTable;

SELECT ColA, ColB, ColC FROM MyTable;

Cuando ColA, ColB y ColC representan cada columna en la tabla?

Si son iguales, ¿hay alguna razón por la que deba usar el 2º modo? Tengo un proyecto pesado en LINQ, y no estoy seguro de si el SELECT * estándar que genera es una mala práctica, o si siempre debería ser un .Select () en él para especificar qué cols quiero.

EDIT: ¿Se modificó "cuando ColA, ColB y ColC son todas las columnas de la tabla?" a "¿Cuándo ColA, ColB y ColC representan cada columna en la tabla?" para mayor claridad.

1) El segundo es más explícito sobre qué columnas se devuelven. El valor del segundo es, entonces, cuánto valoras explícitamente saber qué columnas regresan.

2) Esto implica que potencialmente se devuelven menos datos cuando hay más columnas que las explícitamente utilizadas también.

3) Si cambia la tabla agregando una nueva columna, la primera consulta cambia y la segunda no. Si tiene un código como "para todas las columnas devueltas, haga ...", entonces los resultados cambian si usa el primero, pero no el segundo.

Algunas razones para no usar la primera declaración (seleccione *) son:

Si agrega algunos campos grandes (una columna BLOB sería muy mala) más adelante en esa tabla, podría sufrir problemas de rendimiento en la aplicación
Si la consulta era una consulta JOIN con dos o más tablas, algunos de los campos podrían tener el mismo nombre . Sería mejor asegurarse de que sus nombres de campo sean diferentes.
El propósito de la consulta es más claro con la segunda declaración desde un punto de vista de estética de programación

Cuando selecciona cada campo individualmente, queda más claro qué campos se están seleccionando realmente.

Debe especificar una lista de columnas explícita. SELECT * traerá más columnas de las necesarias para crear más IO y tráfico de red, pero lo más importante es que podría requerir búsquedas adicionales aunque exista un índice de cobertura no agrupado (en SQL Server).

Depende de lo que quiere decir con "diferencia". Existe la diferencia de sintaxis obvia, pero la diferencia real es la de rendimiento.

Cuando dice SELECT * FROM MyTable , le está diciendo al motor de consulta SQL que devuelva un conjunto de datos con todas las columnas de esa tabla, mientras que SELECT ColA, ColB, ColC FROM MyTable le dice al motor de consulta que devuelva un conjunto de datos con solo ColA , ColB y ColC de la tabla.

Supongamos que tiene una tabla con 100 columnas definidas como CHAR [10]. SELECT * devolverá 100 columnas * 10 bytes de datos mientras SELECT ColA, ColB, ColC devolverá 3 columnas * 10 bytes de datos. Esta es una gran diferencia de tamaño en la cantidad de datos que se transmiten a través del cable.

Especificar la lista de columnas también aclara mucho en qué columnas está interesado. El inconveniente es que si agrega / quita una columna de la tabla, debe asegurarse de que la lista de columnas también se actualice, pero creo que es un precio pequeño. en comparación con la ganancia de rendimiento.

El uso de "SELECT *" optimiza para la escritura del programador. Eso es. Esa es la única ventaja.

En general, es mejor ser explícito, por lo que Select col1, col2 from Table es mejor. El motivo es que, en algún momento, se puede agregar una columna adicional a esa tabla y provocar que los datos innecesarios vuelvan de la consulta.

Sin embargo, esta no es una regla difícil.

Es bueno para la compatibilidad hacia adelante.

Cuando usas

SELECT * FROM myTable

y en "myTable" son 3 columnas. Obtienes los mismos resultados que

SELECT Column1, Column2, Column3 FROM myTable

Pero si agrega una nueva columna en el futuro, obtendrá diferentes resultados.

Por supuesto, si cambia el nombre de una columna existente, en el primer caso obtendrá resultados y en el segundo caso obtendrá un error (creo que este es el comportamiento correcto de la aplicación).

Las dos caras del problema son las siguientes: la especificación de columna explícita ofrece un mejor rendimiento a medida que se agregan nuevas columnas, pero la especificación * no requiere mantenimiento a medida que se agregan nuevas columnas.

Cuál usar depende del tipo de columnas que espera agregar a la tabla y cuál es el punto de la consulta.

Si está utilizando su tabla como una tienda de respaldo para un objeto (lo que parece probable en el caso LINQ-to-SQL), probablemente desee incluir cualquier nueva columna en esta tabla en su objeto, y viceversa. Los estás manteniendo en paralelo. Por esta razón, para este caso, la especificación * en la cláusula SELECT es correcta. La especificación explícita le daría un poco más de mantenimiento cada vez que algo cambiaba, y un error si no actualizaba la lista de campos correctamente.

Si la consulta va a devolver una gran cantidad de registros, probablemente esté mejor con la especificación explícita por motivos de rendimiento.

Si ambas cosas son ciertas, considere tener dos consultas diferentes.

Para LinqToSql, si planea modificar esos registros más adelante, debe extraer todo el registro en la memoria.

SELECCIONAR * es una mala práctica en la mayoría de los lugares.

¿Qué sucede si alguien agrega una columna BLOB de 2gb a esa tabla?
¿Qué es alguien que realmente agrega una columna a esa tabla?

Es un error esperando a suceder.

Si su código se basa en ciertas columnas que están en un cierto orden, debe enumerar las columnas. Si no, realmente no hace la diferencia si usa "*" o escribe los nombres de las columnas en la declaración de selección.

Un ejemplo es si inserta una columna en una tabla.

Tome esta tabla: ColA ColB ColC

Puede tener una consulta:

SELECT * FROM myTable

Entonces el código podría ser:

rs = executeSql("SELECT * FROM myTable") while (rs.read()) Print "Col A" + rs[0] Print "Col B" + rs[1] Print "Col C" + rs[2]

Si agrega una columna entre ColB y ColC, la consulta no devolverá lo que está buscando.

Un ejemplo de por qué nunca (imho) debería usar SELECT *. Esto no se relaciona con MSSQL, sino con MySQL. Las versiones anteriores a la 5.0.12 devolvieron columnas de ciertos tipos de combinaciones de una manera no estándar. Por supuesto, si sus consultas definen qué columnas quiere y en qué orden no tiene ningún problema. Imagina la diversión si no lo hacen.

(Una posible excepción: su consulta SELECCIONA de una sola tabla e identifica las columnas en su lenguaje de programación elegido por nombre en lugar de posición).

Un par de cosas:

Un buen número de personas han publicado aquí recomendando no usar *, y se les dieron varias buenas razones para esas respuestas. De las otras 10 respuestas hasta el momento, solo una no recomienda incluir columnas.
Las personas a menudo hacen excepciones a esa regla cuando publican para ayudar a sitios como , porque a menudo no saben qué columnas hay en su tabla o si son importantes para su consulta. Por esa razón, verá un montón de código aquí y en otras partes de la web que usa la sintaxis *, aunque el póster tiende a evitarlo en su propio código.

Una mirada rápida al plan de ejecución de consultas muestra que las consultas son las mismas.

La regla general es que querrá limitar sus consultas solo a los campos que necesita devolver.

Voy a molestar a muchas personas conmigo, pero especialmente si agrego columnas más adelante, normalmente me gusta utilizar la tabla SELECCIONAR * DE. Me han llamado flojo por esta razón, porque si hago alguna modificación en mis tablas, me gustaría no rastrear todos los procesos almacenados que usan esa tabla, y simplemente cambiarla en las clases de capa de acceso a datos en mi aplicación . Hay casos en los que especificaré las columnas, pero en el caso en que trato de obtener un "objeto" completo de la base de datos, prefiero usar el "*". Y, sí, sé que la gente me odiará por esto, pero me ha permitido ser más rápido y menos libre de errores al agregar campos a mis aplicaciones.

seleccionar cada columna es mejor que solo * porque, en caso de que agregue o elimine una nueva fila, TIENE que mirar el código y observar lo que estaba haciendo con los datos recuperados.
Además, le ayuda a comprender mejor su código y le permite usar alias como nombres de columna (en caso de que esté realizando una combinación de tablas con una columna que comparte el nombre)

SELECT * FROM MyTable

select * depende del orden de las columnas en el esquema, por lo que si se refiere al resultado establecido por el índice # de la colección, estará mirando la columna incorrecta.

SELECT Col1,Col2,Col3 FROM MyTable

esta consulta le dará una colección que se mantiene igual a lo largo del tiempo, pero ¿con qué frecuencia está cambiando el orden de las columnas de todos modos?