mercoledì 16 dicembre 2015

ORACLE LINUX - Come settare il repository per yum e setting X11

Ogni volta che installo una macchina virtuale con sistema operativo Linux mi dimetico sempre come fare l'update del repository yum.

Di seguito i passi da fare

[root@ora12oel61 yum.repos.d]# cd /etc/yum.repos.d
[root@ora12oel61 yum.repos.d]# wget http://public-yum.oracle.com/public-yum-ol6.repo
[root@ora12oel61 yum.repos.d]# yum repolist
[root@ora12oel61 yum.repos.d]# yum update
[root@ora12oel61 yum.repos.d]# yum install xorg-x11-xauth xterm
[root@ora12oel61 yum.repos.d]#  vi /etc/ssh/sshd_config.
Settare X11Forwarding a yes se necessario ed effettuare il restart del servizio
[root@ora12oel61 yum.repos.d]#  /etc/init.d/sshd restart
[root@ora12oel61 yum.repos.d]# yum update

venerdì 23 ottobre 2015

ODI 12c - Groovy come creare un file csv leggendo da un file excel

Supponiamo di avere un file excel, per poterlo leggere con ODI occorre installare i drivers ODBC e poi procedere all'esecuzione dei normali KM di caricamento,
Se siamo però su macchine con Sistema Operativo MS, l'operazione è gratuita nel caso di macchine Linux/Unix occorre installare dei drivers ODBC e configurarli. Per evitare di installare e configurare questi drivers si può pensare di scrivere una classe java ed inserirla come script Groovy che effettui la lettura del file excel e generi a valle un file csv per ogni sheet. Per poter fare questo occorre utilizzare le classi java Apache POI che possono essere scaricate al seguente link.
Di seguito un esempio di lettura file excel e relativa scrittura csv.

...
import org.apache.poi.ss.usermodel.Cell;
import org.apache.poi.ss.usermodel.Row;
import org.apache.poi.ss.usermodel.Sheet;
import org.apache.poi.ss.usermodel.Workbook;
import org.apache.poi.ss.usermodel.WorkbookFactory;
...

public class xlsToCsv{

       /** Please change these Parameters 
     * @throws Exception *************/

public static void main(String [] args) throws Exception {

...

 if (directory.isFile() &&(directory.getAbsolutePath().contains(".xls")||directory.getAbsolutePath().contains(".xlsx"))) {
                    ...
                                              
         try {
              name = "";
              FileInputStream file = new FileInputStream(new File(directory.getAbsolutePath()));                      
          if(directory.getName().contains(".xlsx"))
    name = directory.getName().replaceAll(".xlsx", ".csv");
        else
name = directory.getName().replaceAll(".xls", ".csv");                    
                      
                filex = new File(name);
                       
            if (!filex.exists()) {
       filex.createNewFile();
     }
                      
                     ...
                       
             Workbook workbook = null;
             Sheet sheet = null;
             Iterator<Row> rowIterator = null;
             //Get the workbook instance for XLS file 
             workbook = WorkbookFactory.create(file);                    
             //Get first sheet from the workbook
             sheet = workbook.getSheetAt(0);
             rowIterator = sheet.iterator();                      
             //Iterate through each rows from first sheet
                        
                  while(rowIterator.hasNext()) {
                       
                   Row row = rowIterator.next();
                   if(row.getRowNum()!=0){
                   //For each row, iterate through each columns
                   Iterator<Cell> cellIterator = row.cellIterator();
                   String concat = "";
                       while(cellIterator.hasNext()) {                              
                    Cell cell = cellIterator.next();
                    String str = "";
                    switch(cell.getCellType()) {
                     case Cell.CELL_TYPE_BOOLEAN:
                         str = (String.valueOf(cell.getBooleanCellValue()));
                    break;
                     case Cell.CELL_TYPE_NUMERIC:
                         str = (String.valueOf(cell.getNumericCellValue()));
                     break;
                     case Cell.CELL_TYPE_STRING:
                          str = (String.valueOf(cell.getStringCellValue()));
                              break;
                     }
                               
                  if(str.contains("|")){
                           throw new Exception("file "+directory.getAbsolutePath()+" non valido");
                     }
                        concat = concat + str;
                        concat=concat+("|");
                              
                   }
                                        
                      concat = concat.substring(0,concat.length()-1)+"\n";
                      outputStream.write(concat.getBytes());
                   }
                  }
                     outputStream.flush();
                     outputStream.close();
                     file.close();                                                   
                    } catch (FileNotFoundException e) {
                    e.printStackTrace();       
                    } catch (IOException e) {
                       e.printStackTrace();
                    }
...
                   } // if file
                   
...                   
}
}


