Le traduzioni sono generate tramite traduzione automatica. In caso di conflitto tra il contenuto di una traduzione e la versione originale in Inglese, quest'ultima prevarrà.

COPYesempi

Caricamento FAVORITEMOVIES da una tabella DynamoDB

AWS SDKsIncludono un semplice esempio di creazione di una tabella DynamoDB chiamata Movies. (Per questo esempio, consultare Nozioni di base su DynamoDB.) L'esempio seguente carica la tabella Amazon Redshift con i dati della MOVIES tabella DynamoDB. La tabella di Amazon Redshift deve esistere già nel database.

copy favoritemovies from 'dynamodb://Movies'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
readratio 50;

Caricamento LISTING da un bucket Amazon S3

L'esempio seguente viene caricato LISTING da un bucket Amazon S3. Il COPY comando carica tutti i file nella cartella/data/listing/.

copy listing
from 's3://amzn-s3-demo-bucket/data/listing/' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';

Caricamento LISTING da un EMR cluster Amazon

L'esempio seguente carica la SALES tabella con dati delimitati da tabulazioni provenienti da file compressi con lzop in un cluster Amazon. EMR COPYcarica tutti i file nella cartella che inizia con. myoutput/ part-

copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/part-*' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '\t' lzop;

L'esempio seguente carica la SALES tabella con dati JSON formattati in un EMR cluster Amazon. COPYcarica tutti i file nella myoutput/json/ cartella.

copy sales
from 'emr://j-SAMPLE2B500FC/myoutput/json/' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
JSON 's3://amzn-s3-demo-bucket/jsonpaths.txt';

Utilizzo di un manifest per specificare i fili di dati

Puoi utilizzare un manifesto per assicurarti che il tuo COPY comando carichi tutti i file richiesti e solo i file richiesti da Amazon S3. È anche possibile utilizzare un manifest quando è necessario caricare più file da bucket o file diversi che non condividono lo stesso prefisso.

Ad esempio, supponi di dover caricare i seguenti tre file: custdata1.txt, custdata2.txt e custdata3.txt. È possibile usare il seguente comando per caricare tutti i file in amzn-s3-demo-bucket che iniziano con custdata specificando un prefisso:

copy category
from 's3://amzn-s3-demo-bucket/custdata' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';

Se esistono solo due file a causa di un errore, COPY carica solo quei due file e termina correttamente, con conseguente caricamento dei dati incompleto. Se il bucket contiene anche un file indesiderato che utilizza lo stesso prefisso, ad custdata.backup esempio un file denominato, COPY carica anche quel file, con conseguente caricamento di dati indesiderati.

Per assicurarsi che tutti i file richiesti siano caricati e per evitare che vengano caricati file indesiderati, è possibile utilizzare un file manifest. Il manifesto è un file JSON di testo in formato elettronico che elenca i file che devono essere elaborati dal comando. COPY Ad esempio, il seguente manifest carica i tre file nell'esempio precedente.

{  
   "entries":[  
      {  
         "url":"s3://amzn-s3-demo-bucket/custdata.1",
         "mandatory":true
      },
      {  
         "url":"s3://amzn-s3-demo-bucket/custdata.2",
         "mandatory":true
      },
      {  
         "url":"s3://amzn-s3-demo-bucket/custdata.3",
         "mandatory":true
      }
   ]
}

Il mandatory flag opzionale indica se COPY deve terminare se il file non esiste. Il valore predefinito è false. Indipendentemente dalle impostazioni obbligatorie, COPY termina se non viene trovato alcun file. In questo esempio, COPY restituisce un errore se nessuno dei file non viene trovato. I file indesiderati che potrebbero essere stati raccolti se hai specificato solo un prefisso della chiave, come custdata.backup, vengono ignorati, perché non sono sul manifest.

Quando si esegue il caricamento da file ORC di dati in formato Parquet, è necessario un meta campo, come illustrato nell'esempio seguente.

{  
   "entries":[  
      {  
         "url":"s3://amzn-s3-demo-bucket1/orc/2013-10-04-custdata",
         "mandatory":true,
         "meta":{  
            "content_length":99
         }
      },
      {  
         "url":"s3://amzn-s3-demo-bucket2/orc/2013-10-05-custdata",
         "mandatory":true,
         "meta":{  
            "content_length":99
         }
      }
   ]
}

L'esempio seguente utilizza un manifest denominato cust.manifest.

copy customer
from 's3://amzn-s3-demo-bucket/cust.manifest' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc
manifest;

È possibile utilizzare un manifest per caricare file da diversi bucket o file che non condividono lo stesso prefisso. L'esempio seguente mostra come JSON caricare dati con file i cui nomi iniziano con un timbro di data.

