/**
* Constructs a new {@code StringWriter} which has a {@link StringBuffer}
* allocated with a size of {@code initialSize} characters. The {@code
* StringBuffer} is also the {@code lock} used to synchronize access to this
* writer.
*
* @param initialSize
* the intial size of the target string buffer.
*/
public StringWriter(int initialSize)
{
if (initialSize < 0)
{
throw new java.lang.IllegalArgumentException();
}
buf = new java.lang.StringBuffer(initialSize);
lockJ = buf;
}
private bool isNextChar(java.lang.StringBuffer str, int index, char c)
{
bool matches = false;
if (index >= 0 &&
index < str.length() - 1)
{
matches = str.charAt(index + 1) == c;
}
return(matches);
}
private bool isPreviousChar(java.lang.StringBuffer str, int index, char c)
{
bool matches = false;
if (index > 0 &&
index < str.length())
{
matches = str.charAt(index - 1) == c;
}
return(matches);
}
/**
*
* Update a single column.
*
* @param column the column name
* @param value the String value with which update the column
* @see tinySQLTable#UpdateCol
*
*/
public override void UpdateCol(String column, String value)
{//throws tinySQLException {
try
{
// read the column info
//
String[] info = (String[])column_info.get(column);
// retrieve datatype, size, and position within row
//
String datatype = info[COLUMN_TYPE];
long size = java.lang.Long.parseLong(info[COLUMN_SIZE]);
long pos = java.lang.Long.parseLong(info[COLUMN_POS]);
// position the file pointer at the column
// offset.
//
ftbl.seek(ftbl.getFilePointer() + pos);
String writeval;
if (value.length() > (int)size)
{
// truncate the value, if it exceeds the width
// of the column
//
writeval = value.substring(0, (int)size);
}
else
{
// add some padding to the end of the string
//
java.lang.StringBuffer pad = new java.lang.StringBuffer();
for (int p = 0; p < ((int)size) - value.length(); p++)
{
pad.append(" ");
}
writeval = value + pad.toString();
}
// write out the column
//
ftbl.writeBytes(writeval);
// rewind the file pointer
//
ftbl.seek(ftbl.getFilePointer() - (pos + (long)writeval.length()));
}
catch (Exception e)
{
java.lang.SystemJ.err.println(e.toString());// e.printStackTrace();
throw new TinySQLException(e.getMessage());
}
}
private bool regionMatch(java.lang.StringBuffer str, int index, String test)
{
bool matches = false;
if (index >= 0 &&
(index + test.length() - 1) < str.length())
{
String substring = str.substring(index, index + test.length());
matches = substring.equals(test);
}
return(matches);
}
public String toString()
{
java.lang.StringBuffer outputBuffer = new java.lang.StringBuffer();
String columnName, columnValue;
java.util.Enumeration <Object> e;
for (e = this.keys(); e.hasMoreElements();)
{
columnName = (String)e.nextElement();
columnValue = (String)this.get(columnName);
outputBuffer.append(columnName + "=" + columnValue + " ");
}
return(outputBuffer.toString());
}
/*
* Returns a hash code consistent with the definition of the equals method.
*
* @see Object#hashCode()
*/
// default method not twice declared
//public abstract int GetHashCode();
/*
* <p>Returns a <code>String</code> representation of this <code>Duration</code> <code>Object</code>.</p>
*
* <p>The result is formatted according to the XML Schema 1.0 spec and can be always parsed back later into the
* equivalent <code>Duration</code> <code>Object</code> by {@link DatatypeFactory#newDuration(String lexicalRepresentation)}.</p>
*
* <p>Formally, the following holds for any <code>Duration</code>
* <code>Object</code> x:</p>
* <pre>
* new Duration(x.toString()).equals(x)
* </pre>
*
* @return A non-<code>null</code> valid <code>String</code> representation of this <code>Duration</code>.
*/
public override String ToString()
{
java.lang.StringBuffer buf = new java.lang.StringBuffer();
if (getSign() < 0)
{
buf.append('-');
}
buf.append('P');
java.math.BigInteger years = (java.math.BigInteger)getField(DatatypeConstants.YEARS);
if (years != null)
{
buf.append(years + "Y");
}
java.math.BigInteger months = (java.math.BigInteger)getField(DatatypeConstants.MONTHS);
if (months != null)
{
buf.append(months + "M");
}
java.math.BigInteger days = (java.math.BigInteger)getField(DatatypeConstants.DAYS);
if (days != null)
{
buf.append(days + "D");
}
java.math.BigInteger hours = (java.math.BigInteger)getField(DatatypeConstants.HOURS);
java.math.BigInteger minutes = (java.math.BigInteger)getField(DatatypeConstants.MINUTES);
java.math.BigDecimal seconds = (java.math.BigDecimal)getField(DatatypeConstants.SECONDS);
if (hours != null || minutes != null || seconds != null)
{
buf.append('T');
if (hours != null)
{
buf.append(hours + "H");
}
if (minutes != null)
{
buf.append(minutes + "M");
}
if (seconds != null)
{
buf.append(toString(seconds) + "S");
}
}
return(buf.toString());
}
/*
* This method checks to see if the column has the specified context.
*/
public String contextToString()
{
java.lang.StringBuffer outputBuffer = new java.lang.StringBuffer();
int i;
for (i = 0; i < contextList.size(); i++)
{
if (i > 0)
{
outputBuffer.append(",");
}
outputBuffer.append((String)contextList.elementAt(i));
}
return(outputBuffer.toString());
}
/**
* Applies an RFC 1522 compliant encoding scheme to the given string of text with the
* given charset. This method constructs the "encoded-word" header common to all the
* RFC 1522 codecs and then invokes {@link #doEncoding(byte [])} method of a concrete
* class to perform the specific enconding.
*
* @param text a string to encode
* @param charset a charset to be used
*
* @return RFC 1522 compliant "encoded-word"
*
* @throws EncoderException thrown if there is an error conidition during the Encoding
* process.
* @throws UnsupportedEncodingException thrown if charset is not supported
*
* @see <a href="http://java.sun.com/j2se/1.4.2/docs/api/java/nio/charset/Charset.html">Standard charsets</a>
*/
protected String encodeText(String text, String charset)
//throws EncoderException, UnsupportedEncodingException
{
if (text == null)
{
return(null);
}
java.lang.StringBuffer buffer = new java.lang.StringBuffer();
buffer.append(PREFIX);
buffer.append(charset);
buffer.append(SEP);
buffer.append(getEncoding());
buffer.append(SEP);
byte[] rawdata = doEncoding(text.getBytes(charset));
buffer.append(StringUtils.newStringUsAscii(rawdata));
buffer.append(POSTFIX);
return(buffer.toString());
}
/*
* Format a where condition for display.
*/
private String conditionToString(java.util.Vector <Object> inputWhereCondition)
{
String comparison, conditionStatus;
TsColumn leftColumn, rightColumn;
if (inputWhereCondition.size() < 4)
{
return("");
}
java.lang.StringBuffer outputBuffer = new java.lang.StringBuffer("WHERE ");
leftColumn = (TsColumn)inputWhereCondition.elementAt(0);
comparison = (String)inputWhereCondition.elementAt(1);
rightColumn = (TsColumn)inputWhereCondition.elementAt(2);
conditionStatus = (String)inputWhereCondition.elementAt(3);
outputBuffer.append(leftColumn.getString() + " " + comparison
+ " " + rightColumn.getString() + " " + conditionStatus);
return(outputBuffer.toString());
}
/**
* Provides a string representation of the entries within the map. The
* format of the returned string may change with different releases, so this
* method is suitable for debugging purposes only. If a specific format is
* required, use {@link #entrySet()}.{@link Set#iterator() iterator()} and
* iterate over the entries in the map formatting them as appropriate.
*/
public override String ToString()
{
java.lang.StringBuffer buf = new java.lang.StringBuffer();
buf.append('[');
for (Entry pos = sentinel.next; pos != sentinel; pos = pos.next)
{
buf.append(pos.getKey());
buf.append('=');
buf.append(pos.getValue());
if (pos.next != sentinel)
{
buf.append(',');
}
}
buf.append(']');
return(buf.toString());
}
/**
* Returns a string representation of this StackKeyedObjectPool, including
* the number of pools, the keys and the size of each keyed pool.
*
* @return Keys and pool sizes
*/
public override String ToString()
{
lock (this)
{
java.lang.StringBuffer buf = new java.lang.StringBuffer();
buf.append(this.getClass().getName());
buf.append(" contains ").append(_pools.size()).append(" distinct pools: ");
java.util.Iterator <K> it = _pools.keySet().iterator();
while (it.hasNext())
{
K key = it.next();
buf.append(" |").append(key).append("|=");
java.util.Stack <V> s = _pools.get(key);
buf.append(s.size());
}
return(buf.toString());
}
}
private static String padString(String inputString, int padLength)
{
java.lang.StringBuffer outputBuffer;
String blanks = " ";
if (inputString != (String)null)
{
outputBuffer = new java.lang.StringBuffer(inputString);
}
else
{
outputBuffer = new java.lang.StringBuffer(blanks);
}
while (outputBuffer.length() < padLength)
{
outputBuffer.append(blanks);
}
return(outputBuffer.toString().substring(0, padLength));
}
/*
* This method returns the column to build an index on. This is very
* primitive and only works on a single column that is compared to
* to a constant.
*/
public java.util.Vector <Object> getIndexCondition(String inputTableName)
{
int i, j;
java.util.Vector <Object> whereConditions;
TsColumn leftColumn, rightColumn;
Object whereObj;
String objectType, comparison;
java.util.Vector <Object> whereCondition;
java.lang.StringBuffer outputBuffer = new java.lang.StringBuffer();
for (i = 0; i < whereClauseList.size(); i++)
{
whereConditions = (java.util.Vector <Object>)whereClauseList.elementAt(i);
for (j = 0; j < whereConditions.size(); j++)
{
/*
* Where conditions can be tinySQLWhere objects or String arrays.
*/
whereObj = whereConditions.elementAt(j);
objectType = whereObj.getClass().getName();
if (objectType.endsWith("java.util.Vector"))
{
whereCondition = (java.util.Vector <Object>)whereObj;
leftColumn = (TsColumn)whereCondition.elementAt(0);
comparison = (String)whereCondition.elementAt(1);
rightColumn = (TsColumn)whereCondition.elementAt(2);
if (leftColumn.tableName.equals(inputTableName) &
rightColumn.isConstant & comparison.equals("="))
{
return(whereCondition);
}
else if (leftColumn.tableName.equals(inputTableName) &
rightColumn.isConstant & comparison.equals("="))
{
return(whereCondition);
}
}
}
}
return((java.util.Vector <Object>)null);
}
public String toString()
{
int i, j;
java.util.Vector <Object> whereConditions;
Object whereObj;
String objectType;
java.util.Vector <Object> whereCondition;
java.lang.StringBuffer outputBuffer = new java.lang.StringBuffer();
for (i = 0; i < whereClauseList.size(); i++)
{
if (i > 0)
{
outputBuffer.append("OR\n");
}
whereConditions = (java.util.Vector <Object>)whereClauseList.elementAt(i);
for (j = 0; j < whereConditions.size(); j++)
{
if (j > 0)
{
outputBuffer.append("AND\n");
}
/*
* Where conditions can be tinySQLWhere objects or String arrays.
*/
whereObj = whereConditions.elementAt(j);
objectType = whereObj.getClass().getName();
if (objectType.endsWith("tinySQLWhere"))
{
outputBuffer.append(((TinySQLWhere)whereObj).toString());
}
if (objectType.endsWith("java.util.Vector"))
{
whereCondition = (java.util.Vector <Object>)whereObj;
outputBuffer.append(conditionToString(whereCondition) + "\n");
}
}
}
return(outputBuffer.toString());
}
/*
* The following method replaces all occurrences of oldString with newString
* in the inputString. This function can be replaced with the native
* String method replaceAll in JDK 1.4 and above but is provide to support
* earlier versions of the JRE.
*/
public static String replaceAll(String inputString, String oldString,
String newString)
{
java.lang.StringBuffer outputString = new java.lang.StringBuffer(100);
int startIndex = 0, nextIndex;
while (inputString.substring(startIndex).indexOf(oldString) > -1)
{
nextIndex = startIndex + inputString.substring(startIndex).indexOf(oldString);
if (nextIndex > startIndex)
{
outputString.append(inputString.substring(startIndex, nextIndex));
}
outputString.append(newString);
startIndex = nextIndex + oldString.length();
}
if (startIndex <= inputString.length() - 1)
{
outputString.append(inputString.substring(startIndex));
}
return(outputString.toString());
}
/*
* Get the error message with location information
* appended.
*
* @return A <code>String</code> representing the error message with
* location information appended.
*/
public String getMessageAndLocation()
{
java.lang.StringBuffer sbuffer = new java.lang.StringBuffer();
String message = base.getMessage();
if (null != message)
{
sbuffer.append(message);
}
if (null != locator)
{
String systemID = locator.getSystemId();
int line = locator.getLineNumber();
int column = locator.getColumnNumber();
if (null != systemID)
{
sbuffer.append("; SystemID: ");
sbuffer.append(systemID);
}
if (0 != line)
{
sbuffer.append("; Line#: ");
sbuffer.append(line);
}
if (0 != column)
{
sbuffer.append("; Column#: ");
sbuffer.append(column);
}
}
return(sbuffer.toString());
}
/**
* Retreives the Refined Soundex code for a given String object.
*
* @param str
* String to encode using the Refined Soundex algorithm
* @return A soundex code for the String supplied
*/
public String soundex(String str)
{
if (str == null)
{
return(null);
}
str = SoundexUtils.clean(str);
if (str.length() == 0)
{
return(str);
}
java.lang.StringBuffer sBuf = new java.lang.StringBuffer();
sBuf.append(str.charAt(0));
char last, current;
last = '*';
for (int i = 0; i < str.length(); i++)
{
current = getMappingCode(str.charAt(i));
if (current == last)
{
continue;
}
else if (current != 0)
{
sBuf.append(current);
}
last = current;
}
return(sBuf.toString());
}
/*
* <p><code>String</code> representation of this
* <code>QName</code>.</p>
*
* <p>The commonly accepted way of representing a <code>QName</code>
* as a <code>String</code> was <a href="http://jclark.com/xml/xmlns.htm">defined</a>
* by James Clark. Although this is not a <em>standard</em>
* specification, it is in common use, e.g. {@link javax.xml.transform.Transformer#setParameter(String name, Object value)}.
* This implementation represents a <code>QName</code> as:
* "{" + Namespace URI + "}" + local part. If the Namespace URI
* <code>.equals(XMLConstants.NULL_NS_URI)</code>, only the
* local part is returned. An appropriate use of this method is
* for debugging or logging for human consumption.</p>
*
* <p>Note the prefix value is <strong><em>NOT</em></strong>
* returned as part of the <code>String</code> representation.</p>
*
* <p>This method satisfies the general contract of {@link
* java.lang.Object#toString() Object.toString()}.</p>
*
* @return <code>String</code> representation of this <code>QName</code>
*/
public override String ToString()
{
String _qNameAsString = qNameAsString;
if (_qNameAsString == null)
{
int nsLength = namespaceURI.length();
if (nsLength == 0)
{
_qNameAsString = localPart;
}
else
{
java.lang.StringBuffer buffer = new java.lang.StringBuffer(nsLength + localPart.length() + 2);
buffer.append('{');
buffer.append(namespaceURI);
buffer.append('}');
buffer.append(localPart);
_qNameAsString = buffer.toString();
}
qNameAsString = _qNameAsString;
}
return(_qNameAsString);
}
public TinySQLParser(java.io.InputStream sqlInput, TinySQL inputEngine)
//throws TinySQLException
{
java.io.StreamTokenizer st;
FieldTokenizer ft;
java.io.Reader r;
String nextToken, upperField, nextField, keyWord = (String)null;
java.lang.StringBuffer cmdBuffer, inputSQLBuffer;
int lastIndex, keyIndex;
r = new java.io.BufferedReader(new java.io.InputStreamReader(sqlInput));
dbEngine = inputEngine;
actionList = new java.util.Vector <Object>();
columnList = new java.util.Vector <Object>();
columns = new java.util.Vector <Object>();
columnAliasList = new java.util.Vector <Object>();
contextList = new java.util.Vector <Object>();
valueList = new java.util.Vector <Object>();
tableName = (String)null;
whereClause = (TinySQLWhere)null;
/*
* The tableList is a list of table names, in the optimal order
* in which they should be scanned for the SELECT phrase.
* The java.util.Hashtable<Object,Object> tables contains table objects keyed by table
* alias and name.
*/
tableList = new java.util.Vector <Object>();
tables = new java.util.Hashtable <Object, Object>();
tables.put("TABLE_SELECT_ORDER", tableList);
try
{
st = new java.io.StreamTokenizer(r);
st.eolIsSignificant(false);
st.wordChars('\'', '}');
st.wordChars('?', '?');
st.wordChars('"', '.');
st.ordinaryChars('0', '9');
st.wordChars('0', '9');
cmdBuffer = new java.lang.StringBuffer();
inputSQLBuffer = new java.lang.StringBuffer();
while (st.nextToken() != java.io.StreamTokenizer.TT_EOF)
{
if (st.ttype == java.io.StreamTokenizer.TT_WORD)
{
nextToken = st.sval.trim();
}
else
{
continue;
}
if (inputSQLBuffer.length() > 0)
{
inputSQLBuffer.append(" ");
}
inputSQLBuffer.append(nextToken);
}
ft = new FieldTokenizer(inputSQLBuffer.toString(), ' ', false);
while (ft.hasMoreFields())
{
nextField = ft.nextField();
upperField = nextField.toUpperCase();
if (statementType == (String)null)
{
statementType = upperField;
lastIndex = getKeywordIndex(statementType, statementType);
if (lastIndex != 0)
{
throwException(9);
}
keyWord = statementType;
}
else
{
keyIndex = getKeywordIndex(statementType, upperField);
if (keyIndex < 0)
{
if (cmdBuffer.length() > 0)
{
cmdBuffer.append(" ");
}
cmdBuffer.append(nextField);
}
else
{
setPhrase(keyWord, cmdBuffer.toString());
cmdBuffer = new java.lang.StringBuffer();
keyWord = upperField;
if (TinySQLGlobals.PARSER_DEBUG)
{
java.lang.SystemJ.outJ.println("Found keyword " + keyWord);
}
}
}
}
if (keyWord != (String)null)
{
setPhrase(keyWord, cmdBuffer.toString());
}
addAction();
if (TinySQLGlobals.PARSER_DEBUG)
{
java.lang.SystemJ.outJ.println("SQL:" + inputSQLBuffer.toString());
}
} catch (Exception ex) {
if (TinySQLGlobals.DEBUG)
{
java.lang.SystemJ.outJ.println(ex.StackTrace); //ex.printStackTrace(java.lang.SystemJ.outJ);
}
throw new TinySQLException(ex.getMessage());
}
}
/*
* This method sets up particular phrase elements for the SQL command.
* Examples would be a list of selected columns and tables for a SELECT
* statement, or a list of column definitions for a CREATE TABLE
* statement. These phrase elements will be added to the action list
* once the entire statement has been parsed.
*/
public void setPhrase(String inputKeyWord, String inputString)
//throws TinySQLException
{
String nextField, upperField,
fieldString, tempString, columnName, columnAlias;
java.lang.StringBuffer concatBuffer;
FieldTokenizer ft1, ft2, ft3;
TsColumn createColumn;
/*
* Handle compound keywords.
*/
if (inputString == (String)null)
{
lastKeyWord = inputKeyWord;
return;
}
else if (inputString.trim().length() == 0)
{
lastKeyWord = inputKeyWord;
return;
}
if (TinySQLGlobals.PARSER_DEBUG)
{
java.lang.SystemJ.outJ.println("setPhrase " + inputString);
}
ft1 = new FieldTokenizer(inputString, ',', false);
while (ft1.hasMoreFields())
{
nextField = ft1.nextField().trim();
if (TinySQLGlobals.PARSER_DEBUG)
{
java.lang.SystemJ.outJ.println(inputKeyWord + " field is " + nextField);
}
upperField = nextField.toUpperCase();
if (inputKeyWord.equals("SELECT"))
{
/*
* Check for the keyword DISTINCT
*/
if (nextField.toUpperCase().startsWith("DISTINCT"))
{
distinct = true;
nextField = nextField.substring(9).trim();
}
/*
* Check for and set column alias.
*/
ft2 = new FieldTokenizer(nextField, ' ', false);
columnName = ft2.getField(0);
columnAlias = (String)null;
/*
* A column alias can be preceded by the keyword AS which will
* be ignored by tinySQL.
*/
if (ft2.countFields() == 2)
{
columnAlias = ft2.getField(1);
}
else if (ft2.countFields() == 3)
{
columnAlias = ft2.getField(2);
}
/*
* Check for column concatenation using the | symbol
*/
ft2 = new FieldTokenizer(columnName, '|', false);
if (ft2.countFields() > 1)
{
concatBuffer = new java.lang.StringBuffer("CONCAT(");
while (ft2.hasMoreFields())
{
if (concatBuffer.length() > 7)
{
concatBuffer.append(",");
}
concatBuffer.append(ft2.nextField());
}
columnName = concatBuffer.toString() + ")";
}
columnList.addElement(columnName);
columnAliasList.addElement(columnAlias);
contextList.addElement(inputKeyWord);
}
else if (inputKeyWord.equals("TABLE"))
{
/*
* If the input keyword is TABLE, update the statement type to be a
* compound type such as CREATE_TABLE, DROP_TABLE, or ALTER_TABLE.
*/
if (!statementType.equals("INSERT"))
{
statementType = statementType + "_TABLE";
}
if (statementType.equals("CREATE_TABLE"))
{
/*
* Parse out the column definition.
*/
ft2 = new FieldTokenizer(nextField, '(', false);
if (ft2.countFields() != 2)
{
throwException(1);
}
tableName = ft2.getField(0);
fieldString = ft2.getField(1);
ft2 = new FieldTokenizer(fieldString, ',', false);
while (ft2.hasMoreFields())
{
tempString = ft2.nextField();
createColumn = parseColumnDefn(tempString);
if (createColumn != (TsColumn)null)
{
columnList.addElement(createColumn);
}
}
}
else if (statementType.equals("DROP_TABLE"))
{
/*
* Handle dropping of non-existent tables
*/
tableName = upperField;
try
{
validateTable(upperField, true);
} catch (Exception) {
throw new TinySQLException("Table " + tableName
+ " does not exist.");
}
}
else
{
tableName = upperField;
validateTable(upperField, true);
}
}
else if (inputKeyWord.equals("BY"))
{
/*
* Set up Group by and Order by columns.
*/
if (lastKeyWord == (String)null)
{
throwException(6);
}
else
{
ft3 = new FieldTokenizer(upperField, ' ', false);
columnList.addElement(ft3.getField(0));
if (ft3.countFields() == 2)
{
/*
* ASC or DESC are the only allowable directives after GROUP BY
*/
if (ft3.getField(1).startsWith("ASC") |
ft3.getField(1).startsWith("DESC"))
{
orderType = ft3.getField(1);
}
else
{
throwException(7);
}
}
if (lastKeyWord.equals("ORDER"))
{
defaultOrderBy = false;
}
contextList.addElement(lastKeyWord);
}
}
else if (inputKeyWord.equals("DROP"))
{
/*
* Parse list of columns to be dropped.
*/
statementType = "ALTER_DROP";
ft2 = new FieldTokenizer(upperField, ' ', false);
while (ft2.hasMoreFields())
{
columnList.addElement(UtilString.removeQuotes(ft2.nextField()));
}
}
else if (inputKeyWord.equals("RENAME"))
{
/*
* Parse old and new column name.
*/
statementType = "ALTER_RENAME";
ft2 = new FieldTokenizer(upperField, ' ', false);
oldColumnName = ft2.getField(0);
newColumnName = ft2.getField(1);
if (newColumnName.equals("TO") & ft2.countFields() == 3)
{
newColumnName = ft2.getField(2);
}
if (newColumnName.length() > 11)
{
newColumnName = TinySQLGlobals.getShortName(newColumnName);
}
}
else if (inputKeyWord.equals("ADD"))
{
/*
* Parse definition of columns to be added.
*/
statementType = "ALTER_ADD";
createColumn = parseColumnDefn(nextField);
if (createColumn != (TsColumn)null)
{
columnList.addElement(createColumn);
}
}
else if (inputKeyWord.equals("FROM"))
{
/*
* Check for valid table
*/
tableName = upperField;
validateTable(tableName);
}
else if (inputKeyWord.equals("INTO"))
{
ft2 = new FieldTokenizer(nextField, '(', false);
if (ft2.countFields() != 2)
{
throwException(3);
}
tableName = ft2.getField(0).toUpperCase();
validateTable(tableName);
fieldString = ft2.getField(1).toUpperCase();
ft2 = new FieldTokenizer(fieldString, ',', false);
while (ft2.hasMoreFields())
{
tempString = UtilString.removeQuotes(ft2.nextField());
columnList.addElement(tempString);
contextList.addElement(inputKeyWord);
}
}
else if (inputKeyWord.equals("VALUES"))
{
ft2 = new FieldTokenizer(nextField, '(', false);
fieldString = ft2.getField(0);
ft2 = new FieldTokenizer(fieldString, ',', false);
while (ft2.hasMoreFields())
{
tempString = UtilString.removeQuotes(ft2.nextField());
tempString = UtilString.replaceAll(tempString, "''", "'");
valueList.addElement(tempString);
}
}
else if (inputKeyWord.equals("UPDATE"))
{
tableName = nextField.toUpperCase();
validateTable(tableName);
}
else if (inputKeyWord.equals("SET"))
{
/*
* Parse the update column name/value pairs
*/
ft2 = new FieldTokenizer(nextField, '=', false);
if (ft2.countFields() != 2)
{
throwException(4);
}
columnList.addElement(ft2.getField(0));
contextList.addElement(inputKeyWord);
valueList.addElement(UtilString.removeQuotes(ft2.getField(1)));
}
else if (inputKeyWord.equals("WHERE"))
{
whereClause = new TinySQLWhere(nextField, tables);
}
else if (!inputKeyWord.equals("TABLE"))
{
throwException(10);
}
}
lastKeyWord = inputKeyWord;
}
/*
* This method evaluates the value of functions. This step must be kept
* separate from the update of individual columns to prevent evaluation
* of summary functions such as COUNT and SUM more than once, or when
* the row being processed will ultimately fail a where clause condition.
*/
public void updateFunctions()
//throws tinySQLException
{
int i, startAt, charCount, day, monthAt, month, year;
TsColumn argColumn;
java.lang.StringBuffer concatBuffer;
FieldTokenizer ft;
String[] ftFields;
String months = "-JAN-FEB-MAR-APR-MAY-JUN-JUL-AUG-SEP-OCT-NOV-DEC-",
monthName, dayField, monthField, yearField;
if (isConstant)
{
return;
}
if (functionName == (String)null)
{
return;
}
if (functionName.equals("CONCAT"))
{
concatBuffer = new java.lang.StringBuffer();
for (i = 0; i < functionArgs.size(); i++)
{
argColumn = (TsColumn)functionArgs.elementAt(i);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.notNull)
{
concatBuffer.append(argColumn.getString());
notNull = true;
}
}
stringValue = concatBuffer.toString();
}
else if (functionName.equals("UPPER"))
{
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.notNull)
{
stringValue = argColumn.getString().toUpperCase();
notNull = true;
}
}
else if (functionName.equals("TRIM"))
{
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.notNull)
{
stringValue = argColumn.getString().trim();
notNull = true;
}
}
else if (functionName.equals("SUBSTR"))
{
if (functionArgs.size() != 3)
{
throw new TinySQLException("Wrong number of arguments for SUBSTR");
}
argColumn = (TsColumn)functionArgs.elementAt(1);
startAt = argColumn.intValue;
argColumn = (TsColumn)functionArgs.elementAt(2);
charCount = argColumn.intValue;
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.notNull)
{
stringValue = argColumn.stringValue;
if (startAt < stringValue.length() - 1 & charCount > 0)
{
stringValue = stringValue.substring(startAt - 1, startAt + charCount - 1);
notNull = true;
}
else
{
stringValue = (String)null;
}
}
}
else if (functionName.equals("COUNT"))
{
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
/*
* The COUNT function always returns a not null value
*/
notNull = true;
valueSet = true;
if (intValue == java.lang.Integer.MIN_VALUE)
{
intValue = 0;
}
else
{
intValue = intValue + 1;
}
}
else if (functionName.equals("TO_DATE"))
{
/*
* Validate the TO_DATE argument
*/
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
type = java.sql.Types.DATE;
size = 10;
if (argColumn.notNull)
{
stringValue = argColumn.getString().trim();
ft = new FieldTokenizer(stringValue, '-', false);
ftFields = ft.getFields();
if (ftFields.Length < 3)
{
throw new TinySQLException(stringValue + " is not a date with "
+ "format DD-MON-YY!");
}
else
{
try
{
day = java.lang.Integer.parseInt(ftFields[0]);
if (day < 1 | day > 31)
{
throw new TinySQLException(stringValue + " day not "
+ "between 1 and 31.");
}
monthName = ftFields[1].toUpperCase();
monthAt = months.indexOf("-" + monthName + "-");
if (monthAt == -1)
{
throw new TinySQLException(stringValue + " month not "
+ "recognized.");
}
month = (monthAt + 4) / 4;
year = java.lang.Integer.parseInt(ftFields[2]);
if (year < 0 | year > 2100)
{
throw new TinySQLException(stringValue + " year not "
+ "recognized.");
}
/*
* Assume that years < 50 are in the 21st century, otherwise
* the 20th.
*/
if (year < 50)
{
year = 2000 + year;
}
else if (year < 100)
{
year = 1900 + year;
}
dayField = java.lang.Integer.toString(day);
if (dayField.length() < 2)
{
dayField = "0" + dayField;
}
monthField = java.lang.Integer.toString(month);
if (monthField.length() < 2)
{
monthField = "0" + monthField;
}
yearField = java.lang.Integer.toString(year);
stringValue = yearField + "-" + monthField + "-" + dayField;
}
catch (Exception dayEx)
{
throw new TinySQLException(stringValue + " exception "
+ dayEx.getMessage());
}
}
notNull = true;
}
}
else if (functionName.equals("SUM"))
{
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.type == java.sql.Types.CHAR | argColumn.type == java.sql.Types.DATE)
{
throw new TinySQLException(argColumn.name + " is not numeric!");
}
if (argColumn.notNull)
{
notNull = true;
if (floatValue == java.lang.Float.MIN_VALUE)
{
floatValue = (float)0.0;
}
else
{
if (argColumn.type == java.sql.Types.INTEGER)
{
floatValue += new java.lang.Integer(argColumn.intValue).floatValue();
}
else
{
floatValue += argColumn.floatValue;
}
}
}
}
else if (functionName.equals("MAX") | functionName.equals("MIN"))
{
argColumn = (TsColumn)functionArgs.elementAt(0);
argColumn.updateFunctions();
if (argColumn.isValueSet())
{
valueSet = true;
}
if (argColumn.notNull)
{
notNull = true;
if (argColumn.type == java.sql.Types.CHAR | argColumn.type == java.sql.Types.DATE)
{
if (stringValue == null)
{
stringValue = argColumn.stringValue;
}
else
{
/*
* Update the max and min based upon string comparisions.
*/
if (functionName.equals("MAX") &
(argColumn.stringValue.compareTo(stringValue) > 0))
{
stringValue = argColumn.stringValue;
}
else if (functionName.equals("MIN") &
(argColumn.stringValue.compareTo(stringValue) < 0))
{
stringValue = argColumn.stringValue;
}
}
}
else if (argColumn.type == java.sql.Types.INTEGER)
{
/*
* Update max and min based upon numeric values.
*/
if (intValue == java.lang.Integer.MIN_VALUE)
{
intValue = argColumn.intValue;
}
else
{
if (functionName.equals("MIN") &
argColumn.intValue < intValue)
{
intValue = argColumn.intValue;
}
else if (functionName.equals("MAX") &
argColumn.intValue > intValue)
{
intValue = argColumn.intValue;
}
}
}
else if (argColumn.type == java.sql.Types.FLOAT)
{
if (floatValue == java.lang.Float.MIN_VALUE)
{
floatValue = argColumn.floatValue;
}
else
{
if (functionName.equals("MIN") &
argColumn.floatValue < floatValue)
{
floatValue = argColumn.floatValue;
}
else if (functionName.equals("MAX") &
argColumn.floatValue > floatValue)
{
floatValue = argColumn.floatValue;
}
}
}
}
}
}
// To escape a file path to a URI, by using %HH to represent
// special ASCII characters: 0x00~0x1F, 0x7F, ' ', '<', '>', '#', '%'
// and '"' and non-ASCII characters (whose value >= 128).
public static String filepath2URI(String path)
{
// return null if path is null.
if (path == null)
{
return(null);
}
char separator = java.io.File.separatorChar;
path = path.replace(separator, '/');
int len = path.length(), ch;
java.lang.StringBuffer buffer = new java.lang.StringBuffer(len * 3);
buffer.append("file://");
// change C:/blah to /C:/blah
if (len >= 2 && path.charAt(1) == ':')
{
ch = java.lang.Character.toUpperCase(path.charAt(0));
if (ch >= 'A' && ch <= 'Z')
{
buffer.append('/');
}
}
// for each character in the path
int i = 0;
for (; i < len; i++)
{
ch = path.charAt(i);
// if it's not an ASCII character, break here, and use UTF-8 encoding
if (ch >= 128)
{
break;
}
if (gNeedEscaping [ch])
{
buffer.append('%');
buffer.append(gAfterEscaping1 [ch]);
buffer.append(gAfterEscaping2 [ch]);
// record the fact that it's escaped
}
else
{
buffer.append((char)ch);
}
}
// we saw some non-ascii character
if (i < len)
{
// get UTF-8 bytes for the remaining sub-string
byte[] bytes = null;
byte b;
try {
bytes = path.substring(i).getBytes("UTF-8");
} catch (java.io.UnsupportedEncodingException e) {
// should never happen
return(path);
}
len = bytes.Length;
// for each byte
for (i = 0; i < len; i++)
{
b = bytes [i];
// for non-ascii character: make it positive, then escape
if (b < 0)
{
ch = b + 256;
buffer.append('%');
buffer.append(gHexChs [ch >> 4]);
buffer.append(gHexChs [ch & 0xf]);
}
else if (gNeedEscaping [b])
{
buffer.append('%');
buffer.append(gAfterEscaping1 [b]);
buffer.append(gAfterEscaping2 [b]);
}
else
{
buffer.append((char)b);
}
}
}
return(buffer.toString());
}
/*
* This method formats an action Hashtable for display.
*/
public static String actionToString(java.util.Hashtable <Object, Object> displayAction)
{
java.lang.StringBuffer displayBuffer = new java.lang.StringBuffer();
String displayType, tableName;
TinySQLWhere displayWhere;
TsColumn createColumn, displayColumn;
bool groupBy = false, orderBy = false;
int i;
java.util.Vector <Object> displayTables, displayColumns, columnDefs, displayValues;
java.util.Hashtable <Object, Object> tables;
displayType = (String)displayAction.get("TYPE");
displayBuffer.append(displayType + " ");
displayWhere = null;
displayColumns = null;
if (displayType.equals("SELECT"))
{
tables = (java.util.Hashtable <Object, Object>)displayAction.get("TABLES");
displayTables = (java.util.Vector <Object>)tables.get("TABLE_SELECT_ORDER");
displayColumns = (java.util.Vector <Object>)displayAction.get("COLUMNS");
displayWhere = (TinySQLWhere)displayAction.get("WHERE");
for (i = 0; i < displayColumns.size(); i++)
{
displayColumn = (TsColumn)displayColumns.elementAt(i);
if (displayColumn.getContext("GROUP"))
{
groupBy = true;
continue;
}
else if (displayColumn.getContext("ORDER"))
{
orderBy = true;
continue;
}
if (i > 0)
{
displayBuffer.append(",");
}
displayBuffer.append((String)displayColumn.name);
}
displayBuffer.append(" FROM ");
for (i = 0; i < displayTables.size(); i++)
{
if (i > 0)
{
displayBuffer.append(",");
}
displayBuffer.append((String)displayTables.elementAt(i));
}
}
else if (displayType.equals("DROP_TABLE"))
{
tableName = (String)displayAction.get("TABLE");
displayBuffer.append(tableName);
}
else if (displayType.equals("CREATE_TABLE"))
{
tableName = (String)displayAction.get("TABLE");
displayBuffer.append(tableName + " (");
columnDefs = (java.util.Vector <Object>)displayAction.get("COLUMN_DEF");
for (i = 0; i < columnDefs.size(); i++)
{
if (i > 0)
{
displayBuffer.append(",");
}
createColumn = (TsColumn)columnDefs.elementAt(i);
displayBuffer.append(createColumn.name + " " + createColumn.type
+ "( " + createColumn.size + "," + createColumn.decimalPlaces
+ ")");
}
displayBuffer.append(")");
}
else if (displayType.equals("INSERT"))
{
tableName = (String)displayAction.get("TABLE");
displayBuffer.append("INTO " + tableName + "(");
displayColumns = (java.util.Vector <Object>)displayAction.get("COLUMNS");
for (i = 0; i < displayColumns.size(); i++)
{
if (i > 0)
{
displayBuffer.append(",");
}
displayBuffer.append((String)displayColumns.elementAt(i));
}
displayBuffer.append(") VALUES (");
displayValues = (java.util.Vector <Object>)displayAction.get("VALUES");
for (i = 0; i < displayValues.size(); i++)
{
if (i > 0)
{
displayBuffer.append(",");
}
displayBuffer.append((String)displayValues.elementAt(i));
}
displayBuffer.append(")");
}
else if (displayType.equals("UPDATE"))
{
tableName = (String)displayAction.get("TABLE");
displayBuffer.append(tableName + " SET ");
displayColumns = (java.util.Vector <Object>)displayAction.get("COLUMNS");
displayValues = (java.util.Vector <Object>)displayAction.get("VALUES");
displayWhere = (TinySQLWhere)displayAction.get("WHERE");
for (i = 0; i < displayColumns.size(); i++)
{
if (i > 0)
{
displayBuffer.append(",");
}
displayBuffer.append((String)displayColumns.elementAt(i)
+ "=" + (String)displayValues.elementAt(i));
}
}
else if (displayType.equals("DELETE"))
{
tableName = (String)displayAction.get("TABLE");
displayBuffer.append(" FROM " + tableName);
displayWhere = (TinySQLWhere)displayAction.get("WHERE");
}
if (displayWhere != (TinySQLWhere)null)
{
displayBuffer.append(displayWhere.toString());
}
if (groupBy)
{
displayBuffer.append(" GROUP BY ");
for (i = 0; i < displayColumns.size(); i++)
{
displayColumn = (TsColumn)displayColumns.elementAt(i);
if (!displayColumn.getContext("GROUP"))
{
continue;
}
if (!displayBuffer.toString().endsWith(" GROUP BY "))
{
displayBuffer.append(",");
}
displayBuffer.append(displayColumn.name);
}
}
if (orderBy)
{
displayBuffer.append(" ORDER BY ");
for (i = 0; i < displayColumns.size(); i++)
{
displayColumn = (TsColumn)displayColumns.elementAt(i);
if (!displayColumn.getContext("ORDER"))
{
continue;
}
if (!displayBuffer.toString().endsWith(" ORDER BY "))
{
displayBuffer.append(",");
}
displayBuffer.append(displayColumn.name);
}
}
return(displayBuffer.toString());
}
// To escape a file path to a URI, by using %HH to represent
// special ASCII characters: 0x00~0x1F, 0x7F, ' ', '<', '>', '#', '%'
// and '"' and non-ASCII characters (whose value >= 128).
public static String filepath2URI(String path)
{
// return null if path is null.
if (path == null)
return null;
char separator = java.io.File.separatorChar;
path = path.replace (separator, '/');
int len = path.length (), ch;
java.lang.StringBuffer buffer = new java.lang.StringBuffer (len * 3);
buffer.append ("file://");
// change C:/blah to /C:/blah
if (len >= 2 && path.charAt (1) == ':') {
ch = java.lang.Character.toUpperCase (path.charAt (0));
if (ch >= 'A' && ch <= 'Z') {
buffer.append ('/');
}
}
// for each character in the path
int i = 0;
for (; i < len; i++) {
ch = path.charAt (i);
// if it's not an ASCII character, break here, and use UTF-8 encoding
if (ch >= 128)
break;
if (gNeedEscaping [ch]) {
buffer.append ('%');
buffer.append (gAfterEscaping1 [ch]);
buffer.append (gAfterEscaping2 [ch]);
// record the fact that it's escaped
} else {
buffer.append ((char)ch);
}
}
// we saw some non-ascii character
if (i < len) {
// get UTF-8 bytes for the remaining sub-string
byte[] bytes = null;
byte b;
try {
bytes = path.substring (i).getBytes ("UTF-8");
} catch (java.io.UnsupportedEncodingException e) {
// should never happen
return path;
}
len = bytes.Length;
// for each byte
for (i = 0; i < len; i++) {
b = bytes [i];
// for non-ascii character: make it positive, then escape
if (b < 0) {
ch = b + 256;
buffer.append ('%');
buffer.append (gHexChs [ch >> 4]);
buffer.append (gHexChs [ch & 0xf]);
} else if (gNeedEscaping [b]) {
buffer.append ('%');
buffer.append (gAfterEscaping1 [b]);
buffer.append (gAfterEscaping2 [b]);
} else {
buffer.append ((char)b);
}
}
}
return buffer.toString ();
}
public override java.lang.StringBuffer format(Object obj, java.lang.StringBuffer buffer, FieldPosition field)
{
throw new java.lang.UnsupportedOperationException("Not yet implemented");
}
/**
* Constructs a new {@code StringWriter} which has a {@link StringBuffer}
* allocated with the default size of 16 characters. The {@code
* StringBuffer} is also the {@code lock} used to synchronize access to this
* writer.
*/
public StringWriter()
: base()
{
buf = new java.lang.StringBuffer(16);
lockJ = buf;
}
/*
* Returns a hash code consistent with the definition of the equals method.
*
* @see Object#hashCode()
*/
// default method not twice declared
//public abstract int GetHashCode();
/**
* <p>Returns a <code>String</code> representation of this <code>Duration</code> <code>Object</code>.</p>
*
* <p>The result is formatted according to the XML Schema 1.0 spec and can be always parsed back later into the
* equivalent <code>Duration</code> <code>Object</code> by {@link DatatypeFactory#newDuration(String lexicalRepresentation)}.</p>
*
* <p>Formally, the following holds for any <code>Duration</code>
* <code>Object</code> x:</p>
* <pre>
* new Duration(x.toString()).equals(x)
* </pre>
*
* @return A non-<code>null</code> valid <code>String</code> representation of this <code>Duration</code>.
*/
public override String ToString()
{
java.lang.StringBuffer buf = new java.lang.StringBuffer();
if (getSign() < 0)
{
buf.append('-');
}
buf.append('P');
java.math.BigInteger years = (java.math.BigInteger)getField(DatatypeConstants.YEARS);
if (years != null)
{
buf.append(years + "Y");
}
java.math.BigInteger months = (java.math.BigInteger)getField(DatatypeConstants.MONTHS);
if (months != null)
{
buf.append(months + "M");
}
java.math.BigInteger days = (java.math.BigInteger)getField(DatatypeConstants.DAYS);
if (days != null)
{
buf.append(days + "D");
}
java.math.BigInteger hours = (java.math.BigInteger)getField(DatatypeConstants.HOURS);
java.math.BigInteger minutes = (java.math.BigInteger)getField(DatatypeConstants.MINUTES);
java.math.BigDecimal seconds = (java.math.BigDecimal)getField(DatatypeConstants.SECONDS);
if (hours != null || minutes != null || seconds != null)
{
buf.append('T');
if (hours != null)
{
buf.append(hours + "H");
}
if (minutes != null)
{
buf.append(minutes + "M");
}
if (seconds != null)
{
buf.append(toString(seconds) + "S");
}
}
return buf.toString();
}
/**
* <p>Turns {@link BigDecimal} to a string representation.</p>
*
* <p>Due to a behavior change in the {@link BigDecimal#toString()}
* method in JDK1.5, this had to be implemented here.</p>
*
* @param bd <code>BigDecimal</code> to format as a <code>String</code>
*
* @return <code>String</code> representation of <code>BigDecimal</code>
*/
private String toString(java.math.BigDecimal bd)
{
String intString = bd.unscaledValue().toString();
int scale = bd.scale();
if (scale == 0)
{
return intString;
}
/* Insert decimal point */
java.lang.StringBuffer buf;
int insertionPoint = intString.length() - scale;
if (insertionPoint == 0)
{ /* Point goes right before intVal */
return "0." + intString;
}
else if (insertionPoint > 0)
{ /* Point goes inside intVal */
buf = new java.lang.StringBuffer(intString);
buf.insert(insertionPoint, '.');
}
else
{ /* We must insert zeros between point and intVal */
buf = new java.lang.StringBuffer(3 - insertionPoint + intString.length());
buf.append("0.");
for (int i = 0; i < -insertionPoint; i++)
{
buf.append('0');
}
buf.append(intString);
}
return buf.toString();
}
/*
* Constructs a new {@code StringWriter} which has a {@link StringBuffer}
* allocated with the default size of 16 characters. The {@code
* StringBuffer} is also the {@code lock} used to synchronize access to this
* writer.
*/
public StringWriter()
: base()
{
buf = new java.lang.StringBuffer(16);
lockJ = buf;
}
/**
* Get the error message with location information
* appended.
*
* @return A <code>String</code> representing the error message with
* location information appended.
*/
public String getMessageAndLocation()
{
java.lang.StringBuffer sbuffer = new java.lang.StringBuffer();
String message = base.getMessage();
if (null != message) {
sbuffer.append(message);
}
if (null != locator) {
String systemID = locator.getSystemId();
int line = locator.getLineNumber();
int column = locator.getColumnNumber();
if (null != systemID) {
sbuffer.append("; SystemID: ");
sbuffer.append(systemID);
}
if (0 != line) {
sbuffer.append("; Line#: ");
sbuffer.append(line);
}
if (0 != column) {
sbuffer.append("; Column#: ");
sbuffer.append(column);
}
}
return sbuffer.toString();
}
/**
* Get the location information as a string.
*
* @return A string with location info, or null
* if there is no location information.
*/
public String getLocationAsString()
{
if (null != locator) {
java.lang.StringBuffer sbuffer = new java.lang.StringBuffer();
String systemID = locator.getSystemId();
int line = locator.getLineNumber();
int column = locator.getColumnNumber();
if (null != systemID) {
sbuffer.append("; SystemID: ");
sbuffer.append(systemID);
}
if (0 != line) {
sbuffer.append("; Line#: ");
sbuffer.append(line);
}
if (0 != column) {
sbuffer.append("; Column#: ");
sbuffer.append(column);
}
return sbuffer.toString();
} else {
return null;
}
}
/**
* <p><code>String</code> representation of this
* <code>QName</code>.</p>
*
* <p>The commonly accepted way of representing a <code>QName</code>
* as a <code>String</code> was <a href="http://jclark.com/xml/xmlns.htm">defined</a>
* by James Clark. Although this is not a <em>standard</em>
* specification, it is in common use, e.g. {@link javax.xml.transform.Transformer#setParameter(String name, Object value)}.
* This implementation represents a <code>QName</code> as:
* "{" + Namespace URI + "}" + local part. If the Namespace URI
* <code>.equals(XMLConstants.NULL_NS_URI)</code>, only the
* local part is returned. An appropriate use of this method is
* for debugging or logging for human consumption.</p>
*
* <p>Note the prefix value is <strong><em>NOT</em></strong>
* returned as part of the <code>String</code> representation.</p>
*
* <p>This method satisfies the general contract of {@link
* java.lang.Object#toString() Object.toString()}.</p>
*
* @return <code>String</code> representation of this <code>QName</code>
*/
public override String ToString()
{
String _qNameAsString = qNameAsString;
if (_qNameAsString == null)
{
int nsLength = namespaceURI.length();
if (nsLength == 0)
{
_qNameAsString = localPart;
}
else
{
java.lang.StringBuffer buffer = new java.lang.StringBuffer(nsLength + localPart.length() + 2);
buffer.append('{');
buffer.append(namespaceURI);
buffer.append('}');
buffer.append(localPart);
_qNameAsString = buffer.toString();
}
qNameAsString = _qNameAsString;
}
return _qNameAsString;
}
/*
* The constructor builds a Where clause object from the input string.
*/
public TinySQLWhere(String whereString, java.util.Hashtable <Object, Object> tableDefs)
//throws tinySQLException
{
FieldTokenizer ft;
java.util.Vector <Object> whereConditions;
TsColumn leftColumn, rightColumn;
Object whereObj;
java.lang.StringBuffer fieldBuffer;
String nextField, upperField, wherePhrase, comp, left, right, andOr, lastWord;
java.util.Vector <Object> whereCondition;
String[] comparisons = { "<=", "=<", ">=", "=>", "=", "<>", "!=", ">", "<",
"LIKE", "NOT LIKE", "IS" };
String[] fields, keepFields;
bool inBrackets = false, foundFunction = false;
int i, j, foundKeyWord, foundComp, startAt, foundAnd, foundOr, keepCount;
/*
* The whereClauseList is a Vector containing pointers to whereCondition
* Vectors or tinySQLWhere objects.
*/
whereConditions = new java.util.Vector <Object>();
whereClauseList = new java.util.Vector <Object>();
/*
* Identify any phrases that are contained within brackets. Note that
* the FieldTokenizer will catch function definitions as well as
* subPhrases so there has to be additional logic to reconstruct
* the functions.
*/
ft = new FieldTokenizer(whereString, '(', true);
fields = ft.getFields();
keepFields = new String[fields.Length];
lastWord = "NULL";
fieldBuffer = new java.lang.StringBuffer();
foundFunction = false;
keepCount = 0;
for (i = 0; i < fields.Length; i++)
{
keepFields[i] = "";
if (fields[i].equals("("))
{
/*
* If this is a known function reconstruct the function definition
* and save the entire string.
*/
foundFunction = Utils.isFunctionName(lastWord);
if (foundFunction)
{
fieldBuffer.append("(");
}
else
{
if (fieldBuffer.length() > 0)
{
keepFields[keepCount] = fieldBuffer.toString();
keepCount++;
fieldBuffer.delete(0, fieldBuffer.length());
}
keepFields[keepCount] = "(";
keepCount++;
}
}
else if (fields[i].equals(")"))
{
if (foundFunction)
{
fieldBuffer.append(") ");
foundFunction = false;
}
else
{
if (fieldBuffer.length() > 0)
{
keepFields[keepCount] = fieldBuffer.toString();
keepCount++;
fieldBuffer.delete(0, fieldBuffer.length());
}
keepFields[keepCount] = ")";
keepCount++;
}
}
else
{
fieldBuffer.append(fields[i]);
}
lastWord = fields[i].substring(fields[i].lastIndexOf(" ") + 1);
}
/*
* Keep last subPhrase
*/
if (fieldBuffer.length() > 0)
{
keepFields[keepCount] = fieldBuffer.toString();
keepCount++;
}
for (i = 0; i < keepCount; i++)
{
if (TinySQLGlobals.WHERE_DEBUG)
{
java.lang.SystemJ.outJ.println("keepFields[" + i + "]=" + keepFields[i]);
}
nextField = keepFields[i];
upperField = nextField.toUpperCase();
if (nextField.equals("("))
{
whereObj = (Object)null;
inBrackets = true;
}
else if (nextField.equals(")"))
{
inBrackets = false;
whereObj = (Object)null;
}
else if (inBrackets)
{
whereObj = new TinySQLWhere(nextField, tableDefs);
whereConditions.addElement(whereObj);
}
else
{
/*
* Look for AND/OR keywords - if none are found process the
* entire string.
*/
andOr = "AND";
startAt = 0;
while (startAt < upperField.length())
{
if (upperField.startsWith("AND "))
{
foundAnd = 0;
}
else
{
foundAnd = upperField.indexOf(" AND", startAt);
/*
* Make sure this is not just part of a longer string.
*/
if (foundAnd > -1 & foundAnd < upperField.length() - 4)
{
if (upperField.charAt(foundAnd + 4) != ' ')
{
foundAnd = -1;
}
}
}
if (upperField.startsWith("OR "))
{
foundOr = 0;
}
else
{
foundOr = upperField.indexOf(" OR", startAt);
if (foundOr > -1 & foundOr < upperField.length() - 3)
{
if (upperField.charAt(foundOr + 3) != ' ')
{
foundOr = -1;
}
}
}
foundKeyWord = upperField.length();
if (foundAnd > -1)
{
foundKeyWord = foundAnd;
}
if (foundOr > -1 & foundOr < foundKeyWord)
{
foundKeyWord = foundOr;
andOr = "OR";
}
if (foundKeyWord == 0)
{
startAt = andOr.length() + 1;
foundKeyWord = upperField.length();
}
wherePhrase = nextField.substring(startAt, foundKeyWord);
if (TinySQLGlobals.WHERE_DEBUG)
{
java.lang.SystemJ.outJ.println("Where phrase is " + wherePhrase);
}
if (foundKeyWord < upperField.length() - 4)
{
andOr = upperField.substring(foundKeyWord + 1, foundKeyWord + 3);
}
/*
* Build a whereCondition Vector. The elements are
* as follows:
* 0 - left column object
* 1 - comparison
* 2 - right column object
* 3 - status
*
* The status values indicate which parts of the where
* condition have been set.
*/
whereCondition = new java.util.Vector <Object>();
for (j = 0; j < comparisons.Length; j++)
{
comp = comparisons[j];
foundComp = wherePhrase.toUpperCase().indexOf(comp);
if (foundComp > -1)
{
left = wherePhrase.substring(0, foundComp).trim();
leftColumn = new TsColumn(left, tableDefs, "WHERE");
whereCondition.addElement(leftColumn);
whereCondition.addElement(comp);
right = wherePhrase.substring(foundComp + comp.length()).trim();
if (comp.equals("IS"))
{
right = "'" + right.toUpperCase() + "'";
}
rightColumn = new TsColumn(right, tableDefs, "WHERE");
whereCondition.addElement(rightColumn);
if (leftColumn.isConstant & rightColumn.isConstant)
{
whereCondition.addElement("BOTH");
}
else if (leftColumn.isConstant)
{
whereCondition.addElement("LEFT");
}
else if (rightColumn.isConstant)
{
whereCondition.addElement("RIGHT");
}
else
{
whereCondition.addElement("UNKNOWN");
}
break;
}
}
whereConditions.addElement(whereCondition);
/*
* If this condition and the previous one are joined by an
* AND keyword, add the condition to the existing Vector.
* For an OR keyword, create a new entry in the whereClauseList.
*/
if (andOr.equals("OR"))
{
whereClauseList.addElement(whereConditions);
whereConditions = new java.util.Vector <Object>();
}
startAt = foundKeyWord + andOr.length() + 2;
}
}
}
/*
* Add the last where condition to the list.
*/
if (whereConditions.size() > 0)
{
whereClauseList.addElement(whereConditions);
}
if (TinySQLGlobals.WHERE_DEBUG)
{
java.lang.SystemJ.outJ.println("Where clause is \n" + toString());
}
}
/**
* Appends the specified object to the specified string buffer using the
* rules of this format.
* <p>
* {@code field} is an input/output parameter. If its {@code field}
* member contains an enum value specifying a field on input, then its
* {@code beginIndex} and {@code endIndex} members will be updated with the
* text offset of the first occurrence of this field in the formatted text.
*
* @param object
* the object to format.
* @param buffer
* the string buffer where the formatted string is appended to.
* @param field
* on input: an optional alignment field; on output: the offsets
* of the alignment field in the formatted text.
* @return the string buffer.
* @throws IllegalArgumentException
* if the object cannot be formatted by this format.
*/
public abstract java.lang.StringBuffer format(Object obj, java.lang.StringBuffer buffer, FieldPosition field);
public static void main(String[] args) //throws IOException,SQLException
{
java.sql.DatabaseMetaData dbMeta;
java.sql.ResultSetMetaData meta;
java.sql.ResultSet display_rs, typesRS;
java.io.BufferedReader stdin, loadFileReader;
java.io.BufferedReader startReader = (java.io.BufferedReader)null;
String[] fields;
java.sql.Connection con;
java.sql.Statement stmt;
FieldTokenizer ft;
java.sql.PreparedStatement pstmt = (java.sql.PreparedStatement)null;
int i, rsColCount, endAt, colWidth, colScale, colPrecision, typeCount,
colType, parameterIndex, b1, b2, parameterInt, startAt, columnIndex, valueIndex;
String fName, tableName = null, inputString, cmdString, colTypeName, dbType,
parameterString, loadString, fieldString, readString;
java.lang.StringBuffer lineOut, prepareBuffer, valuesBuffer, inputBuffer;
bool echo = false;
stdin = new java.io.BufferedReader(new java.io.InputStreamReader(java.lang.SystemJ.inJ));
try
{
/*
* Register the JDBC driver for dBase
*/
java.lang.Class.forName("com.sqlmagic.tinysql.dbfFileDriver");
}
catch (java.lang.ClassNotFoundException e)
{
java.lang.SystemJ.err.println(
"JDBC Driver could not be registered!!\n");
if (TinySQLGlobals.DEBUG)
{
e.printStackTrace();
}
}
fName = ".";
if (args.Length > 0)
{
fName = args[0];
}
/*
* Establish a connection to dBase
*/
con = dbConnect(fName);
if (con == (java.sql.Connection)null)
{
fName = ".";
con = dbConnect(fName);
}
dbMeta = con.getMetaData();
dbType = dbMeta.getDatabaseProductName();
dbVersion = dbMeta.getDatabaseProductVersion();
java.lang.SystemJ.outJ.println("===================================================");
java.lang.SystemJ.outJ.println(dbType + " Command line interface version "
+ dbVersion + " Java version released March 15, 2007");
java.lang.SystemJ.outJ.println("Type HELP to get information on available commands.");
cmdString = "NULL";
stmt = con.createStatement();
inputString = (String)null;
if (args.Length > 1)
{
inputString = args[1].trim();
}
while (!cmdString.toUpperCase().equals("EXIT"))
{
try
{
if (startReader != (java.io.BufferedReader)null)
{
/*
* Command START files can contain comments and can have
* commands broken over several lines. However, they
* cannot have partial commands on a line.
*/
inputBuffer = new java.lang.StringBuffer();
inputString = (String)null;
while ((readString = startReader.readLine()) != null)
{
if (readString.startsWith("--") |
readString.startsWith("#"))
{
continue;
}
inputBuffer.append(readString + " ");
/*
* A field tokenizer must be used to avoid problems with
* semi-colons inside quoted strings.
*/
ft = new FieldTokenizer(inputBuffer.toString(), ';', true);
if (ft.countFields() > 1)
{
inputString = inputBuffer.toString();
break;
}
}
if (inputString == (String)null)
{
startReader = (java.io.BufferedReader)null;
continue;
}
}
else if (args.Length == 0)
{
java.lang.SystemJ.outJ.print("tinySQL>");
inputString = stdin.readLine().trim();
}
if (inputString == (String)null)
{
break;
}
if (inputString.toUpperCase().startsWith("EXIT") |
inputString.toUpperCase().startsWith("QUIT"))
{
break;
}
startAt = 0;
while (startAt < inputString.length() - 1)
{
endAt = inputString.indexOf(";", startAt);
if (endAt == -1)
{
endAt = inputString.length();
}
cmdString = inputString.substring(startAt, endAt);
if (echo)
{
java.lang.SystemJ.outJ.println(cmdString);
}
startAt = endAt + 1;
if (cmdString.toUpperCase().startsWith("SELECT"))
{
display_rs = stmt.executeQuery(cmdString);
if (display_rs == (java.sql.ResultSet)null)
{
java.lang.SystemJ.outJ.println("Null ResultSet returned from query");
continue;
}
meta = display_rs.getMetaData();
/*
* The actual number of columns retrieved has to be checked
*/
rsColCount = meta.getColumnCount();
lineOut = new java.lang.StringBuffer(100);
int[] columnWidths = new int[rsColCount];
int[] columnScales = new int[rsColCount];
int[] columnPrecisions = new int[rsColCount];
int[] columnTypes = new int[rsColCount];
String[] columnNames = new String[rsColCount];
for (i = 0; i < rsColCount; i++)
{
columnNames[i] = meta.getColumnName(i + 1);
columnWidths[i] = meta.getColumnDisplaySize(i + 1);
columnTypes[i] = meta.getColumnType(i + 1);
columnScales[i] = meta.getScale(i + 1);
columnPrecisions[i] = meta.getPrecision(i + 1);
if (columnNames[i].length() > columnWidths[i])
{
columnWidths[i] = columnNames[i].length();
}
lineOut.append(padString(columnNames[i], columnWidths[i]) + " ");
}
if (TinySQLGlobals.DEBUG)
{
java.lang.SystemJ.outJ.println(lineOut.toString());
}
displayResults(display_rs);
}
else if (cmdString.toUpperCase().startsWith("CONNECT"))
{
con = dbConnect(cmdString.substring(8, cmdString.length()));
}
else if (cmdString.toUpperCase().startsWith("HELP"))
{
helpMsg(cmdString);
}
else if (cmdString.toUpperCase().startsWith("DESCRIBE"))
{
dbMeta = con.getMetaData();
tableName = cmdString.toUpperCase().substring(9);
display_rs = dbMeta.getColumns(null, null, tableName, null);
java.lang.SystemJ.outJ.println("\nColumns for table " + tableName + "\n"
+ "Name Type");
while (display_rs.next())
{
lineOut = new java.lang.StringBuffer(100);
lineOut.append(padString(display_rs.getString(4), 32));
colTypeName = display_rs.getString(6);
colType = display_rs.getInt(5);
colWidth = display_rs.getInt(7);
colScale = display_rs.getInt(9);
colPrecision = display_rs.getInt(10);
if (colTypeName.equals("CHAR"))
{
colTypeName = colTypeName + "("
+ java.lang.Integer.toString(colWidth) + ")";
}
else if (colTypeName.equals("FLOAT"))
{
colTypeName += "(" + java.lang.Integer.toString(colPrecision)
+ "," + java.lang.Integer.toString(colScale) + ")";
}
lineOut.append(padString(colTypeName, 20) + padString(colType, 12));
java.lang.SystemJ.outJ.println(lineOut.toString());
}
}
else if (cmdString.toUpperCase().equals("SHOW TABLES"))
{
for (i = 0; i < tableList.size(); i++)
{
java.lang.SystemJ.outJ.println((String)tableList.elementAt(i));
}
}
else if (cmdString.toUpperCase().equals("SHOW TYPES"))
{
typesRS = dbMeta.getTypeInfo();
typeCount = displayResults(typesRS);
}
else if (cmdString.toUpperCase().startsWith("SET "))
{
/*
* Support for SET DEBUG ON/OFF and SET ECHO ON/OFF
*/
ft = new FieldTokenizer(cmdString.toUpperCase(), ' ', false);
fields = ft.getFields();
if (fields[1].equals("ECHO"))
{
if (fields[2].equals("ON"))
{
echo = true;
}
else
{
echo = false;
}
}
else if (fields[1].equals("DEBUG"))
{
if (fields[2].equals("ON"))
{
TinySQLGlobals.DEBUG = true;
}
else
{
TinySQLGlobals.DEBUG = false;
}
}
else if (fields[1].equals("PARSER_DEBUG"))
{
if (fields[2].equals("ON"))
{
TinySQLGlobals.PARSER_DEBUG = true;
}
else
{
TinySQLGlobals.PARSER_DEBUG = false;
}
}
else if (fields[1].equals("WHERE_DEBUG"))
{
if (fields[2].equals("ON"))
{
TinySQLGlobals.WHERE_DEBUG = true;
}
else
{
TinySQLGlobals.WHERE_DEBUG = false;
}
}
else if (fields[1].equals("EX_DEBUG"))
{
if (fields[2].equals("ON"))
{
TinySQLGlobals.EX_DEBUG = true;
}
else
{
TinySQLGlobals.EX_DEBUG = false;
}
}
}
else if (cmdString.toUpperCase().startsWith("SPOOL "))
{
/*
* Spool output to a file.
*/
ft = new FieldTokenizer(cmdString, ' ', false);
fName = ft.getField(1);
if (fName.equals("OFF"))
{
try
{
spoolFileWriter.close();
}
catch (Exception spoolEx)
{
java.lang.SystemJ.outJ.println("Unable to close spool file "
+ spoolEx.getMessage() + newLine);
}
}
else
{
try
{
spoolFileWriter = new java.io.FileWriter(fName);
if (spoolFileWriter != (java.io.FileWriter)null)
{
java.lang.SystemJ.outJ.println("Output spooled to " + fName);
}
}
catch (Exception spoolEx)
{
java.lang.SystemJ.outJ.println("Unable to spool to file "
+ spoolEx.getMessage() + newLine);
}
}
}
else if (cmdString.toUpperCase().startsWith("START "))
{
ft = new FieldTokenizer(cmdString, ' ', false);
fName = ft.getField(1);
if (!fName.toUpperCase().endsWith(".SQL"))
{
fName += ".SQL";
}
try
{
startReader = new java.io.BufferedReader(new java.io.FileReader(fName));
}
catch (Exception)
{
startReader = (java.io.BufferedReader)null;
throw new TinySQLException("No such file: " + fName);
}
}
else if (cmdString.toUpperCase().startsWith("LOAD"))
{
ft = new FieldTokenizer(cmdString, ' ', false);
fName = ft.getField(1);
tableName = ft.getField(3);
display_rs = stmt.executeQuery("SELECT * FROM " + tableName);
meta = display_rs.getMetaData();
rsColCount = meta.getColumnCount();
/*
* Set up the PreparedStatement for the inserts
*/
prepareBuffer = new java.lang.StringBuffer("INSERT INTO " + tableName);
valuesBuffer = new java.lang.StringBuffer(" VALUES");
for (i = 0; i < rsColCount; i++)
{
if (i == 0)
{
prepareBuffer.append(" (");
valuesBuffer.append(" (");
}
else
{
prepareBuffer.append(",");
valuesBuffer.append(",");
}
prepareBuffer.append(meta.getColumnName(i + 1));
valuesBuffer.append("?");
}
prepareBuffer.append(")" + valuesBuffer.toString() + ")");
try
{
pstmt = con.prepareStatement(prepareBuffer.toString());
loadFileReader = new java.io.BufferedReader(new java.io.FileReader(fName));
while ((loadString = loadFileReader.readLine()) != null)
{
if (loadString.toUpperCase().equals("ENDOFDATA"))
{
break;
}
columnIndex = 0;
valueIndex = 0;
ft = new FieldTokenizer(loadString, '|', true);
while (ft.hasMoreFields())
{
fieldString = ft.nextField();
if (fieldString.equals("|"))
{
columnIndex++;
if (columnIndex > valueIndex)
{
pstmt.setString(valueIndex + 1, (String)null);
valueIndex++;
}
}
else if (columnIndex < rsColCount)
{
pstmt.setString(valueIndex + 1, fieldString);
valueIndex++;
}
}
pstmt.executeUpdate();
}
pstmt.close();
}
catch (Exception loadEx)
{
java.lang.SystemJ.outJ.println(loadEx.getMessage());
}
}
else if (cmdString.toUpperCase().startsWith("SETSTRING") |
cmdString.toUpperCase().startsWith("SETINT"))
{
b1 = cmdString.indexOf(" ");
b2 = cmdString.lastIndexOf(" ");
if (b2 > b1 & b1 > 0)
{
parameterIndex = java.lang.Integer.parseInt(cmdString.substring(b1 + 1, b2));
parameterString = cmdString.substring(b2 + 1);
if (TinySQLGlobals.DEBUG)
{
java.lang.SystemJ.outJ.println("Set parameter["
+ parameterIndex + "]=" + parameterString);
}
if (cmdString.toUpperCase().startsWith("SETINT"))
{
parameterInt = java.lang.Integer.parseInt(parameterString);
pstmt.setInt(parameterIndex, parameterInt);
}
else
{
pstmt.setString(parameterIndex, parameterString);
}
if (parameterIndex == 2)
{
pstmt.executeUpdate();
}
}
}
else
{
if (cmdString.indexOf("?") > -1)
{
pstmt = con.prepareStatement(cmdString);
}
else
{
try
{
stmt.executeUpdate(cmdString);
java.lang.SystemJ.outJ.println("DONE\n");
}
catch (java.lang.Exception upex)
{
java.lang.SystemJ.outJ.println(upex.getMessage());
if (TinySQLGlobals.DEBUG)
{
upex.printStackTrace();
}
}
}
}
}
if (args.Length > 1)
{
cmdString = "EXIT";
}
}
catch (java.sql.SQLException te)
{
java.lang.SystemJ.outJ.println(te.getMessage());
if (TinySQLGlobals.DEBUG)
{
te.printStackTrace(java.lang.SystemJ.outJ);
}
inputString = (String)null;
}
catch (Exception e)
{
java.lang.SystemJ.outJ.println(e.getMessage());
cmdString = "EXIT";
break;
}
}
try
{
if (spoolFileWriter != (java.io.FileWriter)null)
{
spoolFileWriter.close();
}
}
catch (Exception spoolEx)
{
java.lang.SystemJ.outJ.println("Unable to close spool file "
+ spoolEx.getMessage() + newLine);
}
}
/**
*
* Given a tsColumn object, returns its value as a String.
*
* @param column the tsColumn object
*
*/
public String columnAsString(TsColumn column)
{
String outputString, valueString, functionName, argList, nextArg;
java.lang.StringBuffer functionBuffer;
FieldTokenizer ft1, ft2;
/*
* Next try to retrieve as a group function, which will not have a
* tablename prefix.
*/
outputString = (String)get(column.name);
if (outputString != (String)null)
{
return(outputString);
}
ft1 = new FieldTokenizer(column.name, '(', false);
if (ft1.countFields() == 2)
{
/*
* The column is a function. If it is a group function, the value
* will be stored in the record. Otherwise, the function value
* will be determined here by retrieving and processing all the
* columns in the function arguments.
*/
outputString = (String)get(column.name);
if (outputString != (String)null)
{
return(outputString);
}
functionName = ft1.getField(0);
argList = ft1.getField(1);
ft2 = new FieldTokenizer(argList, ',', false);
functionBuffer = new java.lang.StringBuffer();
/*
* Function arguments must consist of table.column names or constants.
*/
while (ft2.hasMoreFields())
{
nextArg = ft2.nextField();
valueString = (String)get(nextArg);
if (debug)
{
java.lang.SystemJ.outJ.println("Function " + functionName
+ " argument " + nextArg + " has value " + valueString);
}
/*
* If the valueString is null then it is a constant rather than
* a database column. Remove enclosing quotes.
*/
if (valueString == (String)null)
{
valueString = UtilString.removeQuotes(nextArg);
}
else
{
valueString = valueString.trim();
}
if (functionName.equals("CONCAT"))
{
functionBuffer.append(valueString);
}
}
outputString = functionBuffer.toString();
}
else if (column.tableName == (String)null)
{
/*
* This is a constant. Return the table name which will be equal to
* the constant value.
*/
outputString = UtilString.removeQuotes(column.name);
}
else
{
/*
* Retrieve as a simple database column.
*/
outputString = (String)get(column.tableName + "." + column.name);
if (Utils.isDateColumn(column.type))
{
/*
* Format dates as DD-MON-YY for output. Note that the value
* stored in the database may already be in this format because
* of incorrect storage of date strings prior to version 2.3.
*/
try
{
outputString = UtilString.toStandardDate(outputString);
}
catch (Exception dateEx)
{
java.lang.SystemJ.outJ.println(dateEx.getMessage());
}
}
}
return(outputString);
}
/**
* Formatted output to stdout
* @return number of tuples
*/
static int displayResults(java.sql.ResultSet rs)
{//throws java.sql.SQLException
{
if (rs == null)
{
java.lang.SystemJ.err.println("ERROR in displayResult(): No data in ResultSet");
return(0);
}
java.sql.Date testDate;
int numCols = 0, nameLength;
java.sql.ResultSetMetaData meta = rs.getMetaData();
int cols = meta.getColumnCount();
int[] width = new int[cols];
String dashes = "=============================================";
/*
* Display column headers
*/
bool first = true;
java.lang.StringBuffer head = new java.lang.StringBuffer();
java.lang.StringBuffer line = new java.lang.StringBuffer();
/*
* Fetch each row
*/
while (rs.next())
{
/*
* Get the column, and see if it matches our expectations
*/
String text = "";
for (int ii = 0; ii < cols; ii++)
{
String value = rs.getString(ii + 1);
if (first)
{
width[ii] = meta.getColumnDisplaySize(ii + 1);
if (TinySQLGlobals.DEBUG &
meta.getColumnType(ii + 1) == java.sql.Types.DATE)
{
testDate = rs.getDate(ii + 1);
java.lang.SystemJ.outJ.println("Value " + value + ", Date "
+ testDate.toString());
}
nameLength = meta.getColumnName(ii + 1).length();
if (nameLength > width[ii])
{
width[ii] = nameLength;
}
head.append(padString(meta.getColumnName(ii + 1), width[ii]));
head.append(" ");
line.append(padString(dashes + dashes, width[ii]));
line.append(" ");
}
text += padString(value, width[ii]);
text += " "; // the gap between the columns
}
try
{
if (first)
{
if (spoolFileWriter != (java.io.FileWriter)null)
{
spoolFileWriter.write(head.toString() + newLine);
spoolFileWriter.write(head.toString() + newLine);
}
else
{
java.lang.SystemJ.outJ.println(head.toString());
java.lang.SystemJ.outJ.println(line.toString());
}
first = false;
}
if (spoolFileWriter != (java.io.FileWriter)null)
{
spoolFileWriter.write(text + newLine);
}
else
{
java.lang.SystemJ.outJ.println(text);
}
numCols++;
}
catch (Exception writeEx)
{
java.lang.SystemJ.outJ.println("Exception writing to spool file "
+ writeEx.getMessage());
}
}
return(numCols);
}
}
