Pour petit rappel, vous trouverez sur ce lien : sqlservergeeks.com l’explication des différents types de SCD possible à faire. Dans cet article nous parlerons du type2.

Votre dimension cible devra contenir 3 champs :

• [DMXXXX_SCD_DATE_DEBUT]
• [DMXXXX_SCD_DATE_FIN]
• [DMXXXX_SCD_FLAG_ACTIF]

Voici le résultat que cela donne en passant par l’assistant du composant :

Ci dessous voici ce que l’on a mis dans l’assistant pour le SCD de type 2: 

Le package global aura donc la forme ci dessous :

1 - il y a un update pour toutes les colonnes sauf sur la colonne qu’on étudie en SCD (afin de prendre en compte de changement de libellés par exemple) : DMXXXX_ID
2- Dans le Load il y a le SCD qui permettra d’ajouter les nouvelles lignes et d’inactiver les anciennes à une date donnée.

Cette méthodologie est possible quand la volumétrie n’est pas très importante. Si votre volumétrie est trop importante et que vous voulez garder la démarche du SCD, il faut passer en full SQL :

1- Garder la démarche du chargement d’un TMP_DMXXXX afin de préparer le chargement des différents ID, les jointures avec les dimensions…
2- Update de tous les champs sauf des champs suivants (pour prendre en compte les changement de libellés, etc) :

• DMXXXX_ID
• DMXXXX_SCD_DATE_DEBUT
• [DMXXXX_SCD_DATE_FIN]
• [DMXXXX_SCD_FLAG_ACTIF]
• DMXXXX_DATE_CREATION

Avec une requête du type :

UPDATE MAJ
SET
MAJ.[DMXXXX_LIBELLE] = TMP.XXXX_LIBELLE
,MAJ.[DMXXXX_DATE_DERN_MAJ] = TMP.XXXX_DATE_DERN_MAJ
FROM
DMXXXX MAJ INNER JOIN
(
SELECT
[DMXXXX_ID]
,DMXXXX_XXXX_ID
,[DMXXXX__LIBELLE]
FROM DMXXXX
) as SRC ON SRC.[DMXXXX_ID] = MAJ.[DMXXXX_ID]
INNER JOIN
(
SELECT
[XXXX_ID]
,[XXXX_LIBELLE]
FROM [STAGING].[dbo].TMP_DMXXXX
) as TMP ON TMP.[XXXX_ID]= SRC.[DMXXXX_XXXX_ID]
WHERE TMP.XXXX_DATE_DERN_MAJ <> SRC.DMXXXX_XXXX_DATE_DERN_MAJ

3- Ensuite on insert les nouvelles lignes c’est-à-dire les lignes qui ont une ID nouveau. En initialisant les champs suivants :

Dans le derived column voici ce que l’on a ajouté :