{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket/2013-10-04-custdata.txt","mandatory":true},
    {"url":"s3://amzn-s3-demo-bucket/2013-10-05-custdata.txt","mandatory":true},
    {"url":"s3://amzn-s3-demo-bucket/2013-10-06-custdata.txt","mandatory":true},
    {"url":"s3://amzn-s3-demo-bucket/2013-10-07-custdata.txt","mandatory":true}
  ]
}

Il manifesto può elencare i file che si trovano in bucket diversi, purché i bucket si trovino nella stessa AWS regione del cluster.

{
  "entries": [
    {"url":"s3://amzn-s3-demo-bucket1/custdata1.txt","mandatory":false},
    {"url":"s3://amzn-s3-demo-bucket2/custdata1.txt","mandatory":false},
    {"url":"s3://amzn-s3-demo-bucket2/custdata2.txt","mandatory":false}
  ]
}

Carica LISTING da un file delimitato da pipe (delimitatore predefinito)

L'esempio seguente è un caso molto semplice in cui non sono specificate opzioni e il file di input contiene il delimitatore predefinito, un carattere pipe ("|").

copy listing 
from 's3://amzn-s3-demo-bucket/data/listings_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole';

Caricamento utilizzando dati colonnari LISTING in formato Parquet

Il seguente esempio carica i dati da una cartella su Amazon S3 chiamata parquet.

copy listing 
from 's3://amzn-s3-demo-bucket/data/listings/parquet/' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as parquet;

Caricamento LISTING utilizzando dati colonnari in formato ORC

Il seguente esempio carica i dati da una cartella su Amazon S3 chiamata orc.

copy listing 
from 's3://amzn-s3-demo-bucket/data/listings/orc/' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as orc;

Carica EVENT con opzioni

L'esempio seguente carica i dati delimitati da tubi nella EVENT tabella e applica le seguenti regole:

copy event
from 's3://amzn-s3-demo-bucket/data/allevents_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
removequotes
emptyasnull
blanksasnull
maxerror 5
delimiter '|'
timeformat 'YYYY-MM-DD HH:MI:SS';

Caricamento VENUE da un file di dati a larghezza fissa

copy venue
from 's3://amzn-s3-demo-bucket/data/venue_fw.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
fixedwidth 'venueid:3,venuename:25,venuecity:12,venuestate:2,venueseats:6';

L'esempio precedente assume un file di dati formattato nello stesso modo dei dati campione mostrati. Nel seguente esempio, gli spazi fungono da placeholder in modo che tutte le colonne abbiano la stessa larghezza indicata nelle specifiche:

1  Toyota Park              Bridgeview  IL0
2  Columbus Crew Stadium    Columbus    OH0
3  RFK Stadium              Washington  DC0
4  CommunityAmerica BallparkKansas City KS0
5  Gillette Stadium         Foxborough  MA68756

Caricare CATEGORY da un file CSV

Supponiamo di voler caricare il file CATEGORY con i valori mostrati nella tabella seguente.

L'esempio seguente mostra il contenuto di un file di testo con i valori dei campi separati da virgole.

12,Shows,Musicals,Musical theatre
13,Shows,Plays,All "non-musical" theatre  
14,Shows,Opera,All opera, light, and "rock" opera
15,Concerts,Classical,All symphony, concerto, and choir concerts

Se caricate il file utilizzando il DELIMITER parametro per specificare un input delimitato da virgole, il COPY comando non riesce perché alcuni campi di input contengono virgole. È possibile evitare questo problema utilizzando il CSV parametro e racchiudendo i campi che contengono virgole tra virgolette. Se il carattere virgolette viene visualizzato all'interno di una stringa tra virgolette, è necessario eseguirne l'escape raddoppiando le virgolette. Il carattere di virgoletta di default è una virgoletta doppia, quindi è necessario eseguire l'escape di ogni virgoletta doppia con una virgoletta doppia aggiuntiva. Il nuovo file di input è simile a questo.

12,Shows,Musicals,Musical theatre
13,Shows,Plays,"All ""non-musical"" theatre"
14,Shows,Opera,"All opera, light, and ""rock"" opera"
15,Concerts,Classical,"All symphony, concerto, and choir concerts"

Supponendo che il nome del file siacategory_csv.txt, è possibile caricare il file utilizzando il comando seguente: COPY

copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
csv;

In alternativa, per evitare di evitare di evitare le virgolette doppie dell'input, è possibile specificare un carattere di virgolette diverso utilizzando il QUOTE parametro AS. Per esempio, la seguente versione di category_csv.txt utilizza "%" come carattere virgolette.

12,Shows,Musicals,Musical theatre
13,Shows,Plays,%All "non-musical" theatre%
14,Shows,Opera,%All opera, light, and "rock" opera%
15,Concerts,Classical,%All symphony, concerto, and choir concerts%

