# Funcionamiento de Amazon DynamoDB En las secciones siguientes se incluye información general sobre los componentes del servicio de Amazon DynamoDB y las interacciones entre ellos. **Topics** + [Hoja de referencia para DynamoDB](CheatSheet.md) + [Componentes básicos de Amazon DynamoDB](HowItWorks.CoreComponents.md) + [API de DynamoDB](HowItWorks.API.md) + [Tipos de datos y reglas de nomenclatura admitidos en Amazon DynamoDB](HowItWorks.NamingRulesDataTypes.md) + [Clases de tablas de DynamoDB](HowItWorks.TableClasses.md) + [Particiones y distribución de datos en DynamoDB](HowItWorks.Partitions.md) + [Información sobre cómo pasar de SQL a NoSQL](SQLtoNoSQL.md) + [Recursos y herramientas de aprendizaje de Amazon DynamoDB](AdditionalResources.md) # Hoja de referencia para DynamoDB Esta hoja de referencia proporciona una base rápida para trabajar con Amazon DynamoDB y los distintos AWS SDK. ## Configuración inicial 1. [Regístrese en AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.SignUpForAWS). 1. [Obtenga una clave de acceso de AWS](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.GetCredentials) para acceder a DynamoDB mediante programación. 1. [Configure las credenciales de DynamoDB](SettingUp.DynamoWebService.html#SettingUp.DynamoWebService.ConfigureCredentials). **Véase también:** + [Configuración de DynamoDB (servicio web)](SettingUp.DynamoWebService.html) + [Introducción a DynamoDB](GettingStartedDynamoDB.html) + [Información básica de los componentes principales](HowItWorks.CoreComponents.html) ## SDK o CLI Elija el [SDK](sdk-general-information-section.html) preferido o configure la [AWS CLI](/cli/latest/index.html). **nota** Cuando se utiliza la AWS CLI en Windows, una barra invertida (\$1) que no esté entre comillas se considera un retorno de carro. Además, debe usar escape entre comillas y corchetes dentro de otras comillas. Para ver un ejemplo, consulte la pestaña **Windows** en "Create a table" (Crear una tabla) en la siguiente sección. **Véase también:** + [AWS CLI con DynamoDB](Tools.CLI.html) + [Introducción a DynamoDB: paso 2](getting-started-step-2.html) ## Acciones básicas En esta sección se proporciona código para las tareas básicas de DynamoDB. Para obtener más información sobre estas tareas, consulte [Introducción a DynamoDB y los AWS SDK](GettingStarted.html). ### Creación de una tabla ------ #### [ Default ] ``` aws dynamodb create-table \ --table-name Music \ --attribute-definitions \ AttributeName=Artist,AttributeType=S \ AttributeName=SongTitle,AttributeType=S \ --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE \ --billing-mode PAY_PER_REQUEST \ --table-class STANDARD ``` ------ #### [ Windows ] ``` aws dynamodb create-table ^ --table-name Music ^ --attribute-definitions ^ AttributeName=Artist,AttributeType=S ^ AttributeName=SongTitle,AttributeType=S ^ --key-schema AttributeName=Artist,KeyType=HASH AttributeName=SongTitle,KeyType=RANGE ^ --billing-mode PAY_PER_REQUEST ^ --table-class STANDARD ``` ------ ### Escribir elemento en una tabla ``` aws dynamodb put-item \ --table-name Music \ --item file://item.json ``` ### Leer elemento de una tabla ``` aws dynamodb get-item \ --table-name Music \ --item file://item.json ``` ### Eliminar un elemento de una tabla ``` aws dynamodb delete-item --table-name Music --key file://key.json ``` ### Consulta de una tabla ``` aws dynamodb query --table-name Music --key-condition-expression "ArtistName=:Artist and SongName=:Songtitle" ``` ### Eliminación de una tabla ``` aws dynamodb delete-table --table-name Music ``` ### Mostrar nombres de tablas ``` aws dynamodb list-tables ``` ## Reglas de nomenclatura + Todos los nombres se deben codificar mediante UTF-8 y distinguen entre mayúsculas y minúsculas. + Los nombres de las tablas y los índices deben tener entre 3 y 255 caracteres, que solo pueden ser los siguientes: + `a-z` + `A-Z` + `0-9` + `_` (guion bajo) + `-` (guion) + `.` (punto) + Los nombres de atributo deben tener al menos un carácter y un tamaño inferior a 64 KB. Para obtener más información, consulte [Naming rules](HowItWorks.NamingRulesDataTypes.html) (Reglas de nomenclatura). ## Conceptos básicos sobre Service Quotas **Unidades de lectura y escritura** + **Unidad de capacidad de lectura (RCU)**: una lectura altamente coherente por segundo o dos lecturas coherentes posteriores por segundo, para elementos con un tamaño de hasta 4 KB. + **Unidad de capacidad de escritura (WCU)**: una escritura por segundo para los elementos con un tamaño de hasta 1 KB. **Límites de tabla** + **Tamaño de tabla**: no existe ningún límite práctico del tamaño de una tabla. Las tablas no presentan restricciones en cuanto al número de elementos o de bytes. + **Número de tablas**: para cualquier cuenta de AWS, existe una cuota inicial de 2500 tablas por región de AWS. + **Límite de tamaño de página para consulta y análisis**: hay un límite de 1 MB por página, por consulta o análisis. Si los parámetros de la consulta o la operación de análisis de una tabla arrojan más de 1 MB de datos, DynamoDB devuelve los elementos coincidentes iniciales. También devuelve una propiedad `LastEvaluatedKey` que puede utilizar en una nueva solicitud para leer la página siguiente. **Índices** + **Índices secundarios locales (LSI)**: puede definir un máximo de cinco índices secundarios locales. Los LSI son útiles principalmente cuando un índice debe tener una gran coherencia con la tabla base. + **Índices secundarios globales (GSI)**: existe una cuota predeterminada de 20 índices secundarios globales por tabla. + **Atributos de índice secundario proyectado por tabla**: puede proyectar un máximo de 100 atributos en todos los índices secundarios locales y globales de una tabla. Esto solo se aplica a los atributos proyectados especificados por el usuario. **Claves de partición** + La longitud mínima de un valor de clave de partición es de 1 byte. La longitud máxima es de 2048 bytes. + No existe ningún límite práctico respecto al número de valores diferentes de clave de partición, ni para tablas ni para los índices secundarios. + La longitud mínima de un valor de clave de ordenación es de 1 byte. La longitud máxima es de 1024 bytes. + En general, no existe ningún límite práctico respecto al número de valores diferentes de clave de ordenación por cada valor de clave de partición. Hay una excepción en las tablas que utilizan índices secundarios. Para obtener más información sobre los índices secundarios, el diseño de la clave de partición y el diseño de la clave de clasificación, consulte [Prácticas recomendadas](best-practices.html). **Límites para los tipos de datos de uso común** + **Cadena**: la longitud de una cadena está limitada por el tamaño de elemento máximo de 400 KB. Los valores de tipo String son Unicode con codificación binaria UTF-8. + **Número**: un número puede tener hasta 38 dígitos de precisión y puede ser positivo, negativo o cero. + **Binario**: la longitud de un valor binario está limitada por el tamaño de elemento máximo de 400 KB. Las aplicaciones que utilizan atributos binarios deben codificar los datos en cifrado base64 antes de enviarlos a DynamoDB. Para obtener una lista completa de los tipos de datos admitidos, consulte [Data types](HowItWorks.NamingRulesDataTypes.html#HowItWorks.DataTypes) (Tipos de datos). Para obtener más información, consulte también [Service Quotas](ServiceQuotas.html#limits-items). ### Elementos, atributos y parámetros de expresión El tamaño máximo de un elemento en DynamoDB es de 400 KB, que incluye la longitud en formato binario de los nombres de los atributos (longitud en UTF-8) y las longitudes en formato binario de los valores de los atributos (longitud en UTF-8). El nombre de los atributos se tiene en cuenta al calcular el límite de tamaño. No existe ningún límite en el número de valores de una lista, un mapa o un conjunto, siempre y cuando el elemento que contiene los valores se ajuste al límite de tamaño de elemento de 400 KB. Para parámetros de expresión, la longitud máxima de cualquier cadena de expresión es 4 KB. Para obtener más información sobre el tamaño del elemento, los atributos y los parámetros de expresión, consulte [Service Quotas](ServiceQuotas.html#limits-items). ## Más información + [Seguridad](security.html) + [Monitoreo y registro](monitoring.html) + [Uso de secuencias](streamsmain.html) + [Copias de seguridad](Backup-and-Restore.html) y [recuperación a un momento dado](Point-in-time-recovery.html) + [Integración con otros servicios de AWS](OtherServices.html) + [Referencia de la API del](/amazondynamodb/latest/APIReference/Welcome.html) + [Centro de arquitectura: prácticas recomendadas de bases de datos](https://aws.amazon.com/architecture/databases/) + [Tutoriales de vídeo](https://youtu.be/Mw8wCj0gkRc) + [Foro de DynamoDB](https://repost.aws/search/questions?globalSearch=dynamodb) # Componentes básicos de Amazon DynamoDB En DynamoDB se trabaja principalmente con tablas, elementos y atributos. Una *tabla* es una colección de *elementos* y cada elemento es una colección de *atributos*. DynamoDB utiliza claves principales para identificar de forma exclusiva cada elemento de una tabla. Puede utilizar DynamoDB Streams para capturar los eventos de modificación de datos en las tablas de DynamoDB. En DynamoDB se aplican algunos límites. Para obtener más información, consulte [Cuotas en Amazon DynamoDB](ServiceQuotas.md). En el siguiente vídeo encontrará una introducción a las tablas, los elementos y los atributos. [Tablas, elementos y atributos](https://www.youtube.com/embed/Mw8wCj0gkRc) ## Tablas, elementos y atributos ![\[Cada tabla de DynamoDB contiene cero o más elementos compuestos por uno o más atributos.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/HowItWorksTables-2024.png) A continuación, se indican los componentes básicos de DynamoDB: + **Tablas**: al igual que otros sistemas de base de datos, DynamoDB almacena datos en tablas. Una *tabla* es una colección de datos. Por ejemplo, consulte la tabla de ejemplo denominada *People*, que puede utilizar para almacenar información de contacto personal sobre amigos, familiares u otras personas de interés. También podría utilizar una tabla *Cars* para almacenar información sobre los vehículos que conducen las personas. + **Elementos**: Cada tabla contiene cero o más elementos. Un *elemento* es un grupo de atributos que puede identificarse de forma exclusiva entre todos los demás elementos. En una tabla *People*, cada elemento representa a una persona. En una tabla *Cars*, cada elemento representa un vehículo. Los elementos de DynamoDB son similares en muchos aspectos a las filas, los registros o las tuplas de otros sistemas de bases de datos. En DynamoDB, no existe ningún límite respecto al número de elementos que pueden almacenarse en una tabla. + **Atributos**: cada elemento se compone de uno o varios atributos. Un *atributo* es un componente fundamental de los datos, que no es preciso dividir más. Por ejemplo, un elemento de una tabla *Personas* contiene los atributos *PersonID*, *LastName*, *FirstName*, etc. En una tabla *Departamento*, un elemento podría tener atributos tales como *DepartmentID*, *Nombre*, *Mánager*, etc. En DynamoDB, los atributos se parecen en muchos aspectos a los campos o columnas en otros sistemas de bases de datos. En el siguiente diagrama se muestra una tabla denominada *People* que contiene algunos ejemplos de elementos y atributos. ``` People { "PersonID": 101, "LastName": "Smith", "FirstName": "Fred", "Phone": "555-4321" } { "PersonID": 102, "LastName": "Jones", "FirstName": "Mary", "Address": { "Street": "123 Main", "City": "Anytown", "State": "OH", "ZIPCode": 12345 } } { "PersonID": 103, "LastName": "Stephens", "FirstName": "Howard", "Address": { "Street": "123 Main", "City": "London", "PostalCode": "ER3 5K8" }, "FavoriteColor": "Blue" } ``` Tenga en cuenta lo siguiente en relación con la tabla *People*: + Cada elemento de la tabla tiene un identificador único, o clave principal, que lo distingue de todos los demás. En la tabla *People*, la clave principal consta de un atributo (*PersonID*). + Dejando a un lado la clave principal, la tabla *People* no tiene esquema. Esto significa que no es preciso definir de antemano los atributos ni sus tipos de datos. Cada elemento puede tener sus propios atributos diferentes. + La mayoría de los atributos son *escalares*, lo que significa que solo pueden tener un valor. Las cadenas y los números son ejemplos comunes de escalares. + Algunos de los elementos tienen un atributo anidado (*Address*). DynamoDB admite atributos anidados hasta un máximo de 32 niveles de profundidad. A continuación se muestra otro ejemplo de tabla denominada *Music* que podría utilizar para llevar un registro de una colección de música. ``` Music { "Artist": "No One You Know", "SongTitle": "My Dog Spot", "AlbumTitle": "Hey Now", "Price": 1.98, "Genre": "Country", "CriticRating": 8.4 } { "Artist": "No One You Know", "SongTitle": "Somewhere Down The Road", "AlbumTitle": "Somewhat Famous", "Genre": "Country", "CriticRating": 8.4, "Year": 1984 } { "Artist": "The Acme Band", "SongTitle": "Still in Love", "AlbumTitle": "The Buck Starts Here", "Price": 2.47, "Genre": "Rock", "PromotionInfo": { "RadioStationsPlaying": [ "KHCR", "KQBX", "WTNR", "WJJH" ], "TourDates": { "Seattle": "20150622", "Cleveland": "20150630" }, "Rotation": "Heavy" } } { "Artist": "The Acme Band", "SongTitle": "Look Out, World", "AlbumTitle": "The Buck Starts Here", "Price": 0.99, "Genre": "Rock" } ``` Tenga en cuenta lo siguiente en relación con la tabla *Music*: + La clave principal de *Music* consta de dos atributos (*Artist* y *SongTitle*). Cada elemento de la tabla debe tener estos dos atributos. La combinación de *Artist* y *SongTitle* distingue a cada elemento de la tabla de todos los demás. + Dejando a un lado la clave principal, la tabla *Music* no tiene esquema. Esto significa que no es preciso definir de antemano los atributos ni sus tipos de datos. Cada elemento puede tener sus propios atributos diferentes. + Uno de los elementos tiene un atributo anidado (*PromotionInfo*), que contiene otros atributos anidados. DynamoDB admite atributos anidados hasta un máximo de 32 niveles de profundidad. Para obtener más información, consulte [Uso de tablas y datos en DynamoDB](WorkingWithTables.md). ## Clave principal Al crear una tabla, además de asignarle un nombre, debe especificar su clave principal. La clave principal identifica de forma única a cada elemento de la tabla, de manera que no puede haber dos elementos con la misma clave. DynamoDB admite dos tipos distintos de clave principal: + **Clave de partición**: una clave principal simple que consta de un solo atributo denominado *clave de partición*. DynamoDB utiliza el valor de clave de partición como información de entrada a una función hash interna. El resultado de la función hash determina la partición (almacenamiento físico interno de DynamoDB) donde se almacenará el elemento. En una tabla que solo tiene una clave de partición, no puede haber dos elementos que tengan el mismo valor de clave de partición. La tabla *People* descrita en [Tablas, elementos y atributos](#HowItWorks.CoreComponents.TablesItemsAttributes) es un ejemplo de una tabla con una clave principal simple (*PersonID*). Puede obtener acceso a cualquier elemento de la tabla *People* directamente al proporcionar el valor de *PersonId* de dicho elemento. + **Clave de partición y clave de ordenación**: este tipo de clave se denomina *clave principal compuesta* y consta de dos atributos. El primer atributo es la *clave de partición* y el segundo, la *clave de ordenación*. DynamoDB utiliza el valor de clave de partición como información de entrada a una función hash interna. El resultado de la función hash determina la partición (almacenamiento físico interno de DynamoDB) donde se almacenará el elemento. Todos los elementos con el mismo valor de clave de partición se almacenan en posiciones contiguas, ordenados según el valor de la clave de ordenación. En una tabla que tenga una clave de partición y una clave de ordenación, es posible que varios elementos tengan el mismo valor de clave de partición. Sin embargo, esos elementos deben tener valores de clave de ordenación distintos. La tabla *Music* descrita en [Tablas, elementos y atributos](#HowItWorks.CoreComponents.TablesItemsAttributes) es un ejemplo de una tabla con una clave principal compuesta (*Artist* y *SongTitle*). Puede obtener acceso a cualquier elemento de la tabla *Music* directamente al proporcionar los valores de *Artist* y *SongTitle* de dicho elemento. Una clave principal compuesta ofrece más flexibilidad a la hora de consultar datos. Por ejemplo, si proporciona el valor de *Artist*, DynamoDB recupera todas las canciones de ese intérprete. Para recuperar solo un subconjunto de canciones de un intérprete determinado, proporcione un valor de *Artist* y un intervalo de valores de *SongTitle*. **nota** La clave de partición de un elemento también se denomina *atributo hash*. El término atributo *hash alude* al uso de una función hash interna en DynamoDB para distribuir los elementos de datos de manera uniforme entre las particiones, según sus valores de clave de partición. La clave de clasificación de un elemento también se denomina *atributo de rango*. El término *atributo de intervalo* alude al hecho de que DynamoDB almacena en ubicaciones físicamente contiguas todos los elementos que tienen la misma clave de partición, ordenados según el valor de la clave de ordenación. Cada atributo de clave principal debe ser escalar (es decir, solo puede contener un único valor). Los únicos tipos de datos que se permiten para los atributos de clave principal son String, Number y Binary. A los demás atributos sin clave no se les aplican restricciones de esta índole. ## Índices secundarios Puede crear uno o varios índices secundarios en una tabla. Un *índice secundario* le permite consultar los datos de la tabla usando una clave alternativa, además de realizar consultas basadas en la clave principal. DynamoDB no requiere que se usen índices; sin embargo, estos ofrecen a las aplicaciones mayor flexibilidad a la hora de consultar los datos. Después de crear un índice secundario en una tabla, podrá leer los datos en el índice prácticamente de la misma forma que en la tabla. DynamoDB admite dos tipos de índices: + Índice secundario global: índice con una clave de partición y una clave de ordenación que pueden diferir de las claves de la tabla. Los valores de clave principal en índices secundarios globales no tienen que ser únicos. + Índice secundario local: índice que tiene la misma clave de partición que la tabla, pero una clave de ordenación distinta. En DynamoDB, los índices secundarios globales (GSI) son índices que abarcan toda la tabla y permiten realizar consultas en todas las claves de partición. Los índices secundarios locales (LSI) son índices que tienen la misma clave de partición que la tabla base, pero una clave de clasificación diferente. Cada tabla de DynamoDB tiene una cuota de 20 índices secundarios globales (cuota predeterminada) y 5 índices secundarios locales. En el ejemplo de la tabla *Música* mostrado anteriormente, puede consultar los elementos de datos por *Artista* (clave de partición) o por *Artista* y *SongTitle* (claves de partición y clasificación). ¿Qué sucede si también desea consultar los datos por género musical (*Genre*) y título de álbum (*AlbumTitle*)? Para ello, puede crear un índice basado en *Genre* y *AlbumTitle* y, a continuación, consultarlo prácticamente de la misma forma que se consultaría la tabla *Music*. El siguiente diagrama muestra la tabla *Music* de ejemplo, con un nuevo índice llamado *GenreAlbumTitle*. En el índice, *Genre* es la clave de partición y *AlbumTitle* es la clave de ordenación. | Tabla Music | *GenreAlbumTitle* | | --- | --- | | 

