# Información sobre cómo pasar de SQL a NoSQL
Si es desarrollador de aplicaciones, es posible que tenga alguna experiencia con el sistema de administración de bases de datos relacionales (RDBMS, por sus siglas en inglés) y con el lenguaje de consulta estructurada SQL. Cuando comience a utilizar Amazon DynamoDB, observará numerosas similitudes, pero también bastantes diferencias. El término *NoSQL* se utiliza para describir los sistemas de bases de datos no relacionales que tienen un alto grado de disponibilidad y escalabilidad y están optimizados para ofrecer un rendimiento elevado. En lugar del modelo relacional, las bases de datos NoSQL (como DynamoDB) utilizan modelos alternativos de administración de datos, como los pares clave-valor o el almacenamiento de documentos. Para obtener más información, consulte [¿Qué es NoSQL?](https://aws.amazon.com/nosql).
Amazon DynamoDB admite [PartiQL](https://partiql.org/), un lenguaje de consulta de código abierto compatible con SQL que facilita la consulta de datos de forma eficiente, independientemente de dónde o en qué formato se almacenen. Con PartiQL, puede procesar fácilmente datos estructurados de bases de datos relacionales, datos semiestructurados y anidados en formatos de datos abiertos e incluso datos sin esquema en bases de datos NoSQL o de documentos que permiten distintos atributos para diferentes filas. Para obtener más información, consulte [Lenguaje de consulta PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html).
En las siguientes secciones se describen las tareas que suelen llevarse a cabo con las bases de datos y se comparan y contrastan las instrucciones de SQL con las operaciones de DynamoDB equivalentes.
**nota**
Los ejemplos de SQL de esta sección son compatibles con el RDBMS MySQL.
En los ejemplos de DynamoDB de esta sección, se muestra el nombre de la operación de DynamoDB junto con los parámetros de dicha operación en formato JSON.
**Topics**
+ [
# Elección entre relacional (SQL) y NoSQL
](SQLtoNoSQL.WhyDynamoDB.md)
+ [
# Diferencias al acceder a una base de datos relacional (SQL) y DynamoDB
](SQLtoNoSQL.Accessing.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al crear una tabla
](SQLtoNoSQL.CreateTable.md)
+ [
# Diferencias entre obtener información de tablas de una base de datos relacional (SQL) y DynamoDB
](SQLtoNoSQL.GetTableInfo.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al escribir datos en una tabla
](SQLtoNoSQL.WriteData.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al leer datos de una tabla
](SQLtoNoSQL.ReadData.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al administrar índices
](SQLtoNoSQL.Indexes.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al modificar datos de una tabla
](SQLtoNoSQL.UpdateData.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al eliminar datos de una tabla
](SQLtoNoSQL.DeleteData.md)
+ [
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al eliminar una tabla
](SQLtoNoSQL.RemoveTable.md)
# Elección entre relacional (SQL) y NoSQL
Los requisitos de las aplicaciones actuales son más exigentes que nunca. Por ejemplo, un juego online podría comenzar con unos pocos usuarios y una pequeña cantidad de datos. No obstante, si el juego tiene éxito, puede superar fácilmente los recursos del sistema de administración de bases de datos subyacente. Es frecuente que las aplicaciones basadas en Web tengan cientos, miles o millones de usuarios simultáneos, que generen nuevos datos del orden de terabytes o más. Las bases de datos de este tipo de aplicaciones deben administrar decenas o cientos de miles de lecturas y escrituras por segundo.
Amazon DynamoDB es apropiada para cargas de trabajo de este tipo. Como desarrollador, puede comenzar a pequeña escala y aumentar gradualmente a medida que su aplicación adquiera popularidad. DynamoDB se escala de manera fluida hasta administrar enormes cantidades de datos y de usuarios.
Para obtener más información sobre el modelado tradicional de bases de datos relacionales y cómo adaptarlo a DynamoDB, consulte [Prácticas recomendadas para modelar datos relacionales en DynamoDB](bp-relational-modeling.md).
En la siguiente tabla se muestran algunas diferencias generales nivel entre un sistema de administración de bases de datos relacionales (RDBMS) y DynamoDB.
****
| Característica | Sistema de base de datos relacional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Cargas de trabajo óptimas | Consultas ad-hoc; almacenamiento de datos; OLAP (procesamiento analítico online). | Aplicaciones a escala Web, tales como redes sociales, juegos, intercambio de contenido multimedia o Internet de las cosas (IoT). |
| Modelo de datos | El modelo relacional requiere un esquema bien definido, cuyos datos estén normalizados en tablas, filas y columnas. Además, se definen todas las relaciones entre las tablas, las columnas, los índices y otros componentes de las bases de datos. | DynamoDB no utiliza ningún esquema. Cada tabla debe tener una clave principal para identificar cada elemento de datos de forma exclusiva, pero no existen restricciones similares para otros atributos que no son de clave. DynamoDB puede administrar datos estructurados o semiestructurados, incluidos los documentos JSON. |
| Acceso a los datos | SQL es el lenguaje de consulta estándar para almacenar y recuperar datos. Las bases de datos relacionales ofrecen un amplio conjunto de herramientas que simplifican el desarrollo de las aplicaciones basadas en bases de datos, pero en todas estas herramientas se utiliza SQL. | Puede utilizar Consola de administración de AWS, AWS CLI o NoSQL WorkBench para trabajar con DynamoDB y llevar a cabo tareas ad-hoc. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un lenguaje de consulta compatible con SQL, le permite seleccionar, insertar, actualizar y eliminar datos en DynamoDB. Las aplicaciones pueden usar los kits de desarrollo de software (SDK) de AWS para trabajar con DynamoDB a través de interfaces basadas en objetos, centradas en documentos o de bajo nivel. |
| Desempeño | Las bases de datos relacionales están optimizadas para el almacenamiento, de modo que, por lo general, su rendimiento depende del subsistema de disco. Los desarrolladores y administradores de bases de datos deben optimizar las consultas, los índices y la estructura de las tablas para lograr el máximo rendimiento. | DynamoDB está optimizado para la informática, por lo que el rendimiento depende principalmente del hardware subyacente y de la latencia de la red. Al tratarse de un servicio administrado, DynamoDB desvincula al desarrollador y a sus aplicaciones de estos detalles de implementación, para que pueda centrarse en diseñar y crear aplicaciones robustas de alto rendimiento. |
| Escalado | Resulta más fácil de escalar con un hardware más rápido. Además, es posible que las tablas de la base de datos abarquen varios hosts en un sistema distribuido, pero para ello se requiere una mayor inversión. Las bases de datos relacionales presentan tamaños máximos en atención al número y al tamaño de los archivos, lo que impone límites máximos de escalabilidad. | DynamoDB se ha diseñado para escalar horizontalmente por medio de clústeres de hardware distribuidos. Este diseño permite obtener un rendimiento mejorado sin aumentar la latencia. Los clientes especifican sus requisitos de rendimiento y DynamoDB asigna recursos suficientes para satisfacer estos requisitos. No hay límite en cuanto al número de elementos por tabla, ni al tamaño total de dicha tabla. |
# Diferencias al acceder a una base de datos relacional (SQL) y DynamoDB
Antes de que su aplicación pueda acceder a una base de datos, debe *autenticarse* para garantizar que la aplicación pueda usar la base de datos. Debe *autorizarse* para que la aplicación pueda realizar solo las acciones para las que tiene permisos.
En el siguiente diagrama se muestra la interacción de un cliente con una base de datos relacional y con Amazon DynamoDB.
![\[Interacción con bases de datos relacionales y NoSQL.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/SQLtoNoSQL.png)
En la tabla siguiente se muestra más información acerca de las tareas de interacción del cliente.
****
| Característica | Sistema de base de datos relacional (RDBMS) | Amazon DynamoDB |
| --- | --- | --- |
| Herramientas para obtener acceso a la base de datos | La mayoría de las bases de datos relacionales ofrecen una interfaz de línea de comandos (CLI), que permite especificar instrucciones SQL ad-hoc y ver los resultados de forma inmediata. | En la mayoría de los casos, el desarrollador debe escribir el código de aplicación. También puede usar Consola de administración de AWS, AWS Command Line Interface (AWS CLI) o NoSQL WorkBench para enviar solicitudes ad-hoc a DynamoDB y ver los resultados. [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un lenguaje de consulta compatible con SQL, le permite seleccionar, insertar, actualizar y eliminar datos en DynamoDB. |
| Conexión a la base de datos | Un programa de aplicación establece y mantiene una conexión de red con la base de datos. Cuando la aplicación finaliza, termina la conexión. | DynamoDB es un servicio web y las interacciones con él son sin estado. Las aplicaciones no tienen que mantener conexiones de red persistentes. En lugar de ello, la interacción con DynamoDB se produce mediante solicitudes y respuestas HTTP(S). |
| Autenticación | Una aplicación no puede conectarse a la base de datos hasta que se ha autenticado. El RDBMS puede llevar a cabo la autenticación por sí mismo, o bien delegar esta tarea en el sistema operativo host o en un servicio de directorio. | Cada solicitud a DynamoDB debe ir acompañada de una firma criptográfica, que autentica esa solicitud concreta. Los SDK de AWS proporcionan toda la lógica necesaria para crear firmas y firmar solicitudes. Para obtener más información, consulte [Firma de solicitudes de la API de AWS](https://docs.aws.amazon.com/general/latest/gr/signing_aws_api_requests.html) en la Referencia general de AWS. |
| Autorización | Las aplicaciones solo pueden llevar a cabo aquellas acciones para las cuales tienen permiso. Los administradores de bases de datos o los propietarios de las aplicaciones pueden utilizar las instrucciones GRANT y REVOKE de SQL para controlar el acceso a los objetos de base de datos (tales como las tablas), los datos (como las filas de una tabla) o la capacidad de emitir determinadas instrucciones de SQL. | En DynamoDB, la autorización se administra mediante AWS Identity and Access Management (IAM). Puede escribir una política de IAM que conceda permisos para un recurso de DynamoDB (por ejemplo, una tabla) y, a continuación, permitir a los usuarios y los roles que utilicen esa política. IAM también presenta control de acceso preciso a los elementos de datos individuales contenidos en las tablas de DynamoDB. Para obtener más información, consulte [Identity and Access Management en Amazon DynamoDB](security-iam.md). |
| Envío de una solicitud | La aplicación emite una instrucción de SQL para todas las operaciones de base de datos que quiere realizar. Al recibir la instrucción de SQL, el RDBMS comprueba su sintaxis, crea un plan para realizar la operación y, a continuación, ejecuta el plan. | La aplicación envía solicitudes HTTP(S) a DynamoDB. Las solicitudes contienen el nombre de la operación de DynamoDB que hay que realizar, junto con los parámetros. DynamoDB ejecuta la solicitud de forma inmediata. |
| Recepción de una respuesta | El RDBMS devuelve los resultados de la instrucción de SQL. Si se produce un error, el RDBMS devuelve un estado de error y un mensaje. | DynamoDB devuelve una respuesta HTTP(S) que contiene los resultados de la operación. Si se produce un error, DynamoDB devuelve un estado de error de HTTP y uno o varios mensajes. |
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al crear una tabla
Las tablas son las estructuras de datos fundamentales tanto en las bases de datos relacionales como en Amazon DynamoDB. Un sistema de administración de bases de datos relacionales (RDBMS) requiere que se defina el esquema de la tabla al crearla. En cambio, las tablas de DynamoDB no tienen esquemas por lo tanto, salvo la clave principal, no hay que definir ningún atributo o tipo de datos al crear la tabla.
En la siguiente sección se compara cómo crearía una tabla con SQL y cómo lo haría con DynamoDB.
**Topics**
+ [
## Creación de una tabla con SQL
](#SQLtoNoSQL.CreateTable.SQL)
+ [
## Creación de una tabla con DynamoDB
](#SQLtoNoSQL.CreateTable.DynamoDB)
## Creación de una tabla con SQL
Con SQL, usaría la instrucción `CREATE TABLE` para crear una tabla, como se muestra en el ejemplo siguiente.
```
CREATE TABLE Music (
Artist VARCHAR(20) NOT NULL,
SongTitle VARCHAR(30) NOT NULL,
AlbumTitle VARCHAR(25),
Year INT,
Price FLOAT,
Genre VARCHAR(10),
Tags TEXT,
PRIMARY KEY(Artist, SongTitle)
);
```
La clave principal de esta tabla consta de *Artist* y *SongTitle*.
Debe definir la clave principal, así como todas las columnas y tipos de datos de la tabla. Puede usar la instrucción `ALTER TABLE` para cambiar estas definiciones más adelante si fuera preciso.
Muchas implementaciones de SQL permiten definir especificaciones de almacenamiento de la tabla en la propia instrucción `CREATE TABLE`. A menos que se indique otra cosa, la tabla se crea con los ajustes de almacenamiento predeterminados. En un entorno de producción, un administrador de base de datos puede ayudar a determinar los parámetros de almacenamiento óptimos.
## Creación de una tabla con DynamoDB
Use la operación `CreateTable` para crear una tabla en modo aprovisionado; para ello, especifique los parámetros que se muestran a continuación:
```
{
TableName : "Music",
KeySchema: [
{
AttributeName: "Artist",
KeyType: "HASH" //Partition key
},
{
AttributeName: "SongTitle",
KeyType: "RANGE" //Sort key
}
],
AttributeDefinitions: [
{
AttributeName: "Artist",
AttributeType: "S"
},
{
AttributeName: "SongTitle",
AttributeType: "S"
}
],
ProvisionedThroughput: { // Only specified if using provisioned mode
ReadCapacityUnits: 1,
WriteCapacityUnits: 1
}
}
```
La clave principal de esta tabla consta de *Artist* (clave de partición) y *SongTitle* (clave de ordenación).
Debe proporcionar los siguientes parámetros a `CreateTable`:
+ `TableName`: nombre de la tabla.
+ `KeySchema`: atributos que se utilizan para la clave principal. Para obtener más información, consulte [Tablas, elementos y atributos](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.TablesItemsAttributes) y [Clave principal](HowItWorks.CoreComponents.md#HowItWorks.CoreComponents.PrimaryKey).
+ `AttributeDefinitions`: tipos de datos de los atributos del esquema de claves.
+ `ProvisionedThroughput (for provisioned tables)`: número de lecturas y escrituras por segundo que se requieren para esta tabla. DynamoDB reserva recursos de almacenamiento y del sistema suficientes para cumplir en todo momento los requisitos de rendimiento. Puede usar la operación `UpdateTable` para cambiar estos valores más adelante si fuera preciso. No es necesario especificar los requisitos de almacenamiento de una tabla, porque DynamoDB se encarga de administrar todas las asignaciones del almacenamiento.
# Diferencias entre obtener información de tablas de una base de datos relacional (SQL) y DynamoDB
Puede comprobar que una tabla se ha creado de acuerdo con sus especificaciones. En una base de datos relacional, se muestra el esquema completo de la tabla. Las tablas de Amazon DynamoDB no tienen esquema, por lo que solo se muestran los atributos de clave principal.
**Topics**
+ [
## Obtención de información sobre una tabla con SQL
](#SQLtoNoSQL.GetTableInfo.SQL)
+ [
## Obtención de información sobre una tabla en DynamoDB
](#SQLtoNoSQL.GetTableInfo.DynamoDB)
## Obtención de información sobre una tabla con SQL
La mayoría de los sistemas de administración de bases de datos relacionales (RDBMS) permiten describir una estructura de tabla; a saber, columnas, tipos de datos, definición de clave principal, etc. No existe una manera estándar de realizar esta tarea en SQL. Sin embargo, en muchos sistemas de base de datos se proporciona un comando `DESCRIBE`. A continuación se muestra un ejemplo de MySQL.
```
DESCRIBE Music;
```
Este código devuelve la estructura de la tabla, con todos los nombres de columnas, los tipos de datos y los tamaños.
```
+------------+-------------+------+-----+---------+-------+
| Field | Type | Null | Key | Default | Extra |
+------------+-------------+------+-----+---------+-------+
| Artist | varchar(20) | NO | PRI | NULL | |
| SongTitle | varchar(30) | NO | PRI | NULL | |
| AlbumTitle | varchar(25) | YES | | NULL | |
| Year | int(11) | YES | | NULL | |
| Price | float | YES | | NULL | |
| Genre | varchar(10) | YES | | NULL | |
| Tags | text | YES | | NULL | |
+------------+-------------+------+-----+---------+-------+
```
La clave principal de esta tabla consta de *Artist* y *SongTitle*.
## Obtención de información sobre una tabla en DynamoDB
DynamoDB posee una operación `DescribeTable`, que es parecida. El único parámetro es el nombre de la tabla.
```
{
TableName : "Music"
}
```
La respuesta de `DescribeTable` tiene el siguiente aspecto.
```
{
"Table": {
"AttributeDefinitions": [
{
"AttributeName": "Artist",
"AttributeType": "S"
},
{
"AttributeName": "SongTitle",
"AttributeType": "S"
}
],
"TableName": "Music",
"KeySchema": [
{
"AttributeName": "Artist",
"KeyType": "HASH" //Partition key
},
{
"AttributeName": "SongTitle",
"KeyType": "RANGE" //Sort key
}
],
...
```
`DescribeTable` también proporciona información acerca de los índices de la tabla, los ajustes de rendimiento aprovisionado, el recuento de elementos aproximado y otros metadatos.
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al escribir datos en una tabla
Las tablas de las bases de datos relacionales contienen *filas* de datos. Las filas constan de *columnas*. Las tablas de Amazon DynamoDB contienen *elementos*. Los elementos constan de *atributos*.
En esta sección se describe cómo escribir una fila (o un elemento) en una tabla.
**Topics**
+ [
## Escritura de datos en una tabla con SQL
](#SQLtoNoSQL.WriteData.SQL)
+ [
## Escritura de datos en una tabla de DynamoDB
](#SQLtoNoSQL.WriteData.DynamoDB)
## Escritura de datos en una tabla con SQL
Una tabla de una base de datos relacional es una estructura de datos bidimensional formada por filas y columnas. Algunos sistemas de administración de bases de datos también ofrecen compatibilidad con datos semiestructurados, normalmente con los tipos de datos de JSON o XML nativos. Sin embargo, los detalles de implementación varían según el proveedor.
En SQL, se utilizaría la instrucción `INSERT` para agregar una fila a una tabla.
```
INSERT INTO Music
(Artist, SongTitle, AlbumTitle,
Year, Price, Genre,
Tags)
VALUES(
'No One You Know', 'Call Me Today', 'Somewhat Famous',
2015, 2.14, 'Country',
'{"Composers": ["Smith", "Jones", "Davis"],"LengthInSeconds": 214}'
);
```
La clave principal de esta tabla consta de *Artist* y *SongTitle*. Debe especificar los valores de estas columnas.
**nota**
En este ejemplo se utiliza la columna *Tags* para almacenar datos semiestructurados relativos a las canciones de la tabla *Music*. La columna *Tags* se define como el tipo TEXT, que permite almacenar hasta 65,535 caracteres en MySQL.
## Escritura de datos en una tabla de DynamoDB
En Amazon DynamoDB, puede utilizar la API de DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para agregar un elemento a una tabla.
------
#### [ DynamoDB API ]
Con la API de DynamoDB, se utiliza la operación `PutItem` para agregar un elemento a una tabla.
```
{
TableName: "Music",
Item: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today",
"AlbumTitle":"Somewhat Famous",
"Year": 2015,
"Price": 2.14,
"Genre": "Country",
"Tags": {
"Composers": [
"Smith",
"Jones",
"Davis"
],
"LengthInSeconds": 214
}
}
}
```
La clave principal de esta tabla consta de *Artist* y *SongTitle*. Debe especificar los valores de estos atributos.
A continuación se indican algunos aspectos clave que es preciso tener en cuenta sobre este ejemplo de `PutItem`:
+ DynamoDB proporciona compatibilidad nativa con documentos mediante JSON. Por ello, DynamoDB resulta idóneo para almacenar datos semiestructurados, como las *etiquetas*. Además, puede recuperar y manipular los datos contenidos en los documentos JSON.
+ La tabla *Music* no tiene atributos predefinidos aparte de la clave principal (*Artist* y *SongTitle*).
+ La mayoría de las bases de datos SQL están orientadas a transacciones. Cuando se emite una instrucción `INSERT`, las modificaciones de los datos no son permanentes hasta que se emite una instrucción `COMMIT`. Con Amazon DynamoDB, los efectos de una operación `PutItem` son permanentes cuando DynamoDB responde con un código de estado HTTP 200 (`OK`).
A continuación, se muestran algunos otros ejemplos de `PutItem`.
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "My Dog Spot",
"AlbumTitle":"Hey Now",
"Price": 1.98,
"Genre": "Country",
"CriticRating": 8.4
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "No One You Know",
"SongTitle": "Somewhere Down The Road",
"AlbumTitle":"Somewhat Famous",
"Genre": "Country",
"CriticRating": 8.4,
"Year": 1984
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Still In Love",
"AlbumTitle":"The Buck Starts Here",
"Price": 2.47,
"Genre": "Rock",
"PromotionInfo": {
"RadioStationsPlaying":[
"KHCR", "KBQX", "WTNR", "WJJH"
],
"TourDates": {
"Seattle": "20150625",
"Cleveland": "20150630"
},
"Rotation": "Heavy"
}
}
}
```
```
{
TableName: "Music",
Item: {
"Artist": "The Acme Band",
"SongTitle": "Look Out, World",
"AlbumTitle":"The Buck Starts Here",
"Price": 0.99,
"Genre": "Rock"
}
}
```
**nota**
Además de `PutItem`, DynamoDB admite la operación `BatchWriteItem` para escribir varios elementos a la vez.
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se utiliza la operación `ExecuteStatement` para agregar un elemento a una tabla, mediante la instrucción `Insert` de PartiQL.
```
INSERT into Music value {
'Artist': 'No One You Know',
'SongTitle': 'Call Me Today',
'AlbumTitle': 'Somewhat Famous',
'Year' : '2015',
'Genre' : 'Acme'
}
```
La clave principal de esta tabla consta de *Artist* y *SongTitle*. Debe especificar los valores de estos atributos.
**nota**
Para obtener ejemplos de código mediante `Insert` y `ExecuteStatement`, consulte [Instrucciones de inserción de PartiQL para DynamoDB](ql-reference.insert.md).
------
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al leer datos de una tabla
Con SQL, se utiliza la instrucción `SELECT` para recuperar una o varias filas de una tabla. Se utiliza la cláusula `WHERE` para determinar qué datos se devuelven.
Es diferente de utilizar Amazon DynamoDB, que proporciona las siguientes operaciones para la lectura de datos:
+ `ExecuteStatement` recupera uno o varios elementos de una tabla. `BatchExecuteStatement` recupera varios elementos de tablas diferentes en una sola operación. Ambas operaciones utilizan [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html), un lenguaje de consulta compatible con SQL.
+ `GetItem`: recupera un solo elemento de una tabla. Se trata de la forma más eficiente de leer un único elemento, ya que proporciona acceso directo a la ubicación física del elemento. (DynamoDB también proporciona la operación `BatchGetItem`, que permite llevar a cabo hasta 100 llamadas a `GetItem` en una sola operación).
+ `Query`: recupera todos los elementos que tienen una clave de partición determinada. Dentro del conjunto de esos elementos, puede aplicar una condición a la clave de ordenación y recuperar únicamente un subconjunto de los datos. `Query` proporciona un acceso rápido y eficiente a las particiones en las que se almacenan los datos. (Para obtener más información, consulte ). [Particiones y distribución de datos en DynamoDB](HowItWorks.Partitions.md).)
+ `Scan`: recupera todos los elementos de la tabla especificada. (Esta operación no debe utilizarse con grandes tablas, ya que puede consumir gran cantidad de recursos del sistema).
**nota**
En una base de datos relacional, puede usar la instrucción `SELECT` para unir los datos de varias tablas y devolver los resultados. Las uniones son fundamentales para el modelo relacional. Con el fin de garantizar que las uniones se ejecuten de forma eficiente, es preciso ajustar continuamente el desempeño de la base de datos y de sus aplicaciones. DynamoDB es una base de datos NoSQL no relacional que no admite uniones de tablas. En lugar de ello, las aplicaciones leen los datos de una tabla cada vez.
En las siguientes secciones se describen varios casos de uso de la lectura de datos y se explica cómo realizar estas tareas con una base de datos relacional y con DynamoDB.
**Topics**
+ [
# Diferencias al leer un elemento mediante la clave principal
](SQLtoNoSQL.ReadData.SingleItem.md)
+ [
# Diferencias al consultar una tabla
](SQLtoNoSQL.ReadData.Query.md)
+ [
# Diferencias al analizar una tabla
](SQLtoNoSQL.ReadData.Scan.md)
# Diferencias al leer un elemento mediante la clave principal
Un patrón de acceso habitual de acceso a las bases de datos consiste en leer un único elemento de una tabla. Es preciso especificar la clave principal del elemento que se desea.
**Topics**
+ [
## Lectura de un elemento usando su clave principal con SQL
](#SQLtoNoSQL.ReadData.SingleItem.SQL)
+ [
## Lectura de un elemento usando su clave principal en DynamoDB
](#SQLtoNoSQL.ReadData.SingleItem.DynamoDB)
## Lectura de un elemento usando su clave principal con SQL
En SQL, se utilizaría la instrucción `SELECT` para recuperar datos de una tabla. Puede solicitar una o varias columnas en el resultado (o todas ellas, si se utiliza el operador `*`). La cláusula `WHERE` determina qué filas se devolverán.
A continuación se muestra una instrucción `SELECT` que recupera una sola fila de la tabla *Music*. La cláusula `WHERE` especifica los valores de la clave principal.
```
SELECT *
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Puede modificar esta consulta para recuperar tan solo un subconjunto de las columnas:
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Observe que la clave principal de esta tabla consta de *Artist* y *SongTitle*.
## Lectura de un elemento usando su clave principal en DynamoDB
En Amazon DynamoDB, puede utilizar la API de DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para leer un elemento de una tabla.
------
#### [ DynamoDB API ]
Con la API de DynamoDB, se utiliza la operación `PutItem` para agregar un elemento a una tabla.
DynamoDB proporciona la operación `GetItem` para recuperar un elemento por su clave principal. `GetItem` es muy eficiente ya que proporciona acceso directo a la ubicación física del elemento. (Para obtener más información, consulte ). [Particiones y distribución de datos en DynamoDB](HowItWorks.Partitions.md).)
De forma predeterminada, `GetItem` devuelve el elemento completo con todos sus atributos.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
}
}
```
Puede agregar un parámetro `ProjectionExpression` para que solo se devuelvan algunos de los atributos.
```
{
TableName: "Music",
Key: {
"Artist": "No One You Know",
"SongTitle": "Call Me Today"
},
"ProjectionExpression": "AlbumTitle, Year, Price"
}
```
Observe que la clave principal de esta tabla consta de *Artist* y *SongTitle*.
La operación `GetItem` de DynamoDB es muy eficiente. Utiliza los valores de clave principal para determinar la ubicación de almacenamiento exacta del elemento en cuestión y lo recupera directamente desde ella. La eficiencia de la instrucción `SELECT` de SQL es parecida para recuperar elementos por sus valores de clave principal.
La instrucción `SELECT` de SQL admite muchos tipos de consultas y exámenes de tablas. DynamoDB proporciona una funcionalidad semejante con las operaciones `Query` y `Scan`, que se describen en [Diferencias al consultar una tabla](SQLtoNoSQL.ReadData.Query.md) y [Diferencias al analizar una tabla](SQLtoNoSQL.ReadData.Scan.md).
La instrucción `SELECT` de SQL puede llevar a cabo uniones de tablas para permitirle recuperar datos de varias tablas al mismo tiempo. Las uniones son más eficaces cuando las tablas de base de datos están normalizadas y las relaciones entre las tablas están claras. Sin embargo, si se unen demasiadas tablas en una misma instrucción `SELECT`, el rendimiento de la aplicación podría verse afectado. Puede solucionar este problema utilizando la replicación de bases de datos, las vistas materializadas o las reescrituras de consultas.
DynamoDB es una base de datos no relacional y no admite uniones de tablas. Si va a migrar una aplicación existente a partir de una base de datos relacional a DynamoDB, debe desnormalizar el modelo de datos para eliminar la necesidad de uniones.
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se utiliza la operación `ExecuteStatement` para leer un elemento de una tabla, mediante la instrucción `Select` de PartiQL.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today'
```
Observe que la clave principal de esta tabla consta de Artist y SongTitle.
**nota**
La instrucción select de PartiQL también se puede utilizar para consultar o analizar una tabla de DynamoDB
Para obtener ejemplos de código mediante `Select` y `ExecuteStatement`, consulte [Instrucciones de selección de PartiQL para DynamoDB](ql-reference.select.md).
------
# Diferencias al consultar una tabla
Otro patrón de acceso habitual consiste en leer varios elementos de una tabla, según los criterios de consulta.
**Topics**
+ [
## Consulta de una tabla con SQL
](#SQLtoNoSQL.ReadData.Query.SQL)
+ [
## Consulta de una tabla en DynamoDB
](#SQLtoNoSQL.ReadData.Query.DynamoDB)
## Consulta de una tabla con SQL
Al utilizar SQL, la instrucción `SELECT` permite realizar consultas por columnas de clave, columnas que no son de clave o cualquier combinación de ellas. La cláusula `WHERE` determina qué filas se devuelven, como se muestra en los ejemplos siguientes.
```
/* Return a single song, by primary key */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle = 'Call Me Today';
```
```
/* Return all of the songs by an artist */
SELECT * FROM Music
WHERE Artist='No One You Know';
```
```
/* Return all of the songs by an artist, matching first part of title */
SELECT * FROM Music
WHERE Artist='No One You Know' AND SongTitle LIKE 'Call%';
```
```
/* Return all of the songs by an artist, only if the price is less than 1.00 */
SELECT * FROM Music
WHERE Artist='No One You Know'
AND Price < 1.00;
```
Observe que la clave principal de esta tabla consta de *Artist* y *SongTitle*.
## Consulta de una tabla en DynamoDB
En Amazon DynamoDB, puede utilizar la API de DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para consultar un elemento de una tabla.
------
#### [ DynamoDB API ]
Con Amazon DynamoDB, puede utilizar la operación `Query` para recuperar datos de manera parecida. La operación `Query` proporciona un acceso rápido y eficiente a las ubicaciones físicas en las que se almacenan los datos. Para obtener más información, consulte [Particiones y distribución de datos en DynamoDB](HowItWorks.Partitions.md).
Se puede utilizar `Query` con cualquier tabla o índice secundario. Debe especificar una condición de igualdad para el valor de la clave de partición y, si lo desea, puede proporcionar otra condición para el atributo de clave de clasificación si está definido.
El parámetro `KeyConditionExpression` especifica los valores de clave que se desea consultar. Puede utilizar una expresión `FilterExpression` opcional para eliminar algunos elementos de los resultados antes de que se devuelvan.
En DynamoDB, debe usar `ExpressionAttributeValues` como marcador de posición en los parámetros de las expresiones (tales como `KeyConditionExpression` y `FilterExpression`). Esto es análogo al uso de las *variables de vínculo* de las bases de datos relacionales, que se sustituyen en la instrucción `SELECT` por los valores reales en tiempo de ejecución.
Observe que la clave principal de esta tabla consta de *Artist* y *SongTitle*.
A continuación, se muestran algunos ejemplos de `Query` de DynamoDB.
```
// Return a single song, by primary key
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and SongTitle = :t",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call Me Today"
}
}
```
```
// Return all of the songs by an artist
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
ExpressionAttributeValues: {
":a": "No One You Know"
}
}
```
```
// Return all of the songs by an artist, matching first part of title
{
TableName: "Music",
KeyConditionExpression: "Artist = :a and begins_with(SongTitle, :t)",
ExpressionAttributeValues: {
":a": "No One You Know",
":t": "Call"
}
}
```
```
// Return all of the songs by an artist, only if the price is less than 1.00
{
TableName: "Music",
KeyConditionExpression: "Artist = :a",
FilterExpression: "Price < :p",
ExpressionAttributeValues: {
":a": "No One You Know",
":p": 1.00
}
}
```
**nota**
Una `FilterExpression` se aplica después de que las lecturas `Query` coincidan con los elementos, por lo que no reduce la capacidad de lectura consumida. Siempre que sea posible, modele los datos de modo que las condiciones de rango utilicen `KeyConditionExpression` en la clave de clasificación para que las consultas sean eficientes. Para obtener más información, consulte [Consulta de tablas en DynamoDB](Query.md).
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, puede hacer una consulta mediante la operación `ExecuteStatement` y la instrucción `Select` sobre la clave de partición.
```
SELECT AlbumTitle, Year, Price
FROM Music
WHERE Artist='No One You Know'
```
El uso de la instrucción `SELECT` de esta manera devuelve todas las canciones asociadas a este `Artist` en particular.
Para obtener ejemplos de código mediante `Select` y `ExecuteStatement`, consulte [Instrucciones de selección de PartiQL para DynamoDB](ql-reference.select.md).
------
# Diferencias al analizar una tabla
En SQL, una instrucción `SELECT` sin cláusula `WHERE` devuelve todas las filas de la tabla. En Amazon DynamoDB, la operación `Scan` hace lo mismo. En ambos casos, puede recuperar todos los elementos o solo algunos de ellos.
Tanto si va a usar una base de datos SQL o NoSQL, los exámenes deben utilizarse con moderación, ya que puede consumir gran cantidad de recursos del sistema. En ocasiones, un examen es lo apropiado (por ejemplo, para examinar una tabla pequeña) o algo inevitable (por ejemplo, para realizar una exportación masiva de datos). Sin embargo, por norma general, debe diseñar las aplicaciones de tal forma que se evite la realización de exámenes. Para obtener más información, consulte [Consulta de tablas en DynamoDB](Query.md).
**nota**
Realizar una exportación masiva también crea al menos 1 archivo por partición. Todos los elementos de cada archivo provienen del espacio de claves hash de esa partición en particular.
**Topics**
+ [
## Análisis de una tabla con SQL
](#SQLtoNoSQL.ReadData.Scan.SQL)
+ [
## Análisis de una tabla en DynamoDB
](#SQLtoNoSQL.ReadData.Scan.DynamoDB)
## Análisis de una tabla con SQL
Al utilizar SQL, puede examinar una tabla y recuperar todos sus datos utilizando una instrucción `SELECT` sin especificar una cláusula `WHERE`. Puede solicitar una o más columnas en el resultado. O bien puede solicitar todas ellas si utiliza el carácter comodín (\$1).
En los siguientes ejemplos se utiliza una instrucción `SELECT`.
```
/* Return all of the data in the table */
SELECT * FROM Music;
```
```
/* Return all of the values for Artist and Title */
SELECT Artist, Title FROM Music;
```
## Análisis de una tabla en DynamoDB
En Amazon DynamoDB, puede utilizar la API de DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para analizar una tabla.
------
#### [ DynamoDB API ]
Con la API de DynamoDB, el usuario utiliza la operación `Scan` para devolver uno o más elementos y atributos de elementos mediante el acceso a todos los elementos de una tabla o un índice secundario.
```
// Return all of the data in the table
{
TableName: "Music"
}
```
```
// Return all of the values for Artist and Title
{
TableName: "Music",
ProjectionExpression: "Artist, Title"
}
```
La operación `Scan` proporciona además un parámetro `FilterExpression`, que se puede usar para descartar elementos que no desee que aparezcan en los resultados. La expresión `FilterExpression` se aplica después de que analizar la tabla completa, pero antes de que se devuelvan los resultados. (Esto no se recomienda en tablas de gran tamaño, porque se le cobrará la operación `Scan` completa aunque solamente se devuelvan algunos elementos coincidentes).
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se hace un análisis mediante la operación `ExecuteStatement` para devolver todo el contenido de una tabla mediante la instrucción `Select`.
```
SELECT AlbumTitle, Year, Price
FROM Music
```
Tenga en cuenta que esta instrucción devolverá todos los elementos de la tabla Música.
Para obtener ejemplos de código mediante `Select` y `ExecuteStatement`, consulte [Instrucciones de selección de PartiQL para DynamoDB](ql-reference.select.md).
------
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al administrar índices
Los índices permiten obtener acceso a patrones de consulta alternativos y agilizar las consultas. En esta sección se compara y contrasta la creación y el uso de índices entre SQL y Amazon DynamoDB.
Tanto si está utilizando una base de datos relacional o DynamoDB, la creación de índices debe realizarse con cautela. Cada vez que se produce una escritura en una tabla, es preciso actualizar todos los índices de esa tabla. En un entorno con uso intensivo de escrituras y grandes tablas, esto puede consumir gran cantidad de recursos del sistema. Esto no es motivo de preocupación en entornos de solo lectura o principalmente de lectura. Sin embargo, hay que asegurarse de que la aplicación utilice los índices realmente, de tal forma que estos no se limiten a consumir espacio.
**Topics**
+ [
## Diferencias entre una base de datos relacional (SQL) y DynamoDB al crear un índice
](#SQLtoNoSQL.Indexes.Creating)
+ [
## Diferencias entre una base de datos relacional (SQL) y DynamoDB al consultar y analizar un índice
](#SQLtoNoSQL.Indexes.QueryAndScan)
## Diferencias entre una base de datos relacional (SQL) y DynamoDB al crear un índice
Compare la instrucción `CREATE INDEX` en SQL con la operación `UpdateTable` en Amazon DynamoDB.
**Topics**
+ [
### Creación de un índice con SQL
](#SQLtoNoSQL.Indexes.Creating.SQL)
+ [
### Creación de un índice en DynamoDB
](#SQLtoNoSQL.Indexes.Creating.DynamoDB)
### Creación de un índice con SQL
En las bases de datos relacionales, los índices son estructuras de datos que permiten realizar consultas rápidas en diferentes columnas de una tabla. Puede usar la instrucción `CREATE INDEX` de SQL para agregar un índice a una tabla existente y especificar las columnas que se van a indexar. Una vez que se ha creado el índice, puede consultar los datos de la tabla como de costumbre, si bien ahora la base de datos podrá utilizar el índice para encontrar rápidamente las filas especificadas de la tabla, en lugar de tener que examinar la tabla completa.
Después de crear un índice, la base de datos lo mantiene automáticamente. Cada vez que se modifica algún dato de la tabla, el índice se modifica automáticamente para reflejar los cambios de la tabla.
En MySQL, se crearía un índice como se indica a continuación.
```
CREATE INDEX GenreAndPriceIndex
ON Music (genre, price);
```
### Creación de un índice en DynamoDB
En DynamoDB puede crear y usar *un índice secundario* con fines semejantes.
Los índices de DynamoDB son diferentes de sus homólogos relacionales. Al crear un índice secundario, hay que especificar sus atributos de clave: una clave de partición y una clave de ordenación. Una vez creado el índice secundario, puede utilizar las operaciones `Query` o `Scan` para consultarlo o examinarlo, respectivamente, como si se tratase de una tabla. DynamoDB no tiene un optimizador de consultas, de modo que el índice secundario solamente se utiliza cuando se utilizan las operaciones `Query` o `Scan` con él.
DynamoDB admite dos tipos distintos de índices:
+ Los índices secundarios globales: la clave principal del índice puede constar de dos atributos cualesquiera de la tabla a la que pertenece.
+ Los índices secundarios locales: la clave de partición del índice debe ser igual que la clave de partición de la tabla a la que pertenece. Sin embargo, la clave de ordenación puede ser cualquier otro atributo.
DynamoDB se asegura de que los datos de un índice secundario presenten consistencia final con la tabla a la que pertenece. Puede solicitar operaciones `Query` o `Scan` de consistencia alta en una tabla o un índice. No obstante, los índices secundarios globales solo admiten la consistencia final.
Puede agregar un índice secundario global a una tabla existente; para ello, utilice la operación `UpdateTable` y especifique `GlobalSecondaryIndexUpdates`.
```
{
TableName: "Music",
AttributeDefinitions:[
{AttributeName: "Genre", AttributeType: "S"},
{AttributeName: "Price", AttributeType: "N"}
],
GlobalSecondaryIndexUpdates: [
{
Create: {
IndexName: "GenreAndPriceIndex",
KeySchema: [
{AttributeName: "Genre", KeyType: "HASH"}, //Partition key
{AttributeName: "Price", KeyType: "RANGE"}, //Sort key
],
Projection: {
"ProjectionType": "ALL"
},
ProvisionedThroughput: { // Only specified if using provisioned mode
"ReadCapacityUnits": 1,"WriteCapacityUnits": 1
}
}
}
]
}
```
Debe proporcionar los siguientes parámetros a `UpdateTable`:
+ `TableName`: tabla a la que se asociará el índice.
+ `AttributeDefinitions`: tipos de datos de los atributos de esquema de claves del índice.
+ `GlobalSecondaryIndexUpdates`: detalles sobre el índice que se desea crear.
+ `IndexName`: nombre del índice.
+ `KeySchema`: atributos utilizados para la clave principal del índice.
+ `Projection`: atributos de la tabla que se copian en el índice. En este caso, `ALL` significa que se copian todos los atributos.
+ `ProvisionedThroughput (for provisioned tables)`: número de lecturas y escrituras por segundo que se requieren para este índice. Este valor es independiente de los ajustes de rendimiento aprovisionado de la tabla.
Parte de esta operación implica reponer datos de la tabla en el nuevo índice. Durante la reposición, la tabla permanece disponible. Sin embargo, el índice no está preparado hasta que el atributo `Backfilling` cambia de true a false. Puede utilizar la operación `DescribeTable` para ver este atributo.
## Diferencias entre una base de datos relacional (SQL) y DynamoDB al consultar y analizar un índice
Compare la realización de consultas y análisis de un índice mediante la instrucción SELECT de SQL con las operaciones `Query` y `Scan` en Amazon DynamoDB.
**Topics**
+ [
### Consulta y análisis de un índice con SQL
](#SQLtoNoSQL.Indexes.QueryAndScan.SQL)
+ [
### Consulta y análisis de un índice en DynamoDB
](#SQLtoNoSQL.Indexes.QueryAndScan.DynamoDB)
### Consulta y análisis de un índice con SQL
En una base de datos relacional, no se trabajar directamente con los índices. En lugar de ello, se consultan las tablas mediante instrucciones `SELECT` y el optimizador de consultas utiliza los índices, si los hay.
Un *optimizador de consultas* es un componente del sistema de administración de bases de datos relacionales (RDBMS) que se encarga de evaluar los índices disponibles y determinar si se pueden utilizar para agilizar consultas. Si los índices pueden utilizarse para agilizar una consulta, el RDBMS obtiene acceso al índice en primer lugar y, a continuación, lo utiliza para localizar los datos en la tabla.
A continuación se muestran algunas instrucciones SQL en las que se puede utilizar *GenreAndPriceIndex* para mejorar el rendimiento. Damos por hecho que la tabla *Music* contiene suficientes datos para que el optimizador de consultas decida utilizar el índice en lugar de examinar la tabla completa.
```
/* All of the rock songs */
SELECT * FROM Music
WHERE Genre = 'Rock';
```
```
/* All of the cheap country songs */
SELECT Artist, SongTitle, Price FROM Music
WHERE Genre = 'Country' AND Price < 0.50;
```
### Consulta y análisis de un índice en DynamoDB
En DynamoDB, se llevan a cabo las operaciones `Query` y `Scan` que consultan el índice directamente, de la misma manera en la que se haría en una tabla. Puede utilizar la API de DynamoDB o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para consultar o analizar el índice. Debe especificar tanto `TableName` como `IndexName`.
A continuación se muestran algunas consultas sobre *GenreAndPriceIndex* en DynamoDB. El esquema de claves de este índice consta de *Genre* y *Price*.
------
#### [ DynamoDB API ]
```
// All of the rock songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre",
ExpressionAttributeValues: {
":genre": "Rock"
},
};
```
En este ejemplo se utiliza una expresión `ProjectionExpression` para indicar que solamente deseamos que aparezcan en los resultados algunos de los atributos y no todos ellos.
```
// All of the cheap country songs
{
TableName: "Music",
IndexName: "GenreAndPriceIndex",
KeyConditionExpression: "Genre = :genre and Price < :price",
ExpressionAttributeValues: {
":genre": "Country",
":price": 0.50
},
ProjectionExpression: "Artist, SongTitle, Price"
};
```
A continuación se muestra un examen de *GenreAndPriceIndex*.
```
// Return all of the data in the index
{
TableName: "Music",
IndexName: "GenreAndPriceIndex"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se utiliza la instrucción `Select` de PartiQL para hacer consultas y análisis en el índice.
```
// All of the rock songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock'
```
```
// All of the cheap country songs
SELECT *
FROM Music.GenreAndPriceIndex
WHERE Genre = 'Rock' AND Price < 0.50
```
A continuación se muestra un examen de *GenreAndPriceIndex*.
```
// Return all of the data in the index
SELECT *
FROM Music.GenreAndPriceIndex
```
**nota**
Para obtener ejemplos de código en los que se utiliza `Select`, consulte [Instrucciones de selección de PartiQL para DynamoDB](ql-reference.select.md).
------
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al modificar datos de una tabla
El lenguaje SQL proporciona la instrucción `UPDATE` para modificar datos. Amazon DynamoDB utiliza la operación `UpdateItem` para llevar a cabo tareas semejantes.
**Topics**
+ [
## Modificación de los datos de una tabla con SQL
](#SQLtoNoSQL.UpdateData.SQL)
+ [
## Modificación de los datos de una tabla en DynamoDB
](#SQLtoNoSQL.UpdateData.DynamoDB)
## Modificación de los datos de una tabla con SQL
En SQL, se utilizaría la instrucción `UPDATE` para modificar una o varias filas. La cláusula `SET` especifica los nuevos valores de una o varias columnas y la cláusula `WHERE` determina qué filas se modifican. A continuación se muestra un ejemplo.
```
UPDATE Music
SET RecordLabel = 'Global Records'
WHERE Artist = 'No One You Know' AND SongTitle = 'Call Me Today';
```
Si no hay ninguna fila que coincida con la cláusula `WHERE`, la instrucción `UPDATE` no surte efecto.
## Modificación de los datos de una tabla en DynamoDB
En DynamoDB, puede utilizar la API clásica o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para modificar un solo elemento. Si desea modificar varios elementos, debe utilizar varias operaciones.
------
#### [ DynamoDB API ]
Con la API de DynamoDB, se utiliza la operación `UpdateItem` para modificar un solo elemento.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ExpressionAttributeValues: {
":label": "Global Records"
}
}
```
Debe especificar los atributos `Key` del elemento que va a modificar y una expresión `UpdateExpression` para especificar los valores de los atributos. `UpdateItem` se comporta como una operación “upsert”. Si el elemento está presente en tabla, se actualiza y, si no está presente, se agrega (inserta).
`UpdateItem` admite las *escrituras condicionales*, en las que la operación únicamente se lleva a cabo correctamente si una expresión `ConditionExpression` determinada se evalúa en true. Por ejemplo, la operación `UpdateItem` siguiente no lleva a cabo la actualización a no ser que el precio de la canción sea mayor o igual que 2,00.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET RecordLabel = :label",
ConditionExpression: "Price >= :p",
ExpressionAttributeValues: {
":label": "Global Records",
":p": 2.00
}
}
```
`UpdateItem` también admite los *contadores atómicos*, que son atributos del tipo `Number` que se pueden incrementar o reducir. Los contadores atómicos se parecen en muchos aspectos a los generadores de secuencia, las columnas de identidad o los campos de incremento automático de las bases de datos SQL.
A continuación se muestra un ejemplo de operación `UpdateItem` utilizada para inicializar un nuevo atributo (*Plays*) que permite realizar el seguimiento del número de veces que se ha reproducido una canción.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = :val",
ExpressionAttributeValues: {
":val": 0
},
ReturnValues: "UPDATED_NEW"
}
```
El parámetro `ReturnValues` se establece en `UPDATED_NEW`, que devuelve los nuevos valores de todos los atributos que se han actualizado. En este caso, devuelve 0 (cero).
Cada vez que alguien reproduce esta canción, podemos usar la operación `UpdateItem` para incrementar *Plays* en una unidad.
```
{
TableName: "Music",
Key: {
"Artist":"No One You Know",
"SongTitle":"Call Me Today"
},
UpdateExpression: "SET Plays = Plays + :incr",
ExpressionAttributeValues: {
":incr": 1
},
ReturnValues: "UPDATED_NEW"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se utiliza la operación `ExecuteStatement` para modificar un elemento de una tabla, mediante la instrucción `Update` de PartiQL.
La clave principal de esta tabla consta de *Artist* y *SongTitle*. Debe especificar los valores de estos atributos.
```
UPDATE Music
SET RecordLabel ='Global Records'
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
También puede modificar varios campos a la vez, como en el ejemplo siguiente.
```
UPDATE Music
SET RecordLabel = 'Global Records'
SET AwardsWon = 10
WHERE Artist ='No One You Know' AND SongTitle='Call Me Today'
```
`Update` también admite los *contadores atómicos*, que son atributos del tipo `Number` que se pueden incrementar o reducir. Los contadores atómicos se parecen en muchos aspectos a los generadores de secuencia, las columnas de identidad o los campos de incremento automático de las bases de datos SQL.
A continuación, se muestra un ejemplo de instrucción `Update` utilizada para inicializar un nuevo atributo (*Plays* [Reproducciones]) que permite hacer el seguimiento del número de veces que se ha reproducido una canción.
```
UPDATE Music
SET Plays = 0
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
Cada vez que alguien reproduce esta canción, podemos usar la instrucción `Update` para aumentar *Plays* (Reproducciones) en una unidad.
```
UPDATE Music
SET Plays = Plays + 1
WHERE Artist='No One You Know' AND SongTitle='Call Me Today'
```
**nota**
Para obtener ejemplos de código mediante `Update` y `ExecuteStatement`, consulte [Instrucciones de actualización de PartiQL para DynamoDB](ql-reference.update.md).
------
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al eliminar datos de una tabla
En SQL, se utiliza la instrucción `DELETE` para eliminar una o varias filas de una tabla. Amazon DynamoDB utiliza la operación `DeleteItem` para eliminar los elementos de uno en uno.
**Topics**
+ [
## Eliminación de datos de una tabla con SQL
](#SQLtoNoSQL.DeleteData.SQL)
+ [
## Eliminación de datos de una tabla en DynamoDB
](#SQLtoNoSQL.DeleteData.DynamoDB)
## Eliminación de datos de una tabla con SQL
En SQL, se utiliza la instrucción `DELETE` para eliminar una o varias filas. La cláusula `WHERE` determina qué filas se van a modificar. A continuación se muestra un ejemplo.
```
DELETE FROM Music
WHERE Artist = 'The Acme Band' AND SongTitle = 'Look Out, World';
```
Puede modificar la cláusula `WHERE` para eliminar varias filas. Por ejemplo, puede eliminar todas las canciones de un determinado intérprete, como se muestra en el siguiente ejemplo.
```
DELETE FROM Music WHERE Artist = 'The Acme Band'
```
## Eliminación de datos de una tabla en DynamoDB
En DynamoDB, puede utilizar la API clásica o [PartiQL](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/ql-reference.html) (un lenguaje de consulta compatible con SQL) para eliminar un solo elemento. Si desea modificar varios elementos, debe utilizar varias operaciones.
------
#### [ DynamoDB API ]
Con la API de DynamoDB, se utiliza la operación `DeleteItem` para eliminar datos de una tabla, de elemento en elemento. Debe especificar los valores de clave principal del elemento.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
}
}
```
**nota**
Además de `DeleteItem`, Amazon DynamoDB admite la operación `BatchWriteItem` para eliminar varios elementos a la vez.
`DeleteItem` admite las *escrituras condicionales*, en las que la operación únicamente se lleva a cabo correctamente si una expresión `ConditionExpression` determinada se evalúa en true. Por ejemplo, la operación `DeleteItem` siguiente elimina un elemento únicamente si tiene el atributo *RecordLabel*.
```
{
TableName: "Music",
Key: {
Artist: "The Acme Band",
SongTitle: "Look Out, World"
},
ConditionExpression: "attribute_exists(RecordLabel)"
}
```
------
#### [ PartiQL for DynamoDB ]
Con PartiQL, se utiliza la instrucción `Delete` mediante la operación `ExecuteStatement` para eliminar datos de una tabla, de elemento en elemento. Debe especificar los valores de clave principal del elemento.
La clave principal de esta tabla consta de *Artist* y *SongTitle*. Debe especificar los valores de estos atributos.
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks'
```
También puede especificar condiciones adicionales para la operación. La siguiente operación `DELETE` solo elimina el elemento si tiene más de 11 *Awards* (Premios).
```
DELETE FROM Music
WHERE Artist = 'Acme Band' AND SongTitle = 'PartiQL Rocks' AND Awards > 11
```
**nota**
Para obtener ejemplos de código mediante `DELETE` y `ExecuteStatement`, consulte [Instrucciones de eliminación de PartiQL para DynamoDB](ql-reference.delete.md).
------
# Diferencias entre una base de datos relacional (SQL) y DynamoDB al eliminar una tabla
En SQL, se utiliza la instrucción `DROP TABLE` para eliminar una tabla. En Amazon DynamoDB, se utiliza la operación `DeleteTable`.
**Topics**
+ [
## Eliminación de una tabla con SQL
](#SQLtoNoSQL.RemoveTable.SQL)
+ [
## Eliminación de una tabla en DynamoDB
](#SQLtoNoSQL.RemoveTable.DynamoDB)
## Eliminación de una tabla con SQL
Cuando ya no necesita una tabla y se desea descartarla de forma permanente, se utilizaría la instrucción `DROP TABLE` de SQL.
```
DROP TABLE Music;
```
Después de eliminar una tabla, ya no se puede recuperar. En algunas bases de datos relacionales se permite deshacer una operación `DROP TABLE`, pero se trata de una funcionalidad específica del proveedor que no se implementa de manera generalizada.
## Eliminación de una tabla en DynamoDB
En DynamoDB, `DeleteTable` es una operación similar. En el siguiente ejemplo, se elimina la tabla de forma permanente.
```
{
TableName: "Music"
}
```