4- on insert ensuite les lignes qui ont un même Id (XXXX_ID) et un XXXX_monchamp (le champ sur lequel je souhaite faire mon historisation) différent. (le data flux reste le même que dans le 3- avec une jointure en plus au niveau du lookup pour récupérer juste les lignes qui ont le même ID métier et un ID du champ à historiser différents. Dans le derived column voici les infos qu’on y a mises :

5 -Et ensuite il faut desactiver les enregistrements les plus anciens avec une requête du type :

UPDATE MAJ
SET
MAJ.DMXXXX_SCD_FLAG_ACTIF = 0,
MAJ.DMXXXX_SCD_DATE_FIN = GETDATE()
FROM
DMXXXX MAJ INNER JOIN
(
SELECT
k.DMXXXX_XXXX_ID,
MIN(k.DMXXXX_SCD_DATE_DEBUT) as DMXXXX_SCD_DATE_DEBUT
FROM DMXXXX k
WHERE EXISTS (
SELECT
t.DMXXXX_XXXX_ID
FROM
(
SELECT
DMXXXX_XXXX_ID,
DMXXXX_SCD_FLAG_ACTIF ,
COUNT(*) as nb
FROM DMXXXX
WHERE  DMXXXX_SCD_FLAG_ACTIF = 1
GROUP BY
DMXXXX_XXXX_ID,
DMXXXX_SCD_FLAG_ACTIF
having count(*)>1
) as t
WHERE t.DMXXXX_XXXX_ID = k.DMXXXX_XXXX_ID
)
GROUP BY
k.DMXXXX_XXXX_ID
)  as tb_finale ON tb_finale.DMXXXX_XXXX_ID = MAJ.DMXXXX_XXXX_ID
and tb_finale.DMXXXX_SCD_DATE_DEBUT = MAJ.DMXXXX_SCD_DATE_DEBUT

Et vous, comment faites vous vos chargements de dimensions?

• un exemple pour comprendre comment fonctionne le binary_checksum

• un article sur msdn qui confirme que cette méthode n’est pas fiable à tous les coups :

“BINARY_CHECKSUM(*), calculé à partir de n’importe quelle ligne d’une table, retourne la même valeur tant que la ligne ne subit aucune modification. BINARY_CHECKSUM(*) retourne une valeur différente pour la plupart des modifications apportées à la ligne (mais pas pour toutes) et permet de détecter la plupart des modifications.”

• un article sur un blog qui résume bien la situation : qu’il ne faut pas utiliser binary_checksum mais plutôt la fonction hashbytes (fonction moins performante que le binary_checksum et plus lourde à mettre en place)

• vous trouverez dans cet article un exemple d’utilisation du hashbytes qui confirme que l’utilisation n’a pas l’air très simple pour arriver à un résultat qui fonctionne à tous les coups

Conclusion nous avons enlever l’utilisation du binary_checksum pour passer à un update classique basé sur :

• une date de mise à jour
• et sur l’ID unique que l’application nous fournissait

Les performances restent correctes.

Si vous avez eu une expérience binary_checksum ou encore hashbytes n’hésitez pas à la partager avec nous!

]]> http://infodecisionnel.com/sql/binary_checksum-lennemi-du-decisionnel/feed/ http://infodecisionnel.com/sql/binary_checksum-lennemi-du-decisionnel/ http://feedproxy.google.com/~r/biexperience/~3/uf3ApCNMhKQ/ http://infodecisionnel.com/microsoft/odbc-ole-db-ado-et-adonet-ca-vous-parle/#comments Thu, 12 Apr 2012 22:03:51 +0000 maryam khiali http://infodecisionnel.com/?p=1710 Nous avons plusieurs types de connexion à la base de données. Mais quelle est la différence entre ces différents types? Et comment choisir le type de connexion dont nous avons besoin?

Tout d’abord voici un bref récapitulatif de leur apparition :

• 1992 : création de l’ODBC
• 1996 : création de l’OLE DB et de l’ADO
• 2002 : création d’ADO.NET

Définitions :

ODBC : (Open Database Connectivity) est une interface de programmation d’application (API) universelle qui permet de se connecter à des bases de données  ayant obligatoirement l’apparence d’une base de données relationnelle. Les données non structurées ne pourront donc pas être traitées avec de l’ODBC.

Caractéristiques générales :

• performant
• codage avec l’API ODBC difficile
• moins robuste que l’ADO par exemple

Son mode de fonctionnement est assez simple : l’API ODBC employé par une application va faire appel à un gestionnaire de drivers qui va lui même appeler le bon driver afin de récupérer le résultat de la demande envoyée par l’application.

OLE DB et ADO:

• l’OLE DB qui est un fournisseur de données aussi bien sur les bases de données relationnels que non relationnelles
• et l’ADO une surcouche entre l’OLE DB et l’application. L’ADO (ActiveX Data Object) encapsule et rend virtuellement accessibles toutes les fonctionnalités de OLE DB.

l’OLE DB et l’ADO sont basés sur COM (Component Object Model : application binary interface ). Ces interfaces, permettent le dialogue entre différents programmes.

Grâce au framework COM, les développeurs bénéficient d’un support riche et homogène de fonctionnalités de conception d’accès aux données dans  tous les langages Microsoft de développement :  (VB, C++, VBScript, J++…)

Le tandem OLEDB et ADO  propose donc une combinaison :