Il COPY comando seguente utilizza QUOTE AS per il caricamento: category_csv.txt

copy category
from 's3://amzn-s3-demo-bucket/data/category_csv.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
csv quote as '%';

Carica VENUE con valori espliciti per una colonna IDENTITY

L'esempio seguente presuppone che al momento della creazione della VENUE tabella sia stata specificata almeno una colonna (ad esempio la venueid colonna) come colonna. IDENTITY Questo comando sovrascrive il IDENTITY comportamento predefinito di generazione automatica dei valori per una IDENTITY colonna e carica invece i valori espliciti dal file venue.txt. Amazon Redshift non verifica se IDENTITY i valori duplicati vengono caricati nella tabella quando si utilizza l'EXLICITopzione _. IDS

copy venue
from 's3://amzn-s3-demo-bucket/data/venue.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
explicit_ids;

Caricamento TIME da un file delimitato da tubi GZIP

L'esempio seguente carica la TIME tabella da un file delimitato da pipe: GZIP

copy time
from 's3://amzn-s3-demo-bucket/data/timerows.gz' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
gzip
delimiter '|';

Caricamento di un Timestamp o di un Datestamp

L'esempio seguente carica i dati con un timestamp formattato.

copy timestamp1 
from 's3://amzn-s3-demo-bucket/data/time.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
timeformat 'YYYY-MM-DD HH:MI:SS';

Il risultato di questa copia è il seguente:

select * from timestamp1;
c1
----------------------------
2009-01-12 14:15:57.119568
(1 row)

Caricamento dei dati da un file con valori predefiniti

L'esempio seguente utilizza una variante della VENUE tabella nel database. TICKIT Consideriamo una NEW tabella VENUE _ definita con la seguente dichiarazione:

create table venue_new(
venueid smallint not null,
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');

Consideriamo un file di dati venue_noseats.txt che non contiene valori per la VENUESEATS colonna, come mostrato nell'esempio seguente:

1|Toyota Park|Bridgeview|IL|
2|Columbus Crew Stadium|Columbus|OH|
3|RFK Stadium|Washington|DC|
4|CommunityAmerica Ballpark|Kansas City|KS|
5|Gillette Stadium|Foxborough|MA|
6|New York Giants Stadium|East Rutherford|NJ|
7|BMO Field|Toronto|ON|
8|The Home Depot Center|Carson|CA|
9|Dick's Sporting Goods Park|Commerce City|CO|
10|Pizza Hut Park|Frisco|TX|

L'COPYistruzione seguente caricherà correttamente la tabella dal file e applicherà il DEFAULT valore ('1000') alla colonna omessa:

copy venue_new(venueid, venuename, venuecity, venuestate) 
from 's3://amzn-s3-demo-bucket/data/venue_noseats.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';

Ora visualizza la tabella caricata:

select * from venue_new order by venueid;
venueid |         venuename          |    venuecity    | venuestate | venueseats
---------+----------------------------+-----------------+------------+------------
1 | Toyota Park                | Bridgeview      | IL         |       1000
2 | Columbus Crew Stadium      | Columbus        | OH         |       1000
3 | RFK Stadium                | Washington      | DC         |       1000
4 | CommunityAmerica Ballpark  | Kansas City     | KS         |       1000
5 | Gillette Stadium           | Foxborough      | MA         |       1000
6 | New York Giants Stadium    | East Rutherford | NJ         |       1000
7 | BMO Field                  | Toronto         | ON         |       1000
8 | The Home Depot Center      | Carson          | CA         |       1000
9 | Dick's Sporting Goods Park | Commerce City   | CO         |       1000
10 | Pizza Hut Park             | Frisco          | TX         |       1000
(10 rows)

Per l'esempio seguente, oltre a supporre che nessun VENUESEATS dato sia incluso nel file, supponiamo anche che non sia incluso alcun VENUENAME dato:

1||Bridgeview|IL|
2||Columbus|OH|
3||Washington|DC|
4||Kansas City|KS|
5||Foxborough|MA|
6||East Rutherford|NJ|
7||Toronto|ON|
8||Carson|CA|
9||Commerce City|CO|
10||Frisco|TX|

Utilizzando la stessa definizione di tabella, l'COPYistruzione seguente non riesce perché non è stato specificato alcun DEFAULT valore perVENUENAME, ed VENUENAME è una NOT NULL colonna:

copy venue(venueid, venuecity, venuestate) 
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';

Consideriamo ora una variante della VENUE tabella che utilizza una IDENTITY colonna:

create table venue_identity(
venueid int identity(1,1),
venuename varchar(100) not null,
venuecity varchar(30),
venuestate char(2),
venueseats integer not null default '1000');

Come nell'esempio precedente, supponiamo che la VENUESEATS colonna non abbia valori corrispondenti nel file sorgente. L'COPYistruzione seguente carica correttamente la tabella, inclusi i valori IDENTITY dei dati predefiniti anziché generarli automaticamente:

copy venue(venueid, venuename, venuecity, venuestate) 
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;

Questa istruzione fallisce perché non include la IDENTITY colonna (VENUEIDmanca nell'elenco delle colonne) ma include un parametro _: EXPLICIT IDS

copy venue(venuename, venuecity, venuestate) 
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|' explicit_ids;

Questa istruzione fallisce perché non include un IDS parametro EXPLICIT _:

copy venue(venueid, venuename, venuecity, venuestate)
from 's3://amzn-s3-demo-bucket/data/venue_pipe.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
delimiter '|';

COPYdati con l'ESCAPEopzione

L'esempio seguente mostra come caricare i caratteri che corrispondono al carattere del delimitatore (in questo caso, il carattere pipe). Nel file di input, assicurati che tutti i caratteri pipe (|) che desideri caricare siano resi una sequenza di escape con il carattere di barra rovesciata (\). Quindi carica il file con il ESCAPE parametro.

$ more redshiftinfo.txt
1|public\|event\|dwuser
2|public\|sales\|dwuser

create table redshiftinfo(infoid int,tableinfo varchar(50));

copy redshiftinfo from 's3://amzn-s3-demo-bucket/data/redshiftinfo.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
delimiter '|' escape;

select * from redshiftinfo order by 1;
infoid |       tableinfo
-------+--------------------
1      | public|event|dwuser
2      | public|sales|dwuser
(2 rows)

Senza il ESCAPE parametro, questo COPY comando ha esito negativo e viene Extra column(s) found generato un errore.

Copia dagli JSON esempi

Negli esempi seguenti, si carica la CATEGORY tabella con i seguenti dati.

Carica dai JSON dati utilizzando l'opzione 'auto'

Per caricare dai JSON dati utilizzando l''auto'opzione, i JSON dati devono essere costituiti da un insieme di oggetti. I nomi delle chiavi devono corrispondere ai nomi delle colonne, ma l'ordine non ha importanza. Di seguito viene mostrato il contenuto di un file denominato category_object_auto.json.

{
    "catdesc": "Major League Baseball",
    "catid": 1,
    "catgroup": "Sports",
    "catname": "MLB"
}
{
    "catgroup": "Sports",
    "catid": 2,
    "catname": "NHL",
    "catdesc": "National Hockey League"
}{
    "catid": 3,
    "catname": "NFL",
    "catgroup": "Sports",
    "catdesc": "National Football League"
}
{
    "bogus": "Bogus Sports LLC",
    "catid": 4,
    "catgroup": "Sports",
    "catname": "NBA",
    "catdesc": "National Basketball Association"
}
{
    "catid": 5,
    "catgroup": "Shows",
    "catname": "Musicals",
    "catdesc": "All symphony, concerto, and choir concerts"
}

Per caricare dal file di JSON dati dell'esempio precedente, eseguite il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_object_auto.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
json 'auto';

Carica dai JSON dati utilizzando l'opzione 'auto ignorecase'

Per caricare dai JSON dati utilizzando l''auto ignorecase'opzione, i JSON dati devono essere costituiti da un insieme di oggetti. Il formato maiuscolo/minuscolo dei nomi delle chiavi non deve corrispondere ai nomi delle colonne e l'ordine non ha importanza. Di seguito viene mostrato il contenuto di un file denominato category_object_auto-ignorecase.json.

{
    "CatDesc": "Major League Baseball",
    "CatID": 1,
    "CatGroup": "Sports",
    "CatName": "MLB"
}
{
    "CatGroup": "Sports",
    "CatID": 2,
    "CatName": "NHL",
    "CatDesc": "National Hockey League"
}{
    "CatID": 3,
    "CatName": "NFL",
    "CatGroup": "Sports",
    "CatDesc": "National Football League"
}
{
    "bogus": "Bogus Sports LLC",
    "CatID": 4,
    "CatGroup": "Sports",
    "CatName": "NBA",
    "CatDesc": "National Basketball Association"
}
{
    "CatID": 5,
    "CatGroup": "Shows",
    "CatName": "Musicals",
    "CatDesc": "All symphony, concerto, and choir concerts"
}

Per caricare dal file di JSON dati dell'esempio precedente, eseguite il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_object_auto ignorecase.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
json 'auto ignorecase';

Caricamento da JSON dati utilizzando un JSONPaths file

Se gli oggetti JSON dati non corrispondono direttamente ai nomi delle colonne, puoi utilizzare un JSONPaths file per mappare gli JSON elementi alle colonne. L'ordine non ha importanza nei dati di JSON origine, ma l'ordine delle espressioni del JSONPaths file deve corrispondere all'ordine delle colonne. Supponi di avere il seguente file di dati, denominato category_object_paths.json.

{
    "one": 1,
    "two": "Sports",
    "three": "MLB",
    "four": "Major League Baseball"
}
{
    "three": "NHL",
    "four": "National Hockey League",
    "one": 2,
    "two": "Sports"
}
{
    "two": "Sports",
    "three": "NFL",
    "one": 3,
    "four": "National Football League"
}
{
    "one": 4,
    "two": "Sports",
    "three": "NBA",
    "four": "National Basketball Association"
}
{
    "one": 6,
    "two": "Shows",
    "three": "Musicals",
    "four": "All symphony, concerto, and choir concerts"
}

Il JSONPaths file seguente, denominatocategory_jsonpath.json, mappa i dati di origine alle colonne della tabella.

{
    "jsonpaths": [
        "$['one']",
        "$['two']",
        "$['three']",
        "$['four']"
    ]
}

Per caricare dal file di JSON dati dell'esempio precedente, esegui il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
json 's3://amzn-s3-demo-bucket/category_jsonpath.json';

Caricamento da JSON matrici utilizzando un JSONPaths file

Per eseguire il caricamento da JSON dati costituiti da un set di matrici, è necessario utilizzare un JSONPaths file per mappare gli elementi dell'array alle colonne. Supponi di avere il seguente file di dati, denominato category_array_data.json.

[1,"Sports","MLB","Major League Baseball"]
[2,"Sports","NHL","National Hockey League"]
[3,"Sports","NFL","National Football League"]
[4,"Sports","NBA","National Basketball Association"]
[5,"Concerts","Classical","All symphony, concerto, and choir concerts"]

Il JSONPaths file seguente, denominatocategory_array_jsonpath.json, mappa i dati di origine alle colonne della tabella.

{
    "jsonpaths": [
        "$[0]",
        "$[1]",
        "$[2]",
        "$[3]"
    ]
}

Per caricare dal file di JSON dati dell'esempio precedente, esegui il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_array_data.json'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
json 's3://amzn-s3-demo-bucket/category_array_jsonpath.json';

Esempi di copia da Avro

Negli esempi seguenti, si carica la CATEGORY tabella con i seguenti dati.

Caricamento dai dati Avro utilizzando l'opzione "auto".

Per caricare dai dati Avro usando l'argomento 'auto', i nomi dei campi nello schema Avro devono corrispondere ai nomi delle colonne. Quando si utilizza l'argomento 'auto', l'ordine non ha importanza. Di seguito viene mostrato lo schema per un file denominato category_auto.avro.

{
    "name": "category",
    "type": "record",
    "fields": [
        {"name": "catid", "type": "int"},
        {"name": "catdesc", "type": "string"},
        {"name": "catname", "type": "string"},
        {"name": "catgroup", "type": "string"},
}

I dati in un file Avro sono in formato binario, quindi non sono leggibili dall'utente. Di seguito viene JSON mostrata una rappresentazione dei dati nel category_auto.avro file.

{
   "catid": 1,
   "catdesc": "Major League Baseball",
   "catname": "MLB",
   "catgroup": "Sports"
}
{
   "catid": 2,
   "catdesc": "National Hockey League",
   "catname": "NHL",
   "catgroup": "Sports"
}
{
   "catid": 3,
   "catdesc": "National Basketball Association",
   "catname": "NBA",
   "catgroup": "Sports"
}
{
   "catid": 4,
   "catdesc": "All symphony, concerto, and choir concerts",
   "catname": "Classical",
   "catgroup": "Concerts"
}

Per caricare dal file di dati Avro nell'esempio precedente, esegui il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_auto.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto';

Caricamento da dati Avro utilizzando l'opzione 'auto ignorecase'

Per caricare dai dati Avro con l'argomento 'auto ignorecase', il formato maiuscolo/minuscolo dei nomi dei campi nello schema Avro non deve corrispondere al formato dei nomi delle colonne. Quando si utilizza l'argomento 'auto ignorecase', l'ordine non ha importanza. Di seguito viene mostrato lo schema per un file denominato category_auto-ignorecase.avro.

{
    "name": "category",
    "type": "record",
    "fields": [
        {"name": "CatID", "type": "int"},
        {"name": "CatDesc", "type": "string"},
        {"name": "CatName", "type": "string"},
        {"name": "CatGroup", "type": "string"},
}

I dati in un file Avro sono in formato binario, quindi non sono leggibili dall'utente. Di seguito viene JSON mostrata una rappresentazione dei dati nel category_auto-ignorecase.avro file.

{
   "CatID": 1,
   "CatDesc": "Major League Baseball",
   "CatName": "MLB",
   "CatGroup": "Sports"
}
{
   "CatID": 2,
   "CatDesc": "National Hockey League",
   "CatName": "NHL",
   "CatGroup": "Sports"
}
{
   "CatID": 3,
   "CatDesc": "National Basketball Association",
   "CatName": "NBA",
   "CatGroup": "Sports"
}
{
   "CatID": 4,
   "CatDesc": "All symphony, concerto, and choir concerts",
   "CatName": "Classical",
   "CatGroup": "Concerts"
}

Per caricare dal file di dati Avro nell'esempio precedente, esegui il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_auto-ignorecase.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'
format as avro 'auto ignorecase';

Carica dati da Avro utilizzando un file JSONPaths

Se i nomi dei campi nello schema Avro non corrispondono direttamente ai nomi delle colonne, puoi utilizzare un JSONPaths file per mappare gli elementi dello schema alle colonne. L'ordine delle espressioni del JSONPaths file deve corrispondere all'ordine delle colonne.

Supponi di avere un file di dati chiamato category_paths.avro che contenga gli stessi dati dell'esempio precedente, ma con lo schema seguente.

{
    "name": "category",
    "type": "record",
    "fields": [
        {"name": "id", "type": "int"},
        {"name": "desc", "type": "string"},
        {"name": "name", "type": "string"},
        {"name": "group", "type": "string"},
        {"name": "region", "type": "string"} 
     ]
}

Il JSONPaths file seguente, denominatocategory_path.avropath, mappa i dati di origine alle colonne della tabella.

{
    "jsonpaths": [
        "$['id']",
        "$['group']",
        "$['name']",
        "$['desc']"
    ]
}

Per caricare dal file di dati Avro dell'esempio precedente, esegui il COPY comando seguente.

copy category
from 's3://amzn-s3-demo-bucket/category_object_paths.avro'
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole' 
format avro 's3://amzn-s3-demo-bucket/category_path.avropath ';

Preparazione dei file per COPY con l'opzione ESCAPE

L'esempio seguente descrive come preparare i dati per «sfuggire» ai caratteri di nuova riga prima di importarli in una tabella Amazon Redshift utilizzando COPY il comando con il parametro. ESCAPE Senza preparare i dati per delimitare i caratteri di nuova riga, Amazon Redshift restituisce errori di caricamento quando esegui COPY il comando, poiché il carattere di nuova riga viene normalmente utilizzato come separatore di record.

Ad esempio, si consideri un file o una colonna in una tabella esterna che si desidera copiare in una tabella Amazon Redshift. Se il file o la colonna contiene contenuti in XML formato elettronico o dati simili, devi assicurarti che tutti i caratteri di nuova riga (\n) che fanno parte del contenuto vengano eliminati con il carattere barra rovesciata (\).

Un file o una tabella che contiene caratteri newline incorporati è che fornisce un modello relativamente facile da associare. Ogni carattere newline incorporato molto probabilmente segue sempre un carattere > con potenzialmente alcuni caratteri di spazio (' ' o tabulazione) in mezzo, come è possibile vedere nel seguente esempio di un file di testo denominato nlTest1.txt.

$ cat nlTest1.txt
<xml start>
<newline characters provide>
<line breaks at the end of each>
<line in content>
</xml>|1000
<xml>
</xml>|2000

Con l'esempio seguente, è possibile eseguire un'utilità di elaborazione del testo per pre-elaborare il file sorgente e inserire caratteri di escape, se necessario. (Il carattere | deve essere usato come delimitatore per separare i dati delle colonne quando viene copiato in una tabella Amazon Redshift).

$ sed -e ':a;N;$!ba;s/>[[:space:]]*\n/>\\\n/g' nlTest1.txt > nlTest2.txt

Allo stesso modo, è possibile utilizzare Perl per eseguire un'operazione simile:

cat nlTest1.txt | perl -p -e 's/>\s*\n/>\\\n/g' > nlTest2.txt

Per facilitare il caricamento dei dati dal file nlTest2.txt in Amazon Redshift, è stata creata una tabella a due colonne in Amazon Redshift. La prima colonna c1 è una colonna di caratteri che contiene il contenuto in formato -formattato del file. XML nlTest2.txt La seconda colonna c2 contiene i valori interi caricati dallo stesso file.

Dopo aver eseguito il sed comando, puoi caricare correttamente i dati dal nlTest2.txt file in una tabella Amazon Redshift utilizzando il ESCAPE parametro.

copy t2 from 's3://amzn-s3-demo-bucket/data/nlTest2.txt' 
iam_role 'arn:aws:iam::0123456789012:role/MyRedshiftRole'  
escape
delimiter as '|';

select * from t2 order by 2;

c1           |  c2
-------------+------
<xml start>
<newline characters provide>
<line breaks at the end of each>
<line in content>
</xml>
| 1000
<xml>
</xml>       | 2000
(2 rows)

In modo analogo è possibile preparare i file di dati esportati da database esterni. Ad esempio, con un database Oracle, puoi utilizzare la REPLACE funzione su ogni colonna interessata in una tabella che desideri copiare in Amazon Redshift.

SELECT c1, REPLACE(c2, \n',\\n' ) as c2 from my_table_with_xml

Inoltre, molti strumenti di esportazione ed estrazione, trasformazione, caricamento (ETL) del database che elaborano regolarmente grandi quantità di dati forniscono opzioni per specificare caratteri di escape e delimitatori.

Caricamento di uno shapefile in Amazon Redshift

Gli esempi seguenti mostrano come caricare uno shapefile Esri utilizzando. COPY Per ulteriori informazioni sul caricamento di shapefile, consultare Caricamento di uno shapefile in Amazon Redshift.

Caricamento di uno shapefile

I passaggi seguenti mostrano come importare OpenStreetMap dati da Amazon S3 utilizzando COPY il comando. Questo esempio presuppone che l'archivio degli shapefile norvegesi dal sito di download di Geofabrik sia stato caricato in un bucket Amazon S3 privato nella tua regione. AWS I file .shp, .shx e .dbf devono condividere lo stesso prefisso Amazon S3 e lo stesso nome file.

Importazione dei dati senza semplificazione

I seguenti comandi creano tabelle e importano dati che possono adattarsi alle dimensioni massime della geometria senza alcuna semplificazione. Apritelo nel vostro software preferito GIS e gis_osm_natural_free_1.shp controllate le colonne di questo livello. Per impostazione predefinita, una IDENTITY o più GEOMETRY colonne vengono assegnate per prime. Quando una GEOMETRY colonna è la prima, è possibile creare la tabella come illustrato di seguito.

CREATE TABLE norway_natural (
   wkb_geometry GEOMETRY,
   osm_id BIGINT,
   code INT,
   fclass VARCHAR,
   name VARCHAR);            

Oppure, quando una IDENTITY colonna è la prima, puoi creare la tabella come illustrato di seguito.

CREATE TABLE norway_natural_with_id (
   fid INT IDENTITY(1,1),
   wkb_geometry GEOMETRY,
   osm_id BIGINT,
   code INT,
   fclass VARCHAR,
   name VARCHAR);            

Ora puoi importare i dati usandoCOPY.

COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural' completed, 83891 record(s) loaded successfully

In alternativa, è possibile importare i dati come illustrato di seguito.

COPY norway_natural_with_id FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO: Load into table 'norway_natural_with_id' completed, 83891 record(s) loaded successfully.

Importazione dei dati con semplificazione

I seguenti comandi creano tabelle e provano a importare i dati che possono adattarsi alle dimensioni massime della geometria senza alcuna semplificazione. Ispezionare lo shapefile gis_osm_water_a_free_1.shp e creare la tabella appropriata come illustrato di seguito.

CREATE TABLE norway_water (
   wkb_geometry GEOMETRY,
   osm_id BIGINT,
   code INT,
   fclass VARCHAR,
   name VARCHAR);

Quando il COPY comando viene eseguito, viene generato un errore.

COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
ERROR:  Load into table 'norway_water' failed.  Check 'stl_load_errors' system table for details.              

L'esecuzione della query su STL_LOAD_ERRORS ,ostra che la geometria è troppo grande.

SELECT line_number, btrim(colname), btrim(err_reason) FROM stl_load_errors WHERE query = pg_last_copy_id();
 line_number |    btrim     |                                 btrim
-------------+--------------+-----------------------------------------------------------------------
     1184705 | wkb_geometry | Geometry size: 1513736 is larger than maximum supported size: 1048447              

Per ovviare a questo problema, il SIMPLIFY AUTO parametro viene aggiunto al COPY comando per semplificare le geometrie.

COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';

INFO:  Load into table 'norway_water' completed, 1989196 record(s) loaded successfully.              

Per visualizzare le righe e le geometrie semplificate, eseguire una query su SVL_SPATIAL_SIMPLIFY.

SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
 query | line_number | maximum_tolerance | initial_size | simplified | final_size |   final_tolerance
-------+-------------+-------------------+--------------+------------+------------+----------------------
    20 |     1184704 |                -1 |      1513736 | t          |    1008808 |   1.276386653895e-05
    20 |     1664115 |                -1 |      1233456 | t          |    1023584 | 6.11707814796635e-06               

Se si utilizza SIMPLIFY AUTO max_tolerance con una tolleranza inferiore a quella calcolata automaticamente, è probabile che si verifichi un errore di ingestione. In questo caso, usa per ignorare gli erroriMAXERROR.

COPY norway_water FROM 's3://bucket_name/shapefiles/norway/gis_osm_water_a_free_1.shp'
FORMAT SHAPEFILE
SIMPLIFY AUTO 1.1E-05
MAXERROR 2
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';

INFO:  Load into table 'norway_water' completed, 1989195 record(s) loaded successfully.
INFO:  Load into table 'norway_water' completed, 1 record(s) could not be loaded.  Check 'stl_load_errors' system table for details.               

SVL_SPATIAL_SIMPLIFYEffettua nuovamente la query per identificare il record che COPY non è riuscito a caricare.

SELECT * FROM svl_spatial_simplify WHERE query = pg_last_copy_id();
 query | line_number | maximum_tolerance | initial_size | simplified | final_size | final_tolerance
-------+-------------+-------------------+--------------+------------+------------+-----------------
    29 |     1184704 |           1.1e-05 |      1513736 | f          |          0 |               0
    29 |     1664115 |           1.1e-05 |      1233456 | t          |     794432 |         1.1e-05             

In questo esempio, il primo record non è riuscito a adattarsi, quindi la colonna simplified riporta false. Il secondo record è stato caricato entro la tolleranza specificata. Tuttavia, la dimensione finale è maggiore rispetto all'utilizzo della tolleranza calcolata automaticamente senza specificare la tolleranza massima.

Caricamento da uno shapefile compresso

Amazon Redshift COPY supporta l'acquisizione di dati da uno shapefile compresso. Tutti i componenti shapefile devono avere lo stesso prefisso Amazon S3 e lo stesso suffisso di compressione. Ad esempio, si supponga di voler caricare i dati dell'esempio precedente. In questo caso, i file gis_osm_water_a_free_1.shp.gz, gis_osm_water_a_free_1.dbf.gz e gis_osm_water_a_free_1.shx.gz devono condividere la stessa directory Amazon S3. Il COPY comando richiede l'GZIPopzione e la FROM clausola deve specificare il file compresso corretto, come illustrato di seguito.

COPY norway_natural FROM 's3://bucket_name/shapefiles/norway/compressed/gis_osm_natural_free_1.shp.gz'
FORMAT SHAPEFILE
GZIP
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO:  Load into table 'norway_natural' completed, 83891 record(s) loaded successfully.          

Caricamento di dati in una tabella con un ordine di colonna diverso

Se hai una tabella che non dispone di GEOMETRY come prima colonna, è possibile mappare le colonne alla tabella di destinazione. Ad esempio, creare una tabella con osm_id specificato come prima colonna.

CREATE TABLE norway_natural_order (
   osm_id BIGINT,
   wkb_geometry GEOMETRY,
   code INT,
   fclass VARCHAR,
   name VARCHAR);         

Quindi importare uno shapefile utilizzando la mappatura delle colonne.

COPY norway_natural_order(wkb_geometry, osm_id, code, fclass, name) 
FROM 's3://bucket_name/shapefiles/norway/gis_osm_natural_free_1.shp'
FORMAT SHAPEFILE
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/MyRoleName';
INFO:  Load into table 'norway_natural_order' completed, 83891 record(s) loaded successfully.         

Caricamento di dati in una tabella con una colonna geografica

Se hai una tabella con una colonna GEOGRAPHY, prima importa in una colonna GEOMETRY e quindi converti gli oggetti in oggetti GEOGRAPHY. Ad esempio, dopo aver copiato lo shapefile in una colonna GEOMETRY, modifica la tabella per aggiungere una colonna del tipo di dati GEOGRAPHY.

ALTER TABLE norway_natural ADD COLUMN wkb_geography GEOGRAPHY;

Quindi converti le geometrie in aree geografiche.

UPDATE norway_natural SET wkb_geography = wkb_geometry::geography;

Facoltativamente, è possibile eliminare la colonna GEOMETRY.

ALTER TABLE norway_natural DROP COLUMN wkb_geometry;

COPYcomando con l'opzione NOLOAD

Per convalidare i file di dati prima di caricarli effettivamente, utilizzate l'NOLOADopzione con il COPY comando. Amazon Redshift analizza il file di input e visualizza gli eventuali errori che si verificano. L'esempio seguente utilizza l'NOLOADopzione e nessuna riga viene effettivamente caricata nella tabella.

COPY public.zipcode1
FROM 's3://amzn-s3-demo-bucket/mydata/zipcode.csv' 
DELIMITER ';' 
IGNOREHEADER 1 REGION 'us-east-1'
NOLOAD
CREDENTIALS 'aws_iam_role=arn:aws:iam::123456789012:role/myRedshiftRole';

Warnings:
Load into table 'zipcode1' completed, 0 record(s) loaded successfully.