예제 #1
0
        /*
         * Validate the column specifications by checking against the tables.
         */
        public void validateColumns() //throws TinySQLException
        {
            String       columnName, columnAlias, columnContext;
            TsColumn     columnObject;
            bool         selectStar;
            TinySQLTable jtbl;
            int          i, j;

/*
 *    Check for a column named *
 */
            selectStar = false;
            for (i = 0; i < columnList.size(); i++)
            {
                columnName    = (String)columnList.elementAt(i);
                columnContext = (String)contextList.elementAt(i);
                if (columnName.equals("*"))
                {
                    if (!columnContext.equals("SELECT"))
                    {
                        throw new TinySQLException("* must be a SELECT column.");
                    }
                    selectStar = true;
                    break;
                }
            }
            if (selectStar)
            {
/*
 *       A column * has been found.  Delete the existing list of SELECT
 *       columns and replace by using an enumeration variable to cycle through
 *       the columns in the tables Hashtable.
 */
                for (i = 0; i < columnList.size(); i++)
                {
                    columnContext = (String)contextList.elementAt(i);
                    if (columnContext.equals("SELECT"))
                    {
                        columnList.removeElementAt(i);
                        contextList.removeElementAt(i);
                        columnAliasList.removeElementAt(i);
                    }
                }
                for (i = 0; i < tableList.size(); i++)
                {
                    jtbl = (TinySQLTable)tables.get((String)tableList.elementAt(i));

/*
 *          Expand to all columns.
 */
                    for (j = 0; j < jtbl.columnNameKeys.size(); j++)
                    {
                        columnName = (String)jtbl.columnNameKeys.elementAt(j);
                        columnList.addElement(jtbl.table + "->" + jtbl.tableAlias
                                              + "." + columnName);
                        columnAliasList.addElement(columnName);
                        contextList.addElement("SELECT");
                    }
                }
            }

/*
 *    Build a column object for each selected column.
 */
            if (tables == (java.util.Hashtable <Object, Object>)null)
            {
                java.lang.SystemJ.outJ.println("*****Column validation - no tables defined.");
            }
            for (i = 0; i < columnList.size(); i++)
            {
                columnName    = (String)columnList.elementAt(i);
                columnContext = (String)contextList.elementAt(i);
                columnAlias   = (String)null;
                if (i < columnAliasList.size())
                {
                    columnAlias = (String)columnAliasList.elementAt(i);
                }
                columnObject       = new TsColumn(columnName, tables, columnContext);
                columnObject.alias = UtilString.removeQuotes(columnAlias);
                columns.addElement(columnObject);
            }
        }
예제 #2
0
파일: TsRow.cs 프로젝트: bastie/NetVampire
        /**
         *
         * 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);
        }
예제 #3
0
        /*
         * 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;
        }
예제 #4
0
        /*
         * Create the tinySQLTable object, then insert a row, and update
         * it with the c and v Vectors
         */
        private void InsertStatement(String statementType, String tableName,
                                     java.util.Vector <Object> c, java.util.Vector <Object> v)
        //throws TinySQLException
        {
            String columnName, valueString;
            int    i, columnType, columnSize;
            double value;

            insertTable = getTable(tableName);

            /*
             *    Check that the values supplied are the correct type and length.
             */
            for (i = 0; i < c.size(); i++)
            {
                columnName  = (String)c.elementAt(i);
                valueString = (String)v.elementAt(i);
                if (valueString == (String)null)
                {
                    continue;
                }
                valueString = UtilString.removeQuotes(valueString);
                valueString = UtilString.replaceAll(valueString, "''", "'");
                columnType  = insertTable.ColType(columnName);
                if (Utils.isNumberColumn(columnType))
                {
                    try
                    {
                        value = java.lang.Double.parseDouble(valueString);
                    }
                    catch (Exception)
                    {
                        throw new TinySQLException("Insert failed: column "
                                                   + columnName + " is numeric - found " + valueString);
                    }
                }
                else if (Utils.isDateColumn(columnType))
                {
                    try
                    {
                        /*
                         *             Modify the input to be the standard YYYYMMDD format
                         */
                        if (valueString.trim().length() > 0)
                        {
                            v.setElementAt(UtilString.dateValue(valueString), i);
                        }
                    }
                    catch (Exception e)
                    {
                        throw new TinySQLException("Insert failed: " + e.getMessage());
                    }
                }
                columnSize = insertTable.ColSize(columnName);
                if (valueString.length() > columnSize)
                {
                    throw new TinySQLException("Insert failed: string too long for "
                                               + " column " + columnName + " "
                                               + java.lang.Integer.toString(valueString.length())
                                               + " > " + java.lang.Integer.toString(columnSize) + "<" + valueString + ">");
                }
            }
            insertTable.InsertRow(c, v);

            /*
             *    Close the table file that has just been updated unless this is a
             *    PreparedStatement.  In that case an explicit close must be done
             *    on the statement object to close any open files.
             */
            if (!statementType.endsWith("tinySQLPreparedStatement"))
            {
                insertTable.close();
            }
        }