• performante
• codage facile pour les développeurs
• robuste

ADO.NET (ActiveX Data Objects for .NET):

Comme vous le savez surment le framework COM est voué à disparaitre au profit de FRAMEWORK.NET.

A partir de là Microsoft a développé l’ADO.NET. Il regroupe à la fois le fournisseur de données et la surcouche permettant l’accès aux résultats du fournisseur de données. Ce nouveau framework corrige plusieurs problématiques que les développeurs rencontraient lors de développements avec ADO. Je vous laisse voir ces évolutions sur developpez.com

Pour conclure plusieurs sources laissent à croire que l’OLE DB et l’ADO sont voués à disparaitre au profit de l’ADO.NET.

Du coup pensez y pour vos prochains développements!!

Il se trouve que SSAS a un bug qui ne nous permet pas de toujours agir dans ce sens.

Si l’on construit, par exemple, une dimension avec comme clef incrémentale, propre au système décisionnel, une IDENTITY(1,1) tinyint, cette dernière ne pourra pas être reliée correctement lors de la construction du cube dans SSAS :

“This causes problems when attempting to define FK relationships between this column and related FK columns in toher tables in the DSV.” (voir dans cet article)

En effet dans la dimension, l’ID incrémental tinyint sera converti en int et dans la table de fait vous aurez un tinyint non incrémental et du coup SSAS n’arrivera pas à les lier.

La solution que certain conseille est de créer des vues en faisant un CAST sur l’ID en question. Mais je ne sais pas si maintenir de genre de vue est bien à recommander.

Pour SQL Server 2012, malheureusement, le bug reste entier! voir sur ce lien

Petit historique :

Microsoft propose donc l’exploitation de 3 outils : Powerpivot, cube OLAP, modèle tabulaire. Mais dans quel cas utiliser l’un ou l’autre?

La BI Personnelle :

Si les utilisateurs finaux ont besoin de croiser des données (pour un volume allant jusqu’à 4Go) mais qu’ils n’ont pas de budget ni le temps de lancer un projet informatique, l’outil PowerPivot est la solution. L’utilisateur pourra télécharger gratuitement un addin pour Excel ou s’il a Sharepoint, utiliser Excel Services pour le faire (en installant powerpivot for sharepoint). Grâce au moteur Vertipaq, des données chargées dans un fichier Excel seront montées en mémoire. L’utilisateur fonctionnel aura ensuite accès aux fonctionnalités d’Excel et plus avec le langage DAX.

La version 2012 de powerPivot a certaines fonctionnalités en plus, notamment le fait de pouvoir faire:

• des mesures calculés
• des hiérarchies (juste au niveau de la représentation des données donc moins puissant que dans AS)
• des KPI

La BI d’Entreprise :

Pour une exploitation des données plus sécurisé, plus contrôlé, plus robuste un projet  de type BI d’entreprise pourra être mis en place.

2 possibilités s’offrent à nous :

• mettre en place des cubes multidimensionnels avec l’exploitation du langage MDX
• mettre en place des modèles tabulaires avec l’exploitation du langage DAX.

Le cube multidimensionnel :

Tout d’abord il faut savoir que les cubes AS ont un stockage physique et une mise en cache. Ce système peut accueillir des Téras de données. Cette technologie permet de gérer des navigations dans les données complexes et répond à des demandes intenses d’ aggrégations de  chiffres.

Exemple : j’ai un plan comptable. Certains indicateurs s’additionnent, d’autres se soustraits et d’autres ne sont pas pris en compte (Le parent n’est pas forcement la somme des enfants. Le petit nom anglais : CustomRollup, UnaryOperations). L’agrégation des données pourra donc être très précise et paramétrée. De plus on pourra donner aux utilisateurs la possibilité d’ écrire directement dans le cube (writeBack) pour faire des simulations. D’autres fonctionnalités singulières au cube AS : Default Members, NameSets, Scope Assignments, relations plusieurs à plusieurs vous feront pencher vers l’utilisation d’un cube multidimentionnel.

Le modèle tabulaire :

