/*
* Copyright (c) 2003, 2012, 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,Class.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;
}
}