Back to index...

	/*
	* Copyright (c) 2003, 2013, Oracle and/or its affiliates. All rights reserved.
	* DO NOT ALTER OR REMOVE COPYRIGHT NOTICES OR THIS FILE HEADER.
	*
	* This code is free software; you can redistribute it and/or modify it
	* under the terms of the GNU General Public License version 2 only, as
	* published by the Free Software Foundation. Oracle designates this
	* particular file as subject to the "Classpath" exception as provided
	* by Oracle in the LICENSE file that accompanied this code.
	*
	* This code is distributed in the hope that it will be useful, but WITHOUT
	* ANY WARRANTY; without even the implied warranty of MERCHANTABILITY or
	* FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
	* version 2 for more details (a copy is included in the LICENSE file that
	* accompanied this code).
	*
	* You should have received a copy of the GNU General Public License version
	* 2 along with this work; if not, write to the Free Software Foundation,
	* Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA.
	*
	* Please contact Oracle, 500 Oracle Parkway, Redwood Shores, CA 94065 USA
	* or visit www.oracle.com if you need additional information or have any
	* questions.
	*/

	package com.sun.rowset.internal;

	import java.util.*;

	import org.xml.sax.*;
	import org.xml.sax.helpers.*;

	import java.sql.*;
	import javax.sql.*;

	import javax.sql.rowset.*;
	import com.sun.rowset.*;
	import java.io.IOException;
	import java.text.MessageFormat;

	/**
	* The document handler that receives parse events that an XML parser sends while it
	* is parsing an XML document representing a <code>WebRowSet</code> object. The
	* parser sends strings to this <code>XmlReaderContentHandler</code> and then uses
	* these strings as arguments for the <code>XmlReaderContentHandler</code> methods
	* it invokes. The final goal of the SAX parser working with an
	* <code>XmlReaderContentHandler</code> object is to read an XML document that represents
	* a <code>RowSet</code> object.
	* <P>
	* A rowset consists of its properties, metadata, and data values. An XML document
	* representating a rowset includes the values in these three categories along with
	* appropriate XML tags to identify them. It also includes a top-level XML tag for
	* the rowset and three section tags identifying the three categories of values.
	* <P>
	* The tags in an XML document are hierarchical.
	* This means that the top-level tag, <code>RowSet</code>, is
	* followed by the three sections with appropriate tags, which are in turn each
	* followed by their constituent elements. For example, the <code>properties</code>
	* element will be followed by an element for each of the properties listed in
	* in this <code>XmlReaderContentHandler</code> object's <code>properties</code>
	* field. The content of the other two fields, <code>colDef</code>, which lists
	* the rowset's metadata elements, and <code>data</code>, which lists the rowset's data
	* elements, are handled similarly .
	* <P>
	* This implementation of <code>XmlReaderContentHandler</code> provides the means for the
	* parser to determine which elements need to have a value set and then to set
	* those values. The methods in this class are all called by the parser; an
	* application programmer never calls them directly.
	*
	*/

	public class XmlReaderContentHandler extends DefaultHandler {

	private HashMap <String, Integer> propMap;
	private HashMap <String, Integer> colDefMap;
	private HashMap <String, Integer> dataMap;

	private HashMap<String,Class<?>> typeMap;

	private Vector<Object[]> updates;
	private Vector<String> keyCols;

	private String columnValue;
	private String propertyValue;
	private String metaDataValue;

	private int tag;
	private int state;

	private WebRowSetImpl rs;
	private boolean nullVal;
	private boolean emptyStringVal;
	private RowSetMetaData md;
	private int idx;
	private String lastval;
	private String Key_map;
	private String Value_map;
	private String tempStr;
	private String tempUpdate;
	private String tempCommand;
	private Object [] upd;

	/**
	* A list of the properties for a rowset. There is a constant defined to
	* correspond to each of these properties so that a <code>HashMap</code>
	* object can be created to map the properties, which are strings, to
	* the constants, which are integers.
	*/
	private String [] properties = {"command", "concurrency", "datasource",
	"escape-processing", "fetch-direction", "fetch-size",
	"isolation-level", "key-columns", "map",
	"max-field-size", "max-rows", "query-timeout",
	"read-only", "rowset-type", "show-deleted",
	"table-name", "url", "null", "column", "type",
	"class", "sync-provider", "sync-provider-name",
	"sync-provider-vendor", "sync-provider-version",
	"sync-provider-grade","data-source-lock"};

	/**
	* A constant representing the tag for the command property.
	*/
	private final static int CommandTag = 0;

	/**
	* A constant representing the tag for the concurrency property.
	*/
	private final static int ConcurrencyTag = 1;

	/**
	* A constant representing the tag for the datasource property.
	*/
	private final static int DatasourceTag = 2;

	/**
	* A constant representing the tag for the escape-processing property.
	*/
	private final static int EscapeProcessingTag = 3;

	/**
	* A constant representing the tag for the fetch-direction property.
	*/
	private final static int FetchDirectionTag = 4;

	/**
	* A constant representing the tag for the fetch-size property.
	*/
	private final static int FetchSizeTag = 5;

	/**
	* A constant representing the tag for the isolation-level property
	*/
	private final static int IsolationLevelTag = 6;

	/**
	* A constant representing the tag for the key-columns property.
	*/
	private final static int KeycolsTag = 7;

	/**
	* A constant representing the tag for the map property.
	* This map is the type map that specifies the custom mapping
	* for an SQL user-defined type.
	*/
	private final static int MapTag = 8;

	/**
	* A constant representing the tag for the max-field-size property.
	*/
	private final static int MaxFieldSizeTag = 9;

	/**
	* A constant representing the tag for the max-rows property.
	*/
	private final static int MaxRowsTag = 10;

	/**
	* A constant representing the tag for the query-timeout property.
	*/
	private final static int QueryTimeoutTag = 11;

	/**
	* A constant representing the tag for the read-only property.
	*/
	private final static int ReadOnlyTag = 12;

	/**
	* A constant representing the tag for the rowset-type property.
	*/
	private final static int RowsetTypeTag = 13;

	/**
	* A constant representing the tag for the show-deleted property.
	*/
	private final static int ShowDeletedTag = 14;

	/**
	* A constant representing the tag for the table-name property.
	*/
	private final static int TableNameTag = 15;

	/**
	* A constant representing the tag for the URL property.
	*/
	private final static int UrlTag = 16;

	/**
	* A constant representing the tag for the null property.
	*/
	private final static int PropNullTag = 17;

	/**
	* A constant representing the tag for the column property.
	*/
	private final static int PropColumnTag = 18;

	/**
	* A constant representing the tag for the type property.
	*/
	private final static int PropTypeTag = 19;

	/**
	* A constant representing the tag for the class property.
	*/
	private final static int PropClassTag = 20;

	/**
	* A constant representing the tag for the sync-provider.
	*/
	private final static int SyncProviderTag = 21;

	/**
	* A constant representing the tag for the sync-provider
	* name
	*/
	private final static int SyncProviderNameTag = 22;

	/**
	* A constant representing the tag for the sync-provider
	* vendor tag.
	*/
	private final static int SyncProviderVendorTag = 23;

	/**
	* A constant representing the tag for the sync-provider
	* version tag.
	*/
	private final static int SyncProviderVersionTag = 24;

	/**
	* A constant representing the tag for the sync-provider
	* grade tag.
	*/
	private final static int SyncProviderGradeTag = 25;

	/**
	* A constant representing the tag for the data source lock.
	*/
	private final static int DataSourceLock = 26;

	/**
	* A listing of the kinds of metadata information available about
	* the columns in a <code>WebRowSet</code> object.
	*/
	private String [] colDef = {"column-count", "column-definition", "column-index",
	"auto-increment", "case-sensitive", "currency",
	"nullable", "signed", "searchable",
	"column-display-size", "column-label", "column-name",
	"schema-name", "column-precision", "column-scale",
	"table-name", "catalog-name", "column-type",
	"column-type-name", "null"};


	/**
	* A constant representing the tag for column-count.
	*/
	private final static int ColumnCountTag = 0;

	/**
	* A constant representing the tag for column-definition.
	*/
	private final static int ColumnDefinitionTag = 1;

	/**
	* A constant representing the tag for column-index.
	*/
	private final static int ColumnIndexTag = 2;

	/**
	* A constant representing the tag for auto-increment.
	*/
	private final static int AutoIncrementTag = 3;

	/**
	* A constant representing the tag for case-sensitive.
	*/
	private final static int CaseSensitiveTag = 4;

	/**
	* A constant representing the tag for currency.
	*/
	private final static int CurrencyTag = 5;

	/**
	* A constant representing the tag for nullable.
	*/
	private final static int NullableTag = 6;

	/**
	* A constant representing the tag for signed.
	*/
	private final static int SignedTag = 7;

	/**
	* A constant representing the tag for searchable.
	*/
	private final static int SearchableTag = 8;

	/**
	* A constant representing the tag for column-display-size.
	*/
	private final static int ColumnDisplaySizeTag = 9;

	/**
	* A constant representing the tag for column-label.
	*/
	private final static int ColumnLabelTag = 10;

	/**
	* A constant representing the tag for column-name.
	*/
	private final static int ColumnNameTag = 11;

	/**
	* A constant representing the tag for schema-name.
	*/
	private final static int SchemaNameTag = 12;

	/**
	* A constant representing the tag for column-precision.
	*/
	private final static int ColumnPrecisionTag = 13;

	/**
	* A constant representing the tag for column-scale.
	*/
	private final static int ColumnScaleTag = 14;

	/**
	* A constant representing the tag for table-name.
	*/
	private final static int MetaTableNameTag = 15;

	/**
	* A constant representing the tag for catalog-name.
	*/
	private final static int CatalogNameTag = 16;

	/**
	* A constant representing the tag for column-type.
	*/
	private final static int ColumnTypeTag = 17;

	/**
	* A constant representing the tag for column-type-name.
	*/
	private final static int ColumnTypeNameTag = 18;

	/**
	* A constant representing the tag for null.
	*/
	private final static int MetaNullTag = 19;

	private String [] data = {"currentRow", "columnValue", "insertRow", "deleteRow", "insdel", "updateRow", "null" , "emptyString"};

	private final static int RowTag = 0;
	private final static int ColTag = 1;
	private final static int InsTag = 2;
	private final static int DelTag = 3;
	private final static int InsDelTag = 4;
	private final static int UpdTag = 5;
	private final static int NullTag = 6;
	private final static int EmptyStringTag = 7;

	/**
	* A constant indicating the state of this <code>XmlReaderContentHandler</code>
	* object in which it has not yet been called by the SAX parser and therefore
	* has no indication of what type of input to expect from the parser next.
	* <P>
	* The state is set to <code>INITIAL</code> at the end of each
	* section, which allows the sections to appear in any order and
	* still be parsed correctly (except that metadata must be
	* set before data values can be set).
	*/
	private final static int INITIAL = 0;

	/**
	* A constant indicating the state in which this <code>XmlReaderContentHandler</code>
	* object expects the next input received from the
	* SAX parser to be a string corresponding to one of the elements in
	* <code>properties</code>.
	*/
	private final static int PROPERTIES = 1;

	/**
	* A constant indicating the state in which this <code>XmlReaderContentHandler</code>
	* object expects the next input received from the
	* SAX parser to be a string corresponding to one of the elements in
	* <code>colDef</code>.
	*/
	private final static int METADATA = 2;

	/**
	* A constant indicating the state in which this <code>XmlReaderContentHandler</code>
	* object expects the next input received from the
	* SAX parser to be a string corresponding to one of the elements in
	* <code>data</code>.
	*/
	private final static int DATA = 3;

	private JdbcRowSetResourceBundle resBundle;

	/**
	* Constructs a new <code>XmlReaderContentHandler</code> object that will
	* assist the SAX parser in reading a <code>WebRowSet</code> object in the
	* format of an XML document. In addition to setting some default values,
	* this constructor creates three <code>HashMap</code> objects, one for
	* properties, one for metadata, and one for data. These hash maps map the
	* strings sent by the SAX parser to integer constants so that they can be
	* compared more efficiently in <code>switch</code> statements.
	*
	* @param r the <code>RowSet</code> object in XML format that will be read
	*/
	public XmlReaderContentHandler(RowSet r) {
	// keep the rowset we've been given
	rs = (WebRowSetImpl)r;

	// set-up the token maps
	initMaps();

	// allocate the collection for the updates
	updates = new Vector<>();

	// start out with the empty string
	columnValue = "";
	propertyValue = "";
	metaDataValue = "";

	nullVal = false;
	idx = 0;
	tempStr = "";
	tempUpdate = "";
	tempCommand = "";

	try {
	resBundle = JdbcRowSetResourceBundle.getJdbcRowSetResourceBundle();
	} catch(IOException ioe) {
	throw new RuntimeException(ioe);
	}
	}

	/**
	* 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<>();
	}

	public void startDocument() throws SAXException {
	}

	public void endDocument() throws SAXException {
	}


	/**
	* 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,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;
	}
	}

	private void applyUpdates() throws SAXException {
	// now handle any updates
	if (updates.size() > 0) {
	try {
	Object upd[];
	Iterator<?> i = updates.iterator();
	while (i.hasNext()) {
	upd = (Object [])i.next();
	idx = ((Integer)upd[0]).intValue();

	if(!(lastval.equals(upd[1]))){
	insertValue((String)(upd[1]));
	}
	}

	rs.updateRow();
	} catch (SQLException ex) {
	throw new SAXException(MessageFormat.format(resBundle.handleGetObject("xmlrch.errupdrow").toString() , ex.getMessage()));
	}
	updates.removeAllElements();
	}


	}

	/**
	* Sets a property, metadata, or data value with the characters in
	* the given array of characters, starting with the array element
	* indicated by <code>start</code> and continuing for <code>length</code>
	* number of characters.
	* <P>
	* The SAX parser invokes this method and supplies
	* the character array, start position, and length parameter values it
	* got from parsing the XML document. An application programmer never
	* invokes this method directly.
	*
	* @param ch an array of characters supplied by the SAX parser, all or part of
	* which will be used to set a value
	* @param start the position in the given array at which to start
	* @param length the number of consecutive characters to use
	*/
	public void characters(char[] ch, int start, int length) throws SAXException {
	try {
	switch (getState()) {
	case PROPERTIES:
	propertyValue = new String(ch, start, length);

	/**
	* This has been added for handling of special characters. When special
	* characters are encountered the characters function gets called for
	* each of the characters so we need to append the value got in the
	* previous call as it is the same data present between the start and
	* the end tag.
	**/
	tempCommand = tempCommand.concat(propertyValue);
	propertyValue = tempCommand;

	// Added the following check for handling of type tags in maps
	if(tag == PropTypeTag)
	{
	Key_map = propertyValue;
	}

	// Added the following check for handling of class tags in maps
	else if(tag == PropClassTag)
	{
	Value_map = propertyValue;
	}
	break;

	case METADATA:

	// The parser will come here after the endElement as there is
	// "\n" in the after endTag is printed. This will cause a problem
	// when the data between the tags is an empty string so adding
	// below condition to take care of that situation.

	if (tag == -1)
	{
	break;
	}

	metaDataValue = new String(ch, start, length);
	break;
	case DATA:
	setDataValue(ch, start, length);
	break;
	default:
	;
	}
	} catch (SQLException ex) {
	throw new SAXException(resBundle.handleGetObject("xmlrch.chars").toString() + ex.getMessage());
	}
	}

	private void setState(String s) throws SAXException {
	if (s.equals("webRowSet")) {
	state = INITIAL;
	} else if (s.equals("properties")) {
	if (state != PROPERTIES)
	state = PROPERTIES;
	else
	state = INITIAL;
	} else if (s.equals("metadata")) {
	if (state != METADATA)
	state = METADATA;
	else
	state = INITIAL;
	} else if (s.equals("data")) {
	if (state != DATA)
	state = DATA;
	else
	state = INITIAL;
	}

	}

	/**
	* Retrieves the current state of this <code>XmlReaderContentHandler</code>
	* object's rowset, which is stored in the document handler's
	* <code>state</code> field.
	*
	* @return one of the following constants:
	* <code>XmlReaderContentHandler.PROPERTIES</code>
	* <code>XmlReaderContentHandler.METADATA</code>
	* <code>XmlReaderContentHandler.DATA</code>
	* <code>XmlReaderContentHandler.INITIAL</code>
	*/
	private int getState() {
	return state;
	}

	private void setTag(int t) {
	tag = t;
	}

	private int getTag() {
	return tag;
	}

	private void setNullValue(boolean n) {
	nullVal = n;
	}

	private boolean getNullValue() {
	return nullVal;
	}

	private void setEmptyStringValue(boolean e) {
	emptyStringVal = e;
	}

	private boolean getEmptyStringValue() {
	return emptyStringVal;
	}

	private String getStringValue(String s) {
	return s;
	}

	private int getIntegerValue(String s) {
	return Integer.parseInt(s);
	}

	private boolean getBooleanValue(String s) {

	return Boolean.valueOf(s).booleanValue();
	}

	private java.math.BigDecimal getBigDecimalValue(String s) {
	return new java.math.BigDecimal(s);
	}

	private byte getByteValue(String s) {
	return Byte.parseByte(s);
	}

	private short getShortValue(String s) {
	return Short.parseShort(s);
	}

	private long getLongValue(String s) {
	return Long.parseLong(s);
	}

	private float getFloatValue(String s) {
	return Float.parseFloat(s);
	}

	private double getDoubleValue(String s) {
	return Double.parseDouble(s);
	}

	private byte[] getBinaryValue(String s) {
	return s.getBytes();
	}

	private java.sql.Date getDateValue(String s) {
	return new java.sql.Date(getLongValue(s));
	}

	private java.sql.Time getTimeValue(String s) {
	return new java.sql.Time(getLongValue(s));
	}

	private java.sql.Timestamp getTimestampValue(String s) {
	return new java.sql.Timestamp(getLongValue(s));
	}

	private void setPropertyValue(String s) throws SQLException {
	// find out if we are going to be dealing with a null
	boolean nullValue = getNullValue();

	switch(getTag()) {
	case CommandTag:
	if (nullValue)
	; //rs.setCommand(null);
	else
	rs.setCommand(s);
	break;
	case ConcurrencyTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setConcurrency(getIntegerValue(s));
	break;
	case DatasourceTag:
	if (nullValue)
	rs.setDataSourceName(null);
	else
	rs.setDataSourceName(s);
	break;
	case EscapeProcessingTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setEscapeProcessing(getBooleanValue(s));
	break;
	case FetchDirectionTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setFetchDirection(getIntegerValue(s));
	break;
	case FetchSizeTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setFetchSize(getIntegerValue(s));
	break;
	case IsolationLevelTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setTransactionIsolation(getIntegerValue(s));
	break;
	case KeycolsTag:
	break;
	case PropColumnTag:
	if (keyCols == null)
	keyCols = new Vector<>();
	keyCols.add(s);
	break;
	case MapTag:
	break;
	case MaxFieldSizeTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setMaxFieldSize(getIntegerValue(s));
	break;
	case MaxRowsTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setMaxRows(getIntegerValue(s));
	break;
	case QueryTimeoutTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setQueryTimeout(getIntegerValue(s));
	break;
	case ReadOnlyTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setReadOnly(getBooleanValue(s));
	break;
	case RowsetTypeTag:
	if (nullValue) {
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	} else {
	//rs.setType(getIntegerValue(s));
	String strType = getStringValue(s);
	int iType = 0;

	if(strType.trim().equals("ResultSet.TYPE_SCROLL_INSENSITIVE")) {
	iType = 1004;
	} else if(strType.trim().equals("ResultSet.TYPE_SCROLL_SENSITIVE")) {
	iType = 1005;
	} else if(strType.trim().equals("ResultSet.TYPE_FORWARD_ONLY")) {
	iType = 1003;
	}
	rs.setType(iType);
	}
	break;
	case ShowDeletedTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue").toString());
	else
	rs.setShowDeleted(getBooleanValue(s));
	break;
	case TableNameTag:
	if (nullValue)
	//rs.setTableName(null);
	;
	else
	rs.setTableName(s);
	break;
	case UrlTag:
	if (nullValue)
	rs.setUrl(null);
	else
	rs.setUrl(s);
	break;
	case SyncProviderNameTag:
	if (nullValue) {
	rs.setSyncProvider(null);
	} else {
	String str = s.substring(0,s.indexOf("@")+1);
	rs.setSyncProvider(str);
	}
	break;
	case SyncProviderVendorTag:
	// to be implemented
	break;
	case SyncProviderVersionTag:
	// to be implemented
	break;
	case SyncProviderGradeTag:
	// to be implemented
	break;
	case DataSourceLock:
	// to be implemented
	break;
	default:
	break;
	}

	}

	private void setMetaDataValue(String s) throws SQLException {
	// find out if we are going to be dealing with a null
	boolean nullValue = getNullValue();

	switch (getTag()) {
	case ColumnCountTag:
	md = new RowSetMetaDataImpl();
	idx = 0;

	if (nullValue) {
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	} else {
	md.setColumnCount(getIntegerValue(s));
	}
	break;
	case ColumnDefinitionTag:
	break;
	case ColumnIndexTag:
	idx++;
	break;
	case AutoIncrementTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setAutoIncrement(idx, getBooleanValue(s));
	break;
	case CaseSensitiveTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setCaseSensitive(idx, getBooleanValue(s));
	break;
	case CurrencyTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setCurrency(idx, getBooleanValue(s));
	break;
	case NullableTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setNullable(idx, getIntegerValue(s));
	break;
	case SignedTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setSigned(idx, getBooleanValue(s));
	break;
	case SearchableTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setSearchable(idx, getBooleanValue(s));
	break;
	case ColumnDisplaySizeTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setColumnDisplaySize(idx, getIntegerValue(s));
	break;
	case ColumnLabelTag:
	if (nullValue)
	md.setColumnLabel(idx, null);
	else
	md.setColumnLabel(idx, s);
	break;
	case ColumnNameTag:
	if (nullValue)
	md.setColumnName(idx, null);
	else
	md.setColumnName(idx, s);

	break;
	case SchemaNameTag:
	if (nullValue) {
	md.setSchemaName(idx, null); }
	else
	md.setSchemaName(idx, s);
	break;
	case ColumnPrecisionTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setPrecision(idx, getIntegerValue(s));
	break;
	case ColumnScaleTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setScale(idx, getIntegerValue(s));
	break;
	case MetaTableNameTag:
	if (nullValue)
	md.setTableName(idx, null);
	else
	md.setTableName(idx, s);
	break;
	case CatalogNameTag:
	if (nullValue)
	md.setCatalogName(idx, null);
	else
	md.setCatalogName(idx, s);
	break;
	case ColumnTypeTag:
	if (nullValue)
	throw new SQLException(resBundle.handleGetObject("xmlrch.badvalue1").toString());
	else
	md.setColumnType(idx, getIntegerValue(s));
	break;
	case ColumnTypeNameTag:
	if (nullValue)
	md.setColumnTypeName(idx, null);
	else
	md.setColumnTypeName(idx, s);
	break;
	default:
	//System.out.println("MetaData: Unknown Tag: (" + getTag() + ")");
	break;

	}
	}

	private void setDataValue(char[] ch, int start, int len) throws SQLException {
	switch (getTag()) {
	case ColTag:
	columnValue = new String(ch, start, len);
	/**
	* This has been added for handling of special characters. When special
	* characters are encountered the characters function gets called for
	* each of the characters so we need to append the value got in the
	* previous call as it is the same data present between the start and
	* the end tag.
	**/
	tempStr = tempStr.concat(columnValue);
	break;
	case UpdTag:
	upd = new Object[2];

	/**
	* This has been added for handling of special characters. When special
	* characters are encountered the characters function gets called for
	* each of the characters so we need to append the value got in the
	* previous call as it is the same data present between the start and
	* the end tag.
	**/

	tempUpdate = tempUpdate.concat(new String(ch,start,len));
	upd[0] = Integer.valueOf(idx);
	upd[1] = tempUpdate;
	//updates.add(upd);

	lastval = (String)upd[1];
	//insertValue(ch, start, len);
	break;
	case InsTag:

	}
	}

	private void insertValue(String s) throws SQLException {

	if (getNullValue()) {
	rs.updateNull(idx);
	return;
	}

	// no longer have to deal with those pesky nulls.
	int type = rs.getMetaData().getColumnType(idx);
	switch (type) {
	case java.sql.Types.BIT:
	rs.updateBoolean(idx, getBooleanValue(s));
	break;
	case java.sql.Types.BOOLEAN:
	rs.updateBoolean(idx, getBooleanValue(s));
	break;
	case java.sql.Types.SMALLINT:
	case java.sql.Types.TINYINT:
	rs.updateShort(idx, getShortValue(s));
	break;
	case java.sql.Types.INTEGER:
	rs.updateInt(idx, getIntegerValue(s));
	break;
	case java.sql.Types.BIGINT:
	rs.updateLong(idx, getLongValue(s));
	break;
	case java.sql.Types.REAL:
	case java.sql.Types.FLOAT:
	rs.updateFloat(idx, getFloatValue(s));
	break;
	case java.sql.Types.DOUBLE:
	rs.updateDouble(idx, getDoubleValue(s));
	break;
	case java.sql.Types.NUMERIC:
	case java.sql.Types.DECIMAL:
	rs.updateObject(idx, getBigDecimalValue(s));
	break;
	case java.sql.Types.BINARY:
	case java.sql.Types.VARBINARY:
	case java.sql.Types.LONGVARBINARY:
	rs.updateBytes(idx, getBinaryValue(s));
	break;
	case java.sql.Types.DATE:
	rs.updateDate(idx, getDateValue(s));
	break;
	case java.sql.Types.TIME:
	rs.updateTime(idx, getTimeValue(s));
	break;
	case java.sql.Types.TIMESTAMP:
	rs.updateTimestamp(idx, getTimestampValue(s));
	break;
	case java.sql.Types.CHAR:
	case java.sql.Types.VARCHAR:
	case java.sql.Types.LONGVARCHAR:
	rs.updateString(idx, getStringValue(s));
	break;
	default:

	}

	}

	/**
	* Throws the given <code>SAXParseException</code> object. This
	* exception was originally thrown by the SAX parser and is passed
	* to the method <code>error</code> when the SAX parser invokes it.
	*
	* @param e the <code>SAXParseException</code> object to throw
	*/
	public void error (SAXParseException e) throws SAXParseException {
	throw e;
	}

	// dump warnings too
	/**
	* Prints a warning message to <code>System.out</code> giving the line
	* number and uri for what caused the warning plus a message explaining
	* the reason for the warning. This method is invoked by the SAX parser.
	*
	* @param err a warning generated by the SAX parser
	*/
	public void warning (SAXParseException err) throws SAXParseException {
	System.out.println (MessageFormat.format(resBundle.handleGetObject("xmlrch.warning").toString(), new Object[] { err.getMessage(), err.getLineNumber(), err.getSystemId() }));
	}

	/**
	*
	*/
	public void notationDecl(String name, String publicId, String systemId) {

	}

	/**
	*
	*/
	public void unparsedEntityDecl(String name, String publicId, String systemId, String notationName) {

	}

	/**
	* Returns the current row of this <code>Rowset</code>object.
	* The ResultSet's cursor is positioned at the Row which is needed
	*
	* @return the <code>Row</code> object on which the <code>RowSet</code>
	* implementation objects's cursor is positioned
	*/
	private Row getPresentRow(WebRowSetImpl rs) throws SQLException {
	//rs.setOriginalRow();
	// ResultSetMetaData rsmd = rs.getMetaData();
	// int numCols = rsmd.getColumnCount();
	// Object vals[] = new Object[numCols];
	// for(int j = 1; j<= numCols ; j++){
	// vals[j-1] = rs.getObject(j);
	// }
	// return(new Row(numCols, vals));
	return null;
	}




	}

Back to index...