Concernant la couche sémantique BISM ou autrement dit le modèle tabulaire, si vous avez des contraintes de temps pour le développement un peu court, que le volume de données ne dépassent pas une centaine de giga, que les utilisateurs ne connaissent pas bien leur chemin d’analyse, cette technologie vous conviendra.

Cette technologie sera beaucoup plus performante pour les demandes de chiffres sur une granularité fine par les utilisateurs. En effet le cube AS sera plus performant sur des demandes d’aggrégations et beaucoup moins performant quand l’utilisateur voudra aller dans le détail de l’information. C’est dans ces cas d’utilisation que le modèle tabulaire prendra tout son sens.

Monter un modèle tabulaire ressemble au montage d’un powerpivot.

Ce modèle propose un partitionnement (même si le stockage des données se fait en mémoire vive) car un modèle tabulaire se process comme un cube multidimensionnel. On pourra mettre en place une sécurité comme sur AS mais en un peu moins poussée. Les démarches de développement sont sensiblements pareil au développement d’un cube AS.

Et il ne faut pas oublié que le modèle tabulaire peut être la source de l’outil powerView dans Sharepoint  qui permet de faire des jolis dashboards  et sur un powerPoint de continuer à naviguer dans les données même après export de sharepoint.

J’espère avoir bien retransmis ce que j’ai pu apprendre lors de cette session des techdays. J’attends vos retours!

Première chose à faire : poser certaines questions au client :

• Les informations NLS_DATABASE_PARAMETERS : pour construire l’instance Oracle avec les bonnes infomations de NLS_CHARACTERSET et de NLS_NCHAR_CHARACTERSET (SELECT * FROM NLS_DATABASE_PARAMETERS)
  
• Les users utilisés
  
• Les rôles utilisés et les droits de chacun
• La liste des tablespaces que pourrez avoir à recréer à la main
  
• Le type d’export qui a été fait ( car il en existe 2 qui sont gérés de manières différentes : exp, expdp
  
• L’espace disque utilisé car un backup peut faire une taille X mais quand il est déployé sa taille peut doubler voir trippler avec les tablespaces par exemple.

Après avoir créé votre instance Oracle et après avoir prévu la place nécessaire, ouvrez un fenêtre “cmd” :

Pour accéder en ligne de commande à votre instance vous pouvez taper :

C:\>sqlplus “/ as sysdba”

A partir de la vous allez pouvoir créer un user :

CREATE USER monUser IDENTIFIED BY motDePasse;

Ensuit créer un rôle pour votre user :

CREATE role monRole;

GRANT CREATE cluster, create sequence , create synonym, create table, create view, create procedure, create trigger, CREATE public synonym, drop public synonym, create role, create any synonym, drop any synonym, drop any materialized view to monRole;

Et on affecte monUser à monRole :
GRANT unlimited tablespace, monRole to monUser;

Pour créer les tablespaces :

CREATE TABLESPACE USER_DATA DATAFILE ‘F:\dump\user_data.dbf’ SIZE 210m AUTOEXTEND ON NEXT 210;

Pour l’import 2 possiblités :

1) imp userid=monUser  file=C:\Users\Administrateur\Desktop\monDump.dmp FULL=Y log=C:\log.log;

2) CREATE DIRECTORY mondirectory AS ‘F:\dump’;

impdp monUser/motDePasse full=Y directory=mondirectory dumpfile=monDump.dmp

Problème de droit? Vous pouvez exécuter cette requête dans SQL Oracle développer, pendre le résultat et l’exécuter :

Select ‘GRANT SELECT ,INSERT,UPDATE,DELETE ON  ‘ || TABLE_NAME || ‘  TO UCPA_DEV;’ FROM USER_TABLES
Select ‘CREATE PUBLIC SYNONYM  ‘ || TABLE_NAME || ‘  FOR  ‘ || TABLE_NAME || ‘;’ FROM USER_TABLES

Un problème que j’ai rencontré :

lors du chargement d’un DUMP les vues matérialisées ont été chargées comme des tables.

Je n’ai pas encore tout compris sur Oracle mais ces petites commandes m’ont permis de mener à bien le chargement de mon DUMP client.

