# Referencia de SQL para Amazon S3 Select
<a name="s3-select-sql-reference"></a>

**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/) 

Esta referencia contiene una descripción de los elementos del lenguaje de consulta estructurada (SQL, Structured Query Language) compatibles con Amazon S3 Select.

**Topics**
+ [

# SELECTComando de la
](s3-select-sql-reference-select.md)
+ [

# Tipos de datos
](s3-select-sql-reference-data-types.md)
+ [

# Operadores
](s3-select-sql-reference-operators.md)
+ [

# Palabras clave reservadas
](s3-select-sql-reference-keyword-list.md)
+ [

# Funciones SQL
](s3-select-sql-reference-sql-functions.md)

# SELECTComando de la
<a name="s3-select-sql-reference-select"></a>

**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
<a name="s3-select-sql-reference-select-list"></a>

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
<a name="s3-select-sql-reference-from"></a>

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
<a name="s3-select-sql-reference-where"></a>

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
<a name="s3-select-sql-reference-limit"></a>

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
<a name="s3-select-sql-reference-attribute-access"></a>

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
<a name="s3-select-sql-reference-attribute-access-csv"></a>
+ **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
<a name="s3-select-sql-reference-attribute-access-json"></a>
+ **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
<a name="s3-select-sql-reference-case-sensitivity"></a>

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
<a name="s3-select-sql-reference-using-keywords"></a>

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
<a name="s3-select-sql-reference-scalar"></a>

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`*** ]

# Tipos de datos
<a name="s3-select-sql-reference-data-types"></a>

**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/) 

Amazon S3 Select y S3 Glacier Select admite varios tipos de datos primitivos.

## Conversiones de tipos de datos
<a name="s3-select-sql-reference-data-conversion"></a>

Por lo general, suele seguirse la función `CAST`, si está definida. Si no se ha definido `CAST`, todos los datos de entrada se tratarán como una cadena. En ese caso, deberá convertir sus datos de entrada en los tipos de datos pertinentes cuando sea necesario.

Para obtener más información sobre la función `CAST`, consulte [CAST](s3-select-sql-reference-conversion.md#s3-select-sql-reference-cast).

## Tipos de datos compatibles
<a name="s3-select-sql-reference-supported-data-types"></a>

Amazon S3 Select admite el siguiente subconjunto de tipos de datos primitivos.


|  Nombre  |  Descripción  |  Ejemplos  | 
| --- | --- | --- | 
| `bool` | Un valor booleano, ya sea `TRUE` o `FALSE`. | `FALSE` | 
| `int`, `integer` | Un entero con signo de 8 bytes comprendido entre -9 223 372 036 854 775 808 y 9 223 372 036 854 775 807.  | `100000` | 
| `string` | Una cadena de longitud variable codificada en UTF8. El límite predeterminado es de 1 carácter. El límite máximo de caracteres es de 2 147 483 647.  | `'xyz'` | 
| `float` | Un número de punto flotante de 8 bits.  | `CAST(0.456 AS FLOAT)` | 
| `decimal`, `numeric` |  Un número en base 10, con una precisión máxima de 38 (es decir, el número máximo de dígitos significativos), y con una escala en un intervalo de entre -231 y 231-1 (es decir, el exponente en base 10).  Amazon S3 Select ignora la escala y la precisión cuando se proporcionan ambos al mismo tiempo.   | `123.456 ` | 
| `timestamp` |  Las marcas temporales representan un momento concreto, siempre incluyen el desfase horario local y permiten establecer una precisión arbitraria. En formato de texto, las marcas temporales siguen los [formatos de fecha y hora de la notación W3C](https://www.w3.org/TR/NOTE-datetime), pero deben terminar por el literal `T` si las marcas temporales no tienen, como mínimo, una precisión de un día completo. Se pueden utilizar fracciones de segundo con al menos un dígito de precisión y sin ningún límite máximo. El desfase horario local puede representarse con el formato hora:minuto con relación a UTC o con el literal `Z` para indicar la hora local en UTC. Los desfases horarios locales deben incluirse en las marcas temporales que contienen la hora, pero no están permitidos en los valores de fecha.  | `CAST('2007-04-05T14:30Z' AS TIMESTAMP)` | 

### Tipos de Parquet admitidos
<a name="s3-select-sql-reference-supported-data-types-parquet"></a>

Amazon S3 Select admite los siguientes tipos de Parquet.
+ `DATE`
+ `DECIMAL`
+ `ENUM`
+ `INT(8)`
+ `INT(16)`
+ `INT(32)`
+ `INT(64)`
+ `LIST`
**nota**  
Para la salida de tipo Parquet `LIST`, Amazon S3 Select solo admite el formato JSON. Sin embargo, si la consulta limita los datos a valores simples, también se puede consultar el tipo Parquet `LIST` en formato CSV.
+ `STRING`
+ Precisión admitida de `TIMESTAMP` (`MILLIS`/`MICROS`/`NANOS`)
**nota**  
No se admiten las marcas temporales guardadas como `INT(96)`.   
Debido al rango del tipo `INT(64)`, las marcas temporales que utilizan la unidad `NANOS` solo pueden representar valores entre `1677-09-21 00:12:43` y `2262-04-11 23:47:16`. Los valores fuera de este rango no se pueden representar con la unidad `NANOS`.

### Asignación de tipos de Parquet a tipos de datos admitidos en Amazon S3 Select
<a name="s3-select-sql-reference-supported-data-types-parquet-mapping"></a>


| Tipos de Parquet | Tipos de datos compatibles | 
| --- | --- | 
| `DATE` |  `timestamp`  | 
|  `DECIMAL`  |  `decimal`, `numeric`  | 
|  `ENUM`  |  `string`  | 
|  `INT(8)`  |  `int`, `integer`  | 
|  `INT(16)`  | `int`, `integer` | 
| `INT(32)` | `int`, `integer` | 
|  `INT(64)`  |  `decimal`, `numeric`  | 
|  `LIST`  |  Cada tipo de Parquet de la lista se asigna al tipo de datos correspondiente.  | 
|  `STRING`  |  `string`  | 
|  `TIMESTAMP`  |  `timestamp`  | 

# Operadores
<a name="s3-select-sql-reference-operators"></a>

**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/) 

Amazon S3 Select admite los siguientes operadores.

## Operadores lógicos
<a name="s3-select-sql-reference-loical-ops"></a>
+ `AND`
+ `NOT`
+ `OR`

## Operadores de comparación
<a name="s3-select-sql-reference-compare-ops"></a>
+ `<` 
+ `>` 
+ `<=`
+ `>=`
+ `=`
+ `<>`
+ `!=`
+ `BETWEEN`
+ `IN` – Por ejemplo: `IN ('a', 'b', 'c')`

  

## Operadores de coincidencia de patrones
<a name="s3-select-sql-reference-pattern"></a>
+ `LIKE`
+ `_` (coincide con cualquier carácter)
+ `%` (coincide con cualquier secuencia de caracteres)

## Operadores unitarios
<a name="s3-select-sql-reference-unitary-ops"></a>
+ `IS NULL`
+ `IS NOT NULL`

## Operadores matemáticos
<a name="s3-select-sql-referencemath-ops"></a>

Se admiten los operadores de suma, resta, multiplicación, división y módulo:
+ \$1
+ -
+ \$1
+ /
+ %

## Jerarquía de los operadores
<a name="s3-select-sql-reference-op-Precedence"></a>

En la siguiente tabla se muestra la prioridad de los operadores en orden descendente.


|  Operador o elemento  |  Asociatividad |  Obligatorio  | 
| --- | --- | --- | 
| `-`  | derecha  | menos unario  | 
| `*`, `/`, `%`  | izquierda  | multiplicación, división, módulo  | 
| `+`, `-`  | izquierda  | suma, resta  | 
| `IN` |  | pertenencia a un conjunto  | 
| `BETWEEN` |  | limitación de intervalos  | 
| `LIKE` |  | coincidencia de patrones de cadena  | 
| `<``>` |  | menor que, mayor que  | 
| `=` | derecha  | igualdad, asignación | 
| `NOT` | derecha | negación lógica  | 
| `AND` | izquierda | conjunción lógica  | 
| `OR` | izquierda | disyunción lógica  | 

# Palabras clave reservadas
<a name="s3-select-sql-reference-keyword-list"></a>

**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/) 

A continuación, se muestra la lista de palabras clave reservadas para Amazon S3 Select. Entre estas palabras clave se incluyen los nombres de funciones, tipos de datos, operadores, etc., que se necesitan para ejecutar las expresiones SQL utilizadas para consultar el contenido de los objetos.

```
absolute
action
add
all
allocate
alter
and
any
are
as
asc
assertion
at
authorization
avg
bag
begin
between
bit
bit_length
blob
bool
boolean
both
by
cascade
cascaded
case
cast
catalog
char
char_length
character
character_length
check
clob
close
coalesce
collate
collation
column
commit
connect
connection
constraint
constraints
continue
convert
corresponding
count
create
cross
current
current_date
current_time
current_timestamp
current_user
cursor
date
day
deallocate
dec
decimal
declare
default
deferrable
deferred
delete
desc
describe
descriptor
diagnostics
disconnect
distinct
domain
double
drop
else
end
end-exec
escape
except
exception
exec
execute
exists
external
extract
false
fetch
first
float
for
foreign
found
from
full
get
global
go
goto
grant
group
having
hour
identity
immediate
in
indicator
initially
inner
input
insensitive
insert
int
integer
intersect
interval
into
is
isolation
join
key
language
last
leading
left
level
like
limit
list
local
lower
match
max
min
minute
missing
module
month
names
national
natural
nchar
next
no
not
null
nullif
numeric
octet_length
of
on
only
open
option
or
order
outer
output
overlaps
pad
partial
pivot
position
precision
prepare
preserve
primary
prior
privileges
procedure
public
read
real
references
relative
restrict
revoke
right
rollback
rows
schema
scroll
second
section
select
session
session_user
set
sexp
size
smallint
some
space
sql
sqlcode
sqlerror
sqlstate
string
struct
substring
sum
symbol
system_user
table
temporary
then
time
timestamp
timezone_hour
timezone_minute
to
trailing
transaction
translate
translation
trim
true
tuple
union
unique
unknown
unpivot
update
upper
usage
user
using
value
values
varchar
varying
view
when
whenever
where
with
work
write
year
zone
```

# Funciones SQL
<a name="s3-select-sql-reference-sql-functions"></a>

**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/) 

Amazon S3 Select admite las siguientes funciones SQL.

**Topics**
+ [

# Funciones de agregación
](s3-select-sql-reference-aggregate.md)
+ [

# Funciones condicionales
](s3-select-sql-reference-conditional.md)
+ [

# Funciones de conversión
](s3-select-sql-reference-conversion.md)
+ [

# Funciones de datos
](s3-select-sql-reference-date.md)
+ [

# Funciones de cadena
](s3-select-sql-reference-string.md)

# Funciones de agregación
<a name="s3-select-sql-reference-aggregate"></a>

**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/) 

Amazon S3 Select admite las siguientes funciones de agregación.


| Función | Tipo de argumento | Tipo de retorno | 
| --- | --- | --- | 
| `AVG(expression)` | `INT`, `FLOAT`, `DECIMAL` | `DECIMAL` para un argumento `INT`, `FLOAT` para un argumento de coma flotante; en el resto de casos, el mismo que el tipo de datos del argumento. | 
| `COUNT` |  `-`  | `INT` | 
| `MAX(expression)` | `INT`, `DECIMAL` | El mismo que el tipo del argumento. | 
| `MIN(expression)` | `INT`, `DECIMAL` | El mismo que el tipo del argumento. | 
| `SUM(expression)` | `INT`, `FLOAT`, `DOUBLE`, `DECIMAL` | `INT` para un argumento `INT`, `FLOAT` para un argumento de coma flotante; en el resto de casos, el mismo que el tipo de datos del argumento. | 

## SUMEjemplo de
<a name="s3-select-sql-reference-aggregate-case-examples"></a>

Para agregar los tamaños totales de los objetos de una carpeta en un [informe de inventario de S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/storage-inventory.html), utilice una expresión `SUM`.

El siguiente informe de inventario de S3 es un archivo CSV comprimido con GZIP. Hay tres columnas.
+ La primera columna es el nombre del bucket de S3 (*`DOC-EXAMPLE-BUCKET`*) al que se destina el informe de inventario de S3.
+ La segunda columna es el nombre clave que identifica de forma exclusiva el objeto en el bucket.

  El valor `example-folder/` de la primera fila corresponde a la carpeta `example-folder`. En Amazon S3, cuando crea una carpeta en su bucket, S3 crea un objeto de 0 bytes con una clave establecida al nombre de la carpeta que ha proporcionado.

  El valor `example-folder/object1` de la segunda fila corresponde al objeto `object1` de la carpeta `example-folder`.

  El valor `example-folder/object2` de la tercera fila corresponde al objeto `object2` de la carpeta `example-folder`.

  Para obtener más información sobre las carpetas de S3, consulte [Organización de objetos en la consola de Amazon S3 con carpetas](using-folders.md).
+ La tercera columna es el tamaño del objeto en bytes.

```
"DOC-EXAMPLE-BUCKET","example-folder/","0"
"DOC-EXAMPLE-BUCKET","example-folder/object1","2011267"
"DOC-EXAMPLE-BUCKET","example-folder/object2","1570024"
```

Para usar una expresión `SUM` para calcular el tamaño total de la carpeta `example-folder`, ejecute la consulta SQL con Amazon S3 Select.

```
SELECT SUM(CAST(_3 as INT)) FROM s3object s WHERE _2 LIKE 'example-folder/%' AND _2 != 'example-folder/';
```

Resultado de la consulta: 

```
3581291
```

# Funciones condicionales
<a name="s3-select-sql-reference-conditional"></a>

**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/) 

Amazon S3 Select admite las siguientes funciones condicionales.

**Topics**
+ [

## CASE
](#s3-select-sql-reference-case)
+ [

## COALESCE
](#s3-select-sql-reference-coalesce)
+ [

## NULLIF
](#s3-select-sql-reference-nullif)

## CASE
<a name="s3-select-sql-reference-case"></a>

La expresión `CASE` es una expresión condicional similar a las instrucciones `if/then/else` que se encuentran en otros lenguajes. `CASE` se utiliza para especificar un resultado cuando hay varias condiciones. Existen dos tipos de expresiones `CASE`: simple y buscada.

En expresiones `CASE` simples, una expresión se compara con un valor. Cuando hay una coincidencia, se aplica la acción especificada en la cláusula `THEN`. Si no se encuentra ninguna coincidencia, se aplica la acción en la cláusula `ELSE`.

En las expresiones `CASE` buscadas, cada `CASE` se evalúa según una expresión booleana y la instrucción `CASE` devuelve el primer `CASE` que coincida. Si no hay ninguna coincidencia de `CASE` entre las cláusulas `WHEN`, se devuelve la acción en la cláusula `ELSE`.

### Sintaxis
<a name="s3-select-sql-reference-case-syntax"></a>

**nota**  
Actualmente, Amazon S3 Select no admite `ORDER BY` ni consultas que contienen líneas nuevas. Asegúrese de usar consultas sin saltos de línea.

A continuación, se muestra una instrucción `CASE` sencilla que se utiliza para hacer coincidir condiciones:

```
CASE expression WHEN value THEN result [WHEN...] [ELSE result] END					
```

La siguiente es una instrucción `CASE` buscada que se utiliza para evaluar cada condición:

```
CASE WHEN boolean condition THEN result [WHEN ...] [ELSE result] END					
```

### Ejemplos
<a name="s3-select-sql-reference-case-examples"></a>

**nota**  
Si utiliza la consola de Amazon S3 para ejecutar los siguientes ejemplos y el archivo CSV contiene una fila de encabezado, elija **Excluir la primera línea de datos CSV**. 

**Ejemplo 1:** utilice una expresión `CASE` simple para reemplazar `New York City` por `Big Apple` en una consulta. Reemplace todos los demás nombres de ciudad por `other`.

```
SELECT venuecity, CASE venuecity WHEN 'New York City' THEN 'Big Apple' ELSE 'other' END FROM S3Object;
```

Resultado de la consulta: 

```
venuecity        |   case
-----------------+-----------
Los Angeles      | other
New York City    | Big Apple
San Francisco    | other
Baltimore        | other
...
```

**Ejemplo 2:** Utilice una expresión `CASE` buscada para asignar números de grupo según el valor `pricepaid` para ventas de tickets individuales:

```
SELECT pricepaid, CASE WHEN CAST(pricepaid as FLOAT) < 10000 THEN 'group 1' WHEN CAST(pricepaid as FLOAT) > 10000 THEN 'group 2' ELSE 'group 3' END FROM S3Object;					
```

Resultado de la consulta: 

```
pricepaid |  case
-----------+---------
12624.00 | group 2
10000.00 | group 3
10000.00 | group 3
9996.00 | group 1
9988.00 | group 1
...
```

## COALESCE
<a name="s3-select-sql-reference-coalesce"></a>

`COALESCE` evalúa los argumentos por orden y devuelve el primero que no sea desconocido, es decir, el primero no nulo o que no falta. Esta función no propaga los argumentos nulos o que faltan.

### Sintaxis
<a name="s3-select-sql-reference-coalesce-syntax"></a>

```
COALESCE ( expression, expression, ... )
```

### Parameters
<a name="s3-select-sql-reference-coalesce-parameters"></a>

 *`expression`*   
La expresión de destino sobre la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-coalesce-examples"></a>

```
COALESCE(1)                -- 1
COALESCE(null)             -- null
COALESCE(null, null)       -- null
COALESCE(missing)          -- null
COALESCE(missing, missing) -- null
COALESCE(1, null)          -- 1
COALESCE(null, null, 1)    -- 1
COALESCE(null, 'string')   -- 'string'
COALESCE(missing, 1)       -- 1
```

## NULLIF
<a name="s3-select-sql-reference-nullif"></a>

Dadas dos expresiones, `NULLIF` devuelve `NULL` si ambas toman el mismo valor; en caso contrario, `NULLIF` devuelve el resultado de la evaluación de la primera expresión.

### Sintaxis
<a name="s3-select-sql-reference-nullif-syntax"></a>

```
NULLIF ( expression1, expression2 )
```

### Parameters
<a name="s3-select-sql-reference-nullif-parameters"></a>

 `expression1, expression2`   
Las expresiones de destino sobre las que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-nullif-examples"></a>

```
NULLIF(1, 1)             -- null
NULLIF(1, 2)             -- 1
NULLIF(1.0, 1)           -- null
NULLIF(1, '1')           -- 1
NULLIF([1], [1])         -- null
NULLIF(1, NULL)          -- 1
NULLIF(NULL, 1)          -- null
NULLIF(null, null)       -- null
NULLIF(missing, null)    -- null
NULLIF(missing, missing) -- null
```

# Funciones de conversión
<a name="s3-select-sql-reference-conversion"></a>

**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/) 

Amazon S3 Select admite la siguiente función de conversión.

**Topics**
+ [

## CAST
](#s3-select-sql-reference-cast)

## CAST
<a name="s3-select-sql-reference-cast"></a>

La función `CAST` convierte una entidad (por ejemplo, una expresión que da como resultado un único valor) de un tipo a otro. 

### Sintaxis
<a name="s3-select-sql-reference-cast-syntax"></a>

```
CAST ( expression AS data_type )
```

### Parameters
<a name="s3-select-sql-reference-cast-parameters"></a>

 *`expression`*   
Combinación de uno o varios valores, operadores o funciones SQL que dan como resultado un valor.

 *`data_type`*   
Tipo de datos de destino (por ejemplo, `INT`) al que se va a convertir la expresión. Para obtener una lista de los tipos de datos admitidos, consulte [Tipos de datos](s3-select-sql-reference-data-types.md).

### Ejemplos
<a name="s3-select-sql-reference-cast-examples"></a>

```
CAST('2007-04-05T14:30Z' AS TIMESTAMP)
CAST(0.456 AS FLOAT)
```

# Funciones de datos
<a name="s3-select-sql-reference-date"></a>

**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/) 

Amazon S3 Select admite las siguientes funciones de fecha.

**Topics**
+ [

## DATE\$1ADD
](#s3-select-sql-reference-date-add)
+ [

## DATE\$1DIFF
](#s3-select-sql-reference-date-diff)
+ [

## EXTRACT
](#s3-select-sql-reference-extract)
+ [

## TO\$1STRING
](#s3-select-sql-reference-to-string)
+ [

## TO\$1TIMESTAMP
](#s3-select-sql-reference-to-timestamp)
+ [

## UTCNOW
](#s3-select-sql-reference-utcnow)

## DATE\$1ADD
<a name="s3-select-sql-reference-date-add"></a>

Dadas una parte de fecha, una cantidad y una marca temporal, `DATE_ADD` devuelve una marca temporal actualizada alterando la parte de fecha por la cantidad especificada.

### Sintaxis
<a name="s3-select-sql-reference-date-add-syntax"></a>

```
DATE_ADD( date_part, quantity, timestamp )
```

### Parameters
<a name="s3-select-sql-reference-date-add-parameters"></a>

*`date_part`*   
Especifica qué parte de la fecha se debe modificar. Puede ser una de las siguientes:  
+ año
+ mes
+ día
+ hora
+ minuto
+ segundos

 *`quantity`*   
El valor que se debe aplicar a la marca temporal actualizada. Los valores positivos de `quantity` se agregan a la parte de fecha de la marca temporal, y los valores negativos se restan.

 *`timestamp`*   
La marca temporal de destino en la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-date-add-examples"></a>

```
DATE_ADD(year, 5, `2010-01-01T`)                -- 2015-01-01 (equivalent to 2015-01-01T)
DATE_ADD(month, 1, `2010T`)                     -- 2010-02T (result will add precision as necessary)
DATE_ADD(month, 13, `2010T`)                    -- 2011-02T
DATE_ADD(day, -1, `2017-01-10T`)                -- 2017-01-09 (equivalent to 2017-01-09T)
DATE_ADD(hour, 1, `2017T`)                      -- 2017-01-01T01:00-00:00
DATE_ADD(hour, 1, `2017-01-02T03:04Z`)          -- 2017-01-02T04:04Z
DATE_ADD(minute, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:05:05.006Z
DATE_ADD(second, 1, `2017-01-02T03:04:05.006Z`) -- 2017-01-02T03:04:06.006Z
```

## DATE\$1DIFF
<a name="s3-select-sql-reference-date-diff"></a>

Dadas una parte de fecha y dos marcas temporales válidas, `DATE_DIFF` devuelve la diferencia entre las partes de fecha. El valor devuelto es un número entero negativo si el valor `date_part` de `timestamp1` es mayor que el valor `date_part` de `timestamp2`. El valor devuelto es un número entero positivo si el valor `date_part` de `timestamp1` es menor que el valor `date_part` de `timestamp2`.

### Sintaxis
<a name="s3-select-sql-reference-date-diff-syntax"></a>

```
DATE_DIFF( date_part, timestamp1, timestamp2 )
```

### Parameters
<a name="s3-select-sql-reference-date-diff-parameters"></a>

 **`date_part`**   
Especifica qué parte de las marcas temporales se debe comparar. Para ver la definición de `date_part`, consulte [DATE\$1ADD](#s3-select-sql-reference-date-add).

 **`timestamp1`**   
La primera marca temporal que se va a comparar.

 **`timestamp2`**   
La segunda marca temporal que se va a comparar.

### Ejemplos
<a name="s3-select-sql-reference-date-diff-examples"></a>

```
DATE_DIFF(year, `2010-01-01T`, `2011-01-01T`)            -- 1
DATE_DIFF(year, `2010T`, `2010-05T`)                     -- 4 (2010T is equivalent to 2010-01-01T00:00:00.000Z)
DATE_DIFF(month, `2010T`, `2011T`)                       -- 12
DATE_DIFF(month, `2011T`, `2010T`)                       -- -12
DATE_DIFF(day, `2010-01-01T23:00`, `2010-01-02T01:00`) -- 0 (need to be at least 24h apart to be 1 day apart)
```

## EXTRACT
<a name="s3-select-sql-reference-extract"></a>

Dadas una parte de fecha y una marca temporal, `EXTRACT` devuelve el valor de la parte de fecha de la marca temporal.

### Sintaxis
<a name="s3-select-sql-reference-extract-syntax"></a>

```
EXTRACT( date_part FROM timestamp )
```

### Parameters
<a name="s3-select-sql-reference-extract-parameters"></a>

 **`date_part`**   
Especifica qué parte de las marcas temporales se va a extraer. Puede ser una de las siguientes:  
+ `YEAR`
+ `MONTH`
+ `DAY`
+ `HOUR`
+ `MINUTE`
+ `SECOND`
+ `TIMEZONE_HOUR`
+ `TIMEZONE_MINUTE`

 **`timestamp`**   
La marca temporal de destino en la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-extract-examples"></a>

```
EXTRACT(YEAR FROM `2010-01-01T`)                           -- 2010
EXTRACT(MONTH FROM `2010T`)                                -- 1 (equivalent to 2010-01-01T00:00:00.000Z)
EXTRACT(MONTH FROM `2010-10T`)                             -- 10
EXTRACT(HOUR FROM `2017-01-02T03:04:05+07:08`)             -- 3
EXTRACT(MINUTE FROM `2017-01-02T03:04:05+07:08`)           -- 4
EXTRACT(TIMEZONE_HOUR FROM `2017-01-02T03:04:05+07:08`)    -- 7
EXTRACT(TIMEZONE_MINUTE FROM `2017-01-02T03:04:05+07:08`)  -- 8
```

## TO\$1STRING
<a name="s3-select-sql-reference-to-string"></a>

Dados una marca temporal y un patrón de formato, `TO_STRING` devuelve una representación de cadena de la marca temporal en el formato especificado.

### Sintaxis
<a name="s3-select-sql-reference-size-syntax"></a>

```
TO_STRING ( timestamp time_format_pattern )
```

### Parameters
<a name="s3-select-sql-reference-size-parameters"></a>

 *`timestamp`*   
La marca temporal de destino en la que opera la función.

 *`time_format_pattern`*   
Una cadena que tiene las siguientes interpretaciones de caracteres especiales:      
[\[See the AWS documentation website for more details\]](http://docs.aws.amazon.com/es_es/AmazonS3/latest/userguide/s3-select-sql-reference-date.html)

### Ejemplos
<a name="s3-select-sql-reference-size-examples"></a>

```
TO_STRING(`1969-07-20T20:18Z`,  'MMMM d, y')                    -- "July 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMM d, yyyy')                   -- "Jul 20, 1969"
TO_STRING(`1969-07-20T20:18Z`, 'M-d-yy')                        -- "7-20-69"
TO_STRING(`1969-07-20T20:18Z`, 'MM-d-y')                        -- "07-20-1969"
TO_STRING(`1969-07-20T20:18Z`, 'MMMM d, y h:m a')               -- "July 20, 1969 8:18 PM"
TO_STRING(`1969-07-20T20:18Z`, 'y-MM-dd''T''H:m:ssX')           -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00Z`, 'y-MM-dd''T''H:m:ssX')     -- "1969-07-20T20:18:00Z"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXX')   -- "1969-07-20T20:18:00+0800"
TO_STRING(`1969-07-20T20:18+08:00`, 'y-MM-dd''T''H:m:ssXXXXX')  -- "1969-07-20T20:18:00+08:00"
```

## TO\$1TIMESTAMP
<a name="s3-select-sql-reference-to-timestamp"></a>

Dada una cadena, `TO_TIMESTAMP` la convierte en una marca temporal. `TO_TIMESTAMP` es la operación inversa de `TO_STRING`.

### Sintaxis
<a name="s3-select-sql-reference-to-timestamp-syntax"></a>

```
TO_TIMESTAMP ( string )
```

### Parameters
<a name="s3-select-sql-reference-to-timestamp-parameters"></a>

 *`string`*   
La cadena de destino sobre la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-to-timestamp-examples"></a>

```
TO_TIMESTAMP('2007T')                         -- `2007T`
TO_TIMESTAMP('2007-02-23T12:14:33.079-08:00') -- `2007-02-23T12:14:33.079-08:00`
```

## UTCNOW
<a name="s3-select-sql-reference-utcnow"></a>

`UTCNOW` devuelve la hora actual en UTC como una marca temporal.

### Sintaxis
<a name="s3-select-sql-reference-utcnow-syntax"></a>

```
UTCNOW()
```

### Parameters
<a name="s3-select-sql-reference-utcnow-parameters"></a>

`UTCNOW` no acepta parámetros.

### Ejemplos
<a name="s3-select-sql-reference-utcnow-examples"></a>

```
UTCNOW() -- 2017-10-13T16:02:11.123Z
```

# Funciones de cadena
<a name="s3-select-sql-reference-string"></a>

**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/) 

