Amazon Redshift dejará de admitir la creación de nuevas UDF de Python a partir del parche 198. Las UDF de Python existentes seguirán funcionando hasta el 30 de junio de 2026. Para obtener más información, consulte la [publicación del blog](https://aws.amazon.com/blogs/big-data/amazon-redshift-python-user-defined-functions-will-reach-end-of-support-after-june-30-2026/). # Tutorial: Carga de datos desde Amazon S3 En este tutorial, siga el proceso de creación de datos en las tablas de bases de datos de Amazon Redshift desde archivos de datos en un bucket de Amazon S3 de principio a fin. En este tutorial, aprenderá a hacer lo siguiente: + Descargar archivos de datos que utilicen formatos de ancho fijo, con caracteres delimitados y de valores separados por comas (CSV). + crear un bucket de Amazon S3 y, luego, cargar los archivos de datos en él + lanzar un clúster de Amazon Redshift y crear tablas de base de datos + usar los comandos COPY para cargar las tablas desde los archivos de datos en Amazon S3 + Solucionar errores de carga y modificar los comandos COPY para corregir los errores. ## Requisitos previos Necesita los siguientes requisitos previos: + Una cuenta de AWS para lanzar un clúster de Amazon Redshift y crear un bucket en Amazon S3. + Sus credenciales de AWS (rol de IAM) para cargar datos de prueba de Amazon S3. Si necesita un nuevo rol de IAM, diríjase a [Creación de roles de IAM](https://docs.aws.amazon.com/IAM/latest/UserGuide/id_roles_create.html). + Un cliente SQL como el editor de consultas de la consola de Amazon Redshift. Este tutorial está diseñado para que pueda realizarlo por sí mismo. Además de este tutorial, recomendamos completar los siguientes tutoriales para obtener un conocimiento más completo sobre cómo diseñar y utilizar las bases de datos de Amazon Redshift: + En la [Guía de introducción a Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/), se detalla el proceso de la creación de un clúster de Amazon Redshift y de la carga de datos de muestra. ## Descripción general Puede agregar datos a las tablas de Amazon Redshift mediante el uso de un comando INSERT o uno COPY. En la escala y la velocidad de un almacenamiento de datos de Amazon Redshift, el comando COPY es muchas veces más rápido y eficiente que los comandos INSERT. El comando COPY utiliza la arquitectura de procesamiento masivo en paralelo (MPP) de Amazon Redshift para leer y cargar datos en paralelo desde varios orígenes de datos. Puede cargar datos desde archivos de datos en Amazon S3, Amazon EMR o cualquier alojamiento remoto que sea accesible a través de una conexión Secure Shell (SSH). También puede cargarlos directamente desde una tabla de Amazon DynamoDB. En este tutorial, se utiliza el comando COPY para cargar datos desde Amazon S3. Muchos de los principios presentados aquí también aplican para la carga desde otros orígenes de datos. Para obtener más información acerca del uso del comando COPY, consulte los siguientes recursos: + [Prácticas recomendadas de Amazon Redshift para la carga de datos](c_loading-data-best-practices.md) + [Carga de datos desde Amazon EMR](loading-data-from-emr.md) + [Carga de datos desde hosts remotos](loading-data-from-remote-hosts.md) + [Carga de datos desde una tabla de Amazon DynamoDB](t_Loading-data-from-dynamodb.md) ## Paso 1: creación de un clúster Puede omitir este paso si ya dispone del clúster que desea utilizar. Para los ejercicios de este tutorial, use un clúster de cuatro nodos. **Pasos para crear un clúster** 1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon Redshift en [https://console.aws.amazon.com/redshiftv2/](https://console.aws.amazon.com/redshiftv2/). En el menú de navegación, elija **Panel de clústeres aprovisionados**. **importante** Asegúrese de que el usuario cuente con los permisos necesarios para realizar las operaciones del clúster. Para obtener información sobre la concesión de los permisos necesarios, consulte [Autorización a Amazon Redshift para obtener acceso a los servicios de AWS](https://docs.aws.amazon.com/redshift/latest/mgmt/authorizing-redshift-service.html). 1. En la parte superior derecha, seleccione la región de AWS en la que quiera crear el clúster. Para realizar este tutorial, elija **EE. UU. Oeste (Oregón)**. 1. En el menú de navegación, elija **Clusters** (Clústeres) y, a continuación, elija **Create cluster** (Crear clúster). Se abrirá la página **Create cluster (Crear clúster)**. 1. En la página **Create cluster** (Crear un clúster), ingrese los parámetros para su clúster. Elija sus propios valores para los parámetros, excepto cambiar los siguientes valores: + Elija **dc2.large** para el tipo de nodo. + Elija **4** para la opción **Number of nodes** (Número de nodos). + En la sección **Cluster permissions (Permisos del clúster)**, seleccione un rol de IAM de los **Available IAM roles (Roles de IAM disponibles)**. Este rol debería ser uno que haya creado previamente y que tenga acceso a Amazon S3. Luego, elija **Associate IAM role** (Asociar un rol de IAM) para agregarlo a la lista de **Associated IAM roles** (Roles de IAM asociados) del clúster. 1. Elija **Create cluster**. Siga los pasos de la [Guía de introducción a Amazon Redshift](https://docs.aws.amazon.com/redshift/latest/gsg/) para conectarse al clúster desde un cliente SQL y probar una conexión. No necesita completar los pasos de introducción restantes para crear tablas, cargar datos y probar consultas de ejemplo. ## Paso 2: Descargar los archivos de datos En este paso, se descarga un conjunto de archivos de datos de muestra en su equipo. En el paso siguiente, se cargan los archivos a un bucket de Amazon S3. **Descarga de los archivos de datos** 1. Descargue el archivo comprimido: [LoadingDataSampleFiles.zip](samples/LoadingDataSampleFiles.zip). 1. Extraiga los archivos en una carpeta de su equipo. 1. Verifique que la carpeta contiene los siguientes archivos. ``` customer-fw-manifest customer-fw.tbl-000 customer-fw.tbl-000.bak customer-fw.tbl-001 customer-fw.tbl-002 customer-fw.tbl-003 customer-fw.tbl-004 customer-fw.tbl-005 customer-fw.tbl-006 customer-fw.tbl-007 customer-fw.tbl.log dwdate-tab.tbl-000 dwdate-tab.tbl-001 dwdate-tab.tbl-002 dwdate-tab.tbl-003 dwdate-tab.tbl-004 dwdate-tab.tbl-005 dwdate-tab.tbl-006 dwdate-tab.tbl-007 part-csv.tbl-000 part-csv.tbl-001 part-csv.tbl-002 part-csv.tbl-003 part-csv.tbl-004 part-csv.tbl-005 part-csv.tbl-006 part-csv.tbl-007 ``` ## Paso 3: Cargar los archivos en un bucket de Amazon S3 En este paso, cree un bucket de Amazon S3 y cargue los archivos de datos en él. ### **Para cargar los archivos en un bucket de Amazon S3** 1. Cree un bucket de Amazon S3. Para obtener más información acerca de la creación de un bucket, consulte [Crear un bucket](https://docs.aws.amazon.com/AmazonS3/latest/userguide/create-bucket-overview.html) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Inicie sesión en la Consola de administración de AWS y abra la consola de Amazon S3 en [https://console.aws.amazon.com/s3/](https://console.aws.amazon.com/s3/). 1. Elija **Crear bucket**. 1. Elija un valor para Región de AWS. Cree el bucket en la misma región del clúster. Si el clúster se encuentra en la región Oeste de EE. UU. (Oregón), elija **US West (Oregon) Region (us-west-2)** (Región Oeste de EE. UU. [Oregón] [us-west-2]). 1. En el cuadro **Nombre del bucket** del cuadro de diálogo **Crear bucket**, escriba el nombre del bucket. El nombre de bucket que elija debe ser único entre todos los nombres de buckets existentes en Amazon S3. Una forma de garantizar su unicidad es agregar el nombre de su organización delante del nombre del bucket. Los nombres de los buckets deben cumplir una serie de reglas. Para obtener más información, consulte [Restricciones y limitaciones de buckets](https://docs.aws.amazon.com/AmazonS3/latest/userguide/BucketRestrictions.html) en la *Guía del usuario de Amazon Simple Storage Service*. 1. Elija los valores predeterminados recomendados para el resto de las opciones. 1. Elija **Crear bucket**. Cuando Amazon S3 cree con éxito el bucket, la consola mostrará el bucket vacío en el panel **Buckets**. 1. Crear una carpeta. 1. Seleccione el nombre del nuevo bucket. 1. Elija el botón **Crear carpeta**. 1. Asigne un nombre para la nueva carpeta **load**. **nota** El bucket que ha creado no se encuentra en un entorno de pruebas. En este ejercicio, se agregan objetos a un bucket real. Se le cobra una cantidad nominal según el tiempo durante el cuál almacena los objetos en el bucket. Para obtener más información acerca de los precios de Amazon S3, visite la página [Precios de Amazon S3](https://aws.amazon.com/s3/pricing/). 1. Cargue los archivos de datos en el bucket de Amazon S3 nuevo. 1. Elija el nombre de la carpeta de datos. 1. En el asistente Cargar, elija **Agregar archivos**. Siga las instrucciones de la consola de Amazon S3 para cargar todos los archivos que descargó y extrajo, 1. Seleccione **Cargar**. **de usuario autentic.** El comando COPY de Amazon Redshift debe tener acceso para leer los objetos de los archivos del bucket de Amazon S3. Si utiliza las mismas credenciales de usuario para crear el bucket de Amazon S3 y ejecutar el comando COPY de Amazon Redshift, el comando COPY tiene todos los permisos necesarios. Si desea utilizar credenciales de usuario diferentes, puede conceder acceso mediante los controles de acceso de Amazon S3. El comando COPY de Amazon Redshift requiere como mínimo los permisos de ListBucket y GetObject para obtener acceso a los objetos de los archivos del bucket de Amazon S3. Para obtener más información acerca del control del acceso a los recursos de Amazon S3, visite [Administración de permisos de acceso para los recursos de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html). ## Paso 4: Crear las tablas de muestra En este tutorial, se utiliza un conjunto de tablas basadas en el esquema de Star Schema Benchmark (SSB). En el siguiente diagrama se muestra el modelo de datos en SSB. ![\[Las cinco tablas del esquema SSB y sus relaciones entre sí.\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/images/tutorial-optimize-tables-ssb-data-model.png) Puede que las tablas de SSB ya existan en la base de datos actual. Si es el caso, deberá eliminarlas para quitarlas de la base de datos antes de crearlas con los comandos CREATE TABLE en el siguiente paso. Las tablas utilizadas en este tutorial pueden tener atributos diferentes a las tablas existentes. **Creación de las tablas de muestra** 1. Para eliminar las tablas SSB, ejecute los siguientes comandos en su cliente SQL. ``` drop table part cascade; drop table supplier; drop table customer; drop table dwdate; drop table lineorder; ``` 1. Ejecute los siguientes comandos CREATE TABLE en el cliente SQL. ``` CREATE TABLE part ( p_partkey INTEGER NOT NULL, p_name VARCHAR(22) NOT NULL, p_mfgr VARCHAR(6), p_category VARCHAR(7) NOT NULL, p_brand1 VARCHAR(9) NOT NULL, p_color VARCHAR(11) NOT NULL, p_type VARCHAR(25) NOT NULL, p_size INTEGER NOT NULL, p_container VARCHAR(10) NOT NULL ); CREATE TABLE supplier ( s_suppkey INTEGER NOT NULL, s_name VARCHAR(25) NOT NULL, s_address VARCHAR(25) NOT NULL, s_city VARCHAR(10) NOT NULL, s_nation VARCHAR(15) NOT NULL, s_region VARCHAR(12) NOT NULL, s_phone VARCHAR(15) NOT NULL ); CREATE TABLE customer ( c_custkey INTEGER NOT NULL, c_name VARCHAR(25) NOT NULL, c_address VARCHAR(25) NOT NULL, c_city VARCHAR(10) NOT NULL, c_nation VARCHAR(15) NOT NULL, c_region VARCHAR(12) NOT NULL, c_phone VARCHAR(15) NOT NULL, c_mktsegment VARCHAR(10) NOT NULL ); CREATE TABLE dwdate ( d_datekey INTEGER NOT NULL, d_date VARCHAR(19) NOT NULL, d_dayofweek VARCHAR(10) NOT NULL, d_month VARCHAR(10) NOT NULL, d_year INTEGER NOT NULL, d_yearmonthnum INTEGER NOT NULL, d_yearmonth VARCHAR(8) NOT NULL, d_daynuminweek INTEGER NOT NULL, d_daynuminmonth INTEGER NOT NULL, d_daynuminyear INTEGER NOT NULL, d_monthnuminyear INTEGER NOT NULL, d_weeknuminyear INTEGER NOT NULL, d_sellingseason VARCHAR(13) NOT NULL, d_lastdayinweekfl VARCHAR(1) NOT NULL, d_lastdayinmonthfl VARCHAR(1) NOT NULL, d_holidayfl VARCHAR(1) NOT NULL, d_weekdayfl VARCHAR(1) NOT NULL ); CREATE TABLE lineorder ( lo_orderkey INTEGER NOT NULL, lo_linenumber INTEGER NOT NULL, lo_custkey INTEGER NOT NULL, lo_partkey INTEGER NOT NULL, lo_suppkey INTEGER NOT NULL, lo_orderdate INTEGER NOT NULL, lo_orderpriority VARCHAR(15) NOT NULL, lo_shippriority VARCHAR(1) NOT NULL, lo_quantity INTEGER NOT NULL, lo_extendedprice INTEGER NOT NULL, lo_ordertotalprice INTEGER NOT NULL, lo_discount INTEGER NOT NULL, lo_revenue INTEGER NOT NULL, lo_supplycost INTEGER NOT NULL, lo_tax INTEGER NOT NULL, lo_commitdate INTEGER NOT NULL, lo_shipmode VARCHAR(10) NOT NULL ); ``` ## Paso 5: Ejecutar los comandos COPY Ejecute los comandos COPY para cargar cada una de las tablas en el esquema SSB. Los ejemplos del comando COPY muestran cómo cargar desde diferentes formatos de archivo, utilizar varias opciones de comando COPY y solucionar los errores de carga. ### Sintaxis del comando COPY La sintaxis básica del comando [COPY](r_COPY.md) es la siguiente. ``` COPY table_name [ column_list ] FROM data_source CREDENTIALS access_credentials [options] ``` Para ejecutar un comando COPY, proporcione los siguientes valores. **Nombre de la tabla** La tabla de destino para el comando COPY. La tabla ya debe existir en la base de datos. La tabla puede ser temporal o persistente. El comando COPY adjunta los nuevos datos de entrada a cualquier fila existente en la tabla. **Lista de columnas** De forma predeterminada, COPY carga los campos desde los datos de origen a las columnas de la tabla en orden. Si lo desea, también puede especificar una *lista de columnas*, que es una lista de nombres de columnas separadas por una coma, para asignar los campos de datos a columnas específicas. No utiliza listas de columnas en este tutorial. Para obtener más información, consulte [Column List](copy-parameters-column-mapping.md#copy-column-list) en COPY command reference. Origen de datos Puede utilizar el comando COPY para cargar datos desde un bucket de Amazon S3, un clúster de Amazon EMR, un alojamiento remoto que utilice una conexión SSH o una tabla de Amazon DynamoDB. Para este tutorial, realice la carga a partir de archivos de datos en un bucket de Amazon S3. Cuando realice cargas desde Amazon S3, debe proporcionar el nombre del bucket y la ubicación de los archivos de datos. Para ello, proporcione o bien una ruta de objecto para los archivos de datos o bien la ubicación de un archivo de manifiesto que enumere explícitamente cada archivo de datos y su ubicación. + Prefijo de clave Un objeto almacenado en Amazon S3 se identifica de manera única por una clave de objeto, que incluye el nombre del bucket, de las carpetas, si hay alguna, y de los objetos. El *prefijo de clave* hace referencia a un conjunto de objetos con el mismo prefijo. La ruta de objeto es un prefijo de clave que el comando COPY utiliza para cargar todos los objetos que comparten el prefijo de clave. Por ejemplo, el prefijo de clave `custdata.txt` puede referirse a un archivo individual o a un conjunto de archivos, incluidos `custdata.txt.001`, `custdata.txt.002` y así sucesivamente. + Archivo de manifiesto En algunos casos, es posible que necesite cargar archivos con diferentes prefijos; por ejemplo, de múltiples buckets o carpetas. En otros, puede que necesite excluir archivos con un mismo prefijo. En estos casos, puede utilizar un archivo de manifiesto. El *archivo de manifiesto* muestra explícitamente cada archivo de carga y su clave de objeto única. Se utiliza un archivo de manifiesto para cargar la tabla PART más adelante en este tutorial. **Credenciales** Para obtener acceso a los recursos de AWS que contienen los datos que se van a cargar, debe proporcionar las credenciales de acceso de AWS de un usuario con privilegios suficientes. Estas credenciales incluyen el Nombre de recurso de Amazon (ARN) de un rol de IAM. Para cargar datos desde Amazon S3, las credenciales deben incluir los permisos de ListBucket y GetObject. Se requerirán credenciales adicionales si los datos están cifrados. Para obtener más información, consulte [Parámetros de autorización](copy-parameters-authorization.md) en COPY command reference. Para obtener más información acerca de la administración del acceso, visite [Administración de permisos de acceso a los recursos de Amazon S3](https://docs.aws.amazon.com/AmazonS3/latest/userguide/s3-access-control.html). Opciones Puede especificar un número de parámetros con el comando COPY para especificar los formatos de archivo, administrar los formatos de datos, administrar errores y controlar otras características. En este tutorial, utilice las siguientes opciones y características del comando COPY: + Prefijo de clave Para obtener información sobre cómo cargar desde varios archivos especificando un prefijo de clave, consulte [Carga de tabla PART con NULL AS](#tutorial-loading-load-part). + formato CSV Para obtener información sobre cómo cargar datos en formato CSV, consulte [Carga de tabla PART con NULL AS](#tutorial-loading-load-part). + NULL AS Para obtener información sobre cómo cargar PART mediante la opción NULL AS, consulte [Carga de tabla PART con NULL AS](#tutorial-loading-load-part). + Formato delimitado por caracteres Para obtener información sobre cómo utilizar la opción DELIMITER, consulte [Las opciones DELIMITER y REGION](#tutorial-loading-load-supplier). + REGION Para obtener información sobre cómo utilizar la opción REGION, consulte [Las opciones DELIMITER y REGION](#tutorial-loading-load-supplier). + Ancho de formato fijo Para obtener información sobre cómo cargar la tabla CUSTOMER a partir de datos de ancho fijo, consulte [Carga de tabla CUSTOMER con MANIFEST](#tutorial-loading-load-customer). + MAXERROR Para obtener información sobre cómo utilizar la opción MAXERROR, consulte [Carga de tabla CUSTOMER con MANIFEST](#tutorial-loading-load-customer). + ACCEPTINVCHARS Para obtener información sobre cómo utilizar la opción ACCEPTINVCHARS, consulte [Carga de tabla CUSTOMER con MANIFEST](#tutorial-loading-load-customer). + MANIFEST Para obtener información sobre cómo utilizar la opción MANIFEST, consulte [Carga de tabla CUSTOMER con MANIFEST](#tutorial-loading-load-customer). + DATEFORMAT Para obtener información sobre cómo utilizar la opción DATEFORMAT, consulte [Carga de la tabla DWDATE con DATEFORMAT](#tutorial-loading-load-dwdate). + GZIP, LZOP y BZIP2 Para obtener información sobre cómo comprimir los archivos, consulte [Carga de varios archivos de datos](#tutorial-loading-load-lineorder). + COMPUPDATE Para obtener información sobre cómo utilizar la opción COMPUPDATE, consulte [Carga de varios archivos de datos](#tutorial-loading-load-lineorder). + Múltiples archivos Para obtener información sobre cómo cargar varios archivos, consulte [Carga de varios archivos de datos](#tutorial-loading-load-lineorder). ### Carga de las tablas SSB Utilice los siguientes comandos COPY para cargar cada una de las tablas en el esquema SSB. El comando de cada tabla muestra diferentes técnicas de solución de problemas y opciones de COPY. Siga estos pasos para cargar las tablas SSB: 1. [Sustituya el nombre del bucket y las credenciales de AWS.](#tutorial-loading-run-copy-replaceables) 1. [Carga de tabla PART con NULL AS](#tutorial-loading-load-part) 1. [Carga de tabla CUSTOMER con MANIFEST](#tutorial-loading-load-customer) 1. [Carga de la tabla DWDATE con DATEFORMAT](#tutorial-loading-load-dwdate) #### Sustituya el nombre del bucket y las credenciales de AWS. En este tutorial, los comandos COPY se presentan en el siguiente formato. ``` copy table from 's3:///load/key_prefix' credentials 'aws_iam_role=arn:aws:iam:::role/' options; ``` Para cada comando COPY, haga lo siguiente: 1. Sustituya ** por el nombre de un bucket de la misma región que el clúster. En este paso se asume que el bucket y el clúster están en la misma región. También puede especificar la región utilizando la opción [REGION](copy-parameters-data-source-s3.md#copy-region) con el comando COPY. 1. Reemplace ** y ** por Cuenta de AWS y con el rol de IAM. El segmento de la cadena de credenciales que está delimitado entre comillas simples no debe contener espacios ni saltos de línea. Tenga en cuenta que el formato del ARN puede diferir ligeramente del de la muestra. Es mejor copiar el ARN del rol desde la consola de IAM para asegurarse de que es correcto cuando ejecute los comandos COPY. #### Carga de tabla PART con NULL AS En este paso, utilice las opciones CSV y NULL AS para cargar la tabla PART. El comando COPY puede cargar datos desde varios archivos en paralelo, lo que es mucho más rápido que cargar desde un archivo individual. Para demostrar este principio, los datos de cada tabla en este tutorial se dividen en ocho archivos, aunque los archivos sean muy pequeños. En un paso posterior, se compara la diferencia de tiempo entre cargar desde un archivo individual y cargar desde varios archivos. Para obtener más información, consulte [Dividir los datos de carga](c_best-practices-use-multiple-files.md). **Prefijo de clave** Puede cargar desde varios archivos especificando un prefijo de clave para el conjunto de archivos o enumerando explícitamente los archivos en un archivo de manifiesto. En este paso, se utiliza un prefijo de clave. En un paso posterior, se utiliza un archivo de manifiesto. El prefijo de clave `'s3://amzn-s3-demo-bucket/load/part-csv.tbl'` carga el siguiente conjunto de los archivos en la carpeta `load`. ``` part-csv.tbl-000 part-csv.tbl-001 part-csv.tbl-002 part-csv.tbl-003 part-csv.tbl-004 part-csv.tbl-005 part-csv.tbl-006 part-csv.tbl-007 ``` **formato CSV** CSV, que significa valores separados por comas, es un formato común utilizado para importar y exportar datos de hojas de cálculo. CSV es más flexible que el formato delimitado por comas porque le permite incluir cadenas entre comillas dentro de los campos. El carácter de comilla predeterminado para COPY desde un formato CSV es una comilla recta doble ( " ), pero puede especificar otro con la opción QUOTE AS. Cuando utilice el carácter de comilla dentro del campo, encierre el carácter con otro carácter de comilla. El siguiente fragmento de una archivo de datos con formato CSV para la tabla PART muestra cadenas encerradas entre comillas dobles (`"LARGE ANODIZED BRASS"`). También muestra un string comprendido entre dos comillas dobles dentro de un string encomillado (`"MEDIUM ""BURNISHED"" TIN"`). ``` 15,dark sky,MFGR#3,MFGR#47,MFGR#3438,indigo,"LARGE ANODIZED BRASS",45,LG CASE 22,floral beige,MFGR#4,MFGR#44,MFGR#4421,medium,"PROMO, POLISHED BRASS",19,LG DRUM 23,bisque slate,MFGR#4,MFGR#41,MFGR#4137,firebrick,"MEDIUM ""BURNISHED"" TIN",42,JUMBO JAR ``` Los datos de la tabla PART contienen caracteres que pueden provocar que COPY falle. En este ejercicio, se identifican los errores y se corrigen. Para cargar datos que estén en formato CSV, agregue `csv` al comando COPY. Ejecute el siguiente comando para cargar la tabla PART. ``` copy part from 's3:///load/part-csv.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' csv; ``` Podría obtener un mensaje de error similar al siguiente. ``` An error occurred when executing the SQL command: copy part from 's3://amzn-s3-demo-bucket/load/part-csv.tbl' credentials' ... ERROR: Load into table 'part' failed. Check 'stl_load_errors' system table for details. [SQL State=XX000] Execution time: 1.46s 1 statement(s) failed. 1 statement(s) failed. ``` Para obtener más información acerca del error, consulte la tabla STL\$1LOAD\$1ERRORS. La siguiente consulta utiliza la función SUBSTRING para acortar columnas y facilitar su legibilidad y utiliza LIMIT 10 para reducir el número de filas que se devuelven. Puede ajustar los valores en `substring(filename,22,25)` para permitir la longitud del nombre de bucket. ``` select query, substring(filename,22,25) as filename,line_number as line, substring(colname,0,12) as column, type, position as pos, substring(raw_line,0,30) as line_text, substring(raw_field_value,0,15) as field_text, substring(err_reason,0,45) as reason from stl_load_errors order by query desc limit 10; ``` ``` query | filename | line | column | type | pos | --------+-------------------------+-----------+------------+------------+-----+---- 333765 | part-csv.tbl-000 | 1 | | | 0 | line_text | field_text | reason ------------------+------------+---------------------------------------------- 15,NUL next, | | Missing newline: Unexpected character 0x2c f ``` **NULL AS** Los archivos de datos `part-csv.tbl` utilizan el carácter de terminación NUL (`\x000` o `\x0`) para indicar los valores NULL. **nota** A pesar de tener nombres muy similares, NUL y NULL no son lo mismo. NUL es un carácter UTF-8 con punto de código `x000` que suele utilizarse para indicar el fin de registro (EOR). NULL es un valor SQL que representa una ausencia de datos. De manera predeterminada COPY trata el carácter de terminación NUL como un carácter EOR y termina el registro, lo que suele ocasionar resultados inesperados o un error. No hay un método estándar único para indicar NULL en datos de texto. Por lo tanto, la opción de comando NULL AS COPY le permite especificar qué carácter sustituir por NULL cuando carga la tabla. En este ejemplo, desea que COPY trate el carácter de terminación NUL como un valor NULL. **nota** La columna de la tabla que recibe el valor NULL debe estar configurada como *nullable*. Es decir, no debe incluir la restricción NOT NULL en la especificación CREATE TABLE. Para cargar PART por medio de la opción NULL AS, ejecute el siguiente comando COPY. ``` copy part from 's3:///load/part-csv.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' csv null as '\000'; ``` Para verificar que COPY cargó los valores NULL, ejecute el siguiente comando para seleccionar solo las filas que contienen NULL. ``` select p_partkey, p_name, p_mfgr, p_category from part where p_mfgr is null; ``` ``` p_partkey | p_name | p_mfgr | p_category -----------+----------+--------+------------ 15 | NUL next | | MFGR#47 81 | NUL next | | MFGR#23 133 | NUL next | | MFGR#44 (2 rows) ``` #### Las opciones DELIMITER y REGION Las opciones DELIMITER y REGION son importantes para entender cómo se cargan los datos. **Formato delimitado por caracteres** Los campos en un archivo delimitado por caracteres están separados por un carácter específico, como un carácter de barra vertical ( \$1 ), una coma ( , ) o una pestaña ( \$1t ). Los archivos delimitados por caracteres pueden utilizar cualquier carácter único ASCII, incluido uno de los caracteres ASCII no imprimibles, como el delimitador. El carácter delimitador se especifica mediante la opción DELIMITER. El delimitador predeterminado es el carácter de barra vertical ( \$1 ). El siguiente fragmento de los datos para la tabla SUPPLIER utiliza el formato delimitado por la barra vertical. ``` 1|1|257368|465569|41365|19950218|2-HIGH|0|17|2608718|9783671|4|2504369|92072|2|19950331|TRUCK 1|2|257368|201928|8146|19950218|2-HIGH|0|36|6587676|9783671|9|5994785|109794|6|19950416|MAIL ``` **REGION** Siempre que sea posible, debe ubicar los datos de carga en la misma región de AWS que el clúster de Amazon Redshift. Si los datos y el clúster se encuentran en la misma región, se reduce la latencia y se evitan los costos de la transferencia de datos entre regiones. Para obtener más información, consulte [Prácticas recomendadas de Amazon Redshift para la carga de datos](c_loading-data-best-practices.md). Si debe cargar datos de una región de AWS diferente, utilice la opción REGION para especificar la región de AWS en la que se ubican los datos de carga. Si especifica una región, todos los datos de carga, incluidos los archivos de manifiesto, deben encontrarse en la región mencionada. Para obtener más información, consulte [REGION](copy-parameters-data-source-s3.md#copy-region). Por ejemplo, si el clúster se encuentra en la región Este de EE. UU. (Norte de Virginia) y su bucket de Amazon S3 se encuentra en la región Oeste de EE. UU. (Oregón), el siguiente comando COPY muestra cómo cargar la tabla SUPPLIER a partir de datos delimitados por la barra vertical. ``` copy supplier from 's3://amzn-s3-demo-bucket/ssb/supplier.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' delimiter '|' gzip region 'us-west-2'; ``` #### Carga de tabla CUSTOMER con MANIFEST En este paso, se utilizan las opciones FIXEDWIDTH, MAXERROR, ACCEPTINVCHARS Y MANIFEST para cargar la tabla CUSTOMER. Los datos de muestra para este ejercicio contienen caracteres que provocan errores cuando COPY trata de cargarlos. Utilice la opción MAXERRORS y la tabla de sistema STL\$1LOAD\$1ERRORS para solucionar los errores de carga y luego utilice las opciones ACCEPTINVCHARS y MANIFEST para eliminar los errores. **Formato de ancho fijo** El formato de ancho fijo define cada campo como un número fijo de caracteres, en lugar de separar los campos con un delimitador. El siguiente fragmento de los datos para la tabla CUSTOMER utiliza el formato de ancho fijo. ``` 1 Customer#000000001 IVhzIApeRb MOROCCO 0MOROCCO AFRICA 25-705 2 Customer#000000002 XSTf4,NCwDVaWNe6tE JORDAN 6JORDAN MIDDLE EAST 23-453 3 Customer#000000003 MG9kdTD ARGENTINA5ARGENTINAAMERICA 11-783 ``` El orden de los pares etiqueta/ancho debe coincidir con el orden de las columnas de la tabla de forma exacta. Para obtener más información, consulte [FIXEDWIDTH](copy-parameters-data-format.md#copy-fixedwidth). La cadena de especificaciones de ancho fijo para la tabla CUSTOMER es la siguiente. ``` fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10' ``` Para cargar la tabla CUSTOMER desde los datos de ancho fijo, ejecute el siguiente comando. ``` copy customer from 's3:///load/customer-fw.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10'; ``` Debería obtener un mensaje de error, similar al siguiente. ``` An error occurred when executing the SQL command: copy customer from 's3://amzn-s3-demo-bucket/load/customer-fw.tbl' credentials'... ERROR: Load into table 'customer' failed. Check 'stl_load_errors' system table for details. [SQL State=XX000] Execution time: 2.95s 1 statement(s) failed. ``` **MAXERROR** De forma predeterminada, la primera vez que COPY encuentra un error, el comando falla y devuelve un mensaje de error. Para ahorrar tiempo durante las pruebas, puede utilizar la opción MAXERROR para indicar a COPY que omita un número específico de errores antes de fallar. Dado que se esperan errores la primera vez que se prueba la carga de los datos de la tabla CUSTOMER, agregue `maxerror 10` al comando COPY. Para realizar la prueba utilizando las opciones FIXEDWIDTH y MAXERROR, ejecute el siguiente comando. ``` copy customer from 's3:///load/customer-fw.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10' maxerror 10; ``` Esta vez, en lugar de un mensaje de error, obtendrá un mensaje de advertencia, similar al siguiente. ``` Warnings: Load into table 'customer' completed, 112497 record(s) loaded successfully. Load into table 'customer' completed, 7 record(s) could not be loaded. Check 'stl_load_errors' system table for details. ``` La advertencia indica que COPY encontró siete errores. Para comprobar los errores, consulte la tabla STL\$1LOAD\$1ERRORS, como se muestra en el siguiente ejemplo. ``` select query, substring(filename,22,25) as filename,line_number as line, substring(colname,0,12) as column, type, position as pos, substring(raw_line,0,30) as line_text, substring(raw_field_value,0,15) as field_text, substring(err_reason,0,45) as error_reason from stl_load_errors order by query desc, filename limit 7; ``` Los resultados de la consulta a STL\$1LOAD\$1ERRORS deben ser similares a los siguientes. ``` query | filename | line | column | type | pos | line_text | field_text | error_reason --------+---------------------------+------+-----------+------------+-----+-------------------------------+------------+---------------------------------------------- 334489 | customer-fw.tbl.log | 2 | c_custkey | int4 | -1 | customer-fw.tbl | customer-f | Invalid digit, Value 'c', Pos 0, Type: Integ 334489 | customer-fw.tbl.log | 6 | c_custkey | int4 | -1 | Complete | Complete | Invalid digit, Value 'C', Pos 0, Type: Integ 334489 | customer-fw.tbl.log | 3 | c_custkey | int4 | -1 | #Total rows | #Total row | Invalid digit, Value '#', Pos 0, Type: Integ 334489 | customer-fw.tbl.log | 5 | c_custkey | int4 | -1 | #Status | #Status | Invalid digit, Value '#', Pos 0, Type: Integ 334489 | customer-fw.tbl.log | 1 | c_custkey | int4 | -1 | #Load file | #Load file | Invalid digit, Value '#', Pos 0, Type: Integ 334489 | customer-fw.tbl000 | 1 | c_address | varchar | 34 | 1 Customer#000000001 | .Mayag.ezR | String contains invalid or unsupported UTF8 334489 | customer-fw.tbl000 | 1 | c_address | varchar | 34 | 1 Customer#000000001 | .Mayag.ezR | String contains invalid or unsupported UTF8 (7 rows) ``` Al examinar los resultados, podrá ver que hay dos mensajes en la columna `error_reasons`: + ``` Invalid digit, Value '#', Pos 0, Type: Integ ``` El archivo `customer-fw.tbl.log` provoca estos errores. El problema es que este es un archivo de registro, no de datos, y no debe cargarse. Puede utilizar el archivo de manifiesto para evitar la carga del archivo incorrecto. + ``` String contains invalid or unsupported UTF8 ``` El tipo de datos VARCHAR es compatible con caracteres multibyte UTF-8 de hasta tres bytes. Si los datos de carga contienen caracteres no válidos o no compatibles, puede utilizar la opción ACCEPTINVCHARS para reemplazar cada carácter no válido por un carácter alternativo especificado. Otro problema con la carga que es más difícil de detectar es cuando la carga produjo resultados inesperados. Para investigar este problema, ejecute el siguiente comando para consultar la tabla CUSTOMER. ``` select c_custkey, c_name, c_address from customer order by c_custkey limit 10; ``` ``` c_custkey | c_name | c_address -----------+---------------------------+--------------------------- 2 | Customer#000000002 | XSTf4,NCwDVaWNe6tE 2 | Customer#000000002 | XSTf4,NCwDVaWNe6tE 3 | Customer#000000003 | MG9kdTD 3 | Customer#000000003 | MG9kdTD 4 | Customer#000000004 | XxVSJsL 4 | Customer#000000004 | XxVSJsL 5 | Customer#000000005 | KvpyuHCplrB84WgAi 5 | Customer#000000005 | KvpyuHCplrB84WgAi 6 | Customer#000000006 | sKZz0CsnMD7mp4Xd0YrBvx 6 | Customer#000000006 | sKZz0CsnMD7mp4Xd0YrBvx (10 rows) ``` Las filas deben ser únicas, pero están duplicadas. Otra forma de comprobar los resultados inesperados es verificar el número de filas que se cargaron. En nuestro caso, deberían haberse cargado 100 000 filas, pero el mensaje de carga notificó que se cargaron 112 497 registros. Las filas adicionales se cargaron porque COPY cargo un archivo extraño, `customer-fw.tbl0000.bak`. En este ejercicio, se utiliza un archivo de manifiesto para evitar la carga de los archivos incorrectos. **ACCEPTINVCHARS** De forma predeterminada, cuando COPY encuentra un carácter que no es compatible con los tipos de datos de la columna, omite la fila y devuelve un error. Para obtener más información acerca de los caracteres UTF-8 no válidos, consulte [Errores de carga de caracteres multibyte](multi-byte-character-load-errors.md). Puede utilizar la opción MAXERRORS para ignorar los errores y continuar la carga, luego consulte STL\$1LOAD\$1ERRORS para ubicar los caracteres no válidos y después corrija los archivos de datos. No obstante, MAXERRORS es más adecuado para solucionar problemas de carga y en general no debe utilizarse en un entorno de producción. La opción ACCEPTINVCHARS suele ser una mejor elección para administrar caracteres no válidos. ACCEPTINVCHARS le indica a COPY reemplazar cada carácter no válido por un carácter válido especificado y continuar con la operación de carga. Puede especificar cualquier carácter ASCII válido, excepto NULL, como el carácter de sustitución. El carácter de sustitución predeterminado es un signo de interrogación (?). COPY reemplaza los caracteres multibyte con una cadena de sustitución de igual longitud. Por ejemplo, un carácter de 4 bytes se reemplazaría con `'????'`. COPY devuelve el número de filas que contenían caracteres UTF-8 no válidos. Además agrega una entrada a la tabla de sistema STL\$1REPLACEMENTS para cada fila afectada, hasta un máximo de 100 filas por sector del nodo. También se sustituyen los caracteres UTF-8 no válidos adicionales, pero esos eventos de sustitución no se registran. ACCEPTINVCHARS es válido solo para las columnas VARCHAR. En este paso, se agrega el ACCEPTINVCHARS con el carácter de reemplazo `'^'`. **MANIFEST** Cuando utiliza el comando COPY desde Amazon S3 mediante un prefijo de clave, existe el riesgo de cargar tablas no deseadas. Por ejemplo, la carpeta `'s3://amzn-s3-demo-bucket/load/` contiene ocho archivos de datos que comparten el prefijo de clave `customer-fw.tbl`, `customer-fw.tbl0000`, `customer-fw.tbl0001` y así sucesivamente. No obstante, la misma carpeta también contiene los archivos extraños `customer-fw.tbl.log` y `customer-fw.tbl-0001.bak`. Para garantizar que carga todos los archivos correctos, y únicamente los archivos correctos, utilice un archivo de manifiesto. El manifiesto es un archivo de texto en formato JSON que muestra explícitamente la clave de objeto única para cada archivo de origen a cargar. Los objetos de archivos pueden encontrarse en diferentes carpetas o diferentes buckets, pero deben estar en la misma región. Para obtener más información, consulte [MANIFEST](copy-parameters-data-source-s3.md#copy-manifest). A continuación se muestra el texto `customer-fw-manifest`. ``` { "entries": [ {"url":"s3:///load/customer-fw.tbl-000"}, {"url":"s3:///load/customer-fw.tbl-001"}, {"url":"s3:///load/customer-fw.tbl-002"}, {"url":"s3:///load/customer-fw.tbl-003"}, {"url":"s3:///load/customer-fw.tbl-004"}, {"url":"s3:///load/customer-fw.tbl-005"}, {"url":"s3:///load/customer-fw.tbl-006"}, {"url":"s3:///load/customer-fw.tbl-007"} ] } ``` **Para cargar los datos para la tabla CUSTOMER utilizando un archivo de manifiesto** 1. Abra el archivo `customer-fw-manifest` en un editor de texto. 1. Sustituya ** por el nombre del bucket. 1. Guarde el archivo. 1. Cargue el archivo a la carpeta de carga en el bucket. 1. Ejecute el siguiente comando COPY. ``` copy customer from 's3:///load/customer-fw-manifest' credentials 'aws_iam_role=arn:aws:iam:::role/' fixedwidth 'c_custkey:10, c_name:25, c_address:25, c_city:10, c_nation:15, c_region :12, c_phone:15,c_mktsegment:10' maxerror 10 acceptinvchars as '^' manifest; ``` #### Carga de la tabla DWDATE con DATEFORMAT En este paso, se utilizan las opciones DELIMITER y DATEFORMAT para cargar la tabla DWDATE . Cuando se cargan las columnas DATE y TIMESTAMP, COPY espera el formato predeterminado, que es AAAA-MM-DD para fechas y AAAA-MM-DD HH:MM:SS para marcas temporales. Si los datos de carga no utilizan un formato predeterminado, puede utilizar DATEFORMAT y TIMEFORMAT para especificar el formato. El siguiente fragmento muestra formatos de fecha en la tabla DWDATE. Observe que los formatos de fecha en la columna dos son inconsistentes. ``` 19920104 1992-01-04 Sunday January 1992 199201 Jan1992 1 4 4 1... 19920112 January 12, 1992 Monday January 1992 199201 Jan1992 2 12 12 1... 19920120 January 20, 1992 Tuesday January 1992 199201 Jan1992 3 20 20 1... ``` **DATEFORMAT** Puede especificar solo un formato de fecha. Si los datos de carga contienen formatos inconsistentes, posiblemente en diferentes columnas, o si en el tiempo de carga no se conoce el formato, utilice DATEFORMAT con el argumento `'auto'`. Cuando se especifica `'auto'`, COPY reconoce cualquier formato válido de fecha u hora y lo convierte al formato predeterminado. La opción `'auto'` reconoce varios formatos que no son compatibles cuando se utiliza una cadena de DATEFORMAT y TIMEFORMAT. Para obtener más información, consulte [Utilización del reconocimiento automático con DATEFORMAT y TIMEFORMAT](automatic-recognition.md). Para cargar la tabla DWDATE, ejecute el siguiente comando COPY. ``` copy dwdate from 's3:///load/dwdate-tab.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' delimiter '\t' dateformat 'auto'; ``` #### Carga de varios archivos de datos Puede usar las opciones GZIP y COMPUPDATE para cargar una tabla. Puede cargar una tabla desde un único archivo de datos o desde varios archivos. Esto le permite comparar los tiempos de carga de ambos métodos. **GZIP, LZOP y BZIP2** Puede comprimir los archivos utilizando los formatos de compresión gzip, lzop o bzip2. Cuando se carga desde archivos comprimidos, COPY descomprime los archivos durante el proceso de carga. La compresión de los archivos ahorra espacio de almacenamiento y reduce los tiempos de carga. **COMPUPDATE** Cuando COPY carga una tabla vacía sin codificaciones de compresión, analiza los datos de carga para determinar las codificaciones óptimas. Luego modifica la tabla para utilizar esas codificaciones antes de comenzar la carga. Este proceso de análisis toma tiempo, pero ocurre una sola vez por tabla, como máximo. Para ahorrar tiempo, puede omitir este paso desactivando COMPUPDATE. Para habilitar una evaluación precisa de los tiempos de COPY, se desactiva COMPUPDATE en este paso. **Múltiples archivos** El comando COPY puede cargar datos desde varios archivos en paralelo de manera muy eficiente, en lugar de desde un archivo individual. Puede dividir los datos en archivos de manera tal que la cantidad de archivos sea múltiplo de la cantidad de sectores en su clúster. Si lo hace, Amazon Redshift divide la carga de trabajo y distribuye los datos de manera uniforme entre los sectores. El número de sectores por nodo depende del tamaño de nodo del clúster. Para obtener más información acerca de la cantidad de sectores que tiene cada tamaño de nodo, consulte [Acerca de clústeres y nodos](https://docs.aws.amazon.com/redshift/latest/mgmt/working-with-clusters.html#rs-about-clusters-and-nodes) en la *Guía de administración de Amazon Redshift*. Por ejemplo, los nodos de computación del clúster que se utiliza en este tutorial tienen dos sectores cada uno, por lo que un clúster de cuatro nodos tendrá ocho sectores. En los pasos anteriores, los datos de carga estaban contenidos en ocho archivos, aunque los archivos sean muy pequeños. Puede comparar la diferencia de tiempo entre cargar desde un solo archivo grande y cargar desde varios archivos. Incluso los archivos que contienen 15 millones de registros y ocupan alrededor de 1,2 GB son muy pequeños en la escala de Amazon Redshift, pero son suficientes para demostrar la ventaja de rendimiento que supone cargar desde varios archivos. En la siguiente imagen se muestran los archivos de datos para LINEORDER. ![\[Los datos de la tabla LINEORDER se dividen en nueve archivos.\]](http://docs.aws.amazon.com/es_es/redshift/latest/dg/images/tutorial-load-lineorder-files.png) **Para evaluar el rendimiento de COPY con varios archivos** 1. En una prueba de laboratorio, se ejecutó el siguiente comando para realizar la copia desde un único archivo. Este comando muestra un bucket ficticio. ``` copy lineorder from 's3://amzn-s3-demo-bucket/load/lo/lineorder-single.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' gzip compupdate off region 'us-east-1'; ``` 1. Los resultados fueron los siguientes. Observe el tiempo de ejecución. ``` Warnings: Load into table 'lineorder' completed, 14996734 record(s) loaded successfully. 0 row(s) affected. copy executed successfully Execution time: 51.56s ``` 1. Luego, se ejecutó el siguiente comando para realizar la copia desde varios archivos. ``` copy lineorder from 's3://amzn-s3-demo-bucket/load/lo/lineorder-multi.tbl' credentials 'aws_iam_role=arn:aws:iam:::role/' gzip compupdate off region 'us-east-1'; ``` 1. Los resultados fueron los siguientes. Observe el tiempo de ejecución. ``` Warnings: Load into table 'lineorder' completed, 14996734 record(s) loaded successfully. 0 row(s) affected. copy executed successfully Execution time: 17.7s ``` 1. Compare los tiempos de ejecución. En nuestro experimento, el tiempo para cargar 15 millones de registros se redujo de 51,56 segundos a 17,7 segundos, lo que supone una disminución del 65,7 %. Estos resultados se basan en la utilización de un clúster de cuatro nodos. Si el clúster tiene más nodos, el ahorro de tiempo se multiplica. Para los clústeres de Amazon Redshift típicos, que tienen de decenas a cientos de nodos, la diferencia es aún más grande. Si tiene un clúster de un nodo, hay una diferencia pequeña entre los tiempos de ejecución. ## Paso 6: Limpiar y analizar la base de datos Siempre que agregue, elimine o modifique una cantidad importante de filas, debe ejecutar un comando VACUUM y luego un comando ANALYZE. Una *limpieza* recupera el espacio de las filas eliminadas y restaura el orden. El comando ANALYZE actualiza los metadatos estadísticos, lo que permite al optimizador de consultas generar planes de consultas más precisos. Para obtener más información, consulte [Limpieza de tablas](t_Reclaiming_storage_space202.md). Si carga los datos en orden de clave de ordenación, la limpieza es rápida. En este tutorial, agregó un número importante de filas, pero lo hizo en tablas vacías. Siendo ese el caso, no hay necesidad de reordenar y no borró ninguna fila. COPY actualiza automáticamente las estadísticas después de cargar una tabla vacía, por lo que las estadísticas deben estar actualizadas. No obstante, por una cuestión de buena organización, se completa este tutorial con la limpieza y el análisis de la base de datos. Para limpiar y analizar la base de datos, ejecute los siguientes comandos. ``` vacuum; analyze; ``` ## Paso 7: Eliminar los recursos El clúster seguirá acumulando cargos mientras esté en ejecución. Una vez que haya completado este tutorial, debe restablecer el entorno al estado anterior si sigue los pasos que se indican en [Paso 5: Revocar el acceso y eliminar el clúster de muestra](https://docs.aws.amazon.com/redshift/latest/gsg/rs-gsg-clean-up-tasks.html) en la *Guía de introducción a Amazon Redshift*. Si desea mantener el clúster y recuperar el almacenamiento utilizado por las tablas de SSB, ejecute los siguientes comandos. ``` drop table part; drop table supplier; drop table customer; drop table dwdate; drop table lineorder; ``` ### Siguiente [Resumen](#tutorial-loading-data-summary) ## Resumen En este tutorial, ha cargado archivos de datos en Amazon S3 y ha utilizado los comandos COPY para cargar los datos de los archivos en tablas de Amazon Redshift. Cargó datos utilizando los siguientes formatos: + Delimitado por caracteres + CSV + De ancho fijo Utilizó la tabla del sistema STL\$1LOAD\$1ERRORS para solucionar errores de carga y luego utilizó las opciones REGION, MANIFEST, MAXERROR, ACCEPTINVCHARS, DATEFORMAT y NULL AS para resolver los errores. Aplicó las siguientes prácticas recomendadas para cargar datos: + [Uso del comando COPY para cargar datos](c_best-practices-use-copy.md) + [Dividir los datos de carga](c_best-practices-use-multiple-files.md) + [Uso de un único comando COPY para cargar desde archivos múltiples](c_best-practices-single-copy-command.md) + [Compresión de los archivos de datos](c_best-practices-compress-data-files.md) + [Control de los archivos de datos antes y después de una carga](c_best-practices-verifying-data-files.md) Para obtener más información acerca de las prácticas recomendadas de Amazon Redshift, consulte los siguientes enlaces: + [Prácticas recomendadas de Amazon Redshift para la carga de datos](c_loading-data-best-practices.md) + [Prácticas recomendadas de Amazon Redshift para el diseño de tablas](c_designing-tables-best-practices.md) + [Prácticas recomendadas de Amazon Redshift para el diseño de consultas](c_designing-queries-best-practices.md)