Informazioni sulle trasformazioni dei dati OCI GoldenGate

Informazioni su come utilizzare le distribuzioni di OCI GoldenGate Data Replication e Trasformazioni dei Dati per caricare e trasformare dati tra due database AI Autonomous.

Prima di iniziare

Per completare correttamente questo Quickstart è necessario:

Un database AI autonomo di origine con dati di esempio caricati e log supplementare abilitato.
Suggerimento
Se è necessario utilizzare dati di esempio, è possibile scaricare i dati di esempio OCI GoldenGate.
- Utilizzare lo strumento SQL Database Actions di Autonomous AI Database per eseguire i due script per creare lo schema utente e le tabelle.
- Utilizzare lo strumento SQL per abilitare il log supplementare.
Per ulteriori dettagli, attenersi alla procedura descritta in Lab 1, Task 3: caricare lo schema ATP.
Sblocca l'utente GGADMIN sull'istanza di origine del database AI autonomo
1. Nella pagina Dettagli Autonomous AI Database selezionare Utenti del database dal menu Azioni del database.
  
  Suggerimento
  Utilizzare le credenziali dell'amministratore di Autonomous AI Database fornite quando è stata creata l'istanza per eseguire il login, se richiesto.
2. Individuare l'utente GGADMIN, quindi selezionare Modifica dal menu con i puntini di sospensione (tre punti).
3. Nel pannello Modifica utente immettere una password, confermare la password, quindi deselezionare Account bloccato.
4. Fare clic su Applica modifiche.

Task 1: Impostare l'ambiente

Creare una distribuzione di replica dati.
Creare una connessione ATP (Autonomous AI Transaction Processing</span>Oracle Autonomous AI Transaction Processing) Oracle <span> di origine.
Creare una connessione Autonomous AI Lakehouse (ALK) di destinazione.
Assegnare una connessione alla distribuzione.
Utilizzare lo strumento SQL per abilitare il log supplementare:
```
ALTER DATABASE ADD SUPPLEMENTAL LOG DATA
```
Eseguire la query seguente nello strumento SQL per assicurarsi che support_mode=FULL per tutte le tabelle del database di origine:
```
select * from DBA_GOLDENGATE_SUPPORT_MODE where owner = 'SRC_OCIGGLL';
```

Task 2: Creazione dell'estrazione integrata

Un'estrazione integrata acquisisce le modifiche in corso al database di origine.

Nella pagina Dettagli distribuzione fare clic su Avvia console.
Se necessario, immettere oggadmin per il nome utente e la password utilizzati durante la creazione della distribuzione, quindi fare clic su Connetti.
Aggiungi dati transazione e tabella checkpoint:
1. Aprire il menu di navigazione, quindi fare clic su Connessioni DB.
2. Fare clic su Connetti al database SourceDB.
3. Nel menu di navigazione fare clic su Trandata, quindi su Aggiungi Trandata (icona più).
4. Per Nome schema, immettere SRC_OCIGGLL, quindi fare clic su Sottometti.
5. Per verificare, immettere SRC_OCIGGLL nel campo Cerca e fare clic su Cerca.
6. Aprire il menu di navigazione, quindi fare clic su Connessioni DB.
7. Fare clic su Connetti al database TargetDB.
8. Nel menu di navigazione, fare clic su Checkpoint, quindi su Aggiungi checkpoint (icona più).
9. Per Tabella checkpoint, immettere "SRCMIRROR_OCIGGLL"."CHECKTABLE", quindi fare clic su Sottometti.

Aggiungere un'estrazione.

Nota

Per ulteriori informazioni sui parametri che è possibile utilizzare per specificare le tabelle di origine, vedere opzioni aggiuntive dei parametri di estrazione.

Nella pagina Estrai parametri aggiungere le righe seguenti in EXTTRAIL <trail-name>:

-- Capture DDL operations for listed schema tables
ddl include mapped

-- Add step-by-step history of 
-- to the report file. Very useful when troubleshooting.
ddloptions report 

-- Write capture stats per table to the report file daily.
report at 00:01 

-- Rollover the report file weekly. Useful when IE runs
-- without being stopped/started for long periods of time to
-- keep the report files from becoming too large.
reportrollover at 00:01 on Sunday 