Si vous aussi vous avez  des astuces à nous transmettre, n’hésitez pas, commentez!

contexte :

• Il y a une machine1 avec sql server d’installé sur du windows 2008 64 bits
• Il y a une machine2 avec la base de données oracle d’installé sur du windows 2008 64 bits

première étape télécharger les drivers oracle : les clients oracle.

Astuce 1 : le site d’Oracle est horrible dès que l’on veut trouver quelque chose c’est comme si on cherchait une aiguille dans une botte de foin. Donc voici les liens de télechargement du client 32bits et du clients 64 bits

Astuce 2 : il faudra installer les deux et respecter bien l’ordre d’installation : client 32 bits puis client 64 bits.

Astuce 3 :malgré le fait que nous soyons sur du 64 bits SSIS pour se connecter ira regarder le client 32 bits. Donc il faudra configurer les listener.ora et tnsname.ora pour les deux clients 64 bits et 32 bits.

Après avoir configurer vos fichiers dans répertoire Oracle>product>NETWORK>ADMIN>clien_X

vous pourrez vérifier votre accès à la base de données en ouvrant une fenêtre cmd et en tapant tnsping servicename.

exemple : tnsping orcl

si cela fonctionne vous pourrez dans SSIS utiliser les providers suivants sans problème:

• Microsoft DB provider for oracle
• Oracle provider for OLEDB

En espérant que ce post évite à quelqu’un de perdre trop de temps sur ce genre de problématique, j’attends votre opinion sur la chose…N’hésitez pas commentez!

A la suite de ce témoignage un journaliste nous a  interviewé moi et mon équipe et voici les 2 articles publiés :

• sur  : cio-online.com
• et sur lemondeinformatique.fr

C’est vraiment une bonne conclusion à mon projet avant de partir vers de nouveaux horizons.

Ce site : mareussite.com, vous permettra de faire un bilan sur vous même. Quatre tests sont proposés :

• Test personnalité permet de vous expliquer  “le pourquoi et le comment de chacune de vos tendances”
• Réussir au travail mettra en exergue ” la manière dont votre personnalité s’exprime sur le plan professionnel : votre façon de travailler, de prendre des décisions, de gérer votre temps”
• Trouver sa voie vous permettra de comprendre ” ce qui vous motive au travail, choisir sa carrière en fonction de votre personnalité, de construire un plan d’action”
• Savoir rebondir vous permettra d’être plus “performant dans vos recherches d’emploi, de valoriser votre candidature, comprendre vos réactions face à cette période de transition”

Si vous besoin de vous rassurer par rapport à votre parcours, votre carrière n’hésitez pas!

Grâce au code partenaire présent sur cette page . Vous pourrez avoir le test de personnalité gratuit. Le reste est payant.

J’attends vos commentaires sur cet outil!

Je vous propose dans ce post de détailler la démarche que nous avons adoptée pour l‘alimentation de notre infocentre : copie des différentes bases de données de la société à partir desquelles le datawarehouse est alimenté.

Un simple job sera réalisé pour amener les données d’une base de données source vers une base de données cible :

Voici l’option en question que vous pourrez utiliser dans votre input:

Et si vous avez des règles de gestion à ajouter n’hésitez pas avec le tJavaFlex :

/**l’exemple de traitement en plus lisible…**/
for(int i = 0; i < row3.dyn_Col.metadatas.size(); i++) { row3.dyn_Col.metadatas.get(i).setName(row3.dyn_Col.metadatas.get(i).getName().toLowerCase());
}

Ce job, décrit ci-dessus, est appelé par un job père qui lui donne le contexte contenant le nom de la table courante à migrer :

Une variable de context est passée au sous job (monsousjobcopie) : my_current_table

L’input requête sur une table de paramétrage. En effet nous n’avons pas forcement besoin de toutes les tables de toutes les bases de données. Donc à travers une table de paramétrage nous choisisson celle que l’on veut migrer :

Ce job père appelle aussi un autre sous job qui lui va permettre de migrer les indexes :

Donc pour chaque table on fera un appel à une routine (code qu’il y a dans le tJava):