{
    "Artist": "No One You Know",
    "SongTitle": "My Dog Spot",
    "AlbumTitle": "Hey Now",
    "Price": 1.98,
    "Genre": "Country",
    "CriticRating": 8.4
}
| 

{
    "Genre": "Country",
    "AlbumTitle": "Hey Now",
    "Artist": "No One You Know",
    "SongTitle": "My Dog Spot"
}
| | 

{
    "Artist": "No One You Know",
    "SongTitle": "Somewhere Down The Road",
    "AlbumTitle": "Somewhat Famous",
    "Genre": "Country",
    "CriticRating": 8.4,
    "Year": 1984
}
| 

{
    "Genre": "Country",
    "AlbumTitle": "Somewhat Famous",
    "Artist": "No One You Know",
    "SongTitle": "Somewhere Down The Road"
}
| | 

{
    "Artist": "The Acme Band",
    "SongTitle": "Still in Love",
    "AlbumTitle": "The Buck Starts Here",
    "Price": 2.47,
    "Genre": "Rock",
    "PromotionInfo": {
        "RadioStationsPlaying": {
            "KHCR",
            "KQBX",
            "WTNR",
            "WJJH"
        },
        "TourDates": {
            "Seattle": "20150622",
            "Cleveland": "20150630"
        },
        "Rotation": "Heavy"
    }
}
| 