-- Report total operations captured, and operations per second
-- every 10 minutes.
reportcount every 10 minutes, rate 

-- Table list for capture
table SRC_OCIGGLL.*;

Verificare le transazioni a esecuzione prolungata. Eseguire lo script seguente nel database di origine:
```
select start_scn, start_time from gv$transaction where start_scn < (select max(start_scn) from dba_capture);
```
Se la query restituisce righe, è necessario individuare l'SCN della transazione e quindi eseguire il commit o il rollback della transazione.

Task 3: Esportare i dati utilizzando Oracle Data Pump (ExpDP)

Utilizzare Oracle Data Pump (ExpDP) per esportare i dati dal database di origine in Oracle Object Store.

Crea un bucket dell'area di memorizzazione degli oggetti Oracle.

Prendere nota dello spazio di nomi e del nome del bucket da utilizzare con gli script di esportazione e importazione.
Creare un token di autenticazione, quindi copiare e incollare la stringa di token in un editor di testo per utilizzarla in un secondo momento.
Creare una credenziale nel database di origine, sostituendo <user-name> e <token> con il nome utente dell'account Oracle Cloud e la stringa di token creata nel passo precedente:
```
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL(
    credential_name => 'ADB_OBJECTSTORE', 
    username => '<user-name>',
    password => '<token>'
  );
END;
```

Eseguire lo script seguente nel database di origine per creare il job Esporta dati. Assicurarsi di sostituire <region>, <namespace> e <bucket-name> nell'URI dell'area di memorizzazione degli oggetti di conseguenza. SRC_OCIGGLL.dmp è un file che verrà creato all'esecuzione dello script.

DECLARE
ind NUMBER;              -- Loop index
h1 NUMBER;               -- Data Pump job handle
percent_done NUMBER;     -- Percentage of job complete
job_state VARCHAR2(30);  -- To keep track of job state
le ku$_LogEntry;         -- For WIP and error messages
js ku$_JobStatus;        -- The job status from get_status
jd ku$_JobDesc;          -- The job description from get_status
sts ku$_Status;          -- The status object returned by get_status

BEGIN
-- Create a (user-named) Data Pump job to do a schema export.
h1 := DBMS_DATAPUMP.OPEN('EXPORT','SCHEMA',NULL,'SRC_OCIGGLL_EXPORT','LATEST');

