/**
   * Creates and initializes three new <code>HashMap</code> objects that map the strings returned by
   * the SAX parser to <code>Integer</code> objects. The strings returned by the parser will match
   * the strings that are array elements in this <code>XmlReaderContentHandler</code> object's
   * <code>properties</code>, <code>colDef</code>, or <code>data</code> fields. For each array
   * element in these fields, there is a corresponding constant defined. It is to these constants
   * that the strings are mapped. In the <code>HashMap</code> objects, the string is the key, and
   * the integer is the value.
   *
   * <p>The purpose of the mapping is to make comparisons faster. Because comparing numbers is more
   * efficient than comparing strings, the strings returned by the parser are mapped to integers,
   * which can then be used in a <code>switch</code> statement.
   */
  private void initMaps() {
    int items, i;

    propMap = new HashMap<>();
    items = properties.length;

    for (i = 0; i < items; i++) {
      propMap.put(properties[i], Integer.valueOf(i));
    }

    colDefMap = new HashMap<>();
    items = colDef.length;

    for (i = 0; i < items; i++) {
      colDefMap.put(colDef[i], Integer.valueOf(i));
    }

    dataMap = new HashMap<>();
    items = data.length;

    for (i = 0; i < items; i++) {
      dataMap.put(data[i], Integer.valueOf(i));
    }

    // Initialize connection map here
    typeMap = new HashMap<>();
  }
  /**
   * Sets this <code>XmlReaderContentHandler</code> object's <code>tag</code> field if the given
   * name is the key for a tag and this object's state is not <code>INITIAL</code>. The field is set
   * to the constant that corresponds to the given element name. If the state is <code>INITIAL
   * </code>, the state is set to the given name, which will be one of the sections <code>PROPERTIES
   * </code>, <code>METADATA</code>, or <code>DATA</code>. In either case, this method puts this
   * document handler in the proper state for calling the method <code>endElement</code>.
   *
   * <p>If the state is <code>DATA</code> and the tag is <code>RowTag</code>, <code>DelTag</code>,
   * or <code>InsTag</code>, this method moves the rowset's cursor to the insert row and sets this
   * <code>XmlReaderContentHandler</code> object's <code>idx</code> field to <code>0</code> so that
   * it will be in the proper state when the parser calls the method <code>endElement</code>.
   *
   * @param lName the name of the element; either (1) one of the array elements in the fields <code>
   *     properties</code>, <code>colDef</code>, or <code>data</code> or (2) one of the <code>RowSet
   *     </code> elements <code>"properties"</code>, <code>"metadata"</code>, or <code>"data"</code>
   * @param attributes <code>org.xml.sax.AttributeList</code> objects that are attributes of the
   *     named section element; may be <code>null</code> if there are no attributes, which is the
   *     case for <code>WebRowSet</code> objects
   * @exception SAXException if a general SAX error occurs
   */
  public void startElement(String uri, String lName, String qName, Attributes attributes)
      throws SAXException {
    int tag;
    String name = "";

    name = lName;

    switch (getState()) {
      case PROPERTIES:
        tempCommand = "";
        tag = propMap.get(name);
        if (tag == PropNullTag) setNullValue(true);
        else setTag(tag);
        break;
      case METADATA:
        tag = colDefMap.get(name);

        if (tag == MetaNullTag) setNullValue(true);
        else setTag(tag);
        break;
      case DATA:

        /**
         * This has been added to clear out the values of the previous read so that we should not
         * add up values of data between different tags
         */
        tempStr = "";
        tempUpdate = "";
        if (dataMap.get(name) == null) {
          tag = NullTag;
        } else if (dataMap.get(name) == EmptyStringTag) {
          tag = EmptyStringTag;
        } else {
          tag = dataMap.get(name);
        }

        if (tag == NullTag) {
          setNullValue(true);
        } else if (tag == EmptyStringTag) {
          setEmptyStringValue(true);
        } else {
          setTag(tag);

          if (tag == RowTag || tag == DelTag || tag == InsTag) {
            idx = 0;
            try {
              rs.moveToInsertRow();
            } catch (SQLException ex) {;
            }
          }
        }

        break;
      default:
        setState(name);
    }
  }
  /**
   * Sets the value for the given element if <code>name</code> is one of the array elements in the
   * fields <code>properties</code>, <code>colDef</code>, or <code>data</code> and this <code>
   * XmlReaderContentHandler</code> object's state is not <code>INITIAL</code>. If the state is
   * <code>INITIAL</code>, this method does nothing.
   *
   * <p>If the state is <code>METADATA</code> and the argument supplied is <code>"metadata"</code>,
   * the rowset's metadata is set. If the state is <code>PROPERTIES</code>, the appropriate property
   * is set using the given name to determine the appropriate value. If the state is <code>DATA
   * </code> and the argument supplied is <code>"data"</code>, this method sets the state to <code>
   * INITIAL</code> and returns. If the argument supplied is one of the elements in the field <code>
   * data</code>, this method makes the appropriate changes to the rowset's data.
   *
   * @param lName the name of the element; either (1) one of the array elements in the fields <code>
   *     properties</code>, <code>colDef</code>, or <code>data</code> or (2) one of the <code>RowSet
   *     </code> elements <code>"properties"</code>, <code>"metadata"</code>, or <code>"data"</code>
   * @exception SAXException if a general SAX error occurs
   */
  @SuppressWarnings("fallthrough")
  public void endElement(String uri, String lName, String qName) throws SAXException {
    int tag;

    String name = "";
    name = lName;

    switch (getState()) {
      case PROPERTIES:
        if (name.equals("properties")) {
          state = INITIAL;
          break;
        }

        try {
          tag = propMap.get(name);
          switch (tag) {
            case KeycolsTag:
              if (keyCols != null) {
                int i[] = new int[keyCols.size()];
                for (int j = 0; j < i.length; j++) i[j] = Integer.parseInt(keyCols.elementAt(j));
                rs.setKeyColumns(i);
              }
              break;

            case PropClassTag:
              // Added the handling for Class tags to take care of maps
              // Makes an entry into the map upon end of class tag
              try {
                typeMap.put(Key_map, j86.sun.reflect.misc.ReflectUtil.forName(Value_map));

              } catch (ClassNotFoundException ex) {
                throw new SAXException(
                    MessageFormat.format(
                        resBundle.handleGetObject("xmlrch.errmap").toString(), ex.getMessage()));
              }
              break;

            case MapTag:
              // Added the handling for Map to take set the typeMap
              rs.setTypeMap(typeMap);
              break;

            default:
              break;
          }

          if (getNullValue()) {
            setPropertyValue(null);
            setNullValue(false);
          } else {
            setPropertyValue(propertyValue);
          }
        } catch (SQLException ex) {
          throw new SAXException(ex.getMessage());
        }

        // propertyValue need to be reset to an empty string
        propertyValue = "";
        setTag(-1);
        break;
      case METADATA:
        if (name.equals("metadata")) {
          try {
            rs.setMetaData(md);
            state = INITIAL;
          } catch (SQLException ex) {
            throw new SAXException(
                MessageFormat.format(
                    resBundle.handleGetObject("xmlrch.errmetadata").toString(), ex.getMessage()));
          }
        } else {
          try {
            if (getNullValue()) {
              setMetaDataValue(null);
              setNullValue(false);
            } else {
              setMetaDataValue(metaDataValue);
            }
          } catch (SQLException ex) {
            throw new SAXException(
                MessageFormat.format(
                    resBundle.handleGetObject("xmlrch.errmetadata").toString(), ex.getMessage()));
          }
          // metaDataValue needs to be reset to an empty string
          metaDataValue = "";
        }
        setTag(-1);
        break;
      case DATA:
        if (name.equals("data")) {
          state = INITIAL;
          return;
        }

        if (dataMap.get(name) == null) {
          tag = NullTag;
        } else {
          tag = dataMap.get(name);
        }
        switch (tag) {
          case ColTag:
            try {
              idx++;
              if (getNullValue()) {
                insertValue(null);
                setNullValue(false);
              } else {
                insertValue(tempStr);
              }
              // columnValue now need to be reset to the empty string
              columnValue = "";
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errinsertval").toString(),
                      ex.getMessage()));
            }
            break;
          case RowTag:
            try {
              rs.insertRow();
              rs.moveToCurrentRow();
              rs.next();

              // Making this as the original to turn off the
              // rowInserted flagging
              rs.setOriginalRow();

              applyUpdates();
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errconstr").toString(), ex.getMessage()));
            }
            break;
          case DelTag:
            try {
              rs.insertRow();
              rs.moveToCurrentRow();
              rs.next();
              rs.setOriginalRow();
              applyUpdates();
              rs.deleteRow();
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errdel").toString(), ex.getMessage()));
            }
            break;
          case InsTag:
            try {
              rs.insertRow();
              rs.moveToCurrentRow();
              rs.next();
              applyUpdates();
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errinsert").toString(), ex.getMessage()));
            }
            break;

          case InsDelTag:
            try {
              rs.insertRow();
              rs.moveToCurrentRow();
              rs.next();
              rs.setOriginalRow();
              applyUpdates();
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errinsdel").toString(), ex.getMessage()));
            }
            break;

          case UpdTag:
            try {
              if (getNullValue()) {
                insertValue(null);
                setNullValue(false);
              } else if (getEmptyStringValue()) {
                insertValue("");
                setEmptyStringValue(false);
              } else {
                updates.add(upd);
              }
            } catch (SQLException ex) {
              throw new SAXException(
                  MessageFormat.format(
                      resBundle.handleGetObject("xmlrch.errupdate").toString(), ex.getMessage()));
            }
            break;

          default:
            break;
        }
      default:
        break;
    }
  }