Java > Open Source Codes > com > knowgate > datacopy > DataStruct


1 /*
2   Copyright (C) 2003 Know Gate S.L. All rights reserved.
3                       C/O�a, 107 1�2 28050 Madrid (Spain)
4
5   Redistribution and use in source and binary forms, with or without
6   modification, are permitted provided that the following conditions
7   are met:
8
9   1. Redistributions of source code must retain the above copyright
10      notice, this list of conditions and the following disclaimer.
11
12   2. The end-user documentation included with the redistribution,
13      if any, must include the following acknowledgment:
14      "This product includes software parts from hipergate
15      (http://www.hipergate.org/)."
16      Alternately, this acknowledgment may appear in the software itself,
17      if and wherever such third-party acknowledgments normally appear.
18
19   3. The name hipergate must not be used to endorse or promote products
20      derived from this software without prior written permission.
21      Products derived from this software may not be called hipergate,
22      nor may hipergate appear in their name, without prior written
23      permission.
24
25   This library is distributed in the hope that it will be useful,
26   but WITHOUT ANY WARRANTY; without even the implied warranty of
27   MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.
28
29   You should have received a copy of hipergate License with this code;
30   if not, visit http://www.hipergate.org or mail to info@hipergate.org
31 */
32
33 package com.knowgate.datacopy;
34
35 import java.sql.DriverManager ;
36 import java.sql.Connection ;
37 import java.sql.Timestamp ;
38 import java.sql.SQLException ;
39 import java.sql.CallableStatement ;
40 import java.sql.Statement ;
41 import java.sql.PreparedStatement ;
42 import java.sql.ResultSet ;
43 import java.sql.ResultSetMetaData ;
44
45 import java.io.IOException ;
46 import java.io.File ;
47 import java.io.FileReader ;
48 import java.io.BufferedReader ;
49 import java.io.StringBufferInputStream ;
50 import java.io.FileInputStream ;
51 import java.io.FileWriter ;
52 import java.io.StringReader ;
53
54 import java.lang.ArrayIndexOutOfBoundsException ;
55 import java.lang.ClassNotFoundException ;
56 import java.math.BigDecimal ;
57 import java.util.Vector ;
58 import java.util.LinkedList ;
59 import java.util.ListIterator ;
60 import java.util.HashMap ;
61 import java.util.Properties ;
62 import java.util.Enumeration ;
63 import java.util.Set ;
64 import java.util.Iterator ;
65 import org.xml.sax.*;
66 import org.xml.sax.helpers.*;
67
68 import org.apache.oro.text.regex.*;
69
70 import com.knowgate.debug.DebugFile;
71
72 /**
73  * <p>Copier for Complex Data Structures stored at database.</p>
74  * This is not a general purpose module, but a custom class tailored to the
75  * design constraints of hipergate standard datamodel.
76  * @author Sergio Montoro Ten
77  * @version 0.6 alpha
78  */
79 public class DataStruct extends DefaultHandler implements ContentHandler {
80
81   public DataStruct() {
82     initMembers();
83   } // DataStruct()
84
85   // ----------------------------------------------------------
86
87   public DataStruct(String sPathXMLFile) throws ClassNotFoundException , IllegalAccessException , InstantiationException , IOException , SAXException {
88     initMembers();
89     parse(sPathXMLFile);
90   } // DataStruct()
91
92   // ----------------------------------------------------------
93
94   public DataStruct(String sPathXMLFile, Properties oProps) throws ClassNotFoundException , IllegalAccessException , InstantiationException , IOException , SAXException {
95     initMembers();
96     parse(sPathXMLFile, oProps);
97   } // DataStruct()
98
99   // ----------------------------------------------------------
100
101   private void initMembers() {
102     // Cuenta de tablas en la estructura de datos
103 cTables = 0;
104
105     // Indicador de si est�n los cursores preparados
106 bOrPrepared = false;
107     bTrPrepared = false;
108
109     // Indicador de estado de las conexiones { DISCONNECTED, CONNECTED, REFERENCED }
110 iTrStatus = iOrStatus = DISCONNECTED;
111
112     // Vector para los DataRowSets
113 DataRowSets = new Vector ();
114     // Vector de HashMaps con mapeos de nombres de campos
115 FieldMaps = new Vector ();
116     // Vector de HashMaps con valores por defecto para campos que no existan en Origen
117 FieldDefs = new Vector ();
118     // Transformaciones de datos para reemplazo de nulos y nuevos valores
119 Transformations = new Vector ();
120     // Vector con acciones para efectuar antes de empezar la copia de cada Rowset
121 Before = new Vector ();
122     // Vector con acciones para efectuar despu�s de terminar la copia de cada Rowset
123 After = new Vector ();
124     // Mapeo entre valores GUID en origen y campos autonum�ricos en destino
125 // GuidToIdentityMap = new HashMap(103);
126 } // initMembers()
127
128   // ----------------------------------------------------------
129
130   public void setAutoCommit(boolean bAutoCommit) throws SQLException {
131     oTrConn.setAutoCommit(bAutoCommit);
132   }
133
134   // ----------------------------------------------------------
135
136   public void commit() throws SQLException {
137     oTrConn.commit();
138   }
139
140   // ----------------------------------------------------------
141
142   public void rollback() throws SQLException {
143     oTrConn.rollback();
144   }
145
146
147   // ----------------------------------------------------------
148
149   public void connectOrigin(String sDriver, String sURL, String sUsr, String sPwd, String sSchema) throws SQLException ,ClassNotFoundException {
150     // Conecta la conexi�n Origen
151 if (DebugFile.trace) DebugFile.writeln ("Begin DataStruct.connectOrigin(" + sDriver + "," + sURL + "," + sUsr + "," + sPwd + ")");
152
153     // Carga el driver JDBC
154 Class oDriver = Class.forName(sDriver);
155
156     if (DebugFile.trace) DebugFile.writeln (" " + sDriver + " JDBC driver loaded");
157
158     oOrConn = DriverManager.getConnection(sURL, sUsr, sPwd);
159     iOrStatus = CONNECTED;
160
161     if (DebugFile.trace) DebugFile.writeln ("End DataStruct.connectOrigin()");
162   } // connectOrigin()
163
164   // ----------------------------------------------------------
165
166   public void connectTarget(String sDriver, String sURL, String sUsr, String sPwd, String sSchema) throws SQLException ,ClassNotFoundException {
167     // Conecta la conexi�n Destino
168 if (DebugFile.trace) DebugFile.writeln ("Begin DataStruct.connectTarget(" + sDriver + "," + sURL + "," + sUsr + "," + sPwd + ")");
169
170     // Carga el driver JDBC
171 Class oDriver = Class.forName(sDriver);
172
173     if (DebugFile.trace) DebugFile.writeln (" " + sDriver + " JDBC driver loaded");
174
175     oTrConn = DriverManager.getConnection(sURL, sUsr, sPwd);
176     iTrStatus = CONNECTED;
177
178     if (DebugFile.trace) DebugFile.writeln ("End DataStruct.connectTarget()");
179   }
180
181   // ----------------------------------------------------------
182
183   public Connection getOriginConnection() {
184     return oOrConn;
185   }
186
187   // ----------------------------------------------------------
188
189   public Connection getTargetConnection() {
190     return oTrConn;
191   }
192
193   // ----------------------------------------------------------
194
195   public void setOriginConnection(Connection oConn) {
196     // Establece una referencia a una conexi�n Origen ya existente
197 oOrConn = oConn;
198     iOrStatus = REFERENCED;
199   }
200
201   // ----------------------------------------------------------
202
203   public void setTargetConnection(Connection oConn) {
204     // Establece una referencia a una conexi�n Destino ya existente
205 oTrConn = oConn;
206     iTrStatus = REFERENCED;
207   }
208
209   // ----------------------------------------------------------
210
211   public void clear() throws SQLException {
212     // Limpia todas las estructuras internas de datos del DataStruct
213 int t;
214
215     if (DebugFile.trace) DebugFile.writeln ("Begin DataStruct.clear()");
216
217     if (bOrPrepared) {
218       for (t=0; t<cTables; t++) {
219         if (null!=OrStatements[t]) OrStatements[t].close();
220         OrStatements[t] = null;
221         if (null!=UpStatements[t]) UpStatements[t].close();
222         UpStatements[t] = null;
223       }
224       OrMetaData = null;
225       bOrPrepared = false;
226     }
227
228     if (bTrPrepared) {
229       for (t=0; t<cTables; t++) {
230         if (null!=TrStatements[t]) TrStatements[t].close();
231         TrStatements[t] = null;
232         if (null!=DlStatements[t]) DlStatements[t].close();
233         DlStatements[t] = null;
234       }
235       TrMetaData = null;
236       bTrPrepared = false;
237     }
238
239     // Cuenta de tablas en la estructura de datos
240 cTables = 0;
241
242     if (null!=After) After.clear();
243     if (null!=Before) Before.clear();
244     if (null!=Transformations) Transformations.clear();
245     if (null!=FieldDefs) FieldDefs.clear();
246     if (null!=FieldMaps) FieldMaps.clear();
247     if (null!=DataRowSets) DataRowSets.clear();
248
249     if (DebugFile.trace) DebugFile.writeln ("End DataStruct.clear()");
250
251   } // clear()
252
253   // ----------------------------------------------------------
254
255   public void disconnectAll() throws SQLException {
256     // Cierra todos los cursores y las conexiones
257 int t;
258
259     if (DebugFile.trace) DebugFile.writeln ("Begin DataStruct.disconnectAll()");
260
261     clear();
262
263     // S�lo hay que cerrar las conexiones si no son referencias externas
264 if (CONNECTED==iOrStatus) { oOrConn.close(); iOrStatus=DISCONNECTED; }
265     if (CONNECTED==iTrStatus) { oTrConn.close(); iTrStatus=DISCONNECTED; }
266
267     if (DebugFile.trace) DebugFile.writeln ("End DataStruct.disconnectAll()");
268   } // close()
269
270   // ----------------------------------------------------------
271
272   protected DataRowSet getRowSet(int i) {
273     return (DataRowSet) DataRowSets.get(i);
274   }
275
276   // ----------------------------------------------------------
277
278   protected Object getResult(int iRow, int iCol) {
279     return ((Vector ) oResults.get(iRow)).get(iCol);
280   }
281
282   // ----------------------------------------------------------
283
284   private boolean isEmpty(String sStr) {
285     // Devuelve true si sStr=="" � sStr==null
286 if (null==sStr)
287       return true;
288     else if (0==sStr.length())
289       return true;
290     else
291       return false;
292   } // isEmpty()
293
294   // ----------------------------------------------------------
295
296   protected void execCommands(String sTime, int iTable, Object PK[], int cParams)
297       throws SQLException ,NullPointerException {
298     // Ejecuta los comandos <INIT>, <TERM>, <BEFORE> o <AFTER> definidos para este DataStruct
299 CallableStatement oCall;
300     Statement oStmt;
301     ResultSet rCount;
302     int cAffected;
303     String sSQL;
304     String sTable;
305     ListIterator oIter;
306
307     if (DebugFile.trace) {
308       if (iTable!=-1)
309         sTable = getRowSet(iTable).OriginTable;
310       else
311         sTable = "";
312       DebugFile.writeln ("Begin DataStruct.execCommands(" + sTime + ", " + sTable + ", ..., " + String.valueOf(cParams) + ")");
313       DebugFile.incIdent();
314     }
315
316     // Seleccionar el iterador para la lista adecudada de comandos
317 if (-1==iTable) {
318       if (sTime.equals("INIT")) {
319         if (null==InitStmts)
320           throw new NullPointerException ("DataStruct.execCommands() InitStmts list not initialized");
321         oIter = InitStmts.listIterator();
322       } else {
323         if (null==TermStmts)
324           throw new NullPointerException ("DataStruct.execCommands() TermStmts list not initialized");
325         oIter = TermStmts.listIterator();
326       }
327     }
328     else {
329       if (sTime.equals("BEFORE"))
330         oIter = ((LinkedList )Before.get(iTable)).listIterator();
331       else
332         oIter = ((LinkedList )After.get(iTable)).listIterator();
333     }
334
335     while (oIter.hasNext()) {
336       sSQL = oIter.next().toString();
337
338       // Si el SQL empieza por "{" entonces se ejecuta como un procedimiento almacenado
339 if (sSQL.startsWith("{") || sSQL.startsWith("k_sp")) {
340         if (DebugFile.trace) DebugFile.writeln ("Connection.prepareCall(" + sSQL + ")");
341         oCall = oTrConn.prepareCall(sSQL);
342         for (int p=0; p<cParams; p++) {
343           if (DebugFile.trace) DebugFile.writeln ("CallableStatement.setObject(" + String.valueOf(p+1) + "," + PK[p].toString() + ")");
344           oCall.setObject(p+1, PK[p]);
345         } // next (p)
346 if (DebugFile.trace) DebugFile.writeln ("Connection.execute(" + sSQL + ")");
347         oCall.execute();
348         oCall.close();
349         oCall = null;
350       }
351       // Si el SQL NO empieza por "{" entonces se ejecuta como un comando sin ResultSet de vuelta
352 else {
353         oStmt = oTrConn.createStatement();
354         if (DebugFile.trace) DebugFile.writeln ("Connection.execute(" + sSQL + ")");
355         oStmt.execute(sSQL);
356         oStmt.close();
357         oStmt = null;
358       }
359     } // wend
360
361     if (DebugFile.trace) {
362       DebugFile.decIdent();
363       DebugFile.writeln ("End DataStruct.execCommands()");
364     }
365   } // execCommands()
366
367   // ----------------------------------------------------------
368
369   public void prepareStatements() throws SQLException {
370     // M�todo para dejar todos los cursores de lectura y escritura preparados
371 // Se llama internamente al inicio de los m�todo inser, update o delete
372
373     HashMap oMap;
374     String sSQL;
375     boolean bIsMapped;
376     boolean bHasDefault;
377     int iTrCols;
378     String sCol;
379     int iCol;
380     int c;
381
382     if (DebugFile.trace) {
383       DebugFile.writeln ("Begin DataStruct.prepareStatements()");
384       DebugFile.incIdent();
385     }
386
387     oInsertTexts = new HashMap (2*cTables); // Texto SQL de las sentencias Insert
388 oSelectTexts = new HashMap (2*cTables); // Texto SQL de las sentencias Select
389
390     OrStatements = new PreparedStatement [cTables]; // Sentencias de lectura
391 TrStatements = new PreparedStatement [cTables]; // Sentencias de escritura
392 UpStatements = new PreparedStatement [cTables]; // Sentencias de actualizaci�n
393 DlStatements = new PreparedStatement [cTables]; // Sentencias de borrado
394
395     OrMetaData = new DataTblDef[cTables]; // Metadatos de las tablas de Origen
396 TrMetaData = new DataTblDef[cTables]; // Metadatos de las tablas de Destino
397
398     // Recorrer la lista de tablas y preparar los cursores de lectura, escritura y borrado
399 for (int s=0; s<cTables; s++) {
400
401       if (CONNECTED==iTrStatus || REFERENCED==iTrStatus) {
402
403         // **************************************
404 // Leer la estructura de la tabla destino
405 TrMetaData[s] = new DataTblDef();
406         if (DebugFile.trace) DebugFile.writeln ("DataTblDef.readMetaData (TargetConnection, " + getRowSet(s).TargetTable + ", " + (String ) oToPKs.get(getRowSet(s).TargetTable) + ")");
407
408         // Evitar una excepci�n Java NullPointerException si no hay PKs en destino
409 if (oToPKs.get(getRowSet(s).TargetTable)!=null)
410           TrMetaData[s].readMetaData(oTrConn, getRowSet(s).TargetTable, oToPKs.get(getRowSet(s).TargetTable).toString());
411         else
412           TrMetaData[s].readMetaData(oTrConn, getRowSet(s).TargetTable, null);
413         // ***
414
415         // **********************************
416 // Preparar las sentencias de borrado
417 sSQL = "DELETE FROM " + getRowSet(s).TargetTable;
418         if (!isEmpty(getRowSet(s).EraseClause))
419           sSQL += " WHERE " + getRowSet(s).EraseClause;
420         else
421           if (!isEmpty(getRowSet(s).WhereClause))
422             sSQL += " WHERE " + getRowSet(s).WhereClause;
423
424         if (DebugFile.trace) DebugFile.writeln ("Connection.prepareStatement(" + sSQL + ")");
425         DlStatements[s] = oTrConn.prepareStatement(sSQL);
426         // ***
427
428         iTrCols = TrMetaData[s].ColCount;
429
430         // ************************************
431 // Preparar las sentencias de inserci�n
432 sSQL = "INSERT INTO " + getRowSet(s).TargetTable + " VALUES (";
433         for (c=iTrCols; c>=1; c--)
434           sSQL += (c!=1) ? "?," : "?)";
435
436         if (DebugFile.trace) DebugFile.writeln ("Connection.prepareStatement(" + sSQL + ")");
437
438         // Guardar el texto de SQL generado en un HashMap por si luego
439 // es preciso recuperarlo usando la tabla de Origen como PK
440 oInsertTexts.put (getRowSet(s).OriginTable, sSQL);
441
442         TrStatements[s] = oTrConn.prepareStatement(sSQL);
443         // ***
444
445         // ****************************************
446 // Preparar las sentencias de actualizaci�n
447 sSQL = "UPDATE " + getRowSet(s).TargetTable + " SET ";
448         for (c=0; c<iTrCols; c++)
449           if (!TrMetaData[s].isPrimaryKey(c))
450             sSQL += TrMetaData[s].ColNames[c] + "=?,";
451         sSQL = sSQL.substring(0, sSQL.length()-1) + " WHERE ";
452         for (c=0; c<TrMetaData[s].cPKs; c++)
453           sSQL += TrMetaData[s].PrimaryKeys[c] + "=? AND ";
454         sSQL = sSQL.substring(0, sSQL.length()-5);
455
456         if (DebugFile.trace) DebugFile.writeln ("Connection.prepareStatement(" + sSQL + ")");
457         UpStatements[s] = oTrConn.prepareStatement(sSQL);
458         // ***
459 } // fi (CONNECTED==iTrStatus)
460
461       if (CONNECTED==iOrStatus || REFERENCED==iOrStatus) {
462
463         // *************************************
464 // Leer la estructura de la tabla origen
465 OrMetaData[s] = new DataTblDef();
466         if (DebugFile.trace) DebugFile.writeln ("DataTblDef.readMetaData (OriginConnection, " + getRowSet(s).OriginTable + ", " + (String ) oToPKs.get(getRowSet(s).OriginTable) + ")");
467         OrMetaData[s].readMetaData(oOrConn, getRowSet(s).OriginTable, (String ) oFromPKs.get(getRowSet(s).OriginTable));
468
469         if (CONNECTED==iTrStatus || REFERENCED==iTrStatus)
470           iTrCols = TrMetaData[s].ColCount;
471         else
472           iTrCols = OrMetaData[s].ColCount;
473
474         if (DebugFile.trace) DebugFile.writeln ("Column count = " + String.valueOf(iTrCols));
475
476         // Preparar las sentencias de lectura
477 if (getRowSet(s).FieldList.compareTo("*")!=0) {
478           sSQL = "SELECT " + getRowSet(s).FieldList + " ";
479         }
480         else {
481           sSQL = "SELECT ";
482           for (c=0; c<iTrCols; c++) {
483             // Obtener el nombre en destino de la columna a leer
484 sCol = TrMetaData[s].ColNames[c];
485
486             try {
487               oMap = (HashMap ) FieldMaps.get(s);
488               // Si existe un mapeo de nombres,
489 // traducir el nombre en destino al que tenga en origen.
490 // Tener en cuenta el caso en que la columna destino est�
491 // definida como autoincremental
492 bIsMapped = oMap.containsKey(sCol);
493               if (bIsMapped)
494                 sCol = (String ) oMap.get(sCol);
495               else {
496                 bIsMapped = oMap.containsKey(sCol.toUpperCase());
497                 if (bIsMapped)
498                   sCol = (String ) oMap.get(sCol.toUpperCase());
499                 else {
500                   bIsMapped = oMap.containsKey(sCol.toLowerCase());
501                   if (bIsMapped)
502                     sCol = (String ) oMap.get(sCol.toLowerCase());
503                 }
504               }
505             }
506             catch (ArrayIndexOutOfBoundsException e) { bIsMapped=false; }
507
508             // Obtener la posici�n de la columna en origen
509 iCol = OrMetaData[s].findColumnPosition(sCol);
510             if (iCol!=-1)
511               sSQL += sCol + ((c<iTrCols-1) ? "," : " ");
512             else {
513               try {
514                 oMap = (HashMap ) FieldDefs.get(s);
515                 bHasDefault = oMap.containsKey(sCol);
516               }
517               catch (ArrayIndexOutOfBoundsException e) {
518                 // Si el XML no tiene una secci�n <DEFVALS>
519 // la llamada FieldDefs.get(s) provocar� una
520 // excepci�n ArrayIndexOutOfBoundsException
521 bHasDefault = false;
522                 oMap = null;
523               }
524               if (bHasDefault)
525                 // Si la columna no existe en origen mirar si tiene definido valor por defecto
526 sSQL += (String ) oMap.get(sCol) + " AS " + TrMetaData[s].ColNames[c] + ((c<iTrCols-1) ? "," : " ");
527               else
528                 if (bIsMapped)
529                   sSQL += sCol + " AS " + TrMetaData[s].ColNames[c] + ((c<iTrCols-1) ? "," : " ");
530                 else
531                   // Si no tiene valor por defecto leer NULL para luego grabarlo a posteriori
532 sSQL += "NULL AS " + TrMetaData[s].ColNames[c] + ((c<iTrCols-1) ? "," : " ");
533             } // fi (iCol!=-1)
534 } // next (c)
535 } // fi (DataRowSets[s].FieldList=="*")
536
537         sSQL += "FROM " + getRowSet(s).OriginTable;
538         if (!isEmpty(getRowSet(s).WhereClause)) {
539           if (getRowSet(s).WhereClause.trim().toUpperCase().startsWith("START"))
540             sSQL += " " + getRowSet(s).WhereClause;
541           else
542             sSQL += " WHERE " + getRowSet(s).WhereClause;
543         } // fi (isEmpty(getRowSet(s).WhereClause)
544
545         if (DebugFile.trace) DebugFile.writeln ("Connection.prepareStatement(" + sSQL + ")");
546
547         oSelectTexts.put (getRowSet(s).OriginTable, sSQL);
548
549         OrStatements[s] = oOrConn.prepareStatement(sSQL, ResultSet.TYPE_FORWARD_ONLY, ResultSet.CONCUR_READ_ONLY);
550         // ***
551 } // end if (CONNECTED==iOrStatus)
552 } // end for (s)
553
554     if (CONNECTED==iOrStatus || REFERENCED==iOrStatus) bOrPrepared = true;
555     if (CONNECTED==iTrStatus || REFERENCED==iTrStatus) bTrPrepared = true;
556
557     if (DebugFile.trace) {
558       DebugFile.decIdent();
559       DebugFile.writeln ("End DataStruct.prepareStatements()");
560     }
561   } // prepareStatements()
562
563   // ----------------------------------------------------------
564
565   public Object convert (Object oValue, int iSQLType) {
566     // Funci�n de soporte para hacer castings de tipos entre bases de datos
567
568     Object oRetVal;
569     String sClass;
570
571     if (null==oValue) {
572       oRetVal = null;
573     }
574     else {
575       sClass = oValue.getClass().getName();
576
577       if (sClass.equals("java.lang.Short") ||
578           sClass.equals("java.lang.Integer") ||
579           sClass.equals("java.math.BigDecimal")) {
580         if (java.sql.Types.VARCHAR == iSQLType || java.sql.Types.CHAR == iSQLType ||
581             java.sql.Types.LONGVARCHAR == iSQLType)
582           oRetVal = oValue.toString();
583         else if (java.sql.Types.DECIMAL == iSQLType ||
584                  java.sql.Types.NUMERIC == iSQLType)
585           oRetVal = new BigDecimal (oValue.toString());
586         else if (java.sql.Types.INTEGER == iSQLType)
587           oRetVal = new Integer (oValue.toString());
588         else if (java.sql.Types.SMALLINT == iSQLType)
589           oRetVal = new Short (oValue.toString());
590         else
591           oRetVal = oValue;
592       }
593       else if (sClass.equals("java.lang.String")) {
594         if (java.sql.Types.DECIMAL == iSQLType ||
595             java.sql.Types.NUMERIC == iSQLType )
596           oRetVal = new BigDecimal (oValue.toString());
597         else if (java.sql.Types.SMALLINT == iSQLType)
598           oRetVal = new Short (oValue.toString());
599         else if (java.sql.Types.INTEGER == iSQLType) {
600           String str = oValue.toString();
601           oRetVal = new Integer (str);
602           }
603         else
604           oRetVal = oValue;
605       }
606       else if (sClass.equals("java.sql.Timestamp")) {
607         oRetVal = new java.sql.Date (((Timestamp )oValue).getTime());
608       }
609       else
610         oRetVal = oValue;
611     }
612     return oRetVal;
613   } // convert()
614
615   // ----------------------------------------------------------
616
617   public int mapType(int iSQLType) {
618     // Mapeo de tipos,
619 // actualmente s�lo sirve para convertir los TIMESTAMP en DATETIME
620
621     int iRetType;
622
623     switch(iSQLType) {
624       case java.sql.Types.TIMESTAMP:
625         iRetType = java.sql.Types.DATE;
626         break;
627       default:
628         iRetType = iSQLType;
629     }
630     return iRetType;
631   } // mapType()
632
633   // ----------------------------------------------------------
634
635   /* ESTA FUNCION NO ESTA TESTEADA Y NO FUNCIONA!!!
636   public void delete(Object[] TrPK, int cParams) throws SQLException {
637
638     PreparedStatement oStmt;
639     DataTblDef oMDat;
640     HashMap oMap;
641     int iErsd;
642
643     if (DebugFile.trace) {
644       DebugFile.writeln ("Begin DataStruct.delete(TrPK[], " + String.valueOf(cParams) + ")");
645       DebugFile.incIdent();
646     }
647
648     execCommands("INIT", -1, TrPK, cParams);
649
650     for (int s=cTables-1; s>=0; s++) {
651       oMDat = TrMetaData[s];
652       oStmt = TrStatements[s];
653       for (int p=0;p<cParams; p++)
654         oStmt.setObject(p+1, TrPK[p], oMDat.findColumnType(oMDat.PrimaryKeys[p]));
655       iErsd = oStmt.executeUpdate();
656       if (DebugFile.trace) DebugFile.writeln (String.valueOf(iErsd) + " rows deleted from " + getRowSet(s).TargetTable);
657     } // end for (s)
658
659     execCommands("TERM", -1, TrPK, cParams);
660
661     if (DebugFile.trace) {
662       DebugFile.decIdent();
663       DebugFile.writeln ("End DataStruct.delete()");
664     }
665   } // delete()
666   */
667
668   // ----------------------------------------------------------
669
670   protected void getRows(Object [] OrPK, Object [] TrPK, int cParams, int iTable) throws SQLException {
671     // M�todo interno de soporte para leer un conjunto de final y almacenarlo
672 // en una matriz bidimensional de objetos
673
674     int iPK;
675     int iFetchBurst = 500; // Tama�o de r�faga de lectura
676 int iSQLType;
677     int cTransforms;
678     Vector oRow;
679     HashMap oTransforms;
680     Object oOriginalValue;
681     Object oTransformedValue;
682     ResultSet oRSet;
683     ResultSetMetaData oRDat;
684     DataRowSet oDatR;
685     String sColName;
686     DataTblDef oMDat = OrMetaData[iTable];
687     DataTransformation oDatT;
688     PreparedStatement oStmt = OrStatements[iTable];
689     PreparedStatement oStmt2;
690
691     // Asignar los parametros de la clave primaria para leer valores en origen
692
693     oDatR = getRowSet(iTable);
694     // Comprobar primero si existen par�metros en la cl�usula WHERE
695 if (oDatR.WhereClause!=null) {
696       if (oDatR.WhereClause.indexOf("?")>0) {
697         for (int p=0;p<cParams; p++) {
698           if (DebugFile.trace) DebugFile.writeln ("binding query input parameter " + String.valueOf(p+1));
699           oStmt.setObject(p+1, OrPK[p]);
700         } // next (p)
701 } // fi (oDatR.WhereClause.indexOf("?")>0)
702 } // fi (oDatR.WhereClause!=null)
703
704     if (DebugFile.trace) DebugFile.writeln ("PreparedStatement.executeQuery()");
705
706     oRSet = oStmt.executeQuery(); // Ejecutar la query de lectura de registros
707
708     /* Not supported under PostgreSQL 7.3.4
709     if (DebugFile.trace) DebugFile.writeln ("ResultSet.setFetchSize(" + String.valueOf(iFetchBurst) + ")");
710
711     oRSet.setFetchSize (iFetchBurst); // Asignar el tama�o de r�faga de vuelta
712     */
713
714     oDatR = null;
715
716     if (DebugFile.trace) {
717       if (DataRowSets.get(iTable)!=null)
718         DebugFile.writeln ("FieldList=" + getRowSet(iTable).FieldList);
719       else
720         DebugFile.writeln ("ERROR: getRowSet(" + String.valueOf(iTable) + ") == null");
721     }
722
723     // Si se especific� expl�citamente una lista de campos a leer,
724 // entonces tomar como n�mero de columnas la del Origen,
725 // en otro caso tomar como n�mero de columnas las del Destino.
726 if (getRowSet(iTable).FieldList.compareTo("*")!=0)
727       iCols = oRSet.getMetaData().getColumnCount();
728     else
729       iCols = TrMetaData[iTable].ColCount;
730
731     if (DebugFile.trace) DebugFile.writeln ("reading " + String.valueOf(iCols) + " columns");
732
733     // Guardar los resultados en una matriz bidimensional almacenada como un vector de filas
734 oResults = new Vector (iFetchBurst, iFetchBurst);
735
736     if (DebugFile.trace) DebugFile.writeln ("new Vector(" + String.valueOf(iFetchBurst) + ")");
737
738     iRows = 0;
739
740     try {
741       // Obtener una referencia a las transformaciones de datos para el RowSet actual
742 oTransforms = (HashMap ) Transformations.get(iTable);
743       cTransforms = oTransforms.size();
744     }
745     catch (ArrayIndexOutOfBoundsException e) {
746       if (DebugFile.trace) DebugFile.writeln ("table has no transformation replacements");
747       oTransforms = null;
748       cTransforms = 0;
749     }
750
751     if (0 == cTransforms) {
752       // Si no hay transformaciones para campos, usar un algoritmo m�s r�pido con menos condiciones
753 while (oRSet.next() && iRows<iFetchBurst) {
754         iRows++;
755         if (DebugFile.trace) DebugFile.writeln ("caching row " + String.valueOf(iRows));
756         oRow = new Vector (iCols);
757         for (int c=1; c<=iCols; c++)
758           oRow.add(oRSet.getObject(c));
759         oResults.add(oRow);
760       } // wend ()
761 }
762     else { // Algoritmo con m�s condiciones para el caso de reemplazo de transformaci�n de datos
763 oRDat = oRSet.getMetaData(); // Alias r�pido a los metadatos del ResultSet
764 while (oRSet.next() && iRows<iFetchBurst) {
765         iRows++;
766         if (DebugFile.trace) DebugFile.writeln ("caching row " + String.valueOf(iRows));
767         // Crear un vector para la fila
768 oRow = new Vector (iCols);
769         // Recorer cada columna y almacenar su valor en el vector fila
770 iPK = 0;
771         for (int c=1; c<=iCols; c++) {
772           try {
773             // Obtener una referencia a la transformaci�n para la columna actual
774 // si no hay transformaci�n saltar� una excepci�n y el valor de la
775 // columna se asignar� en la secci�n catch()
776 sColName = oRDat.getColumnName(c);
777
778             oDatT = (DataTransformation) oTransforms.get(sColName);
779
780             // Asignar el valor transformado del campo
781 if (null==oDatT)
782               oRow.add(oRSet.getObject(c));
783             else {
784               oOriginalValue = oRSet.getObject(c);
785
786               oTransformedValue = oDatT.transform(getOriginConnection(),getTargetConnection(), oOriginalValue);
787
788               if (DebugFile.trace) DebugFile.writeln (sColName + " " + oOriginalValue + " transformed to " + (oTransformedValue!=null ? oTransformedValue : "NULL"));
789
790               oRow.add(oTransformedValue);
791               }
792           }
793           catch (ArrayIndexOutOfBoundsException e) {
794             oRow.add(oRSet.getObject(c));
795           }
796         } // next (c)
797 oResults.add(oRow);
798       } // wend ()
799 oRDat = null;
800     } // end if (FieldNils[s].size()==0)
801
802     if (DebugFile.trace) DebugFile.writeln ("row count = " + String.valueOf(iRows));
803
804     oRSet.close();
805     oRSet = null;
806   } // getRows()
807
808   // ----------------------------------------------------------
809
810   public void insert(Object [] OrPK, Object [] TrPK, int cParams)
811     throws SQLException ,NullPointerException {
812     // Inserta registros del Origen en el Destino,
813 // si encuentra un registro duplicado lo actualiza sin dar ning�n error,
814 // si el registro no est�, lo inserta
815
816     String sField;
817     DataTblDef oMDat;
818     PreparedStatement oInsrt;
819     StringReader oReader;
820     Object oValue;
821     String sValue;
822     int r;
823     int q;
824     int iPK;
825     int iSQLType;
826
827     if (DebugFile.trace) {
828       DebugFile.writeln ("Begin DataStruct.insert(OrPK[], TrPK[], " + String.valueOf(cParams) + ")");
829       DebugFile.incIdent();
830     }
831
832     execCommands("INIT", -1, OrPK, cParams);
833
834     // Preparar todos los cursores
835 if (!bTrPrepared || !bTrPrepared) prepareStatements();
836
837     // Iterar sobre las tablas: para cada una de ellas leer sus registros e insertarlos en destino
838 for (int s=0; s<cTables; s++) {
839       if (DebugFile.trace) DebugFile.writeln ("processing rowset from " + getRowSet(s).OriginTable + " to " + getRowSet(s).TargetTable);
840
841       execCommands("BEFORE", s, OrPK, cParams);
842
843       getRows(OrPK, TrPK, cParams, s); // Modifica {iRows, iCols} como efecto lateral
844
845       oMDat = TrMetaData[s];
846       oInsrt = TrStatements[s];
847
848       // Iterar sobre cada fila leida en origen y actualizarla en destino
849 for (r=0; r<iRows; r++) {
850         iPK = 0;
851         // Iterador de parametros de entrada
852 for (q=0; q<iCols; q++) {
853           sField = oMDat.ColNames[q];
854           iSQLType = oMDat.ColTypes[q];
855           oValue = getResult(r,q);
856
857           if (oMDat.isPrimaryKey(q)) {
858             if (iPK<cParams && oMDat.inheritsPK(TrMetaData[0]))
859               if (null!=TrPK[iPK]) {
860                 if (oValue.getClass().equals(TrPK[iPK].getClass()) &&
861                     oMDat.bestMatch(q, TrMetaData[0], iPK)) {
862                   if (DebugFile.trace) DebugFile.writeln ("swaping PK " + oValue.toString() + " to " + TrPK[iPK].toString() + " before insert");
863                   oValue = TrPK[iPK];
864                 } // fi (oValue.getClass() == TrPK[iPK].getClass())
865 } // fi (null!=TrPK[iPK])
866 iPK++;
867           } // fi (oMDat.isPrimaryKey(q))
868
869           if (DebugFile.trace)
870             if (oValue!=null)
871               DebugFile.writeln ("binding " + sField + "=" + oValue.toString() + " as SQLType " + String.valueOf(iSQLType));
872             else
873               DebugFile.writeln ("binding " + sField + "=NULL as SQLType " + String.valueOf(iSQLType));
874
875           if (iSQLType==java.sql.Types.LONGVARCHAR) {
876             sValue = oValue.toString() + " ";
877             oReader = new StringReader (sValue);
878             oInsrt.setCharacterStream(q+1, oReader, sValue.length()-1);
879           }
880           else
881             oInsrt.setObject(q+1, convert(oValue, iSQLType), mapType(iSQLType));
882         } // end for (q)
883
884         if (DebugFile.trace) DebugFile.writeln ("PreparedStatement.execute()");
885         oInsrt.execute();
886       } // end for (r)
887
888       oResults.clear();
889       oResults = null;
890
891       execCommands("AFTER", s, OrPK, cParams);
892     } // end for (s)
893
894     execCommands("TERM", -1, OrPK, cParams);
895
896     if (DebugFile.trace) {
897       DebugFile.decIdent();
898       DebugFile.writeln ("End DataStruct.insert()");
899     }
900   } // insert
901
902   // ----------------------------------------------------------
903
904   public void update(Object [] OrPK, Object [] TrPK, int cParams) throws SQLException {
905     // Inserta registros del Origen en el Destino,
906 // si encuentra un registro duplicado lo actualiza sin dar ning�n error,
907 // si el registro no est�, lo inserta
908
909     String sField;
910     DataTblDef oMDat;
911     PreparedStatement oInsrt;
912     PreparedStatement oUpdt;
913     Object oValue;
914     String sValue;
915     StringReader oReader;
916     int r;
917     int q;
918     int iPK;
919     int cUpdated;
920     int iSQLType;
921
922     if (DebugFile.trace) {
923       DebugFile.writeln ("Begin DataStruct.update(OrPK[], TrPK[], " + String.valueOf(cParams) + ")");
924       DebugFile.incIdent();
925     }
926
927     execCommands("INIT", -1, OrPK, cParams);
928
929     // Preparar todos los cursores
930 if (!bTrPrepared || !bTrPrepared) prepareStatements();
931
932     // Iterar sobre las tablas: para cada una de ellas leer sus registros e insertarlos en destino
933 for (int s=0; s<cTables; s++) {
934       if (DebugFile.trace) DebugFile.writeln ("processing rowset from " + getRowSet(s).OriginTable + " to " + getRowSet(s).TargetTable);
935
936       execCommands("BEFORE", s, OrPK, cParams);
937
938       getRows(OrPK, TrPK, cParams, s); // Modifica {iRows, iCols} como efecto lateral
939
940       oMDat = TrMetaData[s];
941       oUpdt = UpStatements[s];
942
943       // Iterar sobre cada fila leida en origen y actualizarla en destino
944 for (r=0; r<iRows; r++) {
945         iPK = 0; // Cuenta de parametros de clave primaria con valor asignado
946
947         if (oMDat.ColCount>oMDat.cPKs) {
948
949           // Iterador de parametros de entrada
950 for (q=0; q<iCols; q++) {
951             sField = oMDat.ColNames[q]; // Nombre del campo en destino
952 iSQLType = oMDat.ColTypes[q]; // Tipo del campo en destino
953
954             if (oMDat.isPrimaryKey(q)) {
955               if (iPK<cParams && oMDat.inheritsPK(TrMetaData[0])) {
956                 if (null!=TrPK[iPK]) {
957                   if (getResult(r,q).getClass().equals(TrPK[iPK].getClass()) &&
958                       oMDat.bestMatch(q, TrMetaData[0], iPK)) {
959                     if (DebugFile.trace) DebugFile.writeln("swaping PK " + getResult(r, q).toString() + " to " + TrPK[iPK].toString() + " before update");
960                    oValue = TrPK[iPK];
961                   }
962                   else {
963                     oValue = getResult(r,q);
964                   } // fi (getResult(r,q).getClass() == TrPK[iPK].getClass())
965 }
966                 else {
967                   oValue = getResult(r, q);
968                 } // fi (null!=TrPK[iPK])
969 }
970               else {
971                 oValue = getResult(r,q);
972               } // fi (iPK<cParams && oMDat.inheritsPK(TrMetaData[0])))
973
974               if (DebugFile.trace)
975                 if (oValue==null)
976                   DebugFile.writeln ("binding " + sField + "=null as SQLType " + String.valueOf(iSQLType) + " at parameter " + String.valueOf(iCols-oMDat.cPKs+iPK+1));
977                 else
978                   DebugFile.writeln ("binding " + sField + "=" + oValue.toString() + " as SQLType " + String.valueOf(iSQLType) + " at parameter " + String.valueOf(iCols-oMDat.cPKs+iPK+1));
979
980               oUpdt.setObject(iCols-oMDat.cPKs+iPK+1, convert(oValue, iSQLType), mapType(iSQLType));
981               iPK++;
982             }
983             else {
984               if (DebugFile.trace) DebugFile.writeln ("binding " + sField + " as SQLType " + String.valueOf(iSQLType) + " at parameter " + String.valueOf(q+1-iPK));
985
986               if (iSQLType==java.sql.Types.LONGVARCHAR) {
987                 sValue = getResult(r,q).toString() + " ";
988                 oReader = new StringReader (sValue);
989                 oUpdt.setCharacterStream(q+1-iPK, oReader, sValue.length()-1);
990               }
991               else
992                 oUpdt.setObject(q+1-iPK, convert(getResult(r,q), iSQLType), mapType(iSQLType));
993             }
994           } // next (q)
995
996           if (DebugFile.trace) DebugFile.writeln ("PreparedStatement.executeUpdate()");
997           cUpdated = oUpdt.executeUpdate();
998
999           if (DebugFile.trace) DebugFile.writeln (String.valueOf(cUpdated) + " rows updated");
1000        }
1001        else {
1002          cUpdated = 0;
1003          if (DebugFile.trace)
1004            DebugFile.writeln ("pk count=" + String.valueOf(oMDat.cPKs) + " column count=" + String.valueOf(oMDat.ColCount) + " row not updated because no non-pk columns found");
1005        }
1006        // fi (oMDat.cPKs>oMDat.ColCount)
1007
1008        if (0==cUpdated) {
1009          oInsrt = TrStatements[s];
1010          iPK = 0;
1011          // Iterador de parametros de entrada
1012 for (q=0; q<iCols; q++) {
1013            sField = oMDat.ColNames[q];
1014            iSQLType = oMDat.ColTypes[q];
1015            oValue = getResult(r,q);
1016
1017            if (oMDat.isPrimaryKey(q)) {
1018              if (iPK<cParams && oMDat.inheritsPK(TrMetaData[0])) {
1019                if (null!=TrPK[iPK]) {
1020                  if (oValue.getClass().equals(TrPK[iPK].getClass()) &&
1021                      oMDat.bestMatch(q, TrMetaData[0], iPK)) {
1022                    if (DebugFile.trace) DebugFile.writeln ("swaping PK " + oValue.toString() + " to " + TrPK[iPK].toString());
1023                    oValue = TrPK[iPK];
1024                  }
1025                }
1026              } // fi (iPK<cParams && oMDat.hasSamePK(TrMetaData[0]))
1027 iPK++;
1028            } // fi (oMDat.isPrimaryKey(q))
1029
1030            if (DebugFile.trace) DebugFile.writeln ("binding " + sField + " as SQLType " + String.valueOf(iSQLType));
1031
1032            if (iSQLType==java.sql.Types.LONGVARCHAR) {
1033              sValue = oValue.toString() + " ";
1034              oReader = new StringReader (sValue);
1035              oInsrt.setCharacterStream(q+1, oReader, sValue.length()-1);
1036            }
1037            else
1038              oInsrt.setObject(q+1, convert(oValue, iSQLType), mapType(iSQLType));
1039          } // end for (q)
1040
1041          if (DebugFile.trace) DebugFile.writeln ("PreparedStatement.execute()");
1042          oInsrt.execute();
1043        } // end if (cUpdated==0)
1044 } // end for (r)
1045
1046      oResults.clear();
1047      oResults = null;
1048
1049      execCommands("AFTER", s, OrPK, cParams);
1050    } // end for (s)
1051
1052    execCommands("TERM", -1, OrPK, cParams);
1053
1054    if (DebugFile.trace) {
1055      DebugFile.decIdent();
1056      DebugFile.writeln ("End DataStruct.update()");
1057    }
1058  } // update
1059
1060  // ----------------------------------------------------------
1061
1062  protected void seekReferal(DataTransformation oTransform) {
1063    DataTransformation oTransformRef;
1064    HashMap oTransformsRef;
1065    Set oTransformSet;
1066    Iterator oSetIterator;
1067    String sChildTable;
1068    String sReferedTable = oTransform.ReferedTable;
1069
1070    if (DebugFile.trace) {
1071      DebugFile.writeln ("Begin DataStruct.seekReferal(ReferedTable=" + sReferedTable + ", ReferedField=" + oTransform.ReferedField + ")");
1072      DebugFile.incIdent();
1073    }
1074
1075    for (int r=0; r<DataRowSets.size(); r++) {
1076      // Si el nombre de la tabla de origen del RowSet explorado
1077 // coincide con el nombre de la tabla referencia, entonces
1078 // buscar el campo asociado.
1079 sChildTable = getRowSet(r).OriginTable;
1080
1081      if (sChildTable.equalsIgnoreCase(sReferedTable)) {
1082        oTransformsRef = (HashMap ) Transformations.get(r);
1083        // Recorrer la lista de valores
1084 oTransformSet = oTransformsRef.keySet();
1085        oSetIterator = oTransformSet.iterator();
1086        while (oSetIterator.hasNext()) {
1087          oTransformRef = (DataTransformation) oTransformsRef.get(oSetIterator.next());
1088          if (oTransformRef.OriginField.equalsIgnoreCase(oTransform.ReferedField)) {
1089            oTransform.setReferedValues(oTransformRef);
1090            if (DebugFile.trace) DebugFile.writeln (oTransform.OriginTable + " references " + oTransform.ReferedTable + "." + oTransform.ReferedField);
1091          } // fi (oTransformRef.OriginField == oTransform.ReferedField)
1092 } // wend()
1093 } // fi (DataRowSets[r].OriginTable == oTransform.ReferedTable)
1094 } // next (r)
1095
1096    if (DebugFile.trace) {
1097      DebugFile.decIdent();
1098      DebugFile.writeln ("End DataStruct.seekReferal()");
1099    }
1100  } // seekReferal
1101
1102  // ==========================================================
1103
1104  //
1105 // ContentHandler methods
1106 //
1107
1108  /** Start document. */
1109  public void startDocument() throws SAXException {
1110
1111    if (DebugFile.trace) {
1112      DebugFile.writeln ("Begin DataStruct.startDocument()");
1113      DebugFile.incIdent();
1114    }
1115
1116    fElements = 0;
1117    fCharacters = 0;
1118    sContext = "";
1119    sNode = "";
1120    oFromPKs = new HashMap (5,3);
1121    oToPKs = new HashMap (5,3);
1122
1123    InitStmts = new LinkedList ();
1124    TermStmts = new LinkedList ();
1125
1126    if (DebugFile.trace) {
1127      DebugFile.decIdent();
1128      DebugFile.writeln ("End DataStruct.startDocument()");
1129    }
1130  } // startDocument()
1131
1132  // ----------------------------------------------------------
1133
1134  public void startElement(String uri, String local, String raw,
1135                           Attributes attrs) throws SAXException {
1136    fElements++;
1137    sChars = "";
1138
1139    if (local.equalsIgnoreCase("ROWSET")) {
1140      oCurrRowSet = new DataRowSet();
1141      DataRowSets.add(oCurrRowSet);
1142      cTables++;
1143
1144      oCurrMap = new HashMap (13,5);
1145      FieldMaps.add(oCurrMap);
1146
1147      oCurrTransform = new HashMap (5,3);
1148      Transformations.add(oCurrTransform);
1149
1150      oCurrDef = new HashMap (13,5);
1151      FieldDefs.add(oCurrDef);
1152
1153      oCurrBef = new LinkedList ();
1154      Before.add(oCurrBef);
1155
1156      oCurrAft = new LinkedList ();
1157      After.add(oCurrAft);
1158    } // fi (local.equalsIgnoreCase("ROWSET"))
1159
1160    if (local.equalsIgnoreCase("ACTION") ||
1161        local.equalsIgnoreCase("MAPPINGS") ||
1162        local.equalsIgnoreCase("DEFVALS") ||
1163        local.equalsIgnoreCase("NULLVALS") ||
1164        local.equalsIgnoreCase("BEFORE") ||
1165        local.equalsIgnoreCase("AFTER") ||
1166        local.equalsIgnoreCase("INIT") ||
1167        local.equalsIgnoreCase("TERM") )
1168      sNode = sContext = local.toUpperCase();
1169    else
1170      sNode = local.toUpperCase();
1171
1172    if ((sNode.equals("MAPPING") && attrs.getLength()>0) ||
1173        (sNode.equals("DEFVAL") && attrs.getLength()>0))
1174      sTransform = attrs.getValue(0);
1175    else
1176      sTransform = null;
1177
1178  } // startElement(String,String,StringAttributes)
1179
1180  // ----------------------------------------------------------
1181
1182  public void endElement(String uri, String localName, String qname) throws SAXException {
1183    int iComma;
1184    String sOrFld;
1185    String sOrVal;
1186    String sTrFld;
1187    DataTransformation oTransform;
1188
1189    if (sContext.equalsIgnoreCase("ACTION")) {
1190      if (sNode.equalsIgnoreCase("FROM"))
1191        oCurrRowSet.OriginTable = sChars.trim();
1192      else if (sNode.equalsIgnoreCase("TO"))
1193        oCurrRowSet.TargetTable = sChars.trim();
1194      else if (sNode.equalsIgnoreCase("JOIN"))
1195        oCurrRowSet.JoinTables = sChars;
1196      else if (sNode.equalsIgnoreCase("WHERE"))
1197        oCurrRowSet.WhereClause = sChars;
1198      else if (sNode.equalsIgnoreCase("ERASE"))
1199        oCurrRowSet.EraseClause = sChars;
1200      else if (sNode.equalsIgnoreCase("FIELDLIST"))
1201        oCurrRowSet.FieldList = sChars;
1202      else if (sNode.equalsIgnoreCase("FROM_PK"))
1203        oFromPKs.put(oCurrRowSet.OriginTable, sChars.trim());
1204      else if (sNode.equalsIgnoreCase("TO_PK"))
1205        oToPKs.put(oCurrRowSet.TargetTable, sChars.trim());
1206    } // end if (sContext=="ACTION")
1207 else if (sContext.equalsIgnoreCase("MAPPINGS")) {
1208      if (sNode.equalsIgnoreCase("MAPPING")) {
1209        iComma = sChars.lastIndexOf(",");
1210        sOrFld = sChars.substring(0, iComma).trim();
1211        sTrFld = sChars.substring(iComma+1).trim();
1212        oCurrMap.put(sTrFld, sOrFld);
1213
1214        // Si el elemento <MAPPING> contiene un atributo llamado TRANSFORM
1215 // entonces crear un nuevo objeto de transformaci�n de datos para este mapeo
1216 if (null!=sTransform) {
1217          // Crear un nuevo servicio de transformaci�n de datos para el campo
1218 oTransform = new DataTransformation(sTransform,
1219                                              oCurrRowSet.OriginTable, sOrFld,
1220                                              oCurrRowSet.TargetTable, sTrFld);
1221
1222          // Asociar el nombre del campo con su transformaci�n de datos
1223 oCurrTransform.put (sOrFld, oTransform);
1224
1225          // Si la transformacion es de tipo REFER,
1226 // buscar el mapa de valores para la tabla referenciada
1227 if (oTransform.OperationCode==DataTransformation.Operations.REFER)
1228            seekReferal(/* inout */ oTransform);
1229        } // end if (null!=sTransform)
1230 } // end if (sNode=="MAPPING")
1231 } // end if (sContext=="MAPPINGS")
1232 else if (sContext.equalsIgnoreCase("DEFVALS")) {
1233      if (sNode.equalsIgnoreCase("DEFVAL")) {
1234        iComma = sChars.indexOf(",");
1235        sTrFld = sChars.substring(0, iComma).trim();
1236        sOrFld = sChars.substring(iComma+1).trim();
1237        oCurrDef.put(sTrFld, sOrFld);
1238        // Crear un nuevo servicio de transformaci�n de datos para el campo por defecto
1239 if (null!=sTransform) {
1240          oTransform = new DataTransformation(sTransform,
1241                                              oCurrRowSet.OriginTable, sTrFld,
1242                                              oCurrRowSet.TargetTable, sTrFld);
1243          // Asociar el nombre del campo con su transformaci�n de datos
1244 oCurrTransform.put (sTrFld, oTransform);
1245          // Si la transformacion es de tipo REFER,
1246 // buscar el mapa de valores para la tabla referenciada
1247 if (oTransform.OperationCode==DataTransformation.Operations.REFER)
1248            seekReferal(/* inout */ oTransform);
1249        } // end if (null!=sTransform)
1250 } // end if (sNode=="DEFVAL")
1251 } // end if (sContext=="DEFVALS")
1252 else if (sContext.equalsIgnoreCase("BEFORE")) {
1253      if (localName.equalsIgnoreCase("EXEC") ||
1254          localName.equalsIgnoreCase("CALL"))
1255        oCurrBef.addLast(sChars);
1256    } // end if (sContext=="BEFORE")
1257 else if (sContext.equalsIgnoreCase("AFTER")) {
1258      if (localName.equalsIgnoreCase("EXEC") ||
1259          localName.equalsIgnoreCase("CALL"))
1260        oCurrAft.addLast(sChars);
1261    } // end if (sContext=="AFTER")
1262 else if (sContext.equalsIgnoreCase("INIT")) {
1263      if (localName.equalsIgnoreCase("EXEC") ||
1264          localName.equalsIgnoreCase("CALL"))
1265        InitStmts.addLast(sChars);
1266    } // end if (sContext=="INIT")
1267 else if (sContext.equalsIgnoreCase("TERM")) {
1268      if (localName.equalsIgnoreCase("EXEC") ||
1269          localName.equalsIgnoreCase("CALL"))
1270        TermStmts.addLast(sChars);
1271    } // end if (sContext=="TERM")
1272 } // endElement()
1273
1274  // ----------------------------------------------------------
1275
1276  /** Characters. */
1277  public void characters(char ch[], int start, int length) throws SAXException {
1278    fCharacters += length;
1279    sChars += new String (ch,start,length);
1280  } // characters(char[],int,int);
1281
1282  // ----------------------------------------------------------
1283
1284    //
1285 // ErrorHandler methods
1286 //
1287
1288    /** Warning. */
1289    public void warning(SAXParseException ex) throws SAXException {
1290        if (DebugFile.trace) DebugFile.write(composeError("Warning", ex));
1291    } // warning(SAXParseException)
1292
1293    /** Error. */
1294    public void error(SAXParseException ex) throws SAXException {
1295        if (DebugFile.trace) DebugFile.write(composeError("Error", ex));
1296        throw ex;
1297    } // error(SAXParseException)
1298
1299    /** Fatal error. */
1300    public void fatalError(SAXParseException ex) throws SAXException {
1301      if (DebugFile.trace) DebugFile.write(composeError("Fatal Error", ex));
1302      throw ex;
1303    } // fatalError(SAXParseException)
1304
1305  // ----------------------------------------------------------
1306
1307    //
1308 // Protected methods
1309 //
1310
1311    /** Compose the error message. */
1312    protected String composeError(String type, SAXParseException ex) {
1313        String sErrDesc = "";
1314        String systemId = null;
1315        int index;
1316
1317        sErrDesc += "[SAX " + type + "] ";
1318
1319        if (ex==null)
1320          sErrDesc += "!!!";
1321        else
1322          systemId = ex.getSystemId();
1323
1324        if (systemId != null) {
1325            index = systemId.lastIndexOf('/');
1326            if (index != -1) systemId = systemId.substring(index + 1);
1327            sErrDesc += systemId;
1328        }
1329
1330        sErrDesc += " Line:" + ex.getLineNumber();
1331        sErrDesc += " Column:" + ex.getColumnNumber();
1332        sErrDesc += " Cause: " + ex.getMessage();
1333        sErrDesc += "\n";
1334
1335        return sErrDesc;
1336    } // composeError(String,SAXParseException)
1337
1338  // ----------------------------------------------------------
1339
1340    //
1341 // Public methods
1342 //
1343
1344    public void parse(String sXMLFile) throws InstantiationException ,IllegalAccessException ,ClassNotFoundException ,IOException ,SAXException {
1345      Properties oProps = new Properties ();
1346      parse(sXMLFile, oProps);
1347    }
1348
1349    public void parse(String sXMLFile, Properties oProps) throws InstantiationException ,IllegalAccessException ,ClassNotFoundException ,IOException ,SAXException {
1350        // This method parses an XML document into a DataStruct instace
1351
1352        // local variables
1353 XMLReader parser;
1354        Parser sax1Parser;
1355        File oFile;
1356        FileReader oFileRead;
1357        BufferedReader oBuff;
1358        StringBufferInputStream oStrBuff;
1359        InputSource ioSrc;
1360        FileInputStream oStream;
1361        String sXMLSource;
1362        String sParam;
1363        Enumeration oEnum;
1364        Pattern oPattern;
1365        PatternMatcher oMatcher = new Perl5Matcher();
1366        PatternCompiler oCompiler = new Perl5Compiler();
1367        byte byBuffer[];
1368
1369        if (DebugFile.trace) {
1370          DebugFile.writeln ("Begin DataStruct.parse(" + sXMLFile + ")");
1371          DebugFile.incIdent();
1372        }
1373
1374        try {
1375          if (DebugFile.trace) DebugFile.writeln ("XMLReaderFactory.createXMLReader(" + DEFAULT_PARSER_NAME + ")");
1376
1377          parser = XMLReaderFactory.createXMLReader(DEFAULT_PARSER_NAME);
1378        }
1379        catch (Exception e) {
1380            if (DebugFile.trace) DebugFile.writeln ("ParserFactory.makeParser(" + DEFAULT_PARSER_NAME + ")");
1381
1382            sax1Parser = ParserFactory.makeParser(DEFAULT_PARSER_NAME);
1383
1384            parser = new ParserAdapter(sax1Parser);
1385            if (DebugFile.trace)
1386              DebugFile.writeln("warning: Features and properties not supported on SAX1 parsers.");
1387        }
1388        try {
1389          parser.setFeature(NAMESPACES_FEATURE_ID, DEFAULT_NAMESPACES);
1390          parser.setFeature(VALIDATION_FEATURE_ID, DEFAULT_VALIDATION);
1391        }
1392        catch (SAXException e) {
1393        }
1394
1395      // parse file
1396 parser.setContentHandler(this);
1397      parser.setErrorHandler(this);
1398
1399      oEnum = oProps.keys();
1400      if (sXMLFile.startsWith("<?xml")) {
1401        // replace input parameters
1402 while (oEnum.hasMoreElements()) {
1403          sParam = (String ) oEnum.nextElement();
1404          try {
1405            oPattern = oCompiler.compile("{#" + sParam + "}");
1406          } catch (MalformedPatternException e) { oPattern=null; }
1407
1408          sXMLFile = Util.substitute(oMatcher, oPattern,
1409                                 new Perl5Substitution(oProps.getProperty(sParam), Perl5Substitution.INTERPOLATE_ALL),
1410                                 sXMLFile, Util.SUBSTITUTE_ALL);
1411        } // wend()
1412
1413        oStrBuff = new StringBufferInputStream (sXMLFile);
1414        ioSrc = new InputSource(oStrBuff);
1415        parser.parse(ioSrc);
1416        oStrBuff.close();
1417      }
1418      else {
1419        if (oProps.isEmpty()) {
1420          oFileRead = new FileReader (sXMLFile);
1421          oBuff = new BufferedReader (oFileRead, 32767);
1422          ioSrc = new InputSource(oBuff);
1423          parser.parse(ioSrc);
1424          oBuff.close();
1425          oFileRead.close();
1426        }
1427        else {
1428          oFile = new File (sXMLFile);
1429          byBuffer = new byte[new Long (oFile.length()).intValue()];
1430
1431          oStream = new FileInputStream (oFile);
1432          oStream.read(byBuffer);
1433          sXMLSource = new String (byBuffer);
1434          oStream.close();
1435
1436          while (oEnum.hasMoreElements()) {
1437            sParam = (String ) oEnum.nextElement();
1438            try {
1439              oPattern = oCompiler.compile("{#" + sParam + "}");
1440            } catch (MalformedPatternException e) { oPattern=null; }
1441
1442            sXMLSource = Util.substitute(oMatcher, oPattern,
1443                                   new Perl5Substitution(oProps.getProperty(sParam), Perl5Substitution.INTERPOLATE_ALL),
1444                                   sXMLSource, Util.SUBSTITUTE_ALL);
1445          } // wend()
1446
1447          oStrBuff = new StringBufferInputStream (sXMLSource);
1448          ioSrc = new InputSource(oStrBuff);
1449          parser.parse(ioSrc);
1450          oStrBuff.close();
1451        }
1452      }
1453
1454      if (DebugFile.trace) {
1455        DebugFile.decIdent();
1456        DebugFile.writeln ("End DataStruct.parse()");
1457      }
1458  } // parse()
1459
1460  // ----------------------------------------------------------
1461
1462  public void createClassSource(String sPackage, String sSubClassName, String sFile) throws IOException {
1463    FileWriter oFile = new FileWriter (sFile);
1464    DataTransformation oDatT;
1465    Iterator oIter;
1466    LinkedList oList;
1467    Object oPKs;
1468    String sItem;
1469
1470    oFile.write("package " + sPackage + ";\n");
1471    oFile.write("import java.util.Vector;\n");
1472    oFile.write("import java.util.LinkedList;\n");
1473    oFile.write("import java.util.ListIterator;\n");
1474    oFile.write("import java.util.HashMap;\n");
1475    oFile.write("import java.util.Iterator;\n");
1476    oFile.write("import com.knowgate.datacopy.DataRowSet;\n");
1477    oFile.write("import com.knowgate.datacopy.DataStruct;\n");
1478    oFile.write("import com.knowgate.datacopy.DataTransformation;\n");
1479    oFile.write("\n");
1480
1481    oFile.write("public class " + sSubClassName + " extends DataStruct {\n");
1482    oFile.write(" public " + sSubClassName + "() {\n");
1483    oFile.write(" DataRowSet oRowSet;\n");
1484    oFile.write(" DataTransformation oTransForm;\n");
1485    oFile.write(" LinkedList oBefore;\n");
1486    oFile.write(" LinkedList oAfter;\n");
1487    oFile.write(" HashMap oMappings;\n");
1488    oFile.write(" HashMap oDefaults;\n");
1489    oFile.write(" HashMap oTransforms;\n\n");
1490    oFile.write(" InitStmts = new LinkedList();\n");
1491    oFile.write(" TermStmts = new LinkedList();\n");
1492    oFile.write(" oToPKs = new HashMap();\n");
1493    oFile.write(" oFromPKs = new HashMap();\n");
1494    oFile.write(" cTables = " + String.valueOf(DataRowSets.size()) + ";\n");
1495    oFile.write("\n");
1496
1497    oIter = InitStmts.listIterator();
1498    while (oIter.hasNext())
1499      oFile.write(" InitStmts.addLast(\"" + oIter.next().toString() + "\");\n");
1500    oFile.write("\n");
1501
1502    oIter = TermStmts.listIterator();
1503    while (oIter.hasNext())
1504      oFile.write(" TermStmts.addLast(\"" + oIter.next().toString() + "\");\n");
1505    oFile.write("\n");
1506
1507    for (int c=0;c<cTables;c++) {
1508      oCurrRowSet = getRowSet(c);
1509
1510      oFile.write(" oRowSet = new DataRowSet(\"" + oCurrRowSet.OriginTable + "\",\"" + oCurrRowSet.TargetTable + "\",\"" + oCurrRowSet.JoinTables + "\",\"" + oCurrRowSet.WhereClause + "\",\"" + oCurrRowSet.EraseClause + "\");\n");
1511      oFile.write(" oRowSet.FieldList = \"" + oCurrRowSet.FieldList.trim() + "\";\n");
1512      oFile.write(" DataRowSets.add(oRowSet);\n");
1513      oFile.write(" oBefore = new LinkedList();\n");
1514      oFile.write(" oAfter = new LinkedList();\n");
1515      oFile.write(" oMappings = new HashMap();\n");
1516      oFile.write(" oDefaults = new HashMap();\n");
1517      oFile.write(" oTransforms = new HashMap();\n");
1518
1519      oPKs = oFromPKs.get(oCurrRowSet.OriginTable);
1520      if (null!=oPKs)
1521        oFile.write(" oFromPKs.put(\"" + oCurrRowSet.OriginTable + "\",\"" + oPKs.toString() + "\");\n");
1522      oPKs = oToPKs.get(oCurrRowSet.TargetTable);
1523      if (null!=oPKs)
1524        oFile.write(" oToPKs.put(\"" + oCurrRowSet.TargetTable + "\",\"" + oPKs.toString() + "\");\n\n");
1525
1526      oList = (LinkedList ) Before.get(c);
1527      if (oList.size()>0) {
1528        oIter = oList.iterator();
1529        while (oIter.hasNext())
1530          oFile.write(" oBefore.addLast(\"" + oIter.next().toString() + "\");\n");
1531        oIter = null;
1532      } // fi (oList.size()>0)
1533 oList = null;
1534      oFile.write(" Before.add(oBefore);\n");
1535
1536      oList = (LinkedList ) After.get(c);
1537      if (oList.size()>0) {
1538        oIter = oList.iterator();
1539        while (oIter.hasNext())
1540          oFile.write(" oAfter.addLast(\"" + oIter.next().toString() + "\");\n");
1541        oIter = null;
1542      } // fi (oList.size()>0)
1543 oList = null;
1544      oFile.write(" After.add(oAfter);\n");
1545
1546      try {
1547        oCurrMap = (HashMap ) FieldMaps.get(c);
1548        oIter = oCurrMap.keySet().iterator();
1549        while (oIter.hasNext()) {
1550          sItem = (String ) oIter.next();
1551          oFile.write(" oMappings.put(\"" + sItem + "\",\"" + oCurrMap.get(sItem).toString() + "\");\n");
1552        } // wend
1553 } catch (ArrayIndexOutOfBoundsException e) { }
1554
1555      oFile.write(" FieldMaps.add(oMappings);\n");
1556
1557      try {
1558        oFile.write(" Transformations.add(oTransforms);\n");
1559        oCurrTransform = (HashMap ) Transformations.get(c);
1560        oIter = oCurrTransform.keySet().iterator();
1561        while (oIter.hasNext()) {
1562          sItem = oIter.next().toString();
1563          oDatT = (DataTransformation) oCurrTransform.get(sItem);
1564          oFile.write(" oTransForm = new DataTransformation(" + String.valueOf(oDatT.OperationCode) + "," +
1565                      "\"" + oDatT.OriginTable + "\",\"" + oDatT.OriginField + "\"," +
1566                      "\"" + oDatT.TargetTable + "\",\"" + oDatT.TargetField + "\"," +
1567                      (null==oDatT.ReferedTable ? "null" : "\"" + oDatT.ReferedTable + "\"") + "," +
1568                      (null==oDatT.ReferedField ? "null" : "\"" + oDatT.ReferedField + "\"") + "," +
1569                      (null==oDatT.IfNullValue ? "null" : "\"" + oDatT.IfNullValue + "\"") + ");\n");
1570          oFile.write(" oTransforms.put(\"" + sItem + "\", oTransForm);\n");
1571          if (oDatT.OperationCode==DataTransformation.Operations.REFER) oFile.write(" seekReferal(oTransForm);\n");
1572        } // wend
1573 } catch (ArrayIndexOutOfBoundsException e) { }
1574
1575      try {
1576        oCurrDef = (HashMap ) FieldDefs.get(c);
1577        oIter = oCurrDef.keySet().iterator();
1578        while (oIter.hasNext()) {
1579          sItem = (String ) oIter.next();
1580          oFile.write(" oMappings.put(\"" + sItem + "\",\"" + oCurrDef.get(sItem).toString() + "\");\n");
1581        } // wend
1582 } catch (ArrayIndexOutOfBoundsException e) { }
1583
1584      oFile.write(" FieldDefs.add(oDefaults);\n");
1585
1586      oFile.write("\n");
1587    } // end for (c)
1588
1589    oFile.write(" }\n}");
1590
1591    oFile.close();
1592    oFile = null;
1593  } // createClassSource ()
1594
1595  // ----------------------------------------------------------
1596
1597  private boolean bOrPrepared; // Switch que indica si est�n preparados los cursores en Origen
1598 private boolean bTrPrepared; // Switch que indica si est�n preparados los cursores en Destino
1599 private Connection oOrConn; // Conexi�n de Origen
1600 private Connection oTrConn; // Conexi�n de Destino
1601 private int iOrStatus; // Estado de la Conexi�n de Origen {CONNECTED|DISCONNECTED|REFERENCED}
1602 private int iTrStatus; // Estado de la Conexi�n de Destino {CONNECTED|DISCONNECTED|REFERENCED}
1603
1604  protected Vector oResults; // ResultSet de lectura de registros del Origen
1605 protected int iCols; // Variable intermedia para pasar estado del m�todo getRows() a insert() y update()
1606 protected int iRows; // Variable intermedia para pasar estado del m�todo getRows() a insert()
1607
1608  // ---------------------------------------------------------
1609 // Estructuras de datos cargadas al llamar al m�todo parse()
1610
1611  protected int cTables; // Cuenta de tablas en el conjunto de RowSets
1612 protected Vector FieldMaps; // Vector de HashMaps con los mapeos de campos para cada tabla
1613 protected Vector FieldDefs; // Vector de HashMaps con los valores por defecto para cada tabla
1614 protected Vector DataRowSets; // Vector de objetos DataRowSet (uno por tabla)
1615 protected Vector Before; // Vector de Acciones BEFORE para cada tabla
1616 protected Vector After; // Vector de Acciones AFTER para cada tabla
1617 protected LinkedList InitStmts; // Vector de Acciones Inicializacion
1618 protected LinkedList TermStmts; // Vector de Acciones Terminacion
1619 protected Vector Transformations; // Vector con las transformaciones de valores de campos
1620 protected HashMap oFromPKs;
1621  protected HashMap oToPKs;
1622
1623  // ---------------------------------------------------------------------
1624 // Estructuras de datos cargadas al llamar al m�todo prepareStatements()
1625
1626  protected PreparedStatement OrStatements[]; // Cursores de lectura en origen
1627 protected PreparedStatement TrStatements[]; // Cursores de inserci�n en destino
1628 protected PreparedStatement UpStatements[]; // Cursores de actualizaci�n en destino
1629 protected PreparedStatement DlStatements[]; // Cursores de borrado en destino
1630 protected DataTblDef OrMetaData[]; // Definici�n de metadatos en origen
1631 protected DataTblDef TrMetaData[]; // Definici�n de metadatos en destino
1632 public HashMap oInsertTexts;
1633  public HashMap oSelectTexts;
1634
1635  // ---------------------------------------------------------
1636 // Variables temporales para el procesamiento de eventos SAX
1637
1638  private String sChars; // Buffer de lectura de caracteres para SAX
1639 private long fElements;
1640  private long fCharacters;
1641  private String sTransform;
1642  private String sContext;
1643  private String sNode;
1644  private DataRowSet oCurrRowSet;
1645  private HashMap oCurrMap;
1646  private HashMap oCurrDef;
1647  private HashMap oCurrTransform;
1648  private LinkedList oCurrBef;
1649  private LinkedList oCurrAft;
1650
1651  private static final int DISCONNECTED = 0;
1652  private static final int CONNECTED = 1;
1653  private static final int REFERENCED = 2;
1654
1655  // feature ids
1656
1657    protected static final String NAMESPACES_FEATURE_ID = "http://xml.org/sax/features/namespaces";
1658    protected static final String NAMESPACE_PREFIXES_FEATURE_ID = "http://xml.org/sax/features/namespace-prefixes";
1659    protected static final String VALIDATION_FEATURE_ID = "http://xml.org/sax/features/validation";
1660    protected static final String SCHEMA_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/schema";
1661    protected static final String SCHEMA_FULL_CHECKING_FEATURE_ID = "http://apache.org/xml/features/validation/schema-full-checking";
1662    protected static final String DYNAMIC_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/dynamic";
1663
1664  // default settings
1665
1666    protected static final String DEFAULT_PARSER_NAME = "org.apache.xerces.parsers.SAXParser";
1667    protected static final int DEFAULT_REPETITION = 1;
1668    protected static final boolean DEFAULT_NAMESPACES = true;
1669    protected static final boolean DEFAULT_NAMESPACE_PREFIXES = false;
1670    protected static final boolean DEFAULT_VALIDATION = false;
1671    protected static final boolean DEFAULT_SCHEMA_VALIDATION = false;
1672    protected static final boolean DEFAULT_SCHEMA_FULL_CHECKING = false;
1673    protected static final boolean DEFAULT_DYNAMIC_VALIDATION = false;
1674    protected static final boolean DEFAULT_MEMORY_USAGE = false;
1675    protected static final boolean DEFAULT_TAGGINESS = false;
1676}
1677

A to Z: JavaDoc & Examples

---

Daily Java News & Articles

---

Open Source Projects

---

Open Source Codes

---

Free Computer Books

---

Remove Frame

---

Free Books   Free Magazines  

Popular Tags