-- Specify a single dump file for the job (using the handle just returned
-- and a directory object, which must already be defined and accessible
-- to the user running this procedure.
DBMS_DATAPUMP.ADD_FILE(h1,'https://objectstorage.<region>.oraclecloud.com/n/<namespace>/b/<bucket-name>/o/SRC_OCIGGLL.dmp','ADB_OBJECTSTORE','100MB',DBMS_DATAPUMP.KU$_FILE_TYPE_URIDUMP_FILE,1);

-- A metadata filter is used to specify the schema that will be exported.
DBMS_DATAPUMP.METADATA_FILTER(h1,'SCHEMA_EXPR','IN (''SRC_OCIGGLL'')');

-- Start the job. An exception will be generated if something is not set up properly.
DBMS_DATAPUMP.START_JOB(h1);

-- The export job should now be running. In the following loop, the job
-- is monitored until it completes. In the meantime, progress information is displayed.
percent_done := 0;
job_state := 'UNDEFINED';
while (job_state != 'COMPLETED') and (job_state != 'STOPPED') loop
  dbms_datapump.get_status(h1,dbms_datapump.ku$_status_job_error + dbms_datapump.ku$_status_job_status + dbms_datapump.ku$_status_wip,-1,job_state,sts);
  js := sts.job_status;

-- If the percentage done changed, display the new value.
if js.percent_done != percent_done
then
  dbms_output.put_line('*** Job percent done = ' || to_char(js.percent_done));
  percent_done := js.percent_done;
end if;

-- If any work-in-progress (WIP) or error messages were received for the job, display them.
if (bitand(sts.mask,dbms_datapump.ku$_status_wip) != 0)
then
  le := sts.wip;
else
  if (bitand(sts.mask,dbms_datapump.ku$_status_job_error) != 0)
  then
    le := sts.error;
  else
    le := null;
  end if;
end if;
if le is not null
then
  ind := le.FIRST;
  while ind is not null loop
    dbms_output.put_line(le(ind).LogText);
    ind := le.NEXT(ind);
  end loop;
end if;
  end loop;

  -- Indicate that the job finished and detach from it.
  dbms_output.put_line('Job has completed');
  dbms_output.put_line('Final job state = ' || job_state);
  dbms_datapump.detach(h1);
END;

Task 4: creare un'istanza del database di destinazione utilizzando Oracle Data Pump (ImpDP)

Utilizzare Oracle Data Pump (ImpDP) per importare i dati nel database di destinazione dal file SRC_OCIGGLL.dmp esportato dal database di origine.

Creare una credenziale nel database di destinazione per accedere all'area di memorizzazione degli oggetti Oracle (utilizzando le stesse informazioni nella sezione precedente).
```
BEGIN
  DBMS_CLOUD.CREATE_CREDENTIAL( 
    credential_name => 'ADB_OBJECTSTORE',
    username => '<user-name>',
    password => '<token>'
  );
END;
```

Eseguire lo script seguente nel database di destinazione per importare i dati da SRC_OCIGGLL.dmp. Assicurarsi di sostituire <region>, <namespace> e <bucket-name> nell'URI dell'area di memorizzazione degli oggetti di conseguenza:

DECLARE
ind NUMBER;  -- Loop index
h1 NUMBER;  -- Data Pump job handle
percent_done NUMBER;  -- Percentage of job complete
job_state VARCHAR2(30);  -- To keep track of job state
le ku$_LogEntry;  -- For WIP and error messages
js ku$_JobStatus;  -- The job status from get_status
jd ku$_JobDesc;  -- The job description from get_status
sts ku$_Status;  -- The status object returned by get_status
BEGIN

-- Create a (user-named) Data Pump job to do a "full" import (everything
-- in the dump file without filtering).
h1 := DBMS_DATAPUMP.OPEN('IMPORT','FULL',NULL,'SRCMIRROR_OCIGGLL_IMPORT');

-- Specify the single dump file for the job (using the handle just returned)
-- and directory object, which must already be defined and accessible
-- to the user running this procedure. This is the dump file created by
-- the export operation in the first example.

DBMS_DATAPUMP.ADD_FILE(h1,'https://objectstorage.<region>.oraclecloud.com/n/<namespace>/b/<bucket-name>/o/SRC_OCIGGLL.dmp','ADB_OBJECTSTORE',null,DBMS_DATAPUMP.KU$_FILE_TYPE_URIDUMP_FILE);


-- A metadata remap will map all schema objects from SRC_OCIGGLL to SRCMIRROR_OCIGGLL.
DBMS_DATAPUMP.METADATA_REMAP(h1,'REMAP_SCHEMA','SRC_OCIGGLL','SRCMIRROR_OCIGGLL');

-- If a table already exists in the destination schema, skip it (leave
-- the preexisting table alone). This is the default, but it does not hurt
-- to specify it explicitly.
DBMS_DATAPUMP.SET_PARAMETER(h1,'TABLE_EXISTS_ACTION','SKIP');

-- Start the job. An exception is returned if something is not set up properly.
DBMS_DATAPUMP.START_JOB(h1);

-- The import job should now be running. In the following loop, the job is
-- monitored until it completes. In the meantime, progress information is
-- displayed. Note: this is identical to the export example.
percent_done := 0;
job_state := 'UNDEFINED';
while (job_state != 'COMPLETED') and (job_state != 'STOPPED') loop
  dbms_datapump.get_status(h1,
    dbms_datapump.ku$_status_job_error +
    dbms_datapump.ku$_status_job_status +
    dbms_datapump.ku$_status_wip,-1,job_state,sts);
    js := sts.job_status;

  -- If the percentage done changed, display the new value.
  if js.percent_done != percent_done
  then
    dbms_output.put_line('*** Job percent done = ' ||
    to_char(js.percent_done));
    percent_done := js.percent_done;
  end if;

  -- If any work-in-progress (WIP) or Error messages were received for the job, display them.
  if (bitand(sts.mask,dbms_datapump.ku$_status_wip) != 0)
  then
    le := sts.wip;
  else
    if (bitand(sts.mask,dbms_datapump.ku$_status_job_error) != 0)
    then
      le := sts.error;
    else
      le := null;
    end if;
  end if;
  if le is not null
  then
    ind := le.FIRST;
    while ind is not null loop
      dbms_output.put_line(le(ind).LogText);
      ind := le.NEXT(ind);
    end loop;
  end if;
end loop;

-- Indicate that the job finished and gracefully detach from it.
dbms_output.put_line('Job has completed');
dbms_output.put_line('Final job state = ' || job_state);
dbms_datapump.detach(h1);
END;

Task 5: Aggiunta ed esecuzione di un Replicat non integrato

Aggiungere ed eseguire Replicat.

Nella schermata File dei parametri sostituire MAP *.*, TARGET *.*; con lo script seguente:

-- Capture DDL operations for listed schema tables
--
ddl include mapped
--
-- Add step-by-step history of ddl operations captured
-- to the report file. Very useful when troubleshooting.
--
ddloptions report
--
-- Write capture stats per table to the report file daily.
--
report at 00:01
--
-- Rollover the report file weekly. Useful when PR runs
-- without being stopped/started for long periods of time to
-- keep the report files from becoming too large.
--
reportrollover at 00:01 on Sunday
--
-- Report total operations captured, and operations per second
-- every 10 minutes.
--
reportcount every 10 minutes, rate
--
-- Table map list for apply
--
DBOPTIONS ENABLE_INSTANTIATION_FILTERING;
MAP SRC_OCIGGLL.*, TARGET SRCMIRROR_OCIGGLL.*;

Nota

DBOPTIONS ENABLE_INSTATIATION_FILTERING consente l'applicazione di filtri CSN sulle tabelle importate mediante Oracle Data Pump. Per ulteriori informazioni, vedere Riferimento DBOPTIONS.

Eseguire inserimenti nel database di origine:

Torna alla console di Oracle Cloud e utilizza il menu di navigazione per tornare a Oracle AI Database, Autonomous AI Transaction Processing e quindi a SourceDB.
Nella pagina Dettagli SourceDB fare clic su Azioni del database, quindi su SQL.

Immettere gli inserimenti seguenti, quindi fare clic su Esegui script:

Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1000,'Houston',20,743113);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1001,'Dallas',20,822416);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1002,'San Francisco',21,157574);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1003,'Los Angeles',21,743878);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1004,'San Diego',21,840689);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1005,'Chicago',23,616472);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1006,'Memphis',23,580075);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1007,'New York City',22,124434);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1008,'Boston',22,275581);
Insert into SRC_OCIGGLL.SRC_CITY (CITY_ID,CITY,REGION_ID,POPULATION) values (1009,'Washington D.C.',22,688002);