Alla fine dovremmo avere per ogni sheet un file csv delimitato da "|" nel caso in cui questo valore non è presente nelle stringhe di testo.

domenica 23 agosto 2015

ODI 11g-12c - Groovy come verificare che un file contenga una determinata stringa

Supponiamo di dover trovare una stringa all'interno di un file ed a seguito del risultato occorre bloccare o meno il processo in esecuzione.
Per bloccare l'esecuzione usciamo con un errore fittizio.

//Created by ODI Studio

package odi.sdk;
import java.sql.*;

import java.io.FileWriter;
import java.util.List;
import java.util.ArrayList;

 /************** export *************/

import java.io.File;
import java.io.IOException;
import java.text.ParseException;
import java.text.SimpleDateFormat;
import java.util.Collection;
import java.util.Date;
import java.util.Iterator;
import java.io.BufferedReader;
import java.io.FileReader;
import java.lang.Object;
import java.lang.Runtime;

import java.io.FileNotFoundException;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class From_File{

    private static int   count=0;
     
       /** Please change these Parameters *************/    
 static String Find_Frase = "#V_1"
 static String File_input = "#V_FILE_INPUT" 
 static String Path_ril ="#V_PATH_EXPORT"; 
 static def file_output =  new File(Path_ril+"/EXP_LOG/AOG_FindInFile.log");
 static PrintWriter out2 = new PrintWriter(new FileWriter(file_output));
 
public static void main(String [] args) {


 /************** Please change these Parameters *************/
// def File_Input = File_input.replace("/","\\");
 def file_input =  new File(File_input);
 def s = 0

      out2.println("§*********************   Repository Info ******************")
      out2.println("§***  File Input: "+File_input)   
      out2.println("§***  File Output: "+file_output.getAbsolutePath())   
      out2.println("§**********************************************************")
      out2.println(" ");

   out2.println("******************************************************")
           out2.println("--------------Current Line --------------------------");
               
       BufferedReader br = null;

try 
{

String sCurrentLine;
br = new BufferedReader(new FileReader(file_input));
                        out2.println("--count "+ count);  

while ((sCurrentLine = br.readLine()) != null) {  
                        Pattern pat = Pattern.compile(Find_Frase);
       // Pattern pat = Pattern.compile(Find_Frase,Pattern.CASE_INSENSITIVE);
                        Matcher mat = pat.matcher(sCurrentLine);
                          if(mat.find()){

                              mat.start();
                              count++;         
out2.println("lookingAt(): "+mat.lookingAt()+" "+sCurrentLine+" --- "+Find_Frase);
out2.println("matches(): "+mat.matches()+" "+sCurrentLine+" --- "+Find_Frase);

                           if (count>0) { out2.println("--count "+ count);
                 out2.println("--CurrentLine OK"); 
  }else{
              out2.println("--count "+ count);  
       out2.println("--CurrentLine KO");  
out2.close();
exit();
}  
  } //if
}//while

             if (count==0){
   out2.println("--count "+ count);  
       out2.println("--CurrentLine KO");  
out2.close();
exit();
}  

} catch (IOException e_1) {
out2.println("Exception thrown  :" + e_1.getMessage());  
e_1.printStackTrace(out2);
out2.close();
exit();  
}catch(Exception  e_6){
out2.println("Exception thrown  :" + e_6.getMessage());  
e_6.printStackTrace(out2);
out2.close();
exit();      
                }   out2.println("*****************************************************************")
out2.println(" ");
out2.close(); 
}


// End Main

sabato 22 agosto 2015

ODI 12c - Groovy come testare la connessione di un Agent con relativo Update

Di seguito un semplice script per effettuare il test di connessione ad un agent ODI e per effettuarne l'update.

import oracle.odi.runtime.agent.invocation.RemoteRuntimeAgentInvoker;

def RemoteRuntimeAgentInvoker agent = new
String IPADD="<inserire ip address o logical name host dell'agent>"
String PORTA="10011"
String PWD="<password dell'utente ODI di connessione>
RemoteRuntimeAgentInvoker("http://"+IPADD+":"+PORTA+"/oraclediagent", "SUPERVISOR", PWD.toCharArray());

String Name=agent.getAgentURL();
String User=agent.getUser();
String Pwd=agent.getCharArrayPassword();
String Invokealive=agent.invokeIsAlive();
 
       


// output con info su connessione al repository
      println("§*********************   Repository Info *****************************")
      println("§***  Name: "+Name)
      println("§***  User: "+User)
      println("§***  Pwd: "+Pwd)
      println("§***  Invokealive: "+Invokealive)
      println("§*********************************************************************")
   
try{
agent.invokeComputePlanning();
println("§***  AgentComputePlanning: Ok")
}
catch(Exception e){
println(e.getMessage());
}


ODI 12c - ODI Standalone Installation

Prima di partire con l'installazione di Oracle Data Integrator 12cR1 (12.1.3.0.0) e relativa patch Oracle Data Integrator 12cR1 (12.1.3.0.1) cerchiamo di capire dove reperire il sw e cosa più importante quali altri software sono necessari.

1. Step 0 - Download del software necessario:

A questo punto occorre capire il tipo di installazione che dobbiamo fare, in quanto nel caso di ODI Enterprise (JEE) abbiamo il seguente prerequisito che è quello di installare una Oracle Fusion Middleware Infrastracture. Questo prerequisito non è richiesto per una ODI Standalone Installation.

Analizziamo di seguito il caso di una ODI Standalone Installation, Per effettuare questo tipo di installazione seguiamo il seguente documento Oracle® Fusion Middleware Installing and Configuring Oracle Data Integrator .

2. Step 1 - Installazione JDK
  • Una volta effettuato il download della JDK occorre installarla. Se abbiamo scaricato il file tar.gz occorre solo scompattarlo e poi definire una variabile di ambiente JAVA_HOME che punta a questa directory:
    • export JAVA_HOME=/app/product/oracle/jdk1.7.0_51
    • export PATH=$JAVA_HOME/jre/bin:$PATH
    • export LD_LIBRARY_PATH=$JAVA_HOME/lib/amd64:$LD_LIBRARY_PATH
  • Gli export indicati sopra li possiamo inserire nel .profile dell'utente di installazione.
3. Step 2 - Installazione software ODI Standalone
  • Una volta installata la JDK e settata la JAVA_HOME possiamo procedere eseguendo l'installazione del sw ODI il che significa lanciare un file jar.
    • java -jar <fmw_12.1.3.0.0_odi>.jar

  • A questo punto possiamo seguire quanto indicato nel manuale di installazione e se sulla macchina non è mai stato installato un prodotto ORACLE apparirà una schermata la Inventory Directory fornire quella indcata ed andare avanti. Se l'installazione come abbiamo detto è di tipo Standalone indicare una nuova e vuota ORACLE_HOME in quanto solo nel caso di installazione J2EE è necessario fornire quella della infrastruttura. 
  • Adesso occorre scegliere il tipo di installazione:
    • Nel caso occorra creare una topologia per un JAVA EE o collocotaed standalone Agent allora dobbiamo scegliere  Enterprise Installationinto ed una ORACLE HOME esistente, quella della infrastruttura.
    • Se dobbiamo creare uno uan topology per uno standalone agents allora selezioniamo Standalone Installation.
  • Una volta scelta l'installazione partono i check per i prerequisiti e la richiesta per un security update da evitare declinando l'offerta di ricevere gli update da Support.
  • La schermata che adesso dovrebbe apparire è quella su summary alla quale possiamo dare l'ok e quindi cliccare su install.
  • Partita l'installazione occorre solo aspettare che finisca.
4. Step 3 - Installazione Master e Work Repository utilizzando l'utility RCU
  • Terminata l'installazione Step 2 occorre creare il master e work repository, per crearlo esistono due metodi, noi analizziamo il primo:
    • Installazione utilizzando l'utility RCU
    • Installazione utilizzando ODI STUDIO
  • Posizionarsi sulla directory in cui è presente l'eseguibile rcu:
    • cd $ODI_HOME/oracle_common/bin
    • ./rcu
Prima di procedere, parlare col DBA perchè occorre avere 
  1. le info di connessione all'istanza oracle su cui creare lo schema che conterrà il master ed il work repository 
  2. utenza con credenziali di sysdba in quanto deve creare alcuni schema oracle e relativi tablespaces
  • La prima schermata che appare vi chiede che cosa volete fare a questo punto occorre spuntare:
    • Create Repository
      • System Load and Product load
  • A questo punto a seconda di dove facciamo partire l'rcu abbiamo info diverse:
    • Se partiamo da una Standalone Installazione (nostro caso) verrà visualizzato solo AS COMMON SCHEMA (necessario _STB) ed il nome del MASTER E WORK REPOSITORY.
    • Se partiamo da una Enterprise Installazione appariranno anche altri schema nella AS COMMON SCHEMA oltra a quello _STB.
  • Step successivo occorre definire le password degli utenti, possibilmente la stessa per tutti
  • Altro Step adesso è quello della configurazione delle "custom variables for the Master and Work Repository." . Come valore di Encryption Algorithm indicare quello di default AES-128, mentre come Repository Type indicare D. A questo punto NEXT
  • Appariranno le indicazioni dei nuovi tablespaces se non siete sicuri di dove li  metta potete verificarne la locazione clicclando su MANAGE TABLESPACE. 
  • A questo punto andate di next fino alla fine dell'installazione.
5 Step 4 - Installazione Standalone Agent
  • Terminato lo step precedente creiamo il dominio dell'agent Stadalone:
    • cd  $ODI_HOME/oracle_common/common/bin
    • ./config.sh
  • Partita la schermata scegliere creazione di un nuovo dominio fornendo una directory vuota o lasciare quella di default indicata ed andare avanti.
  • Selezionare Stand Alone Agent e lasciare cliccato il secondo e premere Next
  • Indicare la corretta posizione della JAVA_HOME e Next
  • A questo punto appare la scheramata di autoconfigurazione che ricerca quanto installato con l'utility rcu, Configurare il database dove è installato lo schema _STB e cliccare su GetRCU Configuration. Al termine se tutto OK andare avanti col famoso Next
  • Verificare che nella schermata le informazioni siano corrette, ma dovrebbe averle prese in automatico leggendo lo schema _STB ed andare avanti alla schermata successiva nella quale potete fare un test di connessione se tutto ok Next
  • A questo punto configurate l'agent con nome, porta ecc e fate Next
  • Lasciate cliccato in Node Manager Type - Domain Default Location ed inserite le credenziali relative al NodeManager (memorizzatele da qualche parte)  e cliccate Next ed alla schermata successiva Create.
  • A questo punto aspettate fino a che non termina.
6 Step 5 - Start Agent StandAlone
  • Posizionarsi nella directory bin dell'agent ed effettuarne lo start
    • ./agent.sh -NAME=OracleDIAgent_SA -PORT=20910
7 Step 6 - Creare l'agent in ODI  Studio
  • Per questo step basta seguire la documentazione una volta creato effettuare un test di connessione se tutto ok.

A questo punto se l'ultimo step è ok possiamo considerare terminata l'installazione di Oracle Data Integrator 12cR1 (12.1.3.0.0).

8 Step 7 - Installazione Oracle Data Integrator 12cR1 (12.1.3.0.1) - solo nel caso di BigData

Per quanto riguarda l'installazione della patch Oracle Data Integrator 12cR1 (12.1.3.0.1) questa si installa sul software della 12.1.3.0.0 come una normale patch one/off, solo che non è una sola ma sono invece 3 patch. Effettuare l'unzip dei tre pacchetti e seguire l'installation note. La seconda patch in questo caso essendo una installazione di tipo standalone non deve essere installata.
Dopo aver installato le 3 patch avendo creato il master e work repository con la versione precedente occorre far girare l'utility di upgrade ua.
Per installare le patch one/off ricordarsi di effettuare l'unzip delle patch sotto la directory opatch e di valorizzare correttamente le seguenti variabili:

                    export ORACLE_HOME=<odi_home>
           export JAVA_HOME=/oramw/ODI/jdk1.7.0_55
           export PATH=$ORACLE_HOME:$PATH
           export PATH=$ORACLE_HOME/OPatch:$PATH
           export PATH=$JAVA_HOME/bin:$PATH

Per verificare che le variabili siano settate correttamente lanciare il seguente comando:

           opatch lsinventory

Se tutto ok vi dovrebbero apparire le patch installate su ODI in questo caso nessuna:

Oracle Interim Patch Installer version 13.2.0.0.0
Copyright (c) 2014, Oracle Corporation.  All rights reserved.


...
-------------------------------------------------------------------

There are no Interim patches installed in this Oracle Home.

-------------------------------------------------------------------

OPatch succeeded.

Ogni volta che installate un patch vi deve uscire la scritta in rosso.

Vediamo i passi relativi all'installazione delle singole Patch, creare una directory PATCH_TOP:


  • unzip -d PATCH_TOP p20042369_121300_Generic.zip
    • Verificare che le variabili di ambiente indicate sopra siano settate correttamente e posizionarsi nella prima delle directory contenenti le patch.
    • cd PATCH_TOP/20042369
    • opatch apply

  • La patch 20674616 richiede che l'installazione sia di tipo Enterprise se cosi non fosse possiamo non installarla altrimenti si avrebbe un errore.

  • unzip -d PATCH_TOP p20562777_121300_Generic.zip
    • Verificare che le variabili di ambiente indicate sopra siano settate correttamente e posizionarsi nella directory contenenti la patch.
    • cd PATCH_TOP/20562777
    • opatch apply

  • A questo punto se i repository Master e Work sono stati già creati con la versione precedente occorre effettuarne l'upgrade con l'utility ua. 
Per l'installazione di questa patch ricordatevi di seguire il relativo Readme.txt di cui ho fatto un rapido sunto.

martedì 11 agosto 2015

HFM - RDBMS ORACLE - Come estrarre una gerarchia da HFM 11

Di seguito una query per estrarre una gerarchia da HFM 11 che ha le sue tabelle delle dimensioni sul DB.


// TABELLA gerarchia
CREATE VIEW v_hfm_entity_gr AS
SELECT A.*
FROM
  (SELECT e.*,
    f.description
  FROM
    (SELECT *
    FROM
      (SELECT PARENTID,ITEMID,
        sys_connect_by_path(LABEL, '.') CB_LABEL,
        sys_connect_by_path(itemid, '.') CB_ITEMID,
        LEVEL G_LEVEL
      FROM
        (SELECT a.itemid,a.parentid,b.LABEL
          FROM 

HFM.ENTITY_LAYOUT a,HFM.ENTITY_ITEM b
         WHERE a.itemid=b.itemid
         ORDER BY 1
        ) C
        START WITH PARENTID             =-1
        CONNECT BY NOCYCLE PRIOR itemid = parentid
      )
    ) e,
    HFM.ENTITY_DESC f
  WHERE e.itemid  =f.itemid
  AND f.languageid=0
  ) A;

In questo esempio abbiamo considerato la Entity.
Un risultato simile si ottiene con la seguente query:

// TABELLA gerarchia
CREATE view v_hfm_entity_gm as
  SELECT distinct g.itemid,
  h.label||'.'||g.label label, g.description
 FROM
  (SELECT c.*,d.description
    FROM
     (SELECT a.itemid,
      a.parentid,
      b.label
    FROM HFM.ENTITY_LAYOUT a,
      HFM.PRIMO_ENTITY_ITEM b
    WHERE a.itemid=b.itemid
    ) c,
    HFM.ENTITY_DESC d
  WHERE c.itemid  =d.itemid
  AND d.languageid=0
  ) g,
  HFM.ENTITY_ITEM h
WHERE g.parentid=h.itemid ;


Il risultato dovrebbe essere equivalente.

Lasciate se vi va qualche commento....



venerdì 17 luglio 2015

ODI 12c - Groovy con operatore PIVOT

Vediamo come effettuare la pivot dei valori presenti in una tabella.




I dati presenti nella tabella li vogliamo inserire nella tabella indicata sotto








Quello che si ottiene è la creazione del seguente mapping:



 Se lo eseguiamo il risultato è il seguente:




giovedì 16 luglio 2015

RDBMS ORACLE - String Aggregation Techniques

Per orizzontalizzare i dati esistono differenti metodi più o meno performanti o con qualche limitazione, di seguito ne vedremo alcuni.

Per capirci supponiamo di avere una tabella cosi formata:

SELECT CUBEID,CUBESETID FROM APPO_GR_TEST;

CUBEID          CUBESETID
--------------- ----------
TEST_TAAE0250   TEST_001  
TEST_TBDE0050   TEST_001  
TEST_TBDE0060   TEST_001  
TEST_TBDE0070   TEST_001  
TEST_TBDE0080   TEST_001  
TEST_TBDE0085   TEST_001  
TEST_TBDE0090   TEST_001  
TEST_TBDE0230   TEST_001  
TEST_TBDE0270   TEST_001  
TEST_TBDE0300   TEST_001  
TEST_TBDE0310   TEST_001  
TEST_TBDE0320   TEST_001  
TEST_TBDE0400   TEST_001  
TEST_TIAA0100   TEST_001  
TEST_TIAA0200   TEST_001  
TEST_TIAA0300   TEST_001  
TEST_TIAA0400   TEST_001  
TEST_TIAA0450   TEST_001  
TEST_TIAA0500   TEST_001  


Quello che vogliamo orizzontalizzare è il contenuto del campo CUBEID magari mettendo una "," tra un cubo e l'altro. Allora possiamo utilizzare per fare questa orizzontalizzazione diverse funzioni Oracle, di seguito alcune di queste funzioni.


FUNZIONE LISTAGG

Dalla versione 11g è presente una funzione che permette di orizzontalizzare i dati che all'interno di una tabella risultano essere verticalizzati.




Allora per orizzontalizzare eseguiamo la seguente query:

SELECT LENGTH(LISTAGG(CUBEID, ',') WITHIN GROUP (ORDER BY CUBESETID)) LL,
       LISTAGG(CUBEID, ',') WITHIN GROUP (ORDER BY CUBESETID) LIST
from APPO_GR_TEST where CUBESETID='TEST_001'  ;


        LL LIST        
-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
       265 TEST_TAAE0250,TEST_TBDE0050,TEST_TBDE0060,TEST_TBDE0070,TEST_TBDE0080,TEST_TBDE0085,TEST_TBDE0090,TEST_TBDE0230,TEST_TBDE0270,TEST_TBDE0300,TEST_TBDE0310,TEST_TBDE0320,TEST_TBDE0400,TEST_TIAA0100,TEST_TIAA0200,TEST_TIAA0300,TEST_TIAA0400,TEST_TIAA0450,TEST_TIAA0500


Abbiamo ottenuto una stringa concatenata, l'unico inconveniente è però che se la lunghezza della
stringa supera i 4000 caratteri avremo un errore in quanto la funzione ritorna un VARCHAR2 e non un CLOB.

Report error -
Errore SQL: ORA-01489: Il risultato della concatenazione della stringa è troppo lungo
01489. 00000 -  "result of string concatenation is too long"
*Cause:    String concatenation result is more than the maximum size.
*Action:   Make sure that the result is less than the maximum size.


FUNZIONE WM_CONCAT

Altra funzione che possiamo utilizzare per orizzontalizzare è stata sviluppata per l'option del db chiamata OWM (Oracle Workspace Manager).
A differenza di quella indicata sopra, questa è presente in oracle dalla versione 10g però deve essere utilizzata con una group by e risulta meno performante rispetto alla precedente inoltre non è possibile modificare il carattere separatore che in questo caso è sempre ",", mentre nella funzione precedente poteva essere qualsiasi cosa.

SELECT CUBESETID, WMSYS.WM_CONCAT(CUBEID) AS LIST    
 FROM   APPO_GR_TEST    
GROUP  BY  CUBESETID;

CUBESETID    LIST      
------------ --------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
TEST_001     TEST_TAAE0250,TEST_TIAA0500,TEST_TIAA0450,TEST_TIAA0400,TEST_TIAA0300,TEST_TIAA0200,TEST_TIAA0100,TEST_TBDE0400,TEST_TBDE0320,TEST_TBDE0310,TEST_TBDE0300,TEST_TBDE0270,TEST_TBDE0230,TEST_TBDE0090,TEST_TBDE0085,TEST_TBDE0080,TEST_TBDE0070,TEST_TBDE0060,TEST_TBDE0050


FUNZIONE COLLECT

Dalla versione 10g è presente anche un'altra funzione la COLLECT che però ha un utilizzo un pò più complesso, in quanto occorre prima definire un TYPE.
Vediamo come si utilizza:

CREATE OR REPLACE TYPE varchar2_gr AS TABLE OF VARCHAR2(4000);
 

 TYPE VARCHAR2_GR compilato
 

SELECT CUBESETID, CAST(COLLECT(CUBEID) AS varchar2_gr)  AS LIST
 FROM   APPO_GR_TEST
GROUP  BY CUBESETID;

 

CUBESETID  LIST
---------- -------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------
TEST_001   WRES049.VARCHAR2_GR('TEST_TAAE0250','TEST_TIAA0500','TEST_TIAA0450','TEST_TIAA0400','TEST_TIAA0300','TEST_TIAA0200','TEST_TIAA0100','TEST_TBDE0400','TEST_TBDE0320','TEST_TBDE0310','TEST_TBDE0300','TEST_TBDE0270','TEST_TBDE0230','TEST_TBDE0090','TEST_TBDE0085','TEST_TBDE0080','TEST_TBDE0070','TEST_TBDE0060','TEST_TBDE0050')




Altre opzioni per orizzontalizzare il daro sarebbe lo sviluppo di funzioni ma questo comporta quindi l'utilizzo di funzioni non native di oracle.
Alcuni esempi li trovate qui:

https://oracle-base.com/articles/misc/string-aggregation-techniques


























mercoledì 15 luglio 2015

ODI 12c - Groovy Creare un mapping



A seguito della fusione OWB/ODI molte dei metodi SDK utilizzati per la 11g sono stati deprecati nella 12c. Questo ha portato ad una semplificazione del codice per la creazione di mapping ma ad una maggiore rigidità procedurale in quanto, l’introduzione di operatori utilizzati da OWB rende la programmazione moltro più serializzata e rigida. 
Mentre prima il paradigma era n source ed 1 target adesso l’introduzione degli operatori di OWB ha reso la creazione dei mapping più articolata portando all'interno dei mapping anche più di un target.
Nello script, di esempio, si vede come si sia semplificata la scrittura del codice ma allo stesso tempo come le operazioni da effettuare si siano serializzate.

Esempio Groovy:

//
//
// Sample Mapping SDK Code for ODI 12.1.3
//
//

import oracle.odi.domain.project.finder.IOdiProjectFinder;
import oracle.odi.domain.model.finder.IOdiDataStoreFinder;
import oracle.odi.domain.project.finder.IOdiFolderFinder;
import oracle.odi.domain.project.finder.IOdiKMFinder;
import oracle.odi.domain.mapping.finder.IMappingFinder;
import oracle.odi.domain.adapter.project.IKnowledgeModule.ProcessingType;
import oracle.odi.domain.model.OdiDataStore;
import oracle.odi.core.persistence.transaction.support.DefaultTransactionDefinition;
//
// Helper / utility function
//   set the expression on the component
def createExp(comp, tgtTable, propertyName, expressionText) {   DatastoreComponent.findAttributeForColumn(comp,tgtTable.getColumn(propertyName)).setExpressionText(expressionText)
}


//
// Delete the mapping passed in
//
def removeMapping(folder, map_name) {
...
}

//
// Find a folder within a project
//  returns the folder from the function
def find_folder(project_code, folder_name) {
 ...
  return folder
}

def basic_mapping(prj,fold, myMap) {
  

  folder = find_folder(prj,fold)
  removeMapping(folder, myMap)



  txnDef = new DefaultTransactionDefinition()
  tm = odiInstance.getTransactionManager()
  tme = odiInstance.getTransactionalEntityManager()
  txnStatus = tm.getTransaction(txnDef)

  dsf = (IOdiDataStoreFinder)tme.getFinder(OdiDataStore.class)
  mapf = (IMappingFinder) tme.getFinder(Mapping.class)

  map = new Mapping(myMap, folder)
  tme.persist(map)

  // find del OdiStore source
  boundTo_emp = dsf.findByName("COUNTRIES", "HR")
  comp_emp = new DatastoreComponent(map, boundTo_emp)


  // find del OdiStore target
  boundTo_tgtemp = dsf.findByName("TGT_COUNTRIES", "HR")
  comp_tgtemp = new DatastoreComponent(map, boundTo_tgtemp)
 

  //connessione source target
  comp_emp.connectTo(comp_tgtemp)

  createExp(comp_tgtemp, boundTo_tgtemp, "COUNTRY_ID", "
COUNTRIES.COUNTRY_ID")
  createExp(comp_tgtemp, boundTo_tgtemp, "
COUNTRY_NAME", "COUNTRIES.COUNTRY_NAME")
  ...



  // inserire qui eventuali KM da utilizzare

  ...

  tme.persist(map)
  tm.commit(txnStatus)
  return map
}


m1 = basic_mapping("IF_TEMPLATE_1_GROOVY", "First Folder", "Basic_Mapping")



Quello che si ottiene è il seguente mapping:




Per maggiori informazioni si possono consultare anche i seguenti link:



https://blogs.oracle.com/dataintegration/entry/odi_12c_mapping_sdk_the
https://blogs.oracle.com/dataintegration/entry/odi_12c_mapping_builder
https://blogs.oracle.com/dataintegration/resource/odi12c_sdk/OdiMappingBuilder.java
https://blogs.oracle.com/warehousebuilder/entry/odi_11g_interface_builder
http://www.rittmanmead.com/2014/01/rittman-mead-and-oracle-data-integrator-12c-thoughts-and-experiences-so-far/
http://www.rittmanmead.com/2013/10/oracle-data-integrator-12c-release-part-1
http://www.rittmanmead.com/2013/11/oracle-data-integrator-12c-release-part-2/
http://www.ateam-oracle.com/getting-groovy-with-odi-upgrades-and-owb-migrations/