routines.IndexMigrer.migrate_index(((java.sql.Connection)globalMap.get(”conn_tMSSqlConnection_2″)), ((String)globalMap.get(”current_TABLE.nom_table”)), ((java.sql.Connection)globalMap.get(”conn_tPostgresqlConnection_4″)),context.Cible_Schema + (String)globalMap.get(”schema”) + “.” +
((String)globalMap.get(”current_TABLE.nom_table”)));

Et en bonus voici la routine que nous avons créés qui selon la base de données (Oracle, Posgres, SQL Server 2000 ou SQL Server 2005) va requêter dans la bonne table système :

/***************Routines migration indexes ************************/

public class IndexMigrer {
public static void migrate_index(Connection org_connect, String org_nomtable,
Connection dest_connect, String dest_nomtable)  throws java.sql.SQLException
{
if(org_connect.getMetaData().getDatabaseProductName().equalsIgnoreCase(”Microsoft SQL Server“) )
{
Statement stat = org_connect.createStatement();
ResultSet rs;
if(org_connect.getMetaData().getDatabaseMajorVersion()==9)
{
rs=stat.executeQuery(”SELECT IDX.name as index_name, COL.name as column_name FROM sys.index_columns IDXC”
+” INNER JOIN sys.objects OBJ”
+” ON IDXC.object_id = OBJ.object_id”
+” INNER JOIN sys.schemas SCH”
+” ON SCH.schema_id = OBJ.schema_id”
+” INNER JOIN sys.indexes IDX”
+” ON (IDXC.object_id = IDX.object_id AND IDXC.index_id = IDX.index_id)”
+” INNER JOIN sys.columns COL”
+” ON (IDXC.column_id = COL.column_id AND OBJ.object_id = COL.object_id)”
+” where OBJ.name=\’”+org_nomtable+”\’”
+” ORDER BY OBJ.name” );
}
else
{
rs=stat.executeQuery(”select i.name as index_name,c.name as column_name”
+” from sysindexkeys as indk”
+” inner join sysindexes as i on”
+” (indk.indid=i.indid and indk.id=i.id )”
+” inner join syscolumns as c on”
+” (indk.colid=c.colid and indk.id=c.id )”
+” inner join sysobjects as o on”
+” (indk.id=o.id)”
+” and o.name=\’”+org_nomtable+”\’ ”
+” ORDER BY o.name” );
}
Map m =new HashMap();
Map m_key=new HashMap();
while(rs.next())
{
if(!m.containsKey(rs.getString(1)))
{
List l = new ArrayList();
l.add(rs.getString(2));
m.put(rs.getString(1),l);
m_key.put(rs.getString(1), rs.getString(1));
}
else if(m.containsKey(rs.getString(1)))
{
List l=(List)m.get(rs.getString(1));
l.add(rs.getString(2));
m.put(rs.getString(1),l);
}
}
StringBuffer sb=new StringBuffer();
for (Iterator i = m.keySet().iterator() ; i.hasNext();){
String key = (String)i.next();
sb.append(”CREATE INDEX “);
sb.append(”IDX_”+key);
sb.append(” ON “+dest_nomtable+” (”);
List l=(List)m.get(key);
for(int j=0;j<l.size();j++)
{
sb.append(l.get(j));
if(j!=l.size()-1)
sb.append(”,”);
}
sb.append(”);\n”);
}
try{
Statement bla=dest_connect.createStatement();
System.out.println(”"+sb.toString());
bla.execute(sb.toString());
}
catch (java.sql.SQLException e)
{
//System.out.println(dest_nomtable);
System.out.println(e.getMessage());
}
dest_connect.commit();
//System.out.println(dest_nomtable);
}
if(org_connect.getMetaData().getDatabaseProductName().equalsIgnoreCase(”PostgreSQL“))
{
Statement stat = org_connect.createStatement();
ResultSet rs=stat.executeQuery(”SELECT indkey as colonne_index,pci.relname as nom_index,pct.relname as nom_table from pg_index as pi”
+” , pg_class as pci, pg_class as pct ”
+” where pci.oid=pi.indexrelid”
+” and pct.oid=pi.indrelid and pct.relname  not like ‘pg_%’ and pct.relname=’”+org_nomtable+”‘ ” );
while( rs.next())
{
String s=rs.getString(1);
java.util.StringTokenizer tokenizer = new java.util.StringTokenizer(s, ” “);
List <Integer> num_columns=new ArrayList();
while ( tokenizer.hasMoreTokens() ) {
num_columns.add(Integer.parseInt(tokenizer.nextToken()));
}
Statement sel=org_connect.createStatement();
ResultSet rsset=sel.executeQuery(”SELECT * from “+org_nomtable+” LIMIT 1″);
StringBuffer sb=new StringBuffer();
sb.append(”CREATE INDEX “+rs.getString(2)+” ON “+dest_nomtable+” (” );
Iterator i=num_columns.iterator();
while(i.hasNext())
{
sb.append(rsset.getMetaData().getColumnLabel((Integer)i.next()));
if(i.hasNext())
sb.append(”,”);
}
sb.append(”) ;\n”);
Statement bla=dest_connect.createStatement();
bla.execute(sb.toString());
dest_connect.commit();
bla.close();

}
}
if(org_connect.getMetaData().getDatabaseProductName().equalsIgnoreCase(”Oracle“))
{
Statement stat = org_connect.createStatement();
ResultSet rs=stat.executeQuery(”SELECT col.index_name,col.column_name FROM all_indexes cons INNER JOIN all_ind_columns col ON cons.owner = col.index_owner AND cons.index_name = col.index_name WHERE OWNER = ‘AEFE’ AND cons.table_name=\’”+org_nomtable+”\’” );
Map m =new HashMap();
Map m_key=new HashMap();
while(rs.next())
{
if(!m.containsKey(rs.getString(1)))
{
List l = new ArrayList();
l.add(rs.getString(2));
m.put(rs.getString(1),l);
m_key.put(rs.getString(1), rs.getString(1));
}
else if(m.containsKey(rs.getString(1)))
{
List l=(List)m.get(rs.getString(1));
l.add(rs.getString(2));
m.put(rs.getString(1),l);
}
}
StringBuffer sb=new StringBuffer();
for (Iterator i = m.keySet().iterator() ; i.hasNext();){
String key = (String)i.next();
sb.append(”CREATE INDEX “);
sb.append(”IDX_”+key);
sb.append(” ON “+dest_nomtable+” (”);
List l=(List)m.get(key);
for(int j=0;j<l.size();j++)
{
sb.append(l.get(j));
if(j!=l.size()-1)
sb.append(”,”);
}
sb.append(”);\n”);
}
Statement bla=dest_connect.createStatement();
System.out.println(”"+sb.toString());
bla.execute(sb.toString());
dest_connect.commit();

}}}

Très important, si un problème de typage persiste n’hésitez pas à modifier les fichiers de mapping dans :

Ces fichiers sont utiles et simples à utiliser puisqu’ils permettent de connaitre les transformations de typage. En gros voici comment procède Talend :

typage BDD source => typage JAVA => typage BDD cible

Exemple d’utilisation :

ma base de données source est SQL server et ma base de données cible est postgres  :

La démarche sera donc d’aller dans  MSSQL_mapping.xml  et de regarder la rubrique : <dbToTalendTypes> pour voir en quel type Java les typages de ma base de données MSSQL seront transformés. Ensuite il faudra regarder dans postgres_mapping.xml pour regarder les typages par défault que propose Talend dans la rubrique  <talendToDbTypes> pour la retransformation des types JAVA en typages postgres.

Vous pourrez ainsi personnaliser ces transformations.

Si ces fichiers sont modifiés il faudra bien sur les répercutés sur tous les clients  TIS  et sur le serveur  dans les workspaces dans:

• .JAVA > src > xmlMappings
• et dans .JAVA > classes > xmlMappings

J’espère que ce post vous aura permis de voir les possibilités qu’offrent la solution Talend pour ce genre de besoin.

N’hésitez pas à poster pour donner votre opinion!