Nella console di distribuzione GoldenGate OCI fare clic sul nome dell'estensione (UAEXT), quindi fare clic su Statistiche. Verificare che SRC_OCIGGLL.SRC_CITY sia elencato con 10 inserimenti.
Tornare alla schermata Panoramica, fare clic sul nome Replicat (REP), quindi su Statistiche. Verificare che SRCMIRROR_OCIGGLL.SRC_CITY sia elencato con 10 inserimenti

Task 6: Creare le risorse di trasformazione dei dati

Creare una distribuzione di trasformazione dati.
Creare una connessione generica.
Nota
Ad esempio, per i database autonomi nell'area orientale degli Stati Uniti (Ashburn) utilizzare i valori riportati di seguito.
- Per Host, immettere adb.us-ashburn-1.oraclecloud.com:1522.
- Per Subnet, selezionare la stessa subnet della distribuzione dall'elenco a discesa.
Assegnare la connessione generica alla distribuzione.
Crea TRG_CUSTOMER in SRCMIRROR_OCIGGLL nell'istanza di Autonomous Data Warehouse (ADW):
1. Nella console di Oracle Cloud, aprire il menu di navigazione, andare a Oracle Database, quindi selezionare Autonomous Data Warehouse.
2. Nella pagina Database autonomi, fare clic sull'istanza ADW.
3. Nella pagina dei dettagli di ADW Autonomous Database, fare clic su Azioni del database, quindi selezionare SQL dall'elenco a discesa. Se il caricamento del menu Azioni del database richiede troppo tempo, è possibile fare clic direttamente su Azioni del database, quindi selezionare SQL dalla pagina Azioni del database.
4. Inserire quanto segue nel foglio di lavoro, quindi fare clic su Esegui istruzione.
```
create table SRCMIRROR_OCIGGLL.TRG_CUSTOMER (
   CUST_ID              NUMBER(10,0)     not null,
   DEAR                 VARCHAR2(4 BYTE),
   CUST_NAME            VARCHAR2(50 BYTE),
   ADDRESS              VARCHAR2(100 BYTE),
   CITY_ID              NUMBER(10,0),
   PHONE                VARCHAR2(50 BYTE),
   AGE                  NUMBER(3,0),
   AGE_RANGE            VARCHAR2(50 BYTE),
   SALES_PERS           VARCHAR2(50 BYTE),
   CRE_DATE             DATE,
   UPD_DATE             DATE,
   constraint PK_TRG_CUSTOMER primary key (CUST_ID)
);
```
Avviare la console di distribuzione Data Transforms:
1. Tornare alla pagina Distribuzioni, quindi selezionare la distribuzione creata nel task 6.
2. Nella pagina Dettagli distribuzione fare clic su Avvia console.
3. Eseguire il login alla console di distribuzione di Data Transforms.
Crea connessione ADW:
1. Aprire il menu di navigazione, fare clic su Connessioni, quindi su Crea connessione.
2. Nella pagina Seleziona tipo, in Database selezionare Oracle, quindi fare clic su Successivo.
3. Nella pagina Dettagli connessione, completare i campi del modulo come indicato di seguito, quindi fare clic su Crea.
  1. Per Nome, immettere ADW_IAD.
  2. Selezionare Usa file delle credenziali.
  3. Per File wallet, caricare il file wallet (ADW).
    
    Nota
    Per scaricare il file wallet ADW, fare clic su Connessione al database nella pagina dei dettagli ADW.
  4. Nell'elenco a discesa Servizi selezionare <name>_low.
  5. Per Utente, immettere ADMIN.
  6. Per Password, immettere la password ADW.
