KickJava   Java API By Example, From Geeks To Geeks.

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 JavaDoc;
36 import java.sql.Connection JavaDoc;
37 import java.sql.Timestamp JavaDoc;
38 import java.sql.SQLException JavaDoc;
39 import java.sql.CallableStatement JavaDoc;
40 import java.sql.Statement JavaDoc;
41 import java.sql.PreparedStatement JavaDoc;
42 import java.sql.ResultSet JavaDoc;
43 import java.sql.ResultSetMetaData JavaDoc;
44
45 import java.io.IOException JavaDoc;
46 import java.io.File JavaDoc;
47 import java.io.FileReader JavaDoc;
48 import java.io.BufferedReader JavaDoc;
49 import java.io.StringBufferInputStream JavaDoc;
50 import java.io.FileInputStream JavaDoc;
51 import java.io.FileWriter JavaDoc;
52 import java.io.StringReader JavaDoc;
53
54 import java.lang.ArrayIndexOutOfBoundsException JavaDoc;
55 import java.lang.ClassNotFoundException JavaDoc;
56 import java.math.BigDecimal JavaDoc;
57 import java.util.Vector JavaDoc;
58 import java.util.LinkedList JavaDoc;
59 import java.util.ListIterator JavaDoc;
60 import java.util.HashMap JavaDoc;
61 import java.util.Properties JavaDoc;
62 import java.util.Enumeration JavaDoc;
63 import java.util.Set JavaDoc;
64 import java.util.Iterator JavaDoc;
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 JavaDoc sPathXMLFile) throws ClassNotFoundException JavaDoc, IllegalAccessException JavaDoc, InstantiationException JavaDoc, IOException JavaDoc, SAXException {
88     initMembers();
89     parse(sPathXMLFile);
90   } // DataStruct()
91

92   // ----------------------------------------------------------
93

94   public DataStruct(String JavaDoc sPathXMLFile, Properties JavaDoc oProps) throws ClassNotFoundException JavaDoc, IllegalAccessException JavaDoc, InstantiationException JavaDoc, IOException JavaDoc, 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 JavaDoc();
114     // Vector de HashMaps con mapeos de nombres de campos
115
FieldMaps = new Vector JavaDoc();
116     // Vector de HashMaps con valores por defecto para campos que no existan en Origen
117
FieldDefs = new Vector JavaDoc();
118     // Transformaciones de datos para reemplazo de nulos y nuevos valores
119
Transformations = new Vector JavaDoc();
120     // Vector con acciones para efectuar antes de empezar la copia de cada Rowset
121
Before = new Vector JavaDoc();
122     // Vector con acciones para efectuar después de terminar la copia de cada Rowset
123
After = new Vector JavaDoc();
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 JavaDoc {
131     oTrConn.setAutoCommit(bAutoCommit);
132   }
133
134   // ----------------------------------------------------------
135

136   public void commit() throws SQLException JavaDoc {
137     oTrConn.commit();
138   }
139
140   // ----------------------------------------------------------
141

142   public void rollback() throws SQLException JavaDoc {
143     oTrConn.rollback();
144   }
145
146
147   // ----------------------------------------------------------
148