{
    "Genre": "Rock",
    "AlbumTitle": "The Buck Starts Here",
    "Artist": "The Acme Band",
    "SongTitle": "Still In Love"
}
| | 

{
    "Artist": "The Acme Band",
    "SongTitle": "Look Out, World",
    "AlbumTitle": "The Buck Starts Here",
    "Price": 0.99,
    "Genre": "Rock"
}
| 

{
    "Genre": "Rock",
    "AlbumTitle": "The Buck Starts Here",
    "Artist": "The Acme Band",
    "SongTitle": "Look Out, World"
}
| Tenga en cuenta lo siguiente en relación con el índice *GenreAlbumTitle*: + Cada índice pertenece a una tabla, que se denomina la *tabla base* del índice. En el ejemplo anterior, *Music* es la tabla base del índice *GenreAlbumTitle*. + DynamoDB mantiene los índices automáticamente. Al agregar, actualizar o eliminar un elemento de la tabla base, DynamoDB agrega, actualiza o elimina el elemento correspondiente en los índices que pertenecen a dicha tabla. + Al crear un índice, se especifica qué atributos de la tabla base se copiarán, o *proyectarán*, en el índice. Como mínimo, DynamoDB proyecta en el índice los atributos de clave de la tabla base. Esto es lo que sucede con el índice `GenreAlbumTitle`, en el que únicamente se proyectan los atributos de clave de la tabla `Music`. Puede consultar el índice *GenreAlbumTitle* para encontrar todos los álbumes de un género musical determinado (por ejemplo, todos los álbumes de música *Rock*). También puede consultar el índice para encontrar todos los álbumes de un determinado género musical que tengan un título de álbum específico (por ejemplo, todos los álbumes de música *Country* cuyo título comience por la letra H). Para obtener más información, consulte [Mejora del acceso con índices secundarios en DynamoDB](SecondaryIndexes.md). ## DynamoDB Streams DynamoDB Streams es una característica opcional que captura los eventos de modificación de datos que se producen en las tablas de DynamoDB. Los datos de estos eventos aparecen en la secuencia prácticamente en tiempo real y en el orden en que se han producido. Cada evento se representa mediante un *registro de secuencia*. Si habilita una secuencia en una tabla, DynamoDB Streams escribe un registro de secuencia cada vez que se produzcan los siguientes eventos: + Se agrega un nuevo elemento a la tabla: la secuencia captura una imagen del elemento completo, incluidos todos sus atributos. + Se actualiza un elemento: la secuencia captura las imágenes de "antes" y "después" de los atributos del elemento que se han modificado. + Se elimina un elemento de la tabla: la secuencia captura una imagen del elemento completo antes de eliminarlo. Cada registro de secuencia también contiene el nombre de la tabla, la marca temporal del evento y otros metadatos. Los registros de secuencia tienen una vida útil de 24 horas; después, se eliminan automáticamente de la secuencia. Puede utilizar DynamoDB Streams conjuntamente con AWS Lambda para crear un *desencadenador*; es decir, un código que se ejecute automáticamente cada vez que aparezca un evento de interés en una transmisión. Por ejemplo, tomemos una tabla *Customers* que contiene la información de clientes de una compañía. Supongamos que desea enviar un mensaje de correo electrónico de bienvenida a cada nuevo cliente. Podría habilitar una transmisión en esa tabla y, a continuación, asociar la transmisión con una función Lambda. La función Lambda se ejecutaría cada vez que apareciese un nuevo registro en la transmisión, pero solamente procesaría los nuevos elementos agregados a la tabla *Customers*. Para cualquier elemento que tuviera el atributo `EmailAddress`, la función Lambda podría invocar a Amazon Simple Email Service (Amazon SES) para que enviase un mensaje de correo electrónico a esa dirección. ![\[Integración de DynamoDB Streams y Lambda para enviar automáticamente un correo electrónico de bienvenida a los nuevos clientes.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/HowItWorksStreams.png) **nota** En este ejemplo, observe que el último cliente, Craig Roe, no recibirá un mensaje de correo electrónico, porque no tiene el atributo `EmailAddress`. Además de los disparadores, DynamoDB Streams permite utilizar soluciones sumamente eficientes, tales como replicación de datos en el seno de regiones de AWS y entre ellas, vistas materializadas de datos en las tablas de DynamoDB o análisis de datos mediante vistas materializadas de Kinesis, entre otras. Para obtener más información, consulte [Captura de datos de cambios para DynamoDB Streams](Streams.md). # API de DynamoDB Para trabajar con Amazon DynamoDB, la aplicación debe utilizar algunas operaciones de la API sencillas. A continuación se ofrece un resumen de estas operaciones, organizadas por categorías. **nota** Para obtener una lista completa de las operaciones de la API, consulte la [Referencia de la API de Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/APIReference/Welcome.html). **Topics** + [Plano de control](#HowItWorks.API.ControlPlane) + [Plano de datos](#HowItWorks.API.DataPlane) + [DynamoDB Streams](#HowItWorks.API.Streams) + [Transacciones](#HowItWorks.API.Transactions) ## Plano de control Las operaciones del *plano de control* permiten crear y administrar tablas de DynamoDB. También permiten usar índices, secuencias y otros objetos que dependen de las tablas. + `CreateTable`: crea una nueva tabla. Si lo prefiere, puede crear uno o varios índices secundarios y habilitar DynamoDB Streams para la tabla. + `DescribeTable`: devuelve información sobre una tabla, como su esquema de clave principal, ajustes de rendimiento e información de índice. + `ListTables`: devuelve los nombres de todas las tablas en una lista. + `UpdateTable`: modifica los ajustes de una tabla o sus índices, crea o elimina nuevos índices en una tabla o modifica los ajustes de DynamoDB Streams de una tabla. + `DeleteTable`: elimina de DynamoDB una tabla y todos los objetos que dependen de ella. ## Plano de datos Las operaciones del *plano de datos* permiten llevar a cabo acciones de creación, lectura, actualización y eliminación (también denominadas operaciones *CRUD*, por sus siglas en inglés) con los datos de una tabla. Algunas de las operaciones del plano de datos permiten también leer datos de un índice secundario. Puede utilizar [PartiQL: un lenguaje de consulta compatible con SQL para Amazon DynamoDB](ql-reference.md), para realizar estas operaciones CRUD o puede usar las API CRUD clásicas de DynamoDB que separa cada operación en una llamada a API distinta. ### PartiQL: lenguaje de consulta compatible con SQL + `ExecuteStatement`: lee varios elementos de una tabla. También puede escribir o actualizar un solo elemento de una tabla. Al escribir o actualizar un solo elemento, debe especificar los atributos de clave principal. + `BatchExecuteStatement`: escribe, actualiza o lee varios elementos de una tabla. Resulta más eficiente que `ExecuteStatement`, porque la aplicación solo tiene que completar un único recorrido de ida y vuelta para escribir o leer todos los elementos. ### API clásicas #### Creación de datos + `PutItem`: escribe un solo elemento en una tabla. Debe especificar los atributos de clave principal, pero no es preciso especificar otros atributos. + `BatchWriteItem`: escribe hasta 25 elementos en una tabla. Resulta más eficiente que llamar a `PutItem` varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y vuelta para escribir todos los elementos. #### Lectura de datos + `GetItem`: recupera un solo elemento de una tabla. Es preciso especificar la clave principal del elemento que se desea recuperar. Puede recuperar la totalidad del elemento o solo un subconjunto de sus atributos. + `BatchGetItem`: recupera hasta 100 elementos de una o varias tablas. Resulta más eficiente que llamar a `GetItem` varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y vuelta para leer todos los elementos. + `Query`: recupera todos los elementos que tienen una clave de partición determinada. Debe especificar el valor de clave de partición. Puede recuperar la totalidad de los elementos o solo un subconjunto de sus atributos. De forma opcional, puede aplicar una condición a los valores de la clave de ordenación de tal forma que solo se recupere un subconjunto de los datos que tienen la misma clave de partición. Puede utilizar esta operación en una tabla, siempre y cuando esta tenga tanto una clave de partición como una clave de ordenación. También puede utilizar esta operación en un índice, siempre y cuando este tenga tanto una clave de partición como una clave de ordenación. + `Scan`: recupera todos los elementos de la tabla o el índice especificados. Puede recuperar la totalidad de los elementos o solo un subconjunto de sus atributos. Si lo desea, puede aplicar una condición de filtrado para devolver solamente aquellos valores que le interesan y descartar los demás. #### Actualización de datos + `UpdateItem`: modifica uno o varios atributos de un elemento. Es preciso especificar la clave principal del elemento que se desea modificar. Puede agregar nuevos atributos, así como modificar o eliminar los existentes. También puede realizar actualizaciones condicionales, de tal forma que la actualización solamente se lleve a cabo cuando se cumpla una condición definida por el usuario. Si lo desea, puede implementar un contador atómico, que incrementa o disminuye el valor de un atributo numérico sin interferir con las demás solicitudes de escritura. #### Eliminación de datos + `DeleteItem`: elimina un solo elemento de una tabla. Es preciso especificar la clave principal del elemento que se desea eliminar. + `BatchWriteItem`: elimina hasta 25 elementos de una o varias tablas. Resulta más eficiente que llamar a `DeleteItem` varias veces, porque la aplicación solo tiene que completar un único recorrido de ida y vuelta para eliminar todos los elementos. **nota** Puede usar `BatchWriteItem` para crear y eliminar datos. ## DynamoDB Streams Las operaciones de *DynamoDB Streams* permiten habilitar o deshabilitar una secuencia en una tabla y obtener acceso a los registros de modificación de datos contenidos en una secuencia. + `ListStreams`: devuelve una lista de todas las secuencias o solamente la secuencia de una tabla concreta. + `DescribeStream`: devuelve información sobre una secuencia, como su nombre de recurso de Amazon (ARN) y sobre dónde puede comenzar la aplicación a leer los primeros registros de la secuencia. + `GetShardIterator`: devuelve un *iterador de fragmentos*, que es una estructura de datos que la aplicación utiliza para recuperar los registros de la secuencia. + `GetRecords`: recupera uno o varios registros de secuencia mediante el iterador de fragmentos especificado. ## Transacciones Las *transacciones* proporcionan atomicidad, coherencia, aislamiento y durabilidad (ACID, atomicity, consistency, isolation, and durability), lo que le permite mantener la exactitud de los datos en sus aplicaciones más fácilmente. Puede utilizar [PartiQL: un lenguaje de consulta compatible con SQL para Amazon DynamoDB](ql-reference.md), para realizar operaciones transaccionales o puede usar las API CRUD clásicas de DynamoDB que separa cada operación en una llamada a API distinta. ### PartiQL: lenguaje de consulta compatible con SQL + `ExecuteTransaction`: operación por lote que permite operaciones CRUD para varios elementos dentro y distintas tablas con un resultado garantizado de “todo o nada”. ### API clásicas + `TransactWriteItems`— Una operación por lote que permite operaciones `Put`, `Update` y `Delete` con varios elementos dentro y distintas tablas con un resultado garantizado de “todo o nada”. + `TransactGetItems`— Una operación por lote que permite `Get` para recuperar varios elementos de una o varias tablas. # Tipos de datos y reglas de nomenclatura admitidos en Amazon DynamoDB En esta sección se describen las reglas de nomenclatura de Amazon DynamoDB y los distintos tipos de datos que DynamoDB admite. Existen límites que se aplican a los tipos de datos. Para obtener más información, consulte [Tipos de datos](Constraints.md#limits-data-types). **Topics** + [Reglas de nomenclatura](#HowItWorks.NamingRules) + [Tipos de datos](#HowItWorks.DataTypes) + [Descriptores de tipos de datos](#HowItWorks.DataTypeDescriptors) ## Reglas de nomenclatura Las tablas, los atributos y otros objetos de DynamoDB deben tener nombres. Los nombres deben ser significativos y concisos; por ejemplo, *Products*, *Books* y *Authors* son nombres que indican claramente su significado. A continuación, se indican las reglas de nomenclatura de DynamoDB: + Todos los nombres deben codificarse mediante UTF-8 y distinguen entre mayúsculas y minúsculas. + Los nombres de las tablas y los índices deben tener entre 3 y 255 caracteres, que solo pueden ser los siguientes: + `a-z` + `A-Z ` + ` 0-9 ` + `_` (guion bajo) + `-` (guion) + `.` (punto) + Los nombres de atributo deben tener al menos un carácter y un tamaño inferior a 64 KB. Se considera una práctica recomendada mantener los nombres de los atributos lo más cortos posible. Esto contribuye a reducir las unidades de solicitud de lectura consumidas, ya que los nombres de los atributos se incluyen en la medición del uso del almacenamiento y del rendimiento. A continuación se muestran las excepciones. Los siguientes nombres de atributo no pueden tener más de 255 caracteres: + Nombres de clave de partición de índice secundario + Nombres de clave de clasificación de índice secundario + Nombres de atributos proyectados especificados por el usuario (aplicables solo a índices secundarios locales) ### Palabras reservadas y caracteres especiales DynamoDB tiene una lista de palabras reservadas y caracteres especiales. Para ver una lista completa, consulte [Palabras reservadas en DynamoDB](ReservedWords.md). También los siguientes caracteres tienen un significado especial en DynamoDB: **\$1** (hash) y **:** (dos puntos). Aunque DynamoDB permite utilizar estas palabras reservadas y caracteres especiales en los nombres, recomendamos que evite hacerlo, porque tendría que definir variables de marcador de posición cada vez que utilizase estos nombres en una expresión. Para obtener más información, consulte [Nombres de atributos de expresión (Alias) en DynamoDB](Expressions.ExpressionAttributeNames.md). ## Tipos de datos DynamoDB admite muchos tipos de datos para los atributos de una tabla. Se pueden categorizar como se indica a continuación: + **Tipos escalares**: un tipo escalar es aquel que puede representar exactamente un valor. Los tipos escalares son Number, String, Binary, Boolean y Null. + **Tipos de documentos**: un tipo de documento puede representar una estructura compleja con atributos anidados, como los que se encontraría en un documento JSON. Los tipos de documentos son List y Map. + **Tipos de conjuntos**: un tipo de conjunto puede representar varios valores escalares. Los tipos de conjuntos son String Set, Number Set y Binary Set. Al crear una tabla o un índice secundario, debe especificar los nombres y los tipos de datos de cada uno de los atributos de clave principal (clave de partición y clave de ordenación). Además, cada atributo de clave principal debe definirse como de tipo String, Number o Binary. DynamoDB es una base de datos NoSQL *sin esquema*. Esto significa que, a excepción de los atributos de clave principal, no tiene que definir atributos ni tipos de datos cuando crea las tablas. En comparación, las bases de datos relacionales requieren que se definan los nombres y los tipos de datos de cada columna al crear la tabla. A continuación se muestran las descripciones de cada tipo de datos, junto con ejemplos en formato JSON. ### Tipos escalares Los tipos escalares son Number, String, Binary, Boolean y Null. #### Número Los números pueden ser positivos, negativos o cero. Los números pueden tener hasta 38 dígitos de precisión. Si excede este tope, se generará una excepción. Si necesita una precisión superior a 38 dígitos, puede utilizar cadenas. + Rango de valores positivos: de 1E-130 a 9.9999999999999999999999999999999999999E\$1125 + Rango de valores negativos: de -9.9999999999999999999999999999999999999E\$1125 a -1E-130 En DynamoDB, los números se representan con longitud variable. Los ceros iniciales y finales se recortan. Todos los números se envían a través de la red a DynamoDB como cadenas, para maximizar la compatibilidad entre lenguajes y bibliotecas. Sin embargo, DynamoDB los trata como atributos de tipo Number en las operaciones matemáticas. Puede utilizar el tipo de datos Number para representar una fecha o una marca temporal. Una forma de hacerlo es utilizar fechas en formato de tiempo Unix, es decir, el número de segundos desde las 00:00:00 UTC del 1 de enero de 1970. Por ejemplo, la fecha de inicio `1437136300` representa las 12:31:40 UTC del 17 de julio de 2015. Para obtener más información, consulte [http://en.wikipedia.org/wiki/Unix\$1time](http://en.wikipedia.org/wiki/Unix_time). #### Cadena Los valores de tipo String son Unicode con codificación binaria UTF-8. La longitud mínima de una cadena puede ser cero si el atributo no se utiliza como clave de un índice o tabla y tiene un límite de tamaño máximo de 400 KB para los elementos de DynamoDB. Las siguientes restricciones adicionales son aplicables a atributos de clave principal definidos como cadena de tipo: + Para una clave principal simple, la longitud máxima del valor del primer atributo (clave de partición) es 2048 KB. + Para una clave principal compuesta, la longitud máxima del valor del segundo atributo (clave de ordenación) es 1024 KB. DynamoDB recopila y compara las cadenas utilizando los bytes de la codificación de cadena UTF-8 subyacente. Por ejemplo, "`a`" (0x61) es mayor que "`A`" (0x41) y "`¿`" (0xC2BF) es mayor que "`z`" (0x7A). Puede utilizar el tipo de datos String para representar una fecha o una marca temporal. Una forma de hacerlo es utilizar cadenas ISO 8601, tal y como se muestra en estos ejemplos: + `2016-02-15` + `2015-12-21T17:42:34Z` + `20150311T122706Z` Para obtener más información, consulte [http://en.wikipedia.org/wiki/ISO\$18601](http://en.wikipedia.org/wiki/ISO_8601). **nota** A diferencia de las bases de datos relacionales convencionales, DynamoDB no admite de forma nativa un tipo de datos de fecha y hora. En cambio, puede ser útil almacenar los datos de fecha y hora como un tipo de dato numérico, mediante el tiempo de época de Unix. #### Binario Los atributos de tipo Binary pueden almacenar cualquier tipo de datos binarios, como texto comprimidos, datos cifrados o imágenes. Siempre que DynamoDB compara valores de tipo Binary, trata cada byte de los datos binarios como sin signo. La longitud de un atributo binario puede ser cero si el atributo no se utiliza como clave de un índice o tabla y tiene un límite de tamaño máximo de 400 KB para los elementos de DynamoDB. Si define un atributo de clave principal como atributo de tipo Binary, se aplican las siguientes restricciones adicionales: + Para una clave principal simple, la longitud máxima del valor del primer atributo (clave de partición) es 2048 KB. + Para una clave principal compuesta, la longitud máxima del valor del segundo atributo (clave de ordenación) es 1024 KB. Las aplicaciones deben codificar los valores de tipo Binary en formato codificado en base64 antes de enviarlos a DynamoDB. Al recibirlos, DynamoDB decodifica los datos y los convierte a matrices de bytes sin signo; a continuación, utiliza ese resultado como longitud del atributo de tipo Binary. El siguiente ejemplo es un atributo de tipo Binary en el que se utiliza texto con la codificación en base64. ``` dGhpcyB0ZXh0IGlzIGJhc2U2NC1lbmNvZGVk ``` #### Booleano Un atributo de tipo Boolean puede almacenar los valores `true` o `false`. #### Nulo Null representa un atributo con un estado desconocido o sin definir. ### Tipos de documentos Los tipos de documentos son List y Map. Estos tipos de datos pueden anidarse unos en otros para representar estructuras de datos complejas con un máximo de 32 niveles de profundidad. No existe ningún límite respecto al número de valores de una lista o un mapa, siempre y cuando el elemento que contenga los valores se ajuste al límite de tamaño de elemento de DynamoDB (400 KB). El valor de un atributo puede ser una cadena vacía o un valor binario vacío si el atributo no se utiliza en una tabla o clave de índice. El valor de un atributo no puede ser un conjunto vacío (conjunto de cadenas, conjunto de números o conjunto binario); sin embargo, sí se permiten listas y mapas vacíos. Se pueden utilizar valores binarios y de cadena vacíos en las listas y los mapas. Para obtener más información, consulte [Atributos](Constraints.md#limits-attributes). #### Enumeración Un atributo de tipo List puede almacenar una colección ordenada de valores. Las listas deben ir entre corchetes: .: `[ ... ]` Una lista es similar a una matriz JSON. No hay ninguna limitación respecto a los tipos de datos que se pueden almacenar en una entrada de lista y no es preciso que las entradas de una entrada de lista sean del mismo tipo. En el siguiente ejemplo se muestra una lista que contiene dos cadenas y un número. ``` FavoriteThings: ["Cookies", "Coffee", 3.14159] ``` **nota** DynamoDB permite usar entradas individuales contenidas en las listas, aunque estas entradas estén anidadas a gran profundidad. Para obtener más información, consulte [Uso de expresiones en DynamoDB](Expressions.md). #### Asignación Un atributo de tipo Map puede almacenar una colección desordenada de pares nombre-valor. Los mapas deben ir entre llaves: .: `{ ... }` Un mapa es similar a un objeto JSON. No hay ninguna limitación respecto a los tipos de datos que se pueden almacenar en una entrada de mapa y no es preciso que las entradas de un mapa sean del mismo tipo. Los mapas son idóneos para almacenar documentos JSON en DynamoDB. En el siguiente ejemplo se muestra un mapa que contiene una cadena, un número y una lista anidada que contiene otro mapa. ``` { Day: "Monday", UnreadEmails: 42, ItemsOnMyDesk: [ "Coffee Cup", "Telephone", { Pens: { Quantity : 3}, Pencils: { Quantity : 2}, Erasers: { Quantity : 1} } ] } ``` **nota** DynamoDB permite usar entradas individuales contenidas en los mapas, aunque estas entradas estén anidadas a gran profundidad. Para obtener más información, consulte [Uso de expresiones en DynamoDB](Expressions.md). ### Sets DynamoDB admite tipos que representan conjuntos de valores de tipo number, string o binary. Todas las entradas de un conjunto deben ser del mismo tipo. Por ejemplo, un conjunto de números solo puede contener números y un conjunto de cadenas solo puede contener cadenas. No existe ningún límite respecto al número de valores de un conjunto, siempre y cuando el elemento que contenga los valores se ajuste al límite de tamaño de elemento de DynamoDB (400 KB). Cada valor contenido en un conjunto debe ser único. No se conserva el orden de los valores dentro de un conjunto. Por lo tanto, sus aplicaciones no deben confiar en ningún orden particular de elementos dentro del conjunto. DynamoDB no admite conjuntos vacíos; sin embargo, sí se pueden utilizar valores binarios y de cadena vacíos dentro de un conjunto. En el siguiente ejemplo se muestra un conjunto de cadenas, un conjunto de números y un conjunto de valores binarios: ``` ["Black", "Green", "Red"] [42.2, -19, 7.5, 3.14] ["U3Vubnk=", "UmFpbnk=", "U25vd3k="] ``` ## Descriptores de tipos de datos El protocolo de bajo nivel de la API de DynamoDB utiliza *descriptores de tipo de datos* como tokens que indican a DynamoDB cómo interpretar cada atributo. A continuación se muestra una lista completa de descriptores de tipos de datos de DynamoDB: + **`S`** – cadena + **`N`** – número + **`B`** – Binary + **`BOOL`** – booleano + **`NULL`** – Null + **`M`** – mapa + **`L`** – List + **`SS`** – String Set + **`NS`** – Number Set + **`BS`** – Binary Set # Clases de tablas de DynamoDB DynamoDB ofrece dos clases de tablas diseñadas para ayudarle a optimizar los costos. La clase de tabla DynamoDB Estándar es la predeterminada y se recomienda para la gran mayoría de las cargas de trabajo. La clase de tabla DynamoDB Estándar - Acceso poco frecuente (DynamoDB Standard-IA) está optimizada para tablas en las que el almacenamiento es el costo dominante. Por ejemplo, las tablas que almacenan datos a los que se accede con poca frecuencia, como registros de aplicaciones, publicaciones antiguas en redes sociales, historial de pedidos de comercio electrónico y antiguos logros en juegos, son buenas candidatas para la clase de tabla Standard-IA. Consulte [Precio de Amazon DynamoDB](https://aws.amazon.com/dynamodb/pricing/on-demand/) para obtener más información sobre los precios. Cada tabla DynamoDB está asociada a una clase de tabla (DynamoDB Estándar de forma predeterminada). Todos los índices secundarios asociados a la tabla utilizan la misma clase de tabla. Cada clase de tabla ofrece diferentes precios para el almacenamiento de datos, así como para las solicitudes de lectura y escritura. Puede seleccionar la clase de tabla más rentable para usted en función de sus patrones de uso de almacenamiento y rendimiento. La elección de una clase de tabla no es permanente. Puede cambiar esta configuración mediante la Consola de administración de AWS, la CLI de AWS o el SDK de AWS. DynamoDB también permite administrar la clase de tabla mediante AWS CloudFormation para las tablas de una región concreta y las tablas globales. Para obtener más información acerca de cómo seleccionar una clase de tabla, consulte [Aspectos que tener en cuenta a la hora de elegir una clase de tabla en DynamoDB](WorkingWithTables.tableclasses.md). # Particiones y distribución de datos en DynamoDB Amazon DynamoDB almacena los datos en las particiones. Una *partición* es una asignación de almacenamiento a una tabla que se sustenta en discos de estado sólido (SSD) y se replica automáticamente en varias zonas de disponibilidad de una región de AWS. DynamoDB se encarga de todo lo que concierne a la administración de las particiones para que usted no tenga que ocuparse de ello. Al crear una tabla, su estado inicial es `CREATING`. Durante esta fase, DynamoDB asigna particiones suficientes a la tabla para que pueda satisfacer los requisitos de rendimiento aprovisionado. Puede comenzar a escribir y leer datos en la tabla una vez que su estado haya cambiado a `ACTIVE`. DynamoDB asigna particiones adicionales a una tabla en las siguientes situaciones: + Si aumenta los ajustes de rendimiento aprovisionado de la tabla de tal forma que se supere el límite admitido por las particiones existentes. + Si una partición existente se llena al límite de su capacidad y se requiere más espacio de almacenamiento. La administración de las particiones tiene lugar automáticamente en segundo plano y es transparente para las aplicaciones. La tabla permanece disponible a lo largo del proceso y responde en todo momento a los requisitos de rendimiento aprovisionado. Para obtener más información, consulte [Diseño de claves de partición](bp-partition-key-design.md). Los índices secundarios globales de DynamoDB también constan de particiones. Los datos de un índice secundario global se almacenan de forma independiente de los datos de la tabla base, pero las particiones de índices se comportan prácticamente igual que las particiones de tablas. ## Distribución de datos: clave de partición Si la tabla tiene una clave principal simple (solo clave de partición), DynamoDB almacenará y recuperará cada elemento basándose en su valor de clave de partición. Para escribir un elemento en la tabla, DynamoDB utiliza el valor de la clave de partición como información de entrada para una función hash interna. El valor del resultado de la función hash determina la partición donde se almacenará el elemento. Para leer un elemento de la tabla, debe especificar el valor de clave de partición del elemento. DynamoDB utiliza este valor como información de entrada para la función hash para obtener la partición en la que se encuentra el elemento. En el siguiente diagrama se muestra una tabla denominada *Pets* que abarca varias particiones. La clave principal de la tabla es *AnimalType* (solo se muestra este atributo de clave). DynamoDB utiliza la función hash para determinar dónde se almacenará un nuevo elemento, en este caso de acuerdo con el valor hash de la cadena *Dog*. Tenga en cuenta que los elementos no se almacenan de forma ordenada. La ubicación de cada elemento viene determinada por el valor hash de su clave de partición. ![\[La distribución de los elementos de la tabla en las particiones de DynamoDB se basa en el valor hash de la clave de partición.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKey.png) **nota** DynamoDB está optimizado para distribuir los elementos uniformemente entre las particiones de una tabla, con independencia del número de particiones que haya. Recomendamos elegir una clave de partición que pueda tener un amplio abanico de valores distintos en relación con el número de elementos de la tabla. ## Distribución de datos: clave de partición y clave de clasificación Si la tabla tiene una clave principal compuesta (clave de partición y clave de ordenación), DynamoDB calcula el valor hash de la clave de partición de la misma forma que se describe en [Distribución de datos: clave de partición](#HowItWorks.Partitions.SimpleKey). Sin embargo, tiende a mantener los elementos que tienen el mismo valor de clave de partición juntos y ordenados según el valor del atributo de la clave de clasificación. Al conjunto de elementos que tienen el mismo valor de la clave de partición se le denomina recopilación de elementos. Las recopilaciones de elementos están optimizadas para recuperar de forma eficiente los rangos de los elementos de la recopilación. Si la tabla no tiene índices secundarios locales, DynamoDB dividirá automáticamente la recopilación de elementos en tantas particiones como sea necesario para almacenar los datos y garantizar el rendimiento de lectura y escritura. Para escribir un elemento en la tabla, DynamoDB calcula el valor hash de su clave de partición, con el fin de determinar qué partición debe contener el elemento. En dicha partición, varios elementos podrían tener el mismo valor de clave de partición. Por tanto, DynamoDB almacena el elemento con los otros que tienen la misma clave de partición, en orden ascendente por clave de ordenación. Para leer un elemento de la tabla, debe especificar los valores de sus claves de partición y ordenación. DynamoDB calcula el valor hash de la clave de partición para obtener la partición en la que se encuentra el elemento. Puede leer varios elementos de la tabla en una misma operación (`Query`), si los elementos que desee leer tengan el mismo valor de clave de partición. DynamoDB devuelve todos los elementos que contienen ese valor de clave de partición. De forma opcional, puede aplicar una condición a la clave de ordenación para que devuelva solamente los elementos comprendidos en un rango de valores determinado. Supongamos que la tabla *Pets* tiene una clave principal compuesta que consta de *AnimalType* (clave de partición) y *Name* (clave de ordenación). En el siguiente diagrama se ilustra lo que ocurre cuando DynamoDB escribe un elemento con un valor de clave de partición *Dog* y un valor de clave de ordenación *Fido*. ![\[DynamoDB almacena un elemento con una clave de partición compuesta y lo clasifica mediante el valor del atributo de la clave de clasificación.\]](http://docs.aws.amazon.com/es_es/amazondynamodb/latest/developerguide/images/HowItWorksPartitionKeySortKey.png) Para leer el mismo elemento de la tabla *Pets*, DynamoDB calcula el valor hash de *Dog* para obtener la partición en la que están almacenados estos elementos. A continuación, DynamoDB examina los valores de los atributos de clave de ordenación hasta que encuentra *Fido*. Para leer todos los elementos cuyo valor de *AnimalType* es *Dog*, puede emitir una operación `Query` sin especificar una condición de clave de ordenación. De forma predeterminada, los elementos se devuelven en el orden en el que están almacenados (es decir, en orden ascendente, según su clave de ordenación). Si lo prefiere, puede solicitar que se muestren por orden descendente. Para consultar solo algunos de los elementos *Dog*, puede aplicar una condición a la clave de ordenación (por ejemplo, solo los elementos *Dog* cuyo valor de *Name* comience por una letra comprendida entre la `A` y la `K`). **nota** En una tabla de DynamoDB, no existe ningún límite superior respecto al número de valores diferentes de clave de ordenación por cada valor de clave de partición. Si necesita almacenar muchos miles de millones de elementos *Dog* en la tabla *Pets*, DynamoDB asignaría almacenamiento suficiente para satisfacer este requisito automáticamente. # 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" } ``` # Recursos y herramientas de aprendizaje de Amazon DynamoDB Puede utilizar los siguientes recursos adicionales para entender y trabajar con DynamoDB. **Topics** + [Herramientas de programación y visualización](#AdditionalResources.Tools) + [Artículos de orientación prescriptiva](#AdditionalResources.PrescriptiveGuidance) + [Artículos del Centro de conocimientos](#AdditionalResources.KnowledgeCenter) + [Entradas de blog, repositorios y guías](#AdditionalResources.Guides) + [Presentaciones de modelado de datos y patrones de diseño](#AdditionalResources.DataModeling) + [Cursos de formación técnica](#AdditionalResources.Training) ## Herramientas de programación y visualización Puede utilizar las siguientes herramientas de codificación y visualización para trabajar con DynamoDB: + [NoSQL Workbench para Amazon DynamoDB](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/workbench.html): una herramienta visual unificada que le ayuda a diseñar, crear, consultar y administrar tablas de DynamoDB. Proporciona características de modelado de datos, visualización de datos y desarrollo de consultas. + [Dynobase](https://dynobase.dev/): una herramienta de escritorio que facilita la visualización de las tablas de DynamoDB y el trabajo con ellas, la creación de código de aplicación y la edición de registros con validación en tiempo real. + [Caja de herramientas de DynamoDB](https://github.com/jeremydaly/dynamodb-toolbox): un proyecto de Jeremy Daly que proporciona utilidades eficaces para trabajar con el modelado de datos y JavaScript y Node.js. + [Procesador de DynamoDB Streams](https://github.com/jeremydaly/dynamodb-streams-processor): una herramienta sencilla que puede usar para trabajar con [DynamoDB Streams](https://docs.aws.amazon.com/amazondynamodb/latest/developerguide/Streams.html). ## Artículos de orientación prescriptiva La orientación prescriptiva de AWS proporciona estrategias, guías y patrones comprobados a lo largo del tiempo para ayudar a acelerar los proyectos. Estos recursos los desarrollaron expertos en tecnología de AWS y la comunidad global de socios de AWS, en función de los años de experiencia ayudando a los clientes a alcanzar los objetivos comerciales. **Modelado y migración de datos** + [Un modelo de datos jerárquico en DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-hierarchical-data-model/introduction.html) + [Modelado de datos con DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-data-modeling/welcome.html) + [Migrar una base de datos de Oracle a DynamoDB con AWS DMS](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/migrate-an-oracle-database-to-amazon-dynamodb-using-aws-dms.html) **Tablas globales** + [Uso de tablas globales de Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-global-tables/introduction.html) **sin servidor** + [Implementar el patrón saga sin servidor con AWS Step Functions](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/implement-the-serverless-saga-pattern-by-using-aws-step-functions.html) **Arquitectura SaaS** + [Administrar los inquilinos de varios productos SaaS en un único plano de control](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/manage-tenants-across-multiple-saas-products-on-a-single-control-plane.html) + [Incorporación de inquilinos en la arquitectura SaaS para el modelo de silo mediante C\$1 y AWS CDK](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/tenant-onboarding-in-saas-architecture-for-the-silo-model-using-c-and-aws-cdk.html) **Protección de datos y movimiento de datos** + [Configurar el acceso entre cuentas a Amazon DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/configure-cross-account-access-to-amazon-dynamodb.html) + [Opciones completas de copia de tablas para DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/dynamodb-full-table-copy-options/) + [Estrategia de recuperación de desastres para bases de datos en AWS](https://docs.aws.amazon.com/prescriptive-guidance/latest/strategy-database-disaster-recovery/) **Misceláneo** + [Ayudar a reforzar el etiquetado en DynamoDB](https://docs.aws.amazon.com/prescriptive-guidance/latest/patterns/help-enforce-dynamodb-tagging.html) **Tutoriales en vídeo de orientación prescriptiva** + [Uso de la arquitectura sin servidor para crear canalizaciones de datos](https://youtu.be/JiWHomdh1oI?) + [Novartis: Motor de compras: portal de adquisiciones impulsado por IA](https://youtu.be/vp8oPiHN4cA) + [Veritiv: permita que la información haga la previsión de la demanda de ventas en lagos de datos de AWS](https://youtu.be/jg85DzUZ9Ac) + [mimik: aprovechamiento de la nube perimetral híbrida AWS para Support Edge Microservice Mesh](https://youtu.be/-S-R7MWRpaI) + [Captura de datos de cambios con Amazon DynamoDB](https://youtu.be/6YVjzD-70p4) Para ver más artículos y vídeos de orientación prescriptiva para DynamoDB, consulte [Orientación prescriptiva](https://tiny.amazon.com/fiui3cog/ForinternaldemoofnewpageExternalURLwillbeneededforlive). ## Artículos del Centro de conocimientos Los artículos y vídeos del Centro de conocimiento de AWS cubren las preguntas y solicitudes más frecuentes que recibimos de los clientes de AWS. A continuación se muestran algunos artículos actuales del Centro de conocimiento sobre tareas específicas relacionadas con DynamoDB: **Optimización de costos** + [Cómo puedo optimizar los costes con Amazon DynamoDB?](https://repost.aws/knowledge-center/dynamodb-optimize-costs) **Limitación y latencia** + [How can I troubleshoot high latency on an Amazon DynamoDB table?](https://repost.aws/knowledge-center/dynamodb-high-latency) + [Por qué se está limitando mi tabla de DynamoDB?](https://repost.aws/knowledge-center/dynamodb-table-throttled) + [Por qué se está limitando mi tabla de DynamoDB bajo demanda?](https://repost.aws/knowledge-center/on-demand-table-throttling-dynamodb) **Paginación** + [Cómo implemento la paginación en DynamoDB](https://repost.aws/knowledge-center/dynamodb-implement-pagination) **Transacciones** + [Por qué produce un error mi llamada a la API `TransactWriteItems` en DynamoDB](https://repost.aws/knowledge-center/dynamodb-transactwriteitems) **Solución de problemas** []() + [Cómo resuelvo problemas con el escalado automático de DynamoDB?](https://repost.aws/knowledge-center/dynamodb-auto-scaling) + [Cómo soluciono los errores de HTTP 4XX en DynamoDB](https://repost.aws/knowledge-center/usererrors-dynamodb-table) Para ver artículos y vídeos adicionales de DynamoDB, consulte los [artículos del Centro de conocimiento](https://repost.aws/search/knowledge-center?globalSearch=dynamodb). ## Entradas de blog, repositorios y guías Además de la [Guía para desarrolladores de DynamoDB](Introduction.md), hay muchos recursos útiles para trabajar con DynamoDB. Estas son algunas publicaciones de blog, repositorios y guías seleccionadas para trabajar con DynamoDB: + Repositorio de AWS de [Ejemplos de códigos DynamoDB](https://github.com/aws-samples/aws-dynamodb-examples) en varios idiomas del SDK de AWS: [Node.js,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/node.js) [Java,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/java) [Python,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/python) [.Net,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/dotnet) [Go,](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/golang) y [Rust](https://github.com/aws-samples/aws-dynamodb-examples/tree/master/examples/SDK/rust). + [El libro de DynamoDB](https://www.dynamodbbook.com/): una guía completa de [Alex DeBrie](https://twitter.com/alexbdebrie) que presenta un enfoque basado en la estrategia del modelado de datos con DynamoDB. + [Guía de DynamoDB](https://www.dynamodbguide.com/): una guía abierta de [Alex DeBrie](https://twitter.com/alexbdebrie) que describe los conceptos básicos y las características avanzadas de la base de datos DynamoDB NoSQL. + [Cómo cambiar de RDBMS a DynamoDB en 20 sencillos pasos](https://www.jeremydaly.com/how-to-switch-from-rdbms-to-dynamodb-in-20-easy-steps/): una lista de pasos útiles para obtener información sobre el modelado de datos de [Jeremy Daly](https://twitter.com/jeremy_daly). + [Hoja de trucos DynamoDB JavaScript DocumentClient](https://github.com/dabit3/dynamodb-documentclient-cheat-sheet): una hoja de trucos para ayudarle a empezar a crear aplicaciones con DynamoDB en un entorno Node.js o JavaScript. + [Vídeos de conceptos básicos de DynamoDB](https://www.youtube.com/playlist?list=PLJo-rJlep0EDNtcDeHDMqsXJcuKMcrC5F): esta lista de reproducción cubre muchos de los conceptos básicos de DynamoDB. ## Presentaciones de modelado de datos y patrones de diseño Puede utilizar los siguientes recursos sobre modelos de datos y patrones de diseño para aprovechar DynamoDB al máximo: + [AWS re:Invent 2019: Modelado de datos con DynamoDB](https://www.youtube.com/watch?v=DIQVJqiSUkE) + Una charla de [Alex DeBrie](https://twitter.com/alexbdebrie) que le presenta los principios del modelado de datos de DynamoDB. + [AWS re:Invent 2020: Modelado de datos con DynamoDB: Parte 1](https://www.youtube.com/watch?v=fiP2e-g-r4g) + [AWS re:Invent 2020: Modelado de datos con DynamoDB: Parte 2](https://www.youtube.com/watch?v=0uLF1tjI_BI) + [AWS re:Invent 2017: Advanced design patterns](https://www.youtube.com/watch?v=jzeKPKpucS0) + [AWS re:Invent 2018: Advanced design patterns](https://www.youtube.com/watch?v=HaEPXoXVf2k) + [AWS re:Invent 2019: Advanced design patterns](https://www.youtube.com/watch?v=6yqfmXiZTlM) + Jeremy Daly comparte sus [12 ideas principales](https://www.jeremydaly.com/takeaways-from-dynamodb-deep-dive-advanced-design-patterns-dat403/) de esta sesión. + [AWS re:Invent 2020: DynamoDB advanced design patterns: Parte 1](https://www.youtube.com/watch?v=MF9a1UNOAQo&index=1) + [AWS re:Invent 2020: DynamoDB advanced design patterns: Parte 2](https://www.youtube.com/watch?v=_KNrRdWD25M&index=2) + [Horario de oficina de DynamoDB en Twitch](https://amazondynamodbofficehrs.splashthat.com/) **nota** En cada sesión se explican diferentes casos de uso y ejemplos. ## Cursos de formación técnica Hay muchos cursos de formación y opciones educativas diferentes para obtener más información sobre DynamoDB. Estos son algunos ejemplos actuales: + [Desarrollo con Amazon DynamoDB](https://www.aws.training/Details/Curriculum?id=65583): diseñado por AWS para guiarle de principiante a experto en el desarrollo de aplicaciones del mundo real con modelado de datos para Amazon DynamoDB. + [Curso de información detallada de DynamoDB](https://www.pluralsight.com/courses/aws-dynamodb-deep-dive-2019): un curso de Pluralsight. + [Amazon DynamoDB: creación de aplicaciones controladas por bases de datos NoSQL](https://www.edx.org/course/amazon-dynamodb-building-nosql-database-driven-app): un curso del equipo de formación y certificación de AWS alojado en edX.