1 /*
   2  * Copyright (c) 2003, 2010, Oracle and/or its affiliates. All rights reserved.
   3  * DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
   4  *
   5  * This code is free software; you can redistribute it and/or modify it
   6  * under the terms of the GNU General Public License version 2 only, as
   7  * published by the Free Software Foundation.  Oracle designates this
   8  * particular file as subject to the "Classpath" exception as provided
   9  * by Oracle in the LICENSE file that accompanied this code.
  10  *
  11  * This code is distributed in the hope that it will be useful, but WITHOUT
  12  * ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
  13  * FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  14  * version 2 for more details (a copy is included in the LICENSE file that
  15  * accompanied this code).
  16  *
  17  * You should have received a copy of the GNU General Public License version
  18  * 2 along with this work; if not, write to the Free Software Foundation,
  19  * Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
  20  *
  21  * Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
  22  * or visit www.oracle.com if you need additional information or have any
  23  * questions.
  24  */
  25 
  26 package com.sun.rowset.internal;
  27 
  28 import java.util.*;
  29 
  30 import org.xml.sax.*;
  31 import org.xml.sax.helpers.*;
  32 
  33 import java.sql.*;
  34 import javax.sql.*;
  35 
  36 import javax.sql.rowset.*;
  37 import com.sun.rowset.*;
  38 import java.io.IOException;
  39 import java.text.MessageFormat;
  40 
  41 /**
  42  * The document handler that receives parse events that an XML parser sends while it
  43  * is parsing an XML document representing a <code>WebRowSet</code> object. The
  44  * parser sends strings to this <code>XmlReaderContentHandler</code> and then uses
  45  * these strings as arguments for the <code>XmlReaderContentHandler</code> methods
  46  * it invokes. The final goal of the SAX parser working with an
  47  * <code>XmlReaderContentHandler</code> object is to read an XML document that represents
  48  * a <code>RowSet</code> object.
  49  * <P>
  50  * A rowset consists of its properties, metadata, and data values. An XML document
  51  * representating a rowset includes the values in these three categories along with
  52  * appropriate XML tags to identify them.  It also includes a top-level XML tag for
  53  * the rowset and three section tags identifying the three categories of values.
  54  * <P>
  55  * The tags in an XML document are hierarchical.
  56  * This means that the top-level tag, <code>RowSet</code>, is
  57  * followed by the three sections with appropriate tags, which are in turn each
  58  * followed by their constituent elements. For example, the <code>properties</code>
  59  * element will be followed by an element for each of the properties listed in
  60  * in this <code>XmlReaderContentHandler</code> object's <code>properties</code>
  61  * field.  The content of the other two fields, <code>colDef</code>, which lists
  62  * the rowset's metadata elements, and <code>data</code>, which lists the rowset's data
  63  * elements, are handled similarly .
  64  * <P>
  65  * This implementation of <code>XmlReaderContentHandler</code> provides the means for the
  66  * parser to determine which elements need to have a value set and then to set
  67  * those values. The methods in this class are all called by the parser; an
  68  * application programmer never calls them directly.
  69  *
  70  */
  71 
  72 public class XmlReaderContentHandler extends DefaultHandler {
  73 
  74     private HashMap propMap;
  75     private HashMap colDefMap;
  76     private HashMap dataMap;
  77 
  78     private HashMap typeMap;
  79 
  80     private Vector updates;
  81     private Vector keyCols;
  82 
  83     private String columnValue;
  84     private String propertyValue;
  85     private String metaDataValue;
  86 
  87     private int tag;
  88     private int state;
  89 
  90     private WebRowSetImpl rs;
  91     private boolean nullVal;
  92     private boolean emptyStringVal;
  93     private RowSetMetaData md;
  94     private int idx;
  95     private String lastval;
  96     private String Key_map;
  97     private String Value_map;
  98     private String tempStr;
  99     private String tempUpdate;
 100     private String tempCommand;
 101     private Object [] upd;
 102 
 103     /**
 104      * A list of the properties for a rowset. There is a constant defined to
 105      * correspond to each of these properties so that a <code>HashMap</code>
 106      * object can be created to map the properties, which are strings, to
 107      * the constants, which are integers.
 108      */
 109     private String [] properties = {"command", "concurrency", "datasource",
 110                             "escape-processing", "fetch-direction", "fetch-size",
 111                             "isolation-level", "key-columns", "map",
 112                             "max-field-size", "max-rows", "query-timeout",
 113                             "read-only", "rowset-type", "show-deleted",
 114                             "table-name", "url", "null", "column", "type",
 115                             "class", "sync-provider", "sync-provider-name",
 116                              "sync-provider-vendor", "sync-provider-version",
 117                              "sync-provider-grade","data-source-lock"};
 118 
 119     /**
 120      * A constant representing the tag for the command property.
 121      */
 122     private final static int CommandTag = 0;
 123 
 124     /**
 125      * A constant representing the tag for the concurrency property.
 126      */
 127     private final static int ConcurrencyTag = 1;
 128 
 129     /**
 130      * A constant representing the tag for the datasource property.
 131      */
 132     private final static int DatasourceTag = 2;
 133 
 134     /**
 135      * A constant representing the tag for the escape-processing property.
 136      */
 137     private final static int EscapeProcessingTag = 3;
 138 
 139     /**
 140      * A constant representing the tag for the fetch-direction property.
 141      */
 142     private final static int FetchDirectionTag = 4;
 143 
 144     /**
 145      * A constant representing the tag for the fetch-size property.
 146      */
 147     private final static int FetchSizeTag = 5;
 148 
 149     /**
 150      * A constant representing the tag for the isolation-level property
 151      */
 152     private final static int IsolationLevelTag = 6;
 153 
 154     /**
 155      * A constant representing the tag for the key-columns property.
 156      */
 157     private final static int KeycolsTag = 7;
 158 
 159     /**
 160      * A constant representing the tag for the map property.
 161      * This map is the type map that specifies the custom mapping
 162      * for an SQL user-defined type.
 163      */
 164     private final static int MapTag = 8;
 165 
 166     /**
 167      * A constant representing the tag for the max-field-size property.
 168      */
 169     private final static int MaxFieldSizeTag = 9;
 170 
 171     /**
 172      * A constant representing the tag for the max-rows property.
 173      */
 174     private final static int MaxRowsTag = 10;
 175 
 176     /**
 177      * A constant representing the tag for the query-timeout property.
 178      */
 179     private final static int QueryTimeoutTag = 11;
 180 
 181     /**
 182      * A constant representing the tag for the read-only property.
 183      */
 184     private final static int ReadOnlyTag = 12;
 185 
 186     /**
 187      * A constant representing the tag for the rowset-type property.
 188      */
 189     private final static int RowsetTypeTag = 13;
 190 
 191     /**
 192      * A constant representing the tag for the show-deleted property.
 193      */
 194     private final static int ShowDeletedTag = 14;
 195 
 196     /**
 197      * A constant representing the tag for the table-name property.
 198      */
 199     private final static int TableNameTag = 15;
 200 
 201     /**
 202      * A constant representing the tag for the URL property.
 203      */
 204     private final static int UrlTag = 16;
 205 
 206     /**
 207      * A constant representing the tag for the null property.
 208      */
 209     private final static int PropNullTag = 17;
 210 
 211     /**
 212      * A constant representing the tag for the column property.
 213      */
 214     private final static int PropColumnTag = 18;
 215 
 216     /**
 217      * A constant representing the tag for the type property.
 218      */
 219     private final static int PropTypeTag = 19;
 220 
 221     /**
 222      * A constant representing the tag for the class property.
 223      */
 224     private final static int PropClassTag = 20;
 225 
 226     /**
 227      * A constant representing the tag for the sync-provider.
 228      */
 229     private final static int SyncProviderTag = 21;
 230 
 231     /**
 232      * A constant representing the tag for the sync-provider
 233      * name
 234      */
 235     private final static int SyncProviderNameTag = 22;
 236 
 237     /**
 238      * A constant representing the tag for the sync-provider
 239      * vendor tag.
 240      */
 241     private final static int SyncProviderVendorTag = 23;
 242 
 243     /**
 244      * A constant representing the tag for the sync-provider
 245      * version tag.
 246      */
 247     private final static int SyncProviderVersionTag = 24;
 248 
 249     /**
 250      * A constant representing the tag for the sync-provider
 251      * grade tag.
 252      */
 253     private final static int SyncProviderGradeTag = 25;
 254 
 255     /**
 256      * A constant representing the tag for the data source lock.
 257      */
 258     private final static int DataSourceLock = 26;
 259 
 260     /**
 261      * A listing of the kinds of metadata information available about
 262      * the columns in a <code>WebRowSet</code> object.
 263      */
 264     private String [] colDef = {"column-count", "column-definition", "column-index",
 265                         "auto-increment", "case-sensitive", "currency",
 266                         "nullable", "signed", "searchable",
 267                         "column-display-size", "column-label", "column-name",
 268                         "schema-name", "column-precision", "column-scale",
 269                         "table-name", "catalog-name", "column-type",
 270                         "column-type-name", "null"};
 271 
 272 
 273     /**
 274      * A constant representing the tag for column-count.
 275      */
 276     private final static int ColumnCountTag = 0;
 277 
 278     /**
 279      * A constant representing the tag for column-definition.
 280      */
 281     private final static int ColumnDefinitionTag = 1;
 282 
 283     /**
 284      * A constant representing the tag for column-index.
 285      */
 286     private final static int ColumnIndexTag = 2;
 287 
 288     /**
 289      * A constant representing the tag for auto-increment.
 290      */
 291     private final static int AutoIncrementTag = 3;
 292 
 293     /**
 294      * A constant representing the tag for case-sensitive.
 295      */
 296     private final static int CaseSensitiveTag = 4;
 297 
 298     /**
 299      * A constant representing the tag for currency.
 300      */
 301     private final static int CurrencyTag = 5;
 302 
 303     /**
 304      * A constant representing the tag for nullable.
 305      */
 306     private final static int NullableTag = 6;
 307 
 308     /**
 309      * A constant representing the tag for signed.
 310      */
 311     private final static int SignedTag = 7;
 312 
 313     /**
 314      * A constant representing the tag for searchable.
 315      */
 316     private final static int SearchableTag = 8;
 317 
 318     /**
 319      * A constant representing the tag for column-display-size.
 320      */
 321     private final static int ColumnDisplaySizeTag = 9;
 322 
 323     /**
 324      * A constant representing the tag for column-label.
 325      */
 326     private final static int ColumnLabelTag = 10;
 327 
 328     /**
 329      * A constant representing the tag for column-name.
 330      */
 331     private final static int ColumnNameTag = 11;
 332 
 333     /**
 334      * A constant representing the tag for schema-name.
 335      */
 336     private final static int SchemaNameTag = 12;
 337 
 338     /**
 339      * A constant representing the tag for column-precision.
 340      */
 341     private final static int ColumnPrecisionTag = 13;
 342 
 343     /**
 344      * A constant representing the tag for column-scale.
 345      */
 346     private final static int ColumnScaleTag = 14;
 347 
 348     /**
 349      * A constant representing the tag for table-name.
 350      */
 351     private final static int MetaTableNameTag = 15;
 352 
 353     /**
 354      * A constant representing the tag for catalog-name.
 355      */
 356     private final static int CatalogNameTag = 16;
 357 
 358     /**
 359      * A constant representing the tag for column-type.
 360      */
 361     private final static int ColumnTypeTag = 17;
 362 
 363     /**
 364      * A constant representing the tag for column-type-name.
 365      */
 366     private final static int ColumnTypeNameTag = 18;
 367 
 368     /**
 369      * A constant representing the tag for null.
 370      */
 371     private final static int MetaNullTag = 19;
 372 
 373     private String [] data = {"currentRow", "columnValue", "insertRow", "deleteRow", "insdel", "updateRow", "null" , "emptyString"};
 374 
 375     private final static int RowTag = 0;
 376     private final static int ColTag = 1;
 377     private final static int InsTag = 2;
 378     private final static int DelTag = 3;
 379     private final static int InsDelTag = 4;
 380     private final static int UpdTag = 5;
 381     private final static int NullTag = 6;
 382     private final static int EmptyStringTag = 7;
 383 
 384     /**
 385      * A constant indicating the state of this <code>XmlReaderContentHandler</code>
 386      * object in which it has not yet been called by the SAX parser and therefore
 387      * has no indication of what type of input to expect from the parser next.
 388      * <P>
 389      * The state is set to <code>INITIAL</code> at the end of each
 390      * section, which allows the sections to appear in any order and
 391      * still be parsed correctly (except that metadata must be
 392      * set before data values can be set).
 393      */
 394     private final static int INITIAL = 0;
 395 
 396     /**
 397      * A constant indicating the state in which this <code>XmlReaderContentHandler</code>
 398      * object expects the next input received from the
 399      * SAX parser to be a string corresponding to one of the elements in
 400      * <code>properties</code>.
 401      */
 402     private final static int PROPERTIES = 1;
 403 
 404     /**
 405      * A constant indicating the state in which this <code>XmlReaderContentHandler</code>
 406      * object expects the next input received from the
 407      * SAX parser to be a string corresponding to one of the elements in
 408      * <code>colDef</code>.
 409      */
 410     private final static int METADATA = 2;
 411 
 412     /**
 413      * A constant indicating the state in which this <code>XmlReaderContentHandler</code>
 414      * object expects the next input received from the
 415      * SAX parser to be a string corresponding to one of the elements in
 416      * <code>data</code>.
 417      */
 418     private final static int DATA = 3;
 419 
 420     private  JdbcRowSetResourceBundle resBundle;
 421 
 422     /**
 423      * Constructs a new <code>XmlReaderContentHandler</code> object that will
 424      * assist the SAX parser in reading a <code>WebRowSet</code> object in the
 425      * format of an XML document. In addition to setting some default values,
 426      * this constructor creates three <code>HashMap</code> objects, one for
 427      * properties, one for metadata, and one for data.  These hash maps map the
 428      * strings sent by the SAX parser to integer constants so that they can be
 429      * compared more efficiently in <code>switch</code> statements.
 430      *
 431      * @param r the <code>RowSet</code> object in XML format that will be read
 432      */
 433     public XmlReaderContentHandler(RowSet r) {
 434         // keep the rowset we've been given
 435         rs = (WebRowSetImpl)r;
 436 
 437         // set-up the token maps
 438         initMaps();
 439 
 440         // allocate the collection for the updates
 441         updates = new Vector();
 442 
 443         // start out with the empty string
 444         columnValue = "";
 445         propertyValue = "";
 446         metaDataValue = "";
 447 
 448         nullVal = false;
 449         idx = 0;
 450         tempStr = "";
 451         tempUpdate = "";
 452         tempCommand = "";
 453 
 454         try {
 455            resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
 456         } catch(IOException ioe) {
 457             throw new RuntimeException(ioe);
 458         }
 459     }
 460 
 461     /**
 462      * Creates and initializes three new <code>HashMap</code> objects that map
 463      * the strings returned by the SAX parser to <code>Integer</code>
 464      * objects.  The strings returned by the parser will match the strings that
 465      * are array elements in this <code>XmlReaderContentHandler</code> object's
 466      * <code>properties</code>, <code>colDef</code>, or <code>data</code>
 467      * fields. For each array element in these fields, there is a corresponding
 468      * constant defined. It is to these constants that the strings are mapped.
 469      * In the <code>HashMap</code> objects, the string is the key, and the
 470      * integer is the value.
 471      * <P>
 472      * The purpose of the mapping is to make comparisons faster.  Because comparing
 473      * numbers is more efficient than comparing strings, the strings returned
 474      * by the parser are mapped to integers, which can then be used in a
 475      * <code>switch</code> statement.
 476      */
 477     private void initMaps() {
 478         int items, i;
 479 
 480         propMap = new HashMap();
 481         items = properties.length;
 482 
 483         for (i=0;i<items;i++) {
 484             propMap.put(properties[i], Integer.valueOf(i));
 485         }
 486 
 487         colDefMap = new HashMap();
 488         items = colDef.length;
 489 
 490         for (i=0;i<items;i++) {
 491             colDefMap.put(colDef[i], Integer.valueOf(i));
 492         }
 493 
 494         dataMap = new HashMap();
 495         items = data.length;
 496 
 497         for (i=0;i<items;i++) {
 498             dataMap.put(data[i], Integer.valueOf(i));
 499         }
 500 
 501         //Initialize connection map here
 502         typeMap = new HashMap();
 503     }
 504 
 505     public void startDocument() throws SAXException {
 506     }
 507 
 508     public void endDocument() throws SAXException {
 509     }
 510 
 511 
 512     /**
 513      * Sets this <code>XmlReaderContentHandler</code> object's <code>tag</code>
 514      * field if the given name is the key for a tag and this object's state
 515      * is not <code>INITIAL</code>.  The field is set
 516      * to the constant that corresponds to the given element name.
 517      * If the state is <code>INITIAL</code>, the state is set to the given
 518      * name, which will be one of the sections <code>PROPERTIES</code>,
 519      * <code>METADATA</code>, or <code>DATA</code>.  In either case, this
 520      * method puts this document handler in the proper state for calling
 521      * the method <code>endElement</code>.
 522      * <P>
 523      * If the state is <code>DATA</code> and the tag is <code>RowTag</code>,
 524      * <code>DelTag</code>, or <code>InsTag</code>, this method moves the
 525      * rowset's cursor to the insert row and sets this
 526      * <code>XmlReaderContentHandler</code> object's <code>idx</code>
 527      * field to <code>0</code> so that it will be in the proper
 528      * state when the parser calls the method <code>endElement</code>.
 529      *
 530      * @param lName the name of the element; either (1) one of the array
 531      *        elements in the fields <code>properties</code>,
 532      *        <code>colDef</code>, or <code>data</code> or
 533      *        (2) one of the <code>RowSet</code> elements
 534      *        <code>"properties"</code>, <code>"metadata"</code>, or
 535      *        <code>"data"</code>
 536      * @param attributes <code>org.xml.sax.AttributeList</code> objects that are
 537      *             attributes of the named section element; may be <code>null</code>
 538      *             if there are no attributes, which is the case for
 539      *             <code>WebRowSet</code> objects
 540      * @exception SAXException if a general SAX error occurs
 541      */
 542     public void startElement(String uri, String lName, String qName, Attributes attributes) throws SAXException {
 543         int tag;
 544         String name = "";
 545 
 546         name = lName;
 547 
 548         switch (getState()) {
 549         case PROPERTIES:
 550 
 551             tempCommand = "";
 552             tag = ((Integer)propMap.get(name)).intValue();
 553             if (tag == PropNullTag)
 554                setNullValue(true);
 555             else
 556                 setTag(tag);
 557             break;
 558         case METADATA:
 559             tag = ((Integer)colDefMap.get(name)).intValue();
 560 
 561             if (tag == MetaNullTag)
 562                 setNullValue(true);
 563             else
 564                 setTag(tag);
 565             break;
 566         case DATA:
 567 
 568             /**
 569               * This has been added to clear out the values of the previous read
 570               * so that we should not add up values of data between different tags
 571               */
 572             tempStr = "";
 573             tempUpdate = "";
 574             if(dataMap.get(name) == null) {
 575                 tag = NullTag;
 576             } else if(((Integer)dataMap.get(name)).intValue() == EmptyStringTag) {
 577                 tag = EmptyStringTag;
 578             } else {
 579                  tag = ((Integer)dataMap.get(name)).intValue();
 580             }
 581 
 582             if (tag == NullTag) {
 583                 setNullValue(true);
 584             } else if(tag == EmptyStringTag) {
 585                 setEmptyStringValue(true);
 586             } else {
 587                 setTag(tag);
 588 
 589                 if (tag == RowTag || tag == DelTag || tag == InsTag) {
 590                     idx = 0;
 591                     try {
 592                         rs.moveToInsertRow();
 593                     } catch (SQLException ex) {
 594                         ;
 595                     }
 596                 }
 597             }
 598 
 599             break;
 600         default:
 601             setState(name);
 602         }
 603 
 604     }
 605 
 606     /**
 607      * Sets the value for the given element if <code>name</code> is one of
 608      * the array elements in the fields <code>properties</code>,
 609      * <code>colDef</code>, or <code>data</code> and this
 610      * <code>XmlReaderContentHandler</code> object's state is not
 611      * <code>INITIAL</code>. If the state is <code>INITIAL</code>,
 612      * this method does nothing.
 613      * <P>
 614      * If the state is <code>METADATA</code> and
 615      * the argument supplied is <code>"metadata"</code>, the rowset's
 616      * metadata is set. If the state is <code>PROPERTIES</code>, the
 617      * appropriate property is set using the given name to determine
 618      * the appropriate value. If the state is <code>DATA</code> and
 619      * the argument supplied is <code>"data"</code>, this method sets
 620      * the state to <code>INITIAL</code> and returns.  If the argument
 621      * supplied is one of the elements in the field <code>data</code>,
 622      * this method makes the appropriate changes to the rowset's data.
 623      *
 624      * @param lName the name of the element; either (1) one of the array
 625      *        elements in the fields <code>properties</code>,
 626      *        <code>colDef</code>, or <code>data</code> or
 627      *        (2) one of the <code>RowSet</code> elements
 628      *        <code>"properties"</code>, <code>"metadata"</code>, or
 629      *        <code>"data"</code>
 630      *
 631      * @exception SAXException if a general SAX error occurs
 632      */
 633     public void endElement(String uri, String lName, String qName) throws SAXException {
 634         int tag;
 635 
 636         String name = "";
 637         name = lName;
 638 
 639         switch (getState()) {
 640         case PROPERTIES:
 641             if (name.equals("properties")) {
 642                 state = INITIAL;
 643                 break;
 644             }
 645 
 646             try {
 647                 tag = ((Integer)propMap.get(name)).intValue();
 648                 switch (tag) {
 649                 case KeycolsTag:
 650                     if (keyCols != null) {
 651                         int i[] = new int[keyCols.size()];
 652                         for (int j = 0; j < i.length; j++)
 653                             i[j] = Integer.parseInt((String)keyCols.elementAt(j));
 654                         rs.setKeyColumns(i);
 655                     }
 656                     break;
 657 
 658                  case PropClassTag:
 659                      //Added the handling for Class tags to take care of maps
 660                      //Makes an entry into the map upon end of class tag
 661                      try{
 662                           typeMap.put(Key_map,Class.forName(Value_map));
 663 
 664                         }catch(ClassNotFoundException ex) {
 665                           throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errmap").toString(), ex.getMessage()));
 666                         }
 667                       break;
 668 
 669                  case MapTag:
 670                       //Added the handling for Map to take set the typeMap
 671                       rs.setTypeMap(typeMap);
 672                       break;
 673 
 674                 default:
 675                     break;
 676                 }
 677 
 678                 if (getNullValue()) {
 679                     setPropertyValue(null);
 680                     setNullValue(false);
 681                 } else {
 682                     setPropertyValue(propertyValue);
 683                 }
 684             } catch (SQLException ex) {
 685                 throw new SAXException(ex.getMessage());
 686             }
 687 
 688             // propertyValue need to be reset to an empty string
 689             propertyValue = "";
 690             setTag(-1);
 691             break;
 692         case METADATA:
 693             if (name.equals("metadata")) {
 694                 try {
 695                     rs.setMetaData(md);
 696                     state = INITIAL;
 697                 } catch (SQLException ex) {
 698                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errmetadata").toString(), ex.getMessage()));
 699                 }
 700             } else {
 701                 try {
 702                     if (getNullValue()) {
 703                         setMetaDataValue(null);
 704                         setNullValue(false);
 705                     } else {
 706                         setMetaDataValue(metaDataValue);
 707                     }
 708                 } catch (SQLException ex) {
 709                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errmetadata").toString(), ex.getMessage()));
 710 
 711                 }
 712                 // metaDataValue needs to be reset to an empty string
 713                 metaDataValue = "";
 714             }
 715             setTag(-1);
 716             break;
 717         case DATA:
 718             if (name.equals("data")) {
 719                 state = INITIAL;
 720                 return;
 721             }
 722 
 723             if(dataMap.get(name) == null) {
 724                 tag = NullTag;
 725             } else {
 726                  tag = ((Integer)dataMap.get(name)).intValue();
 727             }
 728             switch (tag) {
 729             case ColTag:
 730                 try {
 731                     idx++;
 732                     if (getNullValue()) {
 733                         insertValue(null);
 734                         setNullValue(false);
 735                     } else {
 736                         insertValue(tempStr);
 737                     }
 738                     // columnValue now need to be reset to the empty string
 739                     columnValue = "";
 740                 } catch (SQLException ex) {
 741                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errinsertval").toString(), ex.getMessage()));
 742                 }
 743                 break;
 744             case RowTag:
 745                 try {
 746                     rs.insertRow();
 747                     rs.moveToCurrentRow();
 748                     rs.next();
 749 
 750                     // Making this as the original to turn off the
 751                     // rowInserted flagging
 752                     rs.setOriginalRow();
 753 
 754                     applyUpdates();
 755                 } catch (SQLException ex) {
 756                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errconstr").toString(), ex.getMessage()));
 757                 }
 758                 break;
 759             case DelTag:
 760                 try {
 761                     rs.insertRow();
 762                     rs.moveToCurrentRow();
 763                     rs.next();
 764                     rs.setOriginalRow();
 765                     applyUpdates();
 766                 } catch (SQLException ex) {
 767                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errdel").toString() , ex.getMessage()));
 768                 }
 769                 break;
 770             case InsTag:
 771                 try {
 772                     rs.insertRow();
 773                     rs.moveToCurrentRow();
 774                     rs.next();
 775                     applyUpdates();
 776                 } catch (SQLException ex) {
 777                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errinsert").toString() , ex.getMessage()));
 778                 }
 779                 break;
 780 
 781             case InsDelTag:
 782                 try {
 783                     rs.insertRow();
 784                     rs.moveToCurrentRow();
 785                     rs.next();
 786                     rs.setOriginalRow();
 787                     applyUpdates();
 788                 } catch (SQLException ex) {
 789                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errinsdel").toString() , ex.getMessage()));
 790                 }
 791                 break;
 792 
 793              case UpdTag:
 794                  try {
 795                         if(getNullValue())
 796                          {
 797                           insertValue(null);
 798                           setNullValue(false);
 799                          } else if(getEmptyStringValue()) {
 800                                insertValue("");
 801                                setEmptyStringValue(false);
 802                          } else {
 803                             updates.add(upd);
 804                          }
 805                  }  catch(SQLException ex) {
 806                         throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errupdate").toString() , ex.getMessage()));
 807                  }
 808                 break;
 809 
 810             default:
 811                 break;
 812             }
 813         default:
 814             break;
 815         }
 816     }
 817 
 818     private void applyUpdates() throws SAXException {
 819         // now handle any updates
 820         if (updates.size() > 0) {
 821             try {
 822                 Object upd[];
 823                 Iterator i = updates.iterator();
 824                 while (i.hasNext()) {
 825                     upd = (Object [])i.next();
 826                     idx = ((Integer)upd[0]).intValue();
 827 
 828                    if(!(lastval.equals(upd[1]))){
 829                        insertValue((String)(upd[1]));
 830                     }
 831                 }
 832 
 833                 rs.updateRow();
 834                 } catch (SQLException ex) {
 835                     throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errupdrow").toString() , ex.getMessage()));
 836                 }
 837             updates.removeAllElements();
 838         }
 839 
 840 
 841     }
 842 
 843     /**
 844      * Sets a property, metadata, or data value with the characters in
 845      * the given array of characters, starting with the array element
 846      * indicated by <code>start</code> and continuing for <code>length</code>
 847      * number of characters.
 848      * <P>
 849      * The SAX parser invokes this method and supplies
 850      * the character array, start position, and length parameter values it
 851      * got from parsing the XML document.  An application programmer never
 852      * invokes this method directly.
 853      *
 854      * @param ch an array of characters supplied by the SAX parser, all or part of
 855      *         which will be used to set a value
 856      * @param start the position in the given array at which to start
 857      * @param length the number of consecutive characters to use
 858      */
 859     public void characters(char[] ch, int start, int length) throws SAXException {
 860         try {
 861             switch (getState()) {
 862             case PROPERTIES:
 863                 propertyValue = new String(ch, start, length);
 864 
 865                 /**
 866                   * This has been added for handling of special characters. When special
 867                   * characters are encountered the characters function gets called for
 868                   * each of the characters so we need to append the value got in the
 869                   * previous call as it is the same data present between the start and
 870                   * the end tag.
 871                   **/
 872                 tempCommand = tempCommand.concat(propertyValue);
 873                 propertyValue = tempCommand;
 874 
 875                 // Added the following check for handling of type tags in maps
 876                 if(tag == PropTypeTag)
 877                 {
 878                         Key_map = propertyValue;
 879                 }
 880 
 881                 // Added the following check for handling of class tags in maps
 882                 else if(tag == PropClassTag)
 883                 {
 884                         Value_map = propertyValue;
 885                 }
 886                 break;
 887 
 888             case METADATA:
 889 
 890                 // The parser will come here after the endElement as there is
 891                 // "\n" in the after endTag is printed. This will cause a problem
 892                 // when the data between the tags is an empty string so adding
 893                 // below condition to take care of that situation.
 894 
 895                 if (tag == -1)
 896                 {
 897                         break;
 898                 }
 899 
 900                 metaDataValue = new String(ch, start, length);
 901                 break;
 902             case DATA:
 903                 setDataValue(ch, start, length);
 904                 break;
 905             default:
 906                 ;
 907             }
 908         } catch (SQLException ex) {
 909             throw new SAXException(resBundle.handleGetObject("xmlrch.chars").toString() + ex.getMessage());
 910         }
 911     }
 912 
 913     private void setState(String s) throws SAXException {
 914         if (s.equals("webRowSet")) {
 915             state = INITIAL;
 916         } else if (s.equals("properties")) {
 917             if (state != PROPERTIES)
 918                 state = PROPERTIES;
 919             else
 920                 state = INITIAL;
 921         } else if (s.equals("metadata")) {
 922             if (state != METADATA)
 923                 state = METADATA;
 924             else
 925                 state = INITIAL;
 926         } else if (s.equals("data")) {
 927             if (state != DATA)
 928                 state = DATA;
 929             else
 930                 state = INITIAL;
 931         }
 932 
 933     }
 934 
 935     /**
 936      * Retrieves the current state of this <code>XmlReaderContentHandler</code>
 937      * object's rowset, which is stored in the document handler's
 938      * <code>state</code> field.
 939      *
 940      * @return one of the following constants:
 941      *         <code>XmlReaderContentHandler.PROPERTIES</code>
 942      *         <code>XmlReaderContentHandler.METADATA</code>
 943      *         <code>XmlReaderContentHandler.DATA</code>
 944      *         <code>XmlReaderContentHandler.INITIAL</code>
 945      */
 946     private int getState() {
 947         return state;
 948     }
 949 
 950     private void setTag(int t) {
 951         tag = t;
 952     }
 953 
 954     private int getTag() {
 955         return tag;
 956     }
 957 
 958     private void setNullValue(boolean n) {
 959         nullVal = n;
 960     }
 961 
 962     private boolean getNullValue() {
 963         return nullVal;
 964     }
 965 
 966     private void setEmptyStringValue(boolean e) {
 967         emptyStringVal = e;
 968     }
 969 
 970     private boolean getEmptyStringValue() {
 971         return emptyStringVal;
 972     }
 973 
 974     private String getStringValue(String s) {
 975          return s;
 976     }
 977 
 978     private int getIntegerValue(String s) {
 979         return Integer.parseInt(s);
 980     }
 981 
 982     private boolean getBooleanValue(String s) {
 983 
 984         return Boolean.valueOf(s).booleanValue();
 985     }
 986 
 987     private java.math.BigDecimal getBigDecimalValue(String s) {
 988         return new java.math.BigDecimal(s);
 989     }
 990 
 991     private byte getByteValue(String s) {
 992         return Byte.parseByte(s);
 993     }
 994 
 995     private short getShortValue(String s) {
 996         return Short.parseShort(s);
 997     }
 998 
 999     private long getLongValue(String s) {
1000         return Long.parseLong(s);
1001     }
1002 
1003     private float getFloatValue(String s) {
1004         return Float.parseFloat(s);
1005     }
1006 
1007     private double getDoubleValue(String s) {
1008         return Double.parseDouble(s);
1009     }
1010 
1011     private byte[] getBinaryValue(String s) {
1012         return s.getBytes();
1013     }
1014 
1015     private java.sql.Date getDateValue(String s) {
1016         return new java.sql.Date(getLongValue(s));
1017     }
1018 
1019     private java.sql.Time getTimeValue(String s) {
1020         return new java.sql.Time(getLongValue(s));
1021     }
1022 
1023     private java.sql.Timestamp getTimestampValue(String s) {
1024         return new java.sql.Timestamp(getLongValue(s));
1025     }
1026 
1027     private void setPropertyValue(String s) throws SQLException {
1028         // find out if we are going to be dealing with a null
1029         boolean nullValue = getNullValue();
1030 
1031         switch(getTag()) {
1032         case CommandTag:
1033             if (nullValue)
1034                ; //rs.setCommand(null);
1035             else
1036                 rs.setCommand(s);
1037             break;
1038         case ConcurrencyTag:
1039             if (nullValue)
1040                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1041             else
1042                 rs.setConcurrency(getIntegerValue(s));
1043             break;
1044         case DatasourceTag:
1045             if (nullValue)
1046                 rs.setDataSourceName(null);
1047             else
1048                 rs.setDataSourceName(s);
1049             break;
1050         case EscapeProcessingTag:
1051             if (nullValue)
1052                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1053             else
1054                 rs.setEscapeProcessing(getBooleanValue(s));
1055             break;
1056         case FetchDirectionTag:
1057             if (nullValue)
1058                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1059             else
1060                 rs.setFetchDirection(getIntegerValue(s));
1061             break;
1062         case FetchSizeTag:
1063             if (nullValue)
1064                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1065             else
1066                 rs.setFetchSize(getIntegerValue(s));
1067             break;
1068         case IsolationLevelTag:
1069             if (nullValue)
1070                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1071             else
1072                 rs.setTransactionIsolation(getIntegerValue(s));
1073             break;
1074         case KeycolsTag:
1075             break;
1076         case PropColumnTag:
1077             if (keyCols == null)
1078                 keyCols = new Vector();
1079             keyCols.add(s);
1080             break;
1081         case MapTag:
1082             break;
1083         case MaxFieldSizeTag:
1084             if (nullValue)
1085                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1086             else
1087                 rs.setMaxFieldSize(getIntegerValue(s));
1088             break;
1089         case MaxRowsTag:
1090             if (nullValue)
1091                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1092             else
1093                 rs.setMaxRows(getIntegerValue(s));
1094             break;
1095         case QueryTimeoutTag:
1096             if (nullValue)
1097                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1098             else
1099                 rs.setQueryTimeout(getIntegerValue(s));
1100             break;
1101         case ReadOnlyTag:
1102             if (nullValue)
1103                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1104             else
1105                 rs.setReadOnly(getBooleanValue(s));
1106             break;
1107         case RowsetTypeTag:
1108             if (nullValue) {
1109                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1110             } else {
1111                 //rs.setType(getIntegerValue(s));
1112                 String strType = getStringValue(s);
1113                 int iType = 0;
1114 
1115                 if(strType.trim().equals("ResultSet.TYPE_SCROLL_INSENSITIVE")) {
1116                    iType = 1004;
1117                 } else if(strType.trim().equals("ResultSet.TYPE_SCROLL_SENSITIVE"))   {
1118                    iType = 1005;
1119                 } else if(strType.trim().equals("ResultSet.TYPE_FORWARD_ONLY")) {
1120                    iType = 1003;
1121                 }
1122                 rs.setType(iType);
1123             }
1124             break;
1125         case ShowDeletedTag:
1126             if (nullValue)
1127                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
1128             else
1129                 rs.setShowDeleted(getBooleanValue(s));
1130             break;
1131         case TableNameTag:
1132             if (nullValue)
1133                 //rs.setTableName(null);
1134                 ;
1135             else
1136                 rs.setTableName(s);
1137             break;
1138         case UrlTag:
1139             if (nullValue)
1140                 rs.setUrl(null);
1141             else
1142                 rs.setUrl(s);
1143             break;
1144         case SyncProviderNameTag:
1145             if (nullValue) {
1146                 rs.setSyncProvider(null);
1147             } else {
1148                 String str = s.substring(0,s.indexOf("@")+1);
1149                 rs.setSyncProvider(str);
1150             }
1151             break;
1152         case SyncProviderVendorTag:
1153             // to be implemented
1154             break;
1155         case SyncProviderVersionTag:
1156             // to be implemented
1157             break;
1158         case SyncProviderGradeTag:
1159             // to be implemented
1160             break;
1161         case DataSourceLock:
1162             // to be implemented
1163             break;
1164         default:
1165             break;
1166         }
1167 
1168     }
1169 
1170     private void setMetaDataValue(String s) throws SQLException {
1171         // find out if we are going to be dealing with a null
1172         boolean nullValue = getNullValue();
1173 
1174         switch (getTag()) {
1175         case ColumnCountTag:
1176             md = new RowSetMetaDataImpl();
1177             idx = 0;
1178 
1179             if (nullValue) {
1180                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1181             } else {
1182                 md.setColumnCount(getIntegerValue(s));
1183             }
1184             break;
1185         case ColumnDefinitionTag:
1186             break;
1187         case ColumnIndexTag:
1188             idx++;
1189             break;
1190         case AutoIncrementTag:
1191             if (nullValue)
1192                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1193             else
1194                 md.setAutoIncrement(idx, getBooleanValue(s));
1195             break;
1196         case CaseSensitiveTag:
1197             if (nullValue)
1198                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1199             else
1200                 md.setCaseSensitive(idx, getBooleanValue(s));
1201             break;
1202         case CurrencyTag:
1203             if (nullValue)
1204                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1205             else
1206                 md.setCurrency(idx, getBooleanValue(s));
1207             break;
1208         case NullableTag:
1209             if (nullValue)
1210                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1211             else
1212                 md.setNullable(idx, getIntegerValue(s));
1213             break;
1214         case SignedTag:
1215             if (nullValue)
1216                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1217             else
1218                 md.setSigned(idx, getBooleanValue(s));
1219             break;
1220         case SearchableTag:
1221             if (nullValue)
1222                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1223             else
1224                 md.setSearchable(idx, getBooleanValue(s));
1225             break;
1226         case ColumnDisplaySizeTag:
1227             if (nullValue)
1228                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1229             else
1230                 md.setColumnDisplaySize(idx, getIntegerValue(s));
1231             break;
1232         case ColumnLabelTag:
1233             if (nullValue)
1234                 md.setColumnLabel(idx, null);
1235             else
1236                 md.setColumnLabel(idx, s);
1237             break;
1238         case ColumnNameTag:
1239             if (nullValue)
1240                 md.setColumnName(idx, null);
1241             else
1242                 md.setColumnName(idx, s);
1243 
1244             break;
1245         case SchemaNameTag:
1246             if (nullValue) {
1247                 md.setSchemaName(idx, null); }
1248             else
1249                 md.setSchemaName(idx, s);
1250             break;
1251         case ColumnPrecisionTag:
1252             if (nullValue)
1253                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1254             else
1255                 md.setPrecision(idx, getIntegerValue(s));
1256             break;
1257         case ColumnScaleTag:
1258             if (nullValue)
1259                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1260             else
1261                 md.setScale(idx, getIntegerValue(s));
1262             break;
1263         case MetaTableNameTag:
1264             if (nullValue)
1265                 md.setTableName(idx, null);
1266             else
1267                 md.setTableName(idx, s);
1268             break;
1269         case CatalogNameTag:
1270             if (nullValue)
1271                 md.setCatalogName(idx, null);
1272             else
1273                 md.setCatalogName(idx, s);
1274             break;
1275         case ColumnTypeTag:
1276             if (nullValue)
1277                 throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
1278             else
1279                 md.setColumnType(idx, getIntegerValue(s));
1280             break;
1281         case ColumnTypeNameTag:
1282             if (nullValue)
1283                 md.setColumnTypeName(idx, null);
1284             else
1285                 md.setColumnTypeName(idx, s);
1286             break;
1287         default:
1288             //System.out.println("MetaData: Unknown Tag: (" + getTag() + ")");
1289             break;
1290 
1291         }
1292     }
1293 
1294     private void setDataValue(char[] ch, int start, int len) throws SQLException {
1295         switch (getTag()) {
1296         case ColTag:
1297             columnValue = new String(ch, start, len);
1298             /**
1299               * This has been added for handling of special characters. When special
1300               * characters are encountered the characters function gets called for
1301               * each of the characters so we need to append the value got in the
1302               * previous call as it is the same data present between the start and
1303               * the end tag.
1304               **/
1305             tempStr = tempStr.concat(columnValue);
1306             break;
1307         case UpdTag:
1308             upd = new Object[2];
1309 
1310             /**
1311               * This has been added for handling of special characters. When special
1312               * characters are encountered the characters function gets called for
1313               * each of the characters so we need to append the value got in the
1314               * previous call as it is the same data present between the start and
1315               * the end tag.
1316               **/
1317 
1318             tempUpdate = tempUpdate.concat(new String(ch,start,len));
1319             upd[0] = Integer.valueOf(idx);
1320             upd[1] = tempUpdate;
1321             //updates.add(upd);
1322 
1323             lastval = (String)upd[1];
1324             //insertValue(ch, start, len);
1325             break;
1326         case InsTag:
1327 
1328         }
1329     }
1330 
1331     private void insertValue(String s) throws SQLException {
1332 
1333         if (getNullValue()) {
1334             rs.updateNull(idx);
1335             return;
1336         }
1337 
1338         // no longer have to deal with those pesky nulls.
1339         int type = rs.getMetaData().getColumnType(idx);
1340         switch (type) {
1341         case java.sql.Types.BIT:
1342             rs.updateBoolean(idx, getBooleanValue(s));
1343             break;
1344         case java.sql.Types.BOOLEAN:
1345             rs.updateBoolean(idx, getBooleanValue(s));
1346             break;
1347         case java.sql.Types.SMALLINT:
1348         case java.sql.Types.TINYINT:
1349             rs.updateShort(idx, getShortValue(s));
1350             break;
1351         case java.sql.Types.INTEGER:
1352             rs.updateInt(idx, getIntegerValue(s));
1353             break;
1354         case java.sql.Types.BIGINT:
1355             rs.updateLong(idx, getLongValue(s));
1356             break;
1357         case java.sql.Types.REAL:
1358         case java.sql.Types.FLOAT:
1359             rs.updateFloat(idx, getFloatValue(s));
1360             break;
1361         case java.sql.Types.DOUBLE:
1362             rs.updateDouble(idx, getDoubleValue(s));
1363             break;
1364         case java.sql.Types.NUMERIC:
1365         case java.sql.Types.DECIMAL:
1366             rs.updateObject(idx, getBigDecimalValue(s));
1367             break;
1368         case java.sql.Types.BINARY:
1369         case java.sql.Types.VARBINARY:
1370         case java.sql.Types.LONGVARBINARY:
1371             rs.updateBytes(idx, getBinaryValue(s));
1372             break;
1373         case java.sql.Types.DATE:
1374             rs.updateDate(idx,  getDateValue(s));
1375             break;
1376         case java.sql.Types.TIME:
1377             rs.updateTime(idx, getTimeValue(s));
1378             break;
1379         case java.sql.Types.TIMESTAMP:
1380             rs.updateTimestamp(idx, getTimestampValue(s));
1381             break;
1382         case java.sql.Types.CHAR:
1383         case java.sql.Types.VARCHAR:
1384         case java.sql.Types.LONGVARCHAR:
1385             rs.updateString(idx, getStringValue(s));
1386             break;
1387         default:
1388 
1389         }
1390 
1391     }
1392 
1393     /**
1394      * Throws the given <code>SAXParseException</code> object. This
1395      * exception was originally thrown by the SAX parser and is passed
1396      * to the method <code>error</code> when the SAX parser invokes it.
1397      *
1398      * @param e the <code>SAXParseException</code> object to throw
1399      */
1400     public void error (SAXParseException e) throws SAXParseException {
1401             throw e;
1402     }
1403 
1404     // dump warnings too
1405     /**
1406      * Prints a warning message to <code>System.out</code> giving the line
1407      * number and uri for what caused the warning plus a message explaining
1408      * the reason for the warning. This method is invoked by the SAX parser.
1409      *
1410      * @param err a warning generated by the SAX parser
1411      */
1412     public void warning (SAXParseException err) throws SAXParseException {
1413         System.out.println (MessageFormat.format(resBundle.handleGetObject("xmlrch.warning").toString(), new Object[] { err.getMessage(), err.getLineNumber(), err.getSystemId() }));
1414     }
1415 
1416     /**
1417      *
1418      */
1419     public void notationDecl(String name, String publicId, String systemId) {
1420 
1421     }
1422 
1423     /**
1424      *
1425      */
1426     public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) {
1427 
1428     }
1429 
1430    /**
1431     * Returns the current row of this <code>Rowset</code>object.
1432     * The ResultSet's cursor is positioned at the Row which is needed
1433     *
1434     * @return the <code>Row</code> object on which the <code>RowSet</code>
1435     *           implementation objects's cursor is positioned
1436     */
1437     private Row getPresentRow(WebRowSetImpl rs) throws SQLException {
1438          //rs.setOriginalRow();
1439          // ResultSetMetaData rsmd = rs.getMetaData();
1440          // int numCols = rsmd.getColumnCount();
1441          // Object vals[] = new Object[numCols];
1442          // for(int j = 1; j<= numCols ; j++){
1443          //     vals[j-1] = rs.getObject(j);
1444          // }
1445          // return(new Row(numCols, vals));
1446          return null;
1447    }
1448 
1449 
1450 
1451 
1452 }