/* * 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 colName, String value) //throws TinySQLException { String shortColumnName; try { /* * If it's the pseudo column _DELETED, return */ if (colName.equals("_DELETED")) { return; } /* * Retrieve the TsColumn object which corresponds to this column. */ shortColumnName = TinySQLGlobals.getShortName(colName); TsColumn column = (TsColumn)column_info.get(shortColumnName); if (column == null) { throw new TinySQLException("Can't update field=" + colName); } if (Utils.isDateColumn(column.type)) { /* * Convert non-blank dates to the standard YYYYMMDD format. */ if (value.trim().length() > 0) { value = UtilString.dateValue(value); } } /* * Seek the starting offset of the current record, * as indicated by currentRecordNumber */ ftbl.seek(dbfHeader.headerLength + (currentRecordNumber - 1) * dbfHeader.recordLength + column.position); /* * Enforce the correct column length, transform to byte and write to file */ value = Utils.forceToSize(value, column.size, " "); byte[] b = value.getBytes(Utils.encode); ftbl.write(b); dbfHeader.setTimestamp(ftbl); } catch (Exception e) { throw new TinySQLException(e.getMessage()); } }
/** * * returns a new dbfFileConnection object, which is cast * to a tinySQLConnection object. * * @exception SQLException when an error occurs * @param user the username - currently unused * @param url the url to the data source * @param d the Driver object. * */ public override TinySQLConnection getConnection (String user, String url, java.sql.Driver d) {//throws SQLException { if (url != (String)null) { if (url.length() > 13) { TinySQLGlobals.readLongNames(url.substring(13)); } } return((TinySQLConnection) new DBFFileConnection(user, url, d)); }
/* * Get a column object for the named column. */ public TsColumn getColumn(String colName) //throws TinySQLException { int foundDot; String columnName; columnName = colName; foundDot = columnName.indexOf("."); if (foundDot > -1) { columnName = columnName.substring(foundDot + 1); } columnName = TinySQLGlobals.getShortName(columnName); TsColumn coldef = (TsColumn)column_info.get(columnName); if (coldef == (TsColumn)null) { throw new TinySQLException("Column " + columnName + " does not" + " exist in table " + table); } return(coldef); }
/** * The name of a given column * @see java.sql.ResultSetMetaData#getColumnName * @param column the column whose name is wanted * @return the name of the requested column */ public String getColumnName(int column) {// throws SQLException { // get the column and return its name // String columnName; int dotAt; TsColumn col = tsql.columnAtIndex(column - 1); dotAt = col.name.indexOf("."); columnName = col.name; if (dotAt > -1) { columnName = col.name.substring(dotAt + 1); } if (col.alias != (String)null) { if (!col.alias.equals(columnName)) { return(col.alias); } } columnName = TinySQLGlobals.getLongName(columnName); return(columnName); }
/* * Parse out the column definition for a CREATE statement. */ public TsColumn parseColumnDefn(String columnDefn) //throws TinySQLException { TsColumn createColumn; int i; FieldTokenizer ft; String columnName, colTypeStr, colTypeSpec; ft = new FieldTokenizer(columnDefn.toUpperCase(), ' ', false); /* * A column definition must consist of a column name followed by a * column specification. */ if (ft.countFields() < 2) { throwException(2); } columnName = ft.getField(0); /* * Check for quotes around a column name that may contain blanks. */ if (columnName.charAt(0) == '"' & columnName.charAt(columnName.length() - 1) == '"') { columnName = columnName.substring(1, columnName.length() - 1); } if (columnName.length() > 11) { columnName = TinySQLGlobals.getShortName(columnName); } createColumn = new TsColumn(columnName); colTypeStr = ""; for (i = 1; i < ft.countFields(); i++) { colTypeStr += ft.getField(1); } ft = new FieldTokenizer(colTypeStr, '(', false); colTypeStr = ft.getField(0); createColumn.size = 10; createColumn.decimalPlaces = 0; if (colTypeStr.equals("FLOAT")) { createColumn.size = 12; createColumn.decimalPlaces = 2; } colTypeSpec = ft.getField(1); if (!colTypeSpec.equals("NULL")) { /* * Parse out the scale and precision if supplied. */ ft = new FieldTokenizer(colTypeSpec, ',', false); createColumn.size = ft.getInt(0, 8); createColumn.decimalPlaces = ft.getInt(1, 0); } createColumn.type = java.lang.Integer.MIN_VALUE; for (i = 0; i < colTypeNames.Length; i++) { if (colTypeStr.equals(colTypeNames[i])) { createColumn.type = colTypes[i]; } } if (createColumn.type == java.lang.Integer.MIN_VALUE) { throwException(8); } if (TinySQLGlobals.PARSER_DEBUG) { java.lang.SystemJ.outJ.println("Column " + createColumn.name + ", type is " + createColumn.type + ",size is " + createColumn.size + ",precision is " + createColumn.decimalPlaces); } return(createColumn); }
/* * 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; }
/* * * Read SQL Statements from the SQLStream, and * return a result set for the last SQL Statement * executed. * * @returns the ResultSet or null, if no result set was created * @exception TinySQLException * */ protected virtual TsResultSet sql(Object s) //throws TinySQLException { /* * Build the ResultSet */ TsResultSet rs = null; TinySQLTable jtbl; TinySQLPreparedStatement pstmt = (TinySQLPreparedStatement)null; bool distinct = false; java.util.Vector <Object> actions, columns, columnDefs, values; String actionType, orderType, tableName, statementType, byteString; java.util.Hashtable <Object, Object> h, selectTables; byte[] bStream; java.io.ByteArrayInputStream st; int i; String actionString; groupBreak = false; statementType = s.getClass().getName(); try { /* * Instantiate a new parser object which reads from the SQLStream. This * should probably be changed to a String at some point. Note that * parsing is only done once for a PreparedStatement. */ actions = (java.util.Vector <Object>)null; if (statementType.endsWith("tinySQLPreparedStatement")) { pstmt = (TinySQLPreparedStatement)s; pstmt.updateActions(actions); actions = pstmt.getActions(); byteString = pstmt.getSQLString(); bStream = (byte[])null; if (pstmt.getSQLString() != (String)null) { bStream = pstmt.getSQLString().getBytes(); } } else if (statementType.endsWith("tinySQLStatement")) { bStream = ((TinySQLStatement)s).getSQLString().getBytes(); } else { throw new TinySQLException("Unknown statement type" + statementType); } if (actions == (java.util.Vector <Object>)null) { st = new java.io.ByteArrayInputStream(bStream); SQLStream = (java.io.InputStream)st; TinySQLParser tinyp = new TinySQLParser(SQLStream, this); TinySQLGlobals.writeLongNames(); actions = tinyp.getActions(); if (statementType.endsWith("tinySQLPreparedStatement")) { pstmt.updateActions(actions); } } /* * The actions Vector consists of a list of Hashtables. Each of these * action Hashtables contains elements required for a particular SQL * statement. The following elements are used for various actions; * * Type Name Description * * String tableName The name of the affected table for * CREATE,INSERT,UPDATE,DELETE actions. * * Hashtable selectTables Hashtable of tables in a SELECT action. * * Vector columns A list of column names used by the * the action. * * Vector columnContexts A list of Strings indicating the context * for the elements in the columns Vector. * Values can be SELECT,ORDER,GROUP. * * Vector columnDefs A list of column objects used by the * CREATE TABLE and ALTER TABLE ADD actions. * * Vector values A list of String values used in INSERT * and UPDATE actions. * * String oldColumnName Old column name for the * ALTER TABLE RENAME action. * * String newColumnName New column name for the * ALTER TABLE RENAME action. * * String orderType Type or ORDER BY - ASC or DESC. * * String distinct Distinct rows only - TRUE or NULL * * tinySQLWhere whereClause An object containing the where clause * which can be updated and queried. */ for (i = 0; i < actions.size(); i++) { h = (java.util.Hashtable <Object, Object>)actions.elementAt(i); actionType = (String)h.get("TYPE"); if (TinySQLGlobals.DEBUG) { java.lang.SystemJ.outJ.println("Action: " + actionType); } /* * Many actions have a table specification. If this one, build * a table object to update the where clause if there is one. */ tableName = (String)h.get("TABLE"); wc = (TinySQLWhere)h.get("WHERE"); if (tableName != (String)null & !actionType.equals("DROP_TABLE") & !actionType.equals("CREATE_TABLE") & !actionType.equals("INSERT") & !actionType.startsWith("ALTER")) { jtbl = getTable(tableName); /* * For prepared statements, store any table objects that * are created so that they can be explicitly closed when * the statement processing is complete. */ if (statementType.endsWith("tinySQLPreparedStatement")) { pstmt.addTable(jtbl); } } actionString = UtilString.actionToString(h); if (debug) { java.lang.SystemJ.outJ.println("ACTION: " + actionString); } if (actionType.equals("UPDATE")) { /* * SQL UPDATE */ columns = (java.util.Vector <Object>)h.get("COLUMNS"); values = (java.util.Vector <Object>)h.get("VALUES"); UpdateStatement(tableName, columns, values, wc); } else if (actionType.equals("DELETE")) { /* * SQL DELETE */ DeleteStatement(tableName, wc); } else if (actionType.equals("SELECT")) { /* * SQL SELECT */ selectTables = (java.util.Hashtable <Object, Object>)h.get("TABLES"); columns = (java.util.Vector <Object>)h.get("COLUMNS"); orderType = (String)h.get("ORDER_TYPE"); if ((String)h.get("DISTINCT") != (String)null) { distinct = true; } rs = SelectStatement(selectTables, columns, wc, orderType, distinct, s); } else if (actionType.equals("INSERT")) { /* * SQL INSERT */ columns = (java.util.Vector <Object>)h.get("COLUMNS"); values = (java.util.Vector <Object>)h.get("VALUES"); InsertStatement(statementType, tableName, columns, values); } else if (actionType.equals("CREATE_TABLE")) { /* * SQL CREATE TABLE * * CREATE TABLE User(user_oid NUMBER(8) NOT NULL, * userType VARCHAR(80) DEFAULT '-' NOT NULL, * PRIMARY KEY (user_oid)) * * -> DEFAULT / NOT NULL / PRIMARY KEY is not supported * */ columnDefs = (java.util.Vector <Object>)h.get("COLUMN_DEF"); CreateTable(tableName, columnDefs); } else if (actionType.equals("ALTER_ADD")) { /* * SQL ALTER TABLE ADD */ columnDefs = (java.util.Vector <Object>)h.get("COLUMN_DEF"); AlterTableAddCol(tableName, columnDefs); } else if (actionType.equals("ALTER_DROP")) { /* * SQL ALTER TABLE DROP */ columns = (java.util.Vector <Object>)h.get("COLUMNS"); AlterTableDropCol(tableName, columns); } else if (actionType.equals("ALTER_RENAME")) { /* * SQL ALTER TABLE RENAME */ String oldColumnName = (String)h.get("OLD_COLUMN"); String newColumnName = (String)h.get("NEW_COLUMN"); AlterTableRenameCol(tableName, oldColumnName, newColumnName); } else if (actionType.equals("DROP_TABLE")) { /* * SQL DROP TABLE */ DropTable(tableName); } else { java.lang.SystemJ.outJ.println("Unrecognized action " + actionType); } } } catch (java.lang.Throwable e) { if (TinySQLGlobals.EX_DEBUG) { e.printStackTrace(java.lang.SystemJ.outJ); } throw new TinySQLException(e.getMessage()); } return(rs); }
/** * Gets a description of table columns available in * the specified catalog. * * <P>Only column descriptions matching the catalog, schema, table * and column name criteria are returned. They are ordered by * TABLE_SCHEM, TABLE_NAME and ORDINAL_POSITION. * * <P>Each column description has the following columns: * <OL> * <LI><B>TABLE_CAT</B> String => table catalog (may be null) * <LI><B>TABLE_SCHEM</B> String => table schema (may be null)sRow record = new TsRow(); * * <LI><B>TABLE_NAME</B> String => table name * <LI><B>COLUMN_NAME</B> String => column name * <LI><B>DATA_TYPE</B> short => SQL type from java.sql.Types * <LI><B>TYPE_NAME</B> String => Data source dependent type name, * for a UDT the type name is fully qualified * <LI><B>COLUMN_SIZE</B> int => column size. For char or date * types this is the maximum number of characters, for numeric or * decimal types this is precision. * <LI><B>BUFFER_LENGTH</B> is not used. * <LI><B>DECIMAL_DIGITS</B> int => the number of fractional digits * <LI><B>NUM_PREC_RADIX</B> int => Radix (typically either 10 or 2) * <LI><B>NULLABLE</B> int => is NULL allowed? * <UL> * <LI> columnNoNulls - might not allow NULL values * <LI> columnNullable - definitely allows NULL values * <LI> columnNullableUnknown - nullability unknown * </UL> * <LI><B>REMARKS</B> String => comment describing column (may be null) * <LI><B>COLUMN_DEF</B> String => default value (may be null) * <LI><B>SQL_DATA_TYPE</B> int => unused * <LI><B>SQL_DATETIME_SUB</B> int => unused * <LI><B>CHAR_OCTET_LENGTH</B> int => for char types the * maximum number of bytes in the column * <LI><B>ORDINAL_POSITION</B> int => index of column in table * (starting at 1) * <LI><B>IS_NULLABLE</B> String => "NO" means column definitely * does not allow NULL values; "YES" means the column might * allow NULL values. An empty string means nobody knows. * </OL> * * @param catalog a catalog name; "" retrieves those without a * catalog; null means drop catalog name from the selection criteria * @param schemaPattern a schema name pattern; "" retrieves those * without a schema * @param tableNamePattern a table name pattern * @param columnNamePattern a column name pattern * @return ResultSet - each row is a column description * @exception SQLException if a database access error occurs * @see #getSearchStringEscape */ public override java.sql.ResultSet getColumns(String catalog, String schemaPattern, String tableNamePattern, String columnNamePattern) { int i; String columnNameKey; try { String dataDir = getDataDir(); Utils.log("Entering getColumns(tableNamePattern='" + tableNamePattern + "')"); if (dataDir == null) { return(null); } java.sql.ResultSet tableRs = getTables(catalog, schemaPattern, tableNamePattern, null); TsResultSet jrs = new TsResultSet(); TsColumn jsc = new TsColumn("TABLE_CAT"); jsc.type = java.sql.Types.CHAR; jsc.size = 9; jrs.addColumn(jsc); jsc = new TsColumn("TABLE_SCHEM"); jsc.type = java.sql.Types.CHAR; jsc.size = 11; jrs.addColumn(jsc); jsc = new TsColumn("TABLE_NAME"); jsc.type = java.sql.Types.CHAR; jsc.size = 10; jrs.addColumn(jsc); jsc = new TsColumn("COLUMN_NAME"); jsc.type = java.sql.Types.CHAR; jsc.size = 11; jrs.addColumn(jsc); jsc = new TsColumn("DATA_TYPE"); jsc.type = java.sql.Types.INTEGER; jsc.size = 6; jrs.addColumn(jsc); jsc = new TsColumn("TYPE_NAME"); jsc.type = java.sql.Types.CHAR; jsc.size = 9; jrs.addColumn(jsc); jsc = new TsColumn("COLUMN_SIZE"); jsc.type = java.sql.Types.INTEGER; jsc.size = 8; jrs.addColumn(jsc); jsc = new TsColumn("BUFFER_LENGTH"); jsc.type = java.sql.Types.INTEGER; jsc.size = 8; jrs.addColumn(jsc); jsc = new TsColumn("DECIMAL_DIGITS"); jsc.type = java.sql.Types.INTEGER; jsc.size = 8; jrs.addColumn(jsc); jsc = new TsColumn("NUM_PREC_RADIX"); jsc.type = java.sql.Types.INTEGER; jsc.size = 8; jrs.addColumn(jsc); jsc = new TsColumn("NULLABLE"); jsc.type = java.sql.Types.INTEGER; jsc.size = 8; jrs.addColumn(jsc); jsc = new TsColumn("REMARKS"); jsc.type = java.sql.Types.CHAR; jsc.size = 128; jrs.addColumn(jsc); jsc = new TsColumn("COLUMN_DEF"); jsc.type = java.sql.Types.CHAR; jsc.size = 128; jrs.addColumn(jsc); jsc = new TsColumn("SQL_DATA_TYPE"); jsc.type = java.sql.Types.INTEGER; jsc.size = 128; jrs.addColumn(jsc); // Several parameters missing. jsc = new TsColumn("IS_NULLABLE"); jsc.type = java.sql.Types.CHAR; jsc.size = 3; jrs.addColumn(jsc); while (tableRs.next()) { // process each DBF file and extract column info ... String tableName = tableRs.getString("TABLE_NAME"); DBFFileTable tbl; try { tbl = new DBFFileTable(dataDir, tableName); } catch (Exception) { continue; // ignore buggy and empty (zero byte size) DBF files } Utils.log("Accessing column info for table " + tableName); java.util.Hashtable <Object, Object> column_info = tbl.column_info; for (i = 0; i < tbl.columnNameKeys.size(); i++) { columnNameKey = (String)tbl.columnNameKeys.elementAt(i); TsColumn tsc = (TsColumn)column_info.get(columnNameKey); // process each column of the current table ... TsRow record = new TsRow(); record.put("TABLE_CAT", ""); record.put("TABLE_SCHEM", ""); record.put("TABLE_NAME", tableName); record.put("COLUMN_NAME", TinySQLGlobals.getLongName(tsc.name)); record.put("DATA_TYPE", new java.lang.Integer(tsc.type).toString()); record.put("TYPE_NAME", DBFFile.typeToLiteral(tsc.type).toString()); record.put("COLUMN_SIZE", new java.lang.Integer(tsc.size).toString()); record.put("DECIMAL_DIGITS", new java.lang.Integer(tsc.decimalPlaces).toString()); int nullable = columnNoNulls; if (tsc.notNull == true) { nullable = columnNullable; } record.put("NULLABLE", new java.lang.Integer(nullable).toString()); record.put("REMARKS", "noRemarks"); String defaultVal = tsc.defaultVal; if (defaultVal == null) { defaultVal = ""; } record.put("COLUMN_DEF", defaultVal); String isNullable = "NO"; if (tsc.notNull == true) { isNullable = "YES"; } record.put("IS_NULLABLE", isNullable); /* * Suppress any sorting of the ResultSet. Column Metadata should * be presented in the order the columns exist in the dBase header. */ jrs.addRow(record, false); } tbl.close(); tbl = null; } return(new TinySQLResultSet(jrs, (TinySQLStatement)null)); } catch (Exception) { return(null); } }
internal TsColumn(String s, java.util.Hashtable <Object, Object> tableDefs, String inputContext) //throws tinySQLException { FieldTokenizer ft, ftArgs; int j, numericType, nameLength, dotAt, argIndex; String upperName, checkName, nextArg; TinySQLTable jtbl; TsColumn tcol; java.util.Vector <Object> t; java.util.Enumeration <Object> col_keys; name = s; longName = name; nameLength = name.length(); contextList = new java.util.Vector <Object>(); contextList.addElement(inputContext); ft = new FieldTokenizer(name, '(', false); if (ft.countFields() == 2) { /* * This is a function rather than a simple column or constant */ functionName = ft.getField(0).toUpperCase(); if (functionName.equals("COUNT")) { type = java.sql.Types.INTEGER; size = 10; intValue = java.lang.Integer.MIN_VALUE; groupedColumn = true; } else if (functionName.equals("SUM")) { type = java.sql.Types.FLOAT; size = 10; groupedColumn = true; } else if (functionName.equals("TO_DATE")) { type = java.sql.Types.DATE; size = 10; } else if (functionName.equals("CONCAT") | functionName.equals("UPPER") | functionName.equals("SUBSTR") | functionName.equals("TRIM")) { type = java.sql.Types.CHAR; } functionArgString = ft.getField(1); ftArgs = new FieldTokenizer(functionArgString, ',', false); functionArgs = new java.util.Vector <Object>(); argIndex = 0; while (ftArgs.hasMoreFields()) { nextArg = ftArgs.nextField(); tcol = new TsColumn(nextArg, tableDefs, inputContext); if (tcol.isGroupedColumn()) { groupedColumn = true; } /* * MAX and MIN functions can be either FLOAT or CHAR types * depending upon the type of the argument. */ if (functionName.equals("MAX") | functionName.equals("MIN")) { if (argIndex > 0) { throw new TinySQLException("Function can only have 1 argument"); } groupedColumn = true; type = tcol.type; size = tcol.size; } else if (functionName.equals("CONCAT")) { type = java.sql.Types.CHAR; size += tcol.size; } else if (functionName.equals("UPPER")) { type = java.sql.Types.CHAR; size = tcol.size; } else if (functionName.equals("TO_DATE")) { type = java.sql.Types.DATE; size = 10; } else if (functionName.equals("TRIM")) { type = java.sql.Types.CHAR; size = tcol.size; } else if (functionName.equals("SUBSTR")) { type = java.sql.Types.CHAR; if (argIndex == 0 & tcol.type != java.sql.Types.CHAR) { throw new TinySQLException("SUBSTR first argument must be character"); } else if (argIndex == 1) { if (tcol.type != java.sql.Types.INTEGER | tcol.intValue < 1) { throw new TinySQLException("SUBSTR second argument " + tcol.getString() + " must be integer > 0"); } } else if (argIndex == 2) { if (tcol.type != java.sql.Types.INTEGER | tcol.intValue < 1) { throw new TinySQLException("SUBSTR third argument " + tcol.getString() + " must be integer > 0"); } size = tcol.intValue; } } argIndex++; functionArgs.addElement(tcol); } } else { /* * Check for SYSDATE */ if (name.toUpperCase().equals("SYSDATE")) { isConstant = true; type = java.sql.Types.DATE; size = 10; notNull = true; valueSet = true; //Basties mote: not really SimpleDateFormat needed... - need yyyy-MM-dd // stringValue = fmtyyyyMMdd.format(today.getTime()); stringValue = System.DateTime.Today.ToString("yyyy-MM-dd"); /* * Check for a quoted string */ } else if (UtilString.isQuotedString(name)) { isConstant = true; type = java.sql.Types.CHAR; stringValue = UtilString.removeQuotes(name); if (stringValue != (String)null) { size = stringValue.length(); notNull = true; valueSet = true; } } else { /* * Check for a numeric constant */ numericType = UtilString.getValueType(name); if (numericType == java.sql.Types.INTEGER) { intValue = java.lang.Integer.valueOf(name).intValue(); size = 10; type = numericType; isConstant = true; notNull = true; valueSet = true; } else if (numericType == java.sql.Types.FLOAT) { floatValue = java.lang.Float.valueOf(name).floatValue(); size = 10; type = numericType; isConstant = true; notNull = true; valueSet = true; } else { /* * This should be a column name. */ columnTable = (TinySQLTable)null; upperName = name.toUpperCase(); if (TinySQLGlobals.DEBUG) { java.lang.SystemJ.outJ.println("Trying to find table for " + upperName); } dotAt = upperName.indexOf("."); if (dotAt > -1) { tableName = upperName.substring(0, dotAt); if (tableDefs != (java.util.Hashtable <Object, Object>)null & tableName.indexOf("->") < 0) { t = (java.util.Vector <Object>)tableDefs.get("TABLE_SELECT_ORDER"); tableName = UtilString.findTableAlias(tableName, t); } upperName = upperName.substring(dotAt + 1); /* * Check to see if this column name has a short equivalent. */ if (upperName.length() > 11) { longName = name; upperName = TinySQLGlobals.getShortName(upperName); } columnTable = (TinySQLTable)tableDefs.get(tableName); } else if (tableDefs != (java.util.Hashtable <Object, Object>)null) { /* * Check to see if this column name has a short equivalent. */ if (upperName.length() > 11) { longName = name; upperName = TinySQLGlobals.getShortName(upperName); } /* * Use an enumeration to go through all of the tables to find * this column. */ t = (java.util.Vector <Object>)tableDefs.get("TABLE_SELECT_ORDER"); for (j = 0; j < t.size(); j++) { tableName = (String)t.elementAt(j); jtbl = (TinySQLTable)tableDefs.get(tableName); col_keys = jtbl.column_info.keys(); /* * Check all columns. */ while (col_keys.hasMoreElements()) { checkName = (String)col_keys.nextElement(); if (checkName.equals(upperName)) { upperName = checkName; columnTable = jtbl; break; } } if (columnTable != (TinySQLTable)null) { break; } } } else { if (TinySQLGlobals.DEBUG) { java.lang.SystemJ.outJ.println("No table definitions."); } } if (columnTable != (TinySQLTable)null) { name = columnTable.table + "->" + columnTable.tableAlias + "." + upperName; type = columnTable.ColType(upperName); size = columnTable.ColSize(upperName); decimalPlaces = columnTable.ColDec(upperName); tableName = columnTable.table + "->" + columnTable.tableAlias; } } } } }