# SELECTComando de la **importante** Amazon S3 Select ya no está disponible para los nuevos clientes. Los clientes actuales de Amazon S3 Select pueden seguir utilizando la característica de la forma habitual. [Más información](https://aws.amazon.com/blogs/storage/how-to-optimize-querying-your-data-in-amazon-s3/) El trabajo Select de solamente es compatible con el comando `SELECT` de SQL. Las siguientes cláusulas del estándar ANSI son compatibles con `SELECT`: + `SELECT` list + `FROM`Cláusula + `WHERE`Cláusula + `LIMIT`Cláusula **nota** Actualmente, las consultas de Amazon S3 Select no admiten subconsultas ni combinaciones. ## SELECT list La lista `SELECT` asigna un nombre a las columnas, funciones y expresiones que desea que devuelva la consulta. La lista representa el resultado de la consulta. ``` SELECT * SELECT projection1 AS column_alias_1, projection2 AS column_alias_2 ``` El primer formato de `SELECT` con `*` (asterisco) devuelve todas las filas que superan la cláusula `WHERE`, tal y como están. La segunda forma de `SELECT` crea una fila con expresiones escalares de resultado definidas por el usuario **`projection1`** y **`projection2`** para cada columna. ## FROMCláusula Amazon S3 Select admite los siguientes formatos en la cláusula `FROM`: ``` FROM table_name FROM table_name alias FROM table_name AS alias ``` En cada forma de la cláusula `FROM`, `table_name` es el `S3Object` que se está consultando. Los usuarios acostumbrados a las bases de datos relacionales tradicionales pueden hacerse a la idea de que se trata de un esquema de base de datos que contiene varias vistas de una tabla. Siguiendo el código SQL estándar, la cláusula `FROM` crea filas que se filtran en la cláusula `WHERE` y se proyectan en la lista `SELECT`. Para objetos JSON almacenados en Amazon S3 Select, también puede usar las siguientes formas de la cláusula `FROM`: ``` FROM S3Object[*].path FROM S3Object[*].path alias FROM S3Object[*].path AS alias ``` Con esta forma de la cláusula `FROM`, puede seleccionar de matrices u objetos dentro de un objeto JSON. Puede especificar `path`, mediante una de las formas siguientes: + Por nombre (en un objeto): `.name` o `['name']` + Por índice (en una matriz): `[index]` + Por carácter comodín (en un objeto): `.*` + Por carácter comodín (en una matriz): `[*]` **nota** Esta forma de la cláusula `FROM` solo funciona con objetos JSON. Los caracteres comodín siempre emiten al menos un registro. Si no coincide ningún registro, Amazon S3 Select emite el valor `MISSING`. Durante la serialización de salida (después de que finalice la ejecución de la consulta), Amazon S3 Select reemplaza los valores de `MISSING` por registros vacíos. Las funciones de agregación (`AVG`, `COUNT`, `MAX`, `MIN` y `SUM`) hacen caso omiso de los valores de `MISSING`. Si no proporciona un alias cuando usa un carácter comodín, puede referirse a la fila mediante el último elemento en la ruta. Por ejemplo, puede seleccionar todos los precios de una lista de libros mediante la consulta `SELECT price FROM S3Object[*].books[*].price`. Si la ruta termina con un carácter comodín en lugar de un nombre, puede usar el valor `_1` para referirse a la fila. Por ejemplo, en lugar de `SELECT price FROM S3Object[*].books[*].price`, podría utilizar la consulta `SELECT _1.price FROM S3Object[*].books[*]`. Amazon S3 Select siempre trata un documento JSON como una matriz de valores de nivel raíz. Por lo tanto, incluso si el objeto JSON que está consultando solo tiene un elemento raíz, la cláusula `FROM` debe comenzar con `S3Object[*]`. Sin embargo, por razones de compatibilidad, Amazon S3 Select le permite omitir el carácter comodín si no incluye una ruta. Además, la cláusula completa `FROM S3Object` es equivalente a `FROM S3Object[*] as S3Object`. Si incluye una ruta, también debe usar el carácter comodín. Por lo tanto, `FROM S3Object` y `FROM S3Object[*].path` son cláusulas válidas, pero `FROM S3Object.path` no. **Example** **Ejemplos:** *Ejemplo \$11* Este ejemplo muestra resultados al usar el conjunto de datos y la consulta siguientes: ``` { "Rules": [ {"id": "1"}, {"expr": "y > x"}, {"id": "2", "expr": "z = DEBUG"} ]} { "created": "June 27", "modified": "July 6" } ``` ``` SELECT id FROM S3Object[*].Rules[*].id ``` ``` {"id":"1"} {} {"id":"2"} {} ``` Amazon S3 Select produce cada resultado por las siguientes razones: + `{"id":"id-1"}`: `S3Object[0].Rules[0].id` produjo una coincidencia. + `{}`: `S3Object[0].Rules[1].id` no encontró un registro coincidente, por lo que Amazon S3 Select emitió `MISSING`, que se cambió a un registro vacío durante la serialización de salida y se devolvió. + `{"id":"id-2"}`: `S3Object[0].Rules[2].id` produjo una coincidencia. + `{}`: `S3Object[1]` no encontró un registro coincidente en `Rules`, por lo que Amazon S3 Select emitió `MISSING`, que se cambió a un registro vacío durante la serialización de salida y se devolvió. Si no quiere que Amazon S3 Select devuelva registros vacíos cuando no encuentre una coincidencia, puede probar el valor `MISSING`. La siguiente consulta devuelve los mismos resultados que la consulta anterior, pero con los valores vacíos omitidos: ``` SELECT id FROM S3Object[*].Rules[*].id WHERE id IS NOT MISSING ``` ``` {"id":"1"} {"id":"2"} ``` *Ejemplo \$12* Este ejemplo muestra resultados al usar el conjunto de datos y las consultas siguientes: ``` { "created": "936864000", "dir_name": "important_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": ".aws" }, { "name": "downloads" } ], "owner": "Amazon S3" } { "created": "936864000", "dir_name": "other_docs", "files": [ { "name": "." }, { "name": ".." }, { "name": "my stuff" }, { "name": "backup" } ], "owner": "User" } ``` ``` SELECT d.dir_name, d.files FROM S3Object[*] d ``` ``` {"dir_name":"important_docs","files":[{"name":"."},{"name":".."},{"name":".aws"},{"name":"downloads"}]} {"dir_name":"other_docs","files":[{"name":"."},{"name":".."},{"name":"my stuff"},{"name":"backup"}]} ``` ``` SELECT _1.dir_name, _1.owner FROM S3Object[*] ``` ``` {"dir_name":"important_docs","owner":"Amazon S3"} {"dir_name":"other_docs","owner":"User"} ``` ## WHERECláusula La cláusula `WHERE` utiliza esta sintaxis: ``` WHERE condition ``` La cláusula `WHERE` filtra las filas en función de `condition`. Una condición es una expresión que tiene un resultado booleano. En el resultado, solamente se devuelven las filas en las que la condición es `TRUE`. ## LIMITCláusula La cláusula `LIMIT` utiliza esta sintaxis: ``` LIMIT number ``` La cláusula `LIMIT` limita el número de registros que debe devolver la consulta basándose en `number`. ## Acceso mediante atributos Las cláusulas `SELECT` y `WHERE` pueden referirse a los datos de los registros mediante uno de los métodos de las secciones siguientes, dependiendo de si el archivo que se está consultando está en formato CSV o en formato JSON. ### CSV + **Números de columnas**: se puede hacer referencia a la columna *n* de una fila con el nombre de columna `_N`, donde *`N`* es la posición de la columna. El número de posición empieza en 1. Por ejemplo, la primera columna se denomina `_1` y la segunda, `_2`. Se puede hacer referencia a una columna como `_N` o `alias._N`. Por ejemplo, `_2` y `myAlias._2` son formas válidas de hacer referencia a una columna en la lista `SELECT` y la cláusula `WHERE`. + **Encabezados de columna**: para los objetos con formato CSV que tienen una fila de encabezado, los encabezados están disponibles para la lista `SELECT` y la cláusula `WHERE`. En concreto, al igual que ocurre en SQL tradicional, dentro de las expresiones de las cláusulas `SELECT` y `WHERE`, se puede hacer referencia a las columnas mediante `alias.column_name` o `column_name`. ### JSON + **Documento**: se puede tener acceso a los campos del documento JSON como `alias.name`. También puede acceder a los campos anidados, por ejemplo, `alias.name1.name2.name3`. + **Lista**: se puede obtener acceso a los elementos de una lista JSON mediante índices basados en cero con el operador `[]`. Por ejemplo, se puede obtener acceso al segundo elemento de una lista como `alias[1]`. Puede combinar el acceso a los elementos de la lista con campos, por ejemplo,`alias.name1.name2[1].name3`. + **Ejemplos**: considere este objeto JSON como un conjunto de datos de ejemplo: ``` {"name": "Susan Smith", "org": "engineering", "projects": [ {"project_name":"project1", "completed":false}, {"project_name":"project2", "completed":true} ] } ``` *Ejemplo \$11* La siguiente consulta devuelve estos resultados: ``` Select s.name from S3Object s ``` ``` {"name":"Susan Smith"} ``` *Ejemplo \$12* La siguiente consulta devuelve estos resultados: ``` Select s.projects[0].project_name from S3Object s ``` ``` {"project_name":"project1"} ``` ## Distinción entre mayúsculas y minúsculas en los nombres de atributos o encabezados Con Amazon S3 Select, puede utilizar comillas dobles para indicar que los encabezados de columna (para los objetos CSV) y los atributos (para los objetos JSON) distinguen entre mayúsculas y minúsculas. Sin comillas dobles, los encabezados y los atributos de los objetos no distinguen entre mayúsculas y minúsculas. En casos de ambigüedad, se produce un error. Los ejemplos siguientes son: 1) objetos de Amazon S3 Select en formato CSV con los encabezados de columna especificados y con `FileHeaderInfo` establecido a `"Use"` para la solicitud de consulta; o 2) objetos de Amazon S3 en formato JSON con los atributos especificados. *Ejemplo 1:* el objeto que se consulta tiene el encabezado o el atributo `NAME`. + La expresión siguiente devuelve los valores del objeto correctamente. Como no hay comillas, la consulta no distingue entre mayúsculas y minúsculas. ``` SELECT s.name from S3Object s ``` + La expresión siguiente da como resultado un error 400 `MissingHeaderName`. Como hay comillas, la consulta distingue entre mayúsculas y minúsculas. ``` SELECT s."name" from S3Object s ``` *Ejemplo 2:* el objeto de Amazon S3 que se consulta tiene un encabezado o un atributo con `NAME` y otro encabezado o atributo con `name`. + La expresión siguiente da como resultado un error 400 `AmbiguousFieldName`. Como no hay comillas, la consulta no distingue entre mayúsculas y minúsculas, pero hay dos coincidencias, por lo que se genera el error. ``` SELECT s.name from S3Object s ``` + La expresión siguiente devuelve los valores del objeto correctamente. Como hay comillas, la consulta distingue entre mayúsculas y minúsculas, por lo que no hay ambigüedad. ``` SELECT s."NAME" from S3Object s ``` ## Uso de palabras clave reservadas como términos definidos por el usuario Amazon S3 Select tiene un conjunto de palabras clave reservadas que son necesarias para ejecutar las expresiones SQL utilizadas para consultar el contenido de los objetos. Entre estas palabras clave reservadas se incluyen nombres de funciones, tipos de datos, operadores, etc. En algunos casos, los términos definidos por el usuario, como los encabezados de columna (para los archivos CSV) o los atributos (para los objetos JSON), pueden entrar en conflicto con una palabra clave reservada. Cuando esto ocurre, debe utilizar comillas dobles para indicar que está utilizando deliberadamente un término definido por el usuario que entra en conflicto con una palabra clave reservada. De lo contrario, se producirá un error de análisis 400. Para obtener la lista completa de las palabras clave reservadas, consulte [Palabras clave reservadas](s3-select-sql-reference-keyword-list.md). El ejemplo siguiente es: 1) un objeto de Amazon S3 Select en formato CSV con los encabezados de columna especificados y con `FileHeaderInfo` establecido a `"Use"` para la solicitud de consulta; o 2) un objeto de Amazon S3 en formato JSON con los atributos especificados. *Ejemplo:* el objeto que se consulta tiene el encabezado o el atributo denominado `CAST`, que es una palabra clave reservada. + La expresión siguiente devuelve los valores del objeto correctamente. Como se utilizan comillas en la consulta, S3 Select utiliza el encabezado o el atributo definido por el usuario. ``` SELECT s."CAST" from S3Object s ``` + La expresión siguiente da como resultado un error de análisis 400. Como no se utilizan comillas en la consulta, `CAST` está en conflicto con una palabra clave reservada. ``` SELECT s.CAST from S3Object s ``` ## Expresiones escalares En la cláusula `WHERE` y la lista `SELECT`, puede tener *expresiones escalares* de SQL, que son expresiones que devuelven valores escalares. Tienen el siguiente formato: + ***`literal`*** Literal SQL. + ***`column_reference`*** Una referencia a una columna con el formato `column_name` o`alias.column_name`. + **`unary_op`** **`expression`** En este caso, ****`unary_op`**** es un operador unario de SQL. + **`expression`** **`binary_op`** ***`expression`*** En este caso, ****`binary_op`**** es un operador binario de SQL. + **`func_name`** En este caso, **`func_name`** es el nombre de la función escalar que se va a invocar. + ***`expression`*** `[ NOT ] BETWEEN` ****`expression`**** `AND` ****`expression`**** + ***`expression`*** `LIKE` ****`expression`**** [ `ESCAPE` ***`expression`*** ]