예제 #5
0
        /*
         *
         * 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);
        }
예제 #6
0
        public int compareTo(Object inputObj) //throws tinySQLException
        {
            String   thisYMD, inputYMD;
            TsColumn inputColumn;
            int      inputType, returnValue;
            double   thisValue, inputValue;

            inputColumn = (TsColumn)inputObj;
            inputType   = inputColumn.type;
            thisValue   = java.lang.Double.MIN_VALUE;
            inputValue  = java.lang.Double.MIN_VALUE;
            returnValue = 0;
            if (Utils.isCharColumn(type))
            {
                /*
                 *       Compare character java.sql.Types.
                 */
                if (!Utils.isCharColumn(inputType))
                {
                    throw new TinySQLException("Type mismatch between "
                                               + getString() + " and " + inputColumn.getString());
                }
                else if (stringValue == (String)null |
                         inputColumn.stringValue == (String)null)
                {
                    throw new TinySQLException("One of the values is NULL");
                }
                else
                {
                    returnValue = stringValue.compareTo(inputColumn.stringValue);
                }
            }
            else if (Utils.isDateColumn(type))
            {
                /*
                 *       Compare date java.sql.Types.
                 */
                if (!Utils.isDateColumn(inputType))
                {
                    throw new TinySQLException("Type mismatch between "
                                               + getString() + " and " + inputColumn.getString());
                }
                else if (stringValue == (String)null |
                         inputColumn.stringValue == (String)null)
                {
                    throw new TinySQLException("One of the values is NULL");
                }
                else
                {
                    inputYMD    = UtilString.toStandardDate(inputColumn.stringValue);
                    thisYMD     = UtilString.toStandardDate(stringValue);
                    returnValue = thisYMD.compareTo(inputYMD);
                }
            }
            else if (Utils.isNumberColumn(type))
            {
                if (type == java.sql.Types.INTEGER)
                {
                    thisValue = (double)intValue;
                }
                else if (type == java.sql.Types.FLOAT)
                {
                    thisValue = (double)floatValue;
                }
                if (inputType == java.sql.Types.INTEGER)
                {
                    inputValue = (double)inputColumn.intValue;
                }
                else if (inputType == java.sql.Types.FLOAT)
                {
                    inputValue = (double)inputColumn.floatValue;
                }
                if (thisValue > inputValue)
                {
                    returnValue = 1;
                }
                else if (thisValue < inputValue)
                {
                    returnValue = -1;
                }
            }
            else
            {
                java.lang.SystemJ.outJ.println("Cannot sort unknown type");
            }
            if (TinySQLGlobals.DEBUG)
            {
                java.lang.SystemJ.outJ.println("Comparing " + getString() + " to " +
                                               inputColumn.getString() + " gave " + returnValue);
            }
            return(returnValue);
        }
예제 #7
0
        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;
                        }
                    }
                }
            }
        }