149   public void connectOrigin(String JavaDoc sDriver, String JavaDoc sURL, String JavaDoc sUsr, String JavaDoc sPwd, String JavaDoc sSchema) throws SQLException JavaDoc,ClassNotFoundException JavaDoc {
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 JavaDoc 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 JavaDoc sDriver, String JavaDoc sURL, String JavaDoc sUsr, String JavaDoc sPwd, String JavaDoc sSchema) throws SQLException JavaDoc,ClassNotFoundException JavaDoc {
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 JavaDoc 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 JavaDoc getOriginConnection() {
184     return oOrConn;
185   }
186
187   // ----------------------------------------------------------
188

189   public Connection JavaDoc getTargetConnection() {
190     return oTrConn;
191   }
192
193   // ----------------------------------------------------------
194

195   public void setOriginConnection(Connection JavaDoc 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 JavaDoc 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 JavaDoc {
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 JavaDoc {
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 JavaDoc getResult(int iRow, int iCol) {
279     return ((Vector JavaDoc) oResults.get(iRow)).get(iCol);
280   }
281
282   // ----------------------------------------------------------
283

284   private boolean isEmpty(String JavaDoc 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 JavaDoc sTime, int iTable, Object JavaDoc PK[], int cParams)
297       throws SQLException JavaDoc,NullPointerException JavaDoc {
298     // Ejecuta los comandos <INIT>, <TERM>, <BEFORE> o <AFTER> definidos para este DataStruct
299
CallableStatement JavaDoc oCall;
300     Statement JavaDoc oStmt;
301     ResultSet JavaDoc rCount;
302     int cAffected;
303     String JavaDoc sSQL;
304     String JavaDoc sTable;
305     ListIterator JavaDoc 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 JavaDoc("DataStruct.execCommands() InitStmts list not initialized");
321         oIter = InitStmts.listIterator();
322       } else {
323         if (null==TermStmts)
324           throw new NullPointerException JavaDoc("DataStruct.execCommands() TermStmts list not initialized");
325         oIter = TermStmts.listIterator();
326       }
327     }
328     else {
329       if (sTime.equals("BEFORE"))
330         oIter = ((LinkedList JavaDoc)Before.get(iTable)).listIterator();
331       else
332         oIter = ((LinkedList JavaDoc)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 JavaDoc {
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 JavaDoc oMap;
374     String JavaDoc sSQL;
375     boolean bIsMapped;
376     boolean bHasDefault;
377     int iTrCols;
378     String JavaDoc 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 JavaDoc(2*cTables); // Texto SQL de las sentencias Insert
388
oSelectTexts = new HashMap JavaDoc(2*cTables); // Texto SQL de las sentencias Select
389

390     OrStatements = new PreparedStatement JavaDoc[cTables]; // Sentencias de lectura
391
TrStatements = new PreparedStatement JavaDoc[cTables]; // Sentencias de escritura
392
UpStatements = new PreparedStatement JavaDoc[cTables]; // Sentencias de actualización
393
DlStatements = new PreparedStatement JavaDoc[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 JavaDoc) 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 JavaDoc) oToPKs.get(getRowSet(s).OriginTable) + ")");
467         OrMetaData[s].readMetaData(oOrConn, getRowSet(s).OriginTable, (String JavaDoc) 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 JavaDoc) 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 JavaDoc) oMap.get(sCol);
495               else {
496                 bIsMapped = oMap.containsKey(sCol.toUpperCase());
497                 if (bIsMapped)
498                   sCol = (String JavaDoc) oMap.get(sCol.toUpperCase());
499                 else {
500                   bIsMapped = oMap.containsKey(sCol.toLowerCase());
501                   if (bIsMapped)
502                     sCol = (String JavaDoc) oMap.get(sCol.toLowerCase());
503                 }
504               }
505             }
506             catch (ArrayIndexOutOfBoundsException JavaDoc 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 JavaDoc) FieldDefs.get(s);
515                 bHasDefault = oMap.containsKey(sCol);
516               }
517               catch (ArrayIndexOutOfBoundsException JavaDoc 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 JavaDoc) 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 JavaDoc convert (Object JavaDoc oValue, int iSQLType) {
566     // Función de soporte para hacer castings de tipos entre bases de datos
567

568     Object JavaDoc oRetVal;
569     String JavaDoc 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 JavaDoc(oValue.toString());
586         else if (java.sql.Types.INTEGER == iSQLType)
587           oRetVal = new Integer JavaDoc(oValue.toString());
588         else if (java.sql.Types.SMALLINT == iSQLType)
589           oRetVal = new Short JavaDoc(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 JavaDoc(oValue.toString());
597         else if (java.sql.Types.SMALLINT == iSQLType)
598           oRetVal = new Short JavaDoc(oValue.toString());
599         else if (java.sql.Types.INTEGER == iSQLType) {
600           String JavaDoc str = oValue.toString();
601           oRetVal = new Integer JavaDoc(str);
602           }
603         else
604           oRetVal = oValue;
605       }
606       else if (sClass.equals("java.sql.Timestamp")) {
607         oRetVal = new java.sql.Date JavaDoc(((Timestamp JavaDoc)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 JavaDoc[] OrPK, Object JavaDoc[] TrPK, int cParams, int iTable) throws SQLException JavaDoc {
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 JavaDoc oRow;
679     HashMap JavaDoc oTransforms;
680     Object JavaDoc oOriginalValue;
681     Object JavaDoc oTransformedValue;
682     ResultSet JavaDoc oRSet;
683     ResultSetMetaData JavaDoc oRDat;
684     DataRowSet oDatR;
685     String JavaDoc sColName;
686     DataTblDef oMDat = OrMetaData[iTable];
687     DataTransformation oDatT;
688     PreparedStatement JavaDoc oStmt = OrStatements[iTable];
689     PreparedStatement JavaDoc 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 JavaDoc(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 JavaDoc) Transformations.get(iTable);
743       cTransforms = oTransforms.size();
744     }
745     catch (ArrayIndexOutOfBoundsException JavaDoc 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 JavaDoc(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 JavaDoc(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 JavaDoc 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 JavaDoc[] OrPK, Object JavaDoc[] TrPK, int cParams)
811     throws SQLException JavaDoc,NullPointerException JavaDoc {
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 JavaDoc sField;
817     DataTblDef oMDat;
818     PreparedStatement JavaDoc oInsrt;
819     StringReader JavaDoc oReader;
820     Object JavaDoc oValue;
821     String JavaDoc 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 JavaDoc(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 JavaDoc[] OrPK, Object JavaDoc[] TrPK, int cParams) throws SQLException JavaDoc {
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 JavaDoc sField;
910     DataTblDef oMDat;
911     PreparedStatement JavaDoc oInsrt;
912     PreparedStatement JavaDoc oUpdt;
913     Object JavaDoc oValue;
914     String JavaDoc sValue;
915     StringReader JavaDoc 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 JavaDoc(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 JavaDoc(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 JavaDoc oTransformsRef;
1065    Set JavaDoc oTransformSet;
1066    Iterator JavaDoc oSetIterator;
1067    String JavaDoc sChildTable;
1068    String JavaDoc 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 JavaDoc) 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 JavaDoc (5,3);
1121    oToPKs = new HashMap JavaDoc (5,3);
1122
1123    InitStmts = new LinkedList JavaDoc();
1124    TermStmts = new LinkedList JavaDoc();
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 JavaDoc uri, String JavaDoc local, String JavaDoc 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 JavaDoc(13,5);
1145      FieldMaps.add(oCurrMap);
1146
1147      oCurrTransform = new HashMap JavaDoc(5,3);
1148      Transformations.add(oCurrTransform);
1149
1150      oCurrDef = new HashMap JavaDoc(13,5);
1151      FieldDefs.add(oCurrDef);
1152
1153      oCurrBef = new LinkedList JavaDoc();
1154      Before.add(oCurrBef);
1155
1156      oCurrAft = new LinkedList JavaDoc();
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 JavaDoc uri, String JavaDoc localName, String JavaDoc qname) throws SAXException {
1183    int iComma;
1184    String JavaDoc sOrFld;
1185    String JavaDoc sOrVal;
1186    String JavaDoc 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 JavaDoc(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 JavaDoc composeError(String JavaDoc type, SAXParseException ex) {
1313        String JavaDoc sErrDesc = "";
1314        String JavaDoc 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 JavaDoc sXMLFile) throws InstantiationException JavaDoc,IllegalAccessException JavaDoc,ClassNotFoundException JavaDoc,IOException JavaDoc,SAXException {
1345      Properties JavaDoc oProps = new Properties JavaDoc();
1346      parse(sXMLFile, oProps);
1347    }
1348
1349    public void parse(String JavaDoc sXMLFile, Properties JavaDoc oProps) throws InstantiationException JavaDoc,IllegalAccessException JavaDoc,ClassNotFoundException JavaDoc,IOException JavaDoc,SAXException {
1350        // This method parses an XML document into a DataStruct instace
1351

1352        // local variables
1353
XMLReader parser;
1354        Parser sax1Parser;
1355        File JavaDoc oFile;
1356        FileReader JavaDoc oFileRead;
1357        BufferedReader JavaDoc oBuff;
1358        StringBufferInputStream JavaDoc oStrBuff;
1359        InputSource ioSrc;
1360        FileInputStream JavaDoc oStream;
1361        String JavaDoc sXMLSource;
1362        String JavaDoc sParam;
1363        Enumeration JavaDoc 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 JavaDoc 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 JavaDoc) 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 JavaDoc(sXMLFile);
1414        ioSrc = new InputSource(oStrBuff);
1415        parser.parse(ioSrc);
1416        oStrBuff.close();
1417      }
1418      else {
1419        if (oProps.isEmpty()) {
1420          oFileRead = new FileReader JavaDoc(sXMLFile);
1421          oBuff = new BufferedReader JavaDoc(oFileRead, 32767);
1422          ioSrc = new InputSource(oBuff);
1423          parser.parse(ioSrc);
1424          oBuff.close();
1425          oFileRead.close();
1426        }
1427        else {
1428          oFile = new File JavaDoc(sXMLFile);
1429          byBuffer = new byte[new Long JavaDoc(oFile.length()).intValue()];
1430
1431          oStream = new FileInputStream JavaDoc(oFile);
1432          oStream.read(byBuffer);
1433          sXMLSource = new String JavaDoc(byBuffer);
1434          oStream.close();
1435
1436          while (oEnum.hasMoreElements()) {
1437            sParam = (String JavaDoc) 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 JavaDoc(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 JavaDoc sPackage, String JavaDoc sSubClassName, String JavaDoc sFile) throws IOException JavaDoc{
1463    FileWriter JavaDoc oFile = new FileWriter JavaDoc(sFile);
1464    DataTransformation oDatT;
1465    Iterator JavaDoc oIter;
1466    LinkedList JavaDoc oList;
1467    Object JavaDoc oPKs;
1468    String JavaDoc 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 JavaDoc) 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 JavaDoc) 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 JavaDoc) FieldMaps.get(c);
1548        oIter = oCurrMap.keySet().iterator();
1549        while (oIter.hasNext()) {
1550          sItem = (String JavaDoc) oIter.next();
1551          oFile.write(" oMappings.put(\"" + sItem + "\",\"" + oCurrMap.get(sItem).toString() + "\");\n");
1552        } // wend
1553
} catch (ArrayIndexOutOfBoundsException JavaDoc e) { }
1554
1555      oFile.write(" FieldMaps.add(oMappings);\n");
1556
1557      try {
1558        oFile.write(" Transformations.add(oTransforms);\n");
1559        oCurrTransform = (HashMap JavaDoc) 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 JavaDoc e) { }
1574
1575      try {
1576        oCurrDef = (HashMap JavaDoc) FieldDefs.get(c);
1577        oIter = oCurrDef.keySet().iterator();
1578        while (oIter.hasNext()) {
1579          sItem = (String JavaDoc) oIter.next();
1580          oFile.write(" oMappings.put(\"" + sItem + "\",\"" + oCurrDef.get(sItem).toString() + "\");\n");
1581        } // wend
1582
} catch (ArrayIndexOutOfBoundsException JavaDoc 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 JavaDoc oOrConn; // Conexión de Origen
1600
private Connection JavaDoc 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 JavaDoc 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 JavaDoc FieldMaps; // Vector de HashMaps con los mapeos de campos para cada tabla
1613
protected Vector JavaDoc FieldDefs; // Vector de HashMaps con los valores por defecto para cada tabla
1614
protected Vector JavaDoc DataRowSets; // Vector de objetos DataRowSet (uno por tabla)
1615
protected Vector JavaDoc Before; // Vector de Acciones BEFORE para cada tabla
1616
protected Vector JavaDoc After; // Vector de Acciones AFTER para cada tabla
1617
protected LinkedList JavaDoc InitStmts; // Vector de Acciones Inicializacion
1618
protected LinkedList JavaDoc TermStmts; // Vector de Acciones Terminacion
1619
protected Vector JavaDoc Transformations; // Vector con las transformaciones de valores de campos
1620
protected HashMap JavaDoc oFromPKs;
1621  protected HashMap JavaDoc oToPKs;
1622
1623  // ---------------------------------------------------------------------
1624
// Estructuras de datos cargadas al llamar al método prepareStatements()
1625

1626  protected PreparedStatement JavaDoc OrStatements[]; // Cursores de lectura en origen
1627
protected PreparedStatement JavaDoc TrStatements[]; // Cursores de inserción en destino
1628
protected PreparedStatement JavaDoc UpStatements[]; // Cursores de actualización en destino
1629
protected PreparedStatement JavaDoc 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 JavaDoc oInsertTexts;
1633  public HashMap JavaDoc oSelectTexts;
1634
1635  // ---------------------------------------------------------
1636
// Variables temporales para el procesamiento de eventos SAX
1637

1638  private String JavaDoc sChars; // Buffer de lectura de caracteres para SAX
1639
private long fElements;
1640  private long fCharacters;
1641  private String JavaDoc sTransform;
1642  private String JavaDoc sContext;
1643  private String JavaDoc sNode;
1644  private DataRowSet oCurrRowSet;
1645  private HashMap JavaDoc oCurrMap;
1646  private HashMap JavaDoc oCurrDef;
1647  private HashMap JavaDoc oCurrTransform;
1648  private LinkedList JavaDoc oCurrBef;
1649  private LinkedList JavaDoc 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 JavaDoc NAMESPACES_FEATURE_ID = "http://xml.org/sax/features/namespaces";
1658    protected static final String JavaDoc NAMESPACE_PREFIXES_FEATURE_ID = "http://xml.org/sax/features/namespace-prefixes";
1659    protected static final String JavaDoc VALIDATION_FEATURE_ID = "http://xml.org/sax/features/validation";
1660    protected static final String JavaDoc SCHEMA_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/schema";
1661    protected static final String JavaDoc SCHEMA_FULL_CHECKING_FEATURE_ID = "http://apache.org/xml/features/validation/schema-full-checking";
1662    protected static final String JavaDoc DYNAMIC_VALIDATION_FEATURE_ID = "http://apache.org/xml/features/validation/dynamic";
1663
1664  // default settings
1665

1666    protected static final String JavaDoc 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
Popular Tags