Amazon S3 Select admite las siguientes funciones de cadena.

**Topics**
+ [

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
](#s3-select-sql-reference-char-length)
+ [

## LOWER
](#s3-select-sql-reference-lower)
+ [

## SUBSTRING
](#s3-select-sql-reference-substring)
+ [

## TRIM
](#s3-select-sql-reference-trim)
+ [

## UPPER
](#s3-select-sql-reference-upper)

## CHAR\$1LENGTH, CHARACTER\$1LENGTH
<a name="s3-select-sql-reference-char-length"></a>

`CHAR_LENGTH` (o `CHARACTER_LENGTH`) cuenta el número de caracteres de la cadena especificada.

**nota**  
`CHAR_LENGTH` y `CHARACTER_LENGTH` son sinónimos.

### Sintaxis
<a name="s3-select-sql-reference-char-length-syntax"></a>

```
CHAR_LENGTH ( string )
```

### Parameters
<a name="s3-select-sql-reference-char-length-parameters"></a>

 *`string`*   
La cadena de destino sobre la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-char-length-examples"></a>

```
CHAR_LENGTH('')          -- 0
CHAR_LENGTH('abcdefg')   -- 7
```

## LOWER
<a name="s3-select-sql-reference-lower"></a>

Dada una cadena, `LOWER` convierte todos los caracteres en mayúsculas a minúsculas. Los caracteres que no estén en mayúscula permanecen igual.

### Sintaxis
<a name="s3-select-sql-reference-lower-syntax"></a>

```
LOWER ( string )
```

### Parameters
<a name="s3-select-sql-reference-lower-parameters"></a>

 **`string`**   
La cadena de destino sobre la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-lower-examples"></a>

```
LOWER('AbCdEfG!@#$') -- 'abcdefg!@#$'
```

## SUBSTRING
<a name="s3-select-sql-reference-substring"></a>

Dada una cadena, un índice de comienzo y, de forma opcional, una longitud, `SUBSTRING` devuelve la subcadena que va desde el índice de comienzo hasta el final de la cadena, o hasta la longitud especificada.

**nota**  
El primer carácter de la cadena de entrada tiene una posición de índice de 1.  
 Si `start` es < 1, sin especificar una longitud, la posición de índice se establece a 1. 
 Si `start` es < 1, con la longitud especificada, la posición de índice se establece a `start + length -1`. 
 Si `start + length -1` < 0, se devuelve una cadena vacía. 
 Si `start + length -1` > = 0, se devuelve la subcadena que comienza en la posición de índice 1 con la longitud `start + length - 1`. 

### Sintaxis
<a name="s3-select-sql-reference-substring-syntax"></a>

```
SUBSTRING( string FROM start [ FOR length ] )
```

### Parameters
<a name="s3-select-sql-reference-substring-parameters"></a>

 **`string`**   
La cadena de destino sobre la que opera la función.

 **`start`**   
La posición de inicio de la cadena.

 **`length`**   
La longitud de la subcadena que se va a devolver. Si no existe, continúa hasta el final de la cadena.

### Ejemplos
<a name="s3-select-sql-reference-substring-examples"></a>

```
SUBSTRING("123456789", 0)      -- "123456789"
SUBSTRING("123456789", 1)      -- "123456789"
SUBSTRING("123456789", 2)      -- "23456789"
SUBSTRING("123456789", -4)     -- "123456789"
SUBSTRING("123456789", 0, 999) -- "123456789" 
SUBSTRING("123456789", 1, 5)   -- "12345"
```

## TRIM
<a name="s3-select-sql-reference-trim"></a>

Elimina los caracteres anteriores o posteriores de una cadena. De forma predeterminada, el carácter que se elimina es un espacio (`' '`).

### Sintaxis
<a name="s3-select-sql-reference-trim-syntax"></a>

```
TRIM ( [[LEADING | TRAILING | BOTH remove_chars] FROM] string )
```

### Parameters
<a name="s3-select-sql-reference-trim-parameters"></a>

 **`string`**   
La cadena de destino sobre la que opera la función.

 `LEADING` \$1 `TRAILING` \$1 `BOTH`   
Este parámetro indica si se deben eliminar los caracteres anteriores o posteriores, o ambos.

 **`remove_chars`**   
El conjunto de caracteres que se debe eliminar. `remove_chars` puede ser una cadena con longitud > 1. Esta función devuelve la cadena con los caracteres de `remove_chars` encontrados al principio o al final de la cadena que se han eliminado.

### Ejemplos
<a name="s3-select-sql-reference-trim-examples"></a>

```
TRIM('       foobar         ')               -- 'foobar'
TRIM('      \tfoobar\t         ')            -- '\tfoobar\t'
TRIM(LEADING FROM '       foobar         ')  -- 'foobar         '
TRIM(TRAILING FROM '       foobar         ') -- '       foobar'
TRIM(BOTH FROM '       foobar         ')     -- 'foobar'
TRIM(BOTH '12' FROM '1112211foobar22211122') -- 'foobar'
```

## UPPER
<a name="s3-select-sql-reference-upper"></a>

Dada una cadena, `UPPER` convierte todos los caracteres en minúsculas a mayúsculas. Los caracteres que no estén en minúscula permanecen igual.

### Sintaxis
<a name="s3-select-sql-reference-upper-syntax"></a>

```
UPPER ( string )
```

### Parameters
<a name="s3-select-sql-reference-upper-parameters"></a>

 **`string`**   
La cadena de destino sobre la que opera la función.

### Ejemplos
<a name="s3-select-sql-reference-upper-examples"></a>

```
UPPER('AbCdEfG!@#$') -- 'ABCDEFG!@#$'
```