Importa entità dati:
1. Aprire il menu di navigazione, fare clic su Entità dati, quindi su Importa entità dati.
2. Per la connessione, selezionare ADW_IAD dall'elenco a discesa.
3. Per Schema, selezionare SRCMIRROR_OCIGGLL dall'elenco a discesa.
4. Fate clic su Start.
Crea il progetto:
1. Aprire il menu di navigazione, fare clic su Progetti.
2. Nella pagina Progetti, fare clic su Crea progetto.
3. Nella finestra di dialogo Crea progetto, in Nome, immettere pipeline demo, quindi fare clic su Crea.

Task 7: Creazione ed esecuzione di un flusso di lavoro

Crea flusso di dati:

Nota
Ulteriori informazioni su Data Flow Editor.
1. Selezionare il nome del progetto.
2. Nella pagina Dettagli progetto, in Risorse, fare clic su Flussi di dati, quindi su Crea flusso di dati.
3. Nella finestra di dialogo Crea flusso dati, in Nome, immettere Carica TRG_CUSTOMER e, facoltativamente, una descrizione. Fare clic su Crea. Viene visualizzato lo sfondo della progettazione.
4. Nella finestra di dialogo Aggiungi uno schema, completare i campi del modulo come indicato di seguito, quindi fare clic su OK.
  1. Per Connessione, selezionare ADW_IAD dall'elenco a discesa.
  2. Per Schema, selezionare SRCMIRROR_OCIGGLL dall'elenco a discesa.
5. Trascinare le entità dati e i componenti riportati di seguito nello sfondo della progettazione.
  1. Nel pannello Entità dati espandere lo schema SRCMIRROR_OCIGGLL. Trascinare l'entità dati SRC_AGE_GROUP nello sfondo della progettazione.
  2. Nel pannello Entità dati espandere lo schema SRCMIRROR_OCIGGLL. Trascinare l'entità dati SRC_SALES_PERSON nello sfondo della progettazione.
  3. Nella barra degli strumenti Trasformazione dati trascinare il componente Ricerca nello sfondo della progettazione.
  4. Nella barra degli strumenti Trasformazione dati trascinare il componente Join nello sfondo della progettazione.
  5. Nel pannello Entità dati, in SRCMIRROR_OCIGGLL, trascinare l'entità dati SRC_CUSTOMER nello sfondo della progettazione.
6. Connettere le entità dati seguenti al componente Ricerca:
  1. Fare clic sull'icona Connettore SRC_AGE_GROUP e trascinare l'icona nel componente Ricerca.
  2. Fare clic sull'icona Connettore SRC_CUSTOMER e trascinare l'icona nel componente Ricerca.
7. Nello sfondo della progettazione, fare clic su Ricerca per aprire il pannello di ricerca. Nel pannello di ricerca passare alla scheda Attributi, quindi incollare la query seguente in Condizione di ricerca:
```
SRC_CUSTOMER.AGE between SRC_AGE_GROUP.AGE_MIN and SRC_AGE_GROUP.AGE_MAX
```
8. Connettere i seguenti componenti al componente Entra:
  1. Fare clic sull'icona Connettore SRC_SALES_PERSON e trascinare l'icona nel componente Partecipa.
  2. Fare clic sull'icona Connettore ricerca e trascinare l'icona nel componente Entra.
9. Nello sfondo della progettazione, fare clic su Partecipa per aprire il pannello Join. Nel pannello Join passare alla scheda Attributi, quindi incollare la query seguente in Condizione join:
```
SRC_CUSTOMER.SALES_PERS_ID=SRC_SALES_PERSON.SALES_PERS_ID
```
10. Trascinare l'entità dati e il componente riportati di seguito nello sfondo della progettazione.
  1. Nel pannello Entità dati, in SRCMIRROR_OCIGGLL, trascinare l'entità dati TRG_CUSTOMER nello sfondo della progettazione.
  2. Fare clic sull'icona Connettore Entra e trascinare l'icona nell'entità dati TRG_CUSTOMER.
  3. Nell'area di creazione fare clic su TRG_CUSTOMER ed espandere l'entità dati.
11. Nella scheda Attributi, abilitare la chiave per CUST_ID e disabilitare Aggiorna per CRE_DATE e disabilitare Inserisci per UPD_DATE.
12. Nella scheda Mapping colonne, assicurarsi che il nome corrisponda all'espressione:
  1. CUST_ID
```
SRC_CUSTOMER.CUSTID
```
  2. RICHIESTA
```
CASE WHEN SRC_CUSTOMER.DEAR = 0 THEN 'Mr' WHEN SRC_CUSTOMER.DEAR = 1 THEN 'Mrs' ELSE 'Ms' END
```
  3. CUST_NAME
```
SRC_CUSTOMER.FIRST_NAME || ' ' || UPPER(SRC_CUSTOMER.LAST_NAME)
```
  4. SALES_PERS
```
SRC_SALES_PERSON.FIRST_NAME || ' ' ||UPPER(SRC_SALES_PERSON.LAST_NAME)
```
  5. CRE_DATE
```
SYSDATE
```
  6. UPD_DATE
```
SYSDATE
```
  7. Utilizzare altri mapping così com'è.
13. Nella scheda Opzioni, per Modalità, selezionare Aggiornamento incrementale dall'elenco a discesa.
14. Comprimere TRG_CUSTOMER.
15. Fare clic su Salva flusso di dati.
Crea workflow:
1. Selezionare il nome del progetto, selezionare Workflow e quindi Crea workflow.
2. Per il nome, immettere Orchestra caricamento data warehouse. Fare clic su Crea.
3. Trascinare l'icona SQL nello sfondo della progettazione.
4. Fare doppio clic sul passo SQL nell'editor per aprire la pagina delle proprietà del passo.
5. Nella scheda Generale, per nome, immettere Pulizia dati.
6. Selezionare la scheda Attributi. Per Connessione, selezionare ADW_IAD dall'elenco a discesa.
7. Per SQL, copiare la query seguente:
```
delete from SRCMIRROR_OCIGGLL.TRG_CUSTOMER where CITY_ID > 110
```
8. Comprimi SQL.
9. In Flusso di dati, trascinare il flusso di dati TRG_CUSTOMER nello sfondo della progettazione.
10. Fare clic sulla riga del flusso di lavoro SQL Pulizia dati e trascinare l'icona OK (freccia verde) nel flusso di dati TRG_CUSTOMER.
11. Fare clic su Salva workflow, quindi su Avvia workflow.
Creazione e gestione di job.

Titolo e informazioni sul copyright

Oracle e/o relative consociate.