Quadcap Embeddable Database

com/quadcap/jdbc/PreparedStatement.java

Go to the documentation of this file.

package com.quadcap.jdbc;

/* Copyright 1999 - 2003 Quadcap Software.  All rights reserved.
 *
 * This software is distributed under the Quadcap Free Software License.
 * This software may be used or modified for any purpose, personal or
 * commercial.  Open Source redistributions are permitted.  Commercial
 * redistribution of larger works derived from, or works which bundle
 * this software requires a "Commercial Redistribution License"; see
 * http://www.quadcap.com/purchase.
 *
 * Redistributions qualify as "Open Source" under  one of the following terms:
 *   
 *    Redistributions are made at no charge beyond the reasonable cost of
 *    materials and delivery.
 *
 *    Redistributions are accompanied by a copy of the Source Code or by an
 *    irrevocable offer to provide a copy of the Source Code for up to three
 *    years at the cost of materials and delivery.  Such redistributions
 *    must allow further use, modification, and redistribution of the Source
 *    Code under substantially the same terms as this license.
 *
 * Redistributions of source code must retain the copyright notices as they
 * appear in each source code file, these license terms, and the
 * disclaimer/limitation of liability set forth as paragraph 6 below.
 *
 * Redistributions in binary form must reproduce this Copyright Notice,
 * these license terms, and the disclaimer/limitation of liability set
 * forth as paragraph 6 below, in the documentation and/or other materials
 * provided with the distribution.
 *
 * The Software is provided on an "AS IS" basis.  No warranty is
 * provided that the Software is free of defects, or fit for a
 * particular purpose.  
 *
 * Limitation of Liability. Quadcap Software shall not be liable
 * for any damages suffered by the Licensee or any third party resulting
 * from use of the Software.
 */

import java.io.IOException;
import java.io.InputStream;
import java.io.Reader;

import java.util.Calendar;
import java.util.Vector;

import java.math.BigDecimal;

//#ifndef JDK11
import java.sql.Array;
import java.sql.Blob;
import java.sql.Clob;
import java.sql.Ref;
//#endif

import java.sql.Date;
import java.sql.SQLException;
import java.sql.SQLWarning;
import java.sql.Time;
import java.sql.Timestamp;
import java.sql.Types;

import antlr.RecognitionException;

import com.quadcap.sql.InsertBlob;
import com.quadcap.sql.ParameterExpression;
import com.quadcap.sql.SQLParser;
import com.quadcap.sql.Stmt;

import com.quadcap.io.AsciiReader;
import com.quadcap.io.ReaderInputStream;

import com.quadcap.sql.file.BlockFile;

import com.quadcap.sql.types.*;

import com.quadcap.util.Debug;

/**
 * This class implements the <code>java.sql.PreparedStatement</code>
 * interface, and provides facilities for execution of pre-compiled
 * SQL statements.  This release of QED performs all of the SQL parsing
 * during the prepare phase, so that subsequent execution of the
 * compiled statement is considerably faster than directly executing
 * the statement using the <code>Statement</code> interface.
 *
 * @author Stan Bailes
 */
public class PreparedStatement extends Statement
    implements java.sql.PreparedStatement
{
    Stmt                                stmt;
    Vector                              params;
    //#ifdef DEBUG
    String                              sql;
    //#endif
    
    /**
     * @deprecated in order to not appear in public javadoc
     */
    public PreparedStatement(Connection conn, String sql)
        throws SQLException, IOException
    {
        super(conn);
        //#ifdef DEBUG
        this.sql = sql;
        if (Statement.trace.bit(0)) {
            Debug.println("prepare(" + sql + ")");
        }
        //#endif
        session.makeTransaction();
        SQLParser p = new SQLParser(session, sql, escapeProcessing);
        String auth = qConn.getAuth();
        try {
            stmt = p.statement();
            params = p.getParameters();
        } catch (RecognitionException e) {
            throw new SQLException(e.toString(), "42000");
        } catch (antlr.TokenStreamException e) {
            throw new SQLException(e.toString(), "Q0010");
        } finally {
            // XXX
            // This is a hack. 'create schema' will temporarily set the
            // 'auth' to the schema name, and this is the first place where
            // we get a chance to restore the correct auth.
            //
            // This is made worse by the fact that names are resolved during
            // the parse phase, and could be made better if antlr parser 
            // rules allowed you to specify a 'finally' handler.

            // Also 'create schema' where the schema name is a parameter is
            // going to fail badly.
            qConn.setAuth(auth, null);
        }
    }
    
    /**
     * This QED release doesn't support batch statement execution.
     *
     * @exception SQLException "not implemented"
     */
    public void addBatch() throws SQLException {
        throw new SQLException("not implemented", "0A000");
    }
    
    ParameterExpression getParam(int i) {
        return (ParameterExpression)params.elementAt(i-1);
    }
    
    /**
     * Clear the values of any parameters to this prepared statement;
     * i.e., set them all to <code>NULL</code>
     *
     * @exception SQLException may be thrown
     */
    public void clearParameters() throws SQLException {
        for (int i = 1; i <= params.size(); i++) {
            ParameterExpression pe = getParam(i);
            pe.setValue(ValueNull.valueNull);
        }
    }
    
    /**
     * Execute the current SQL statement, returning <code>true</code>
     * if the statement generates a <code>ResultSet</code> object.
     *
     * @return true if execution of the statement results in the creation
     *  of a <code>ResultSet</code>
     * @see #getResultSet()
     * @exception SQLException may be thrown
     */
    public boolean execute() throws SQLException {
        //#ifdef DEBUG
        if (Statement.trace.bit(1)) {
            Debug.println("PreparedStatement.execute(" + sql + ")");
        }
        //#endif
        this.rs = null;
        this.updateCount = -1;

        if (this.qConn.isClosed()) {
            throw new SQLException("Connection closed");
        }
        try {
            session.doStatement(stmt);
            this.rs = (ResultSet)session.getResultSet(this);
            if (rs != null) {
                return true;
            } else {
                this.updateCount = session.getUpdateCount();
                return false;
            }
        } catch (IOException e) {
            try {
                session.endStatement(true);
            } catch (IOException e1) {}
            throw new SQLException(e.toString(), "Q0011");
        } catch (SQLException e) {
            try {
                session.endStatement(true);
            } catch (IOException e1) {}
            throw e;
        } catch (Throwable e) {
            Debug.print(e);
            try {
                session.endStatement(true);
            } catch (IOException e1) {}
            throw new SQLException(e.toString(), "Q0013");
        }
    }
    
    /**
     * Execute the prepared SQL query statement, returning the 
     * <code>ResultSet</code> object containing the results of the
     * query.
     *
     * @return a <code>ResultSet</code> object containing the results of
     *          the query
     * @exception SQLException may be thrown
     */
    public java.sql.ResultSet executeQuery() throws SQLException {
        if (execute()) {
            return this.rs;
        } else {
            return null;
        }
    }
    
    /**
     * Execute the prepared SQL update statement, returning the update
     * count, meaning the number of rows updated or inserted by this
     * statement.
     *
     * @return the update count
     * @exception SQLException may be thrown
     */
    public int executeUpdate() throws SQLException {
        if (!execute()) {
            return updateCount;
        } else {
            return 0;
        }
    }
    
    /**
     * QED doesn't implement this feature, which requires information
     * about the <code>ResultSet</code> that will be generated by this
     * <code>PreparedStatement</code> object when it is executed.  
     * Instead, first call <code>execute()</code> or
     * <code>executeQuery()</code>, then call 
     * <code>ResultSet.getMetaData()</code> on the 
     * <code>ResultSet</code> object that is returned.
     *    
     * @return null
     */
    public java.sql.ResultSetMetaData getMetaData() {
        return null;
    }
    
    /**
     * Set the statement parameter to the specified character value using an 
     * <code>InputStream</code> that contains a stream of ASCII bytes.
     * The ASCII bytes are converted to Unicode character values before
     * being inserted into the database.
     *
     * @param col the parameter index
     * @param is an input stream containing ASCII bytes.
     * @param length the number of bytes to read from the stream
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public void setAsciiStream(int col, InputStream in, int length)
        throws SQLException
    {
        try {
            if (in == null) {
                setParamValue(col, ValueNull.valueNull);
            } else {
                ValueClob clob = new ValueClob(session.getDatabase(),
                                               session.makeTransaction(),
                                               new AsciiReader(in), length);
                setParamValue(col, clob);
                session.doStep(new InsertBlob(session, clob));
                clob.close();
            }
            
        } catch (IOException e) {
            Debug.print(e);
            throw new SQLException(e.toString(), "Q001H");
        }
    }

    final void setParamValue(int col, Value v) throws SQLException {
        //#ifdef DEBUG
        if (Statement.trace.bit(4)) {
            Debug.println("setValue(" + col + ", " +  v + ")");
        }
        //#endif
        getParam(col).setValue(v);
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>BigDecimal</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setBigDecimal(int col, BigDecimal val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueScaledInteger(val));
        }
    }
    
    /**
     * Set the statement parameter to the specified binary value using an 
     * <code>InputStream</code> that contains a stream of bytes.
     *
     * @param col the parameter index
     * @param is an input stream containing ASCII bytes.
     * @param length the number of bytes to read from the stream
     *        <p>
     *        If 'length &gt; 0', then the blob's length will be set to the value
     *        of the 'length' parameter.
     *        <p>
     *        If 'length &lt; 0', then the blob's length will be set to the number
     *        of bytes read.
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public void setBinaryStream(int col, InputStream in, int length)
        throws SQLException
    {
        try {
            if (in == null) {
                setParamValue(col, ValueNull.valueNull);
            } else {
                ValueBlob blob = new ValueBlob(session.getDatabase(),
                                               session.makeTransaction(),
                                               in, length);
                setParamValue(col, blob);
                session.doStep(new InsertBlob(session, blob));
                blob.close();
            }
            
        } catch (IOException e) {
            Debug.print(e);
            throw new SQLException(e.toString(), "Q001H");
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>boolean</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setBoolean(int col, boolean val) throws SQLException {
        setParamValue(col, new ValueBoolean(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>byte</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setByte(int col, byte val) throws SQLException {
        setParamValue(col, new ValueShort(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>byte</code> array value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setBytes(int col, byte[] val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueOctets(val));
        }
    }
    
    /**
     * Set the statement parameter to the specified character value using a 
     * <code>Reader</code> that contains a stream of Unicode characters.
     *
     * @param col the parameter index
     * @param r a reader containing the value's characters.
     * @param length the number of bytes to read from the stream
     * @return an <code>InputStream</code>
     * @exception SQLException may be thrown
     */
    public void setCharacterStream(int col, Reader r, int length)
        throws SQLException
    {
        try {
            if (r == null) {
                setParamValue(col, ValueNull.valueNull);
            } else {
                ValueClob clob = new ValueClob(session.getDatabase(),
                                               session.makeTransaction(),
                                               r, length);
                setParamValue(col, clob);
                session.doStep(new InsertBlob(session, clob));
                clob.close();
            }
            
        } catch (IOException e) {
            Debug.print(e);
            throw new SQLException(e.toString(), "Q001H");
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Date</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setDate(int col, Date val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueDate(val.getTime()));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Date</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @param cal a <code>Calendar<code> object that is used for converting
     *  the database date to the local timezone.  The database date is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @exception SQLException may be thrown
     */
    public void setDate(int col, Date val, Calendar cal) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            cal.setTime(val);
            setParamValue(col, new ValueDate(cal.getTime().getTime()));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>double</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setDouble(int col, double val) throws SQLException {
        setParamValue(col, new ValueDouble(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>float</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setFloat(int col, float val) throws SQLException {
        setParamValue(col, new ValueDouble(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>int</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setInt(int col, int val) throws SQLException {
        setParamValue(col, new ValueInteger(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>long</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setLong(int col, long val) throws SQLException {
        setParamValue(col, new ValueLong(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>null</code> value.
     *
     * @param col the parameter index
     * @param type the JDBC type of the parameter.  This is ignored by QED
     *          because a null is a null is a null.
     * @exception SQLException may be thrown
     */
    public void setNull(int col, int type) throws SQLException {
        setParamValue(col, ValueNull.valueNull);
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>null</code> value.
     *
     * @param col the parameter index
     * @param type the JDBC type of the parameter.  This is ignored by QED
     *          because a null is a null is a null.
     * @param typename the fully qualified type name of the parameter.
     *          This is ignored by QED
     *          because a null is a null is a null.
     * @exception SQLException may be thrown
     */
    public void setNull(int col, int type, String typename) 
        throws SQLException 
    {
        setParamValue(col, ValueNull.valueNull);
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Object</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setObject(int col, Object val) throws SQLException {
        if (val instanceof Blob) {
            Blob blob = (Blob)val;
            setBinaryStream(col, blob.getBinaryStream(), (int)blob.length());
        } else if (val instanceof Clob) {
            Clob clob = (Clob)val;
            setCharacterStream(col, clob.getCharacterStream(),
                               (int)clob.length());
        } else {
            setParamValue(col, Value.fromObject(val));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Object</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @param type the JDBC type of the parameter.
     * @exception SQLException may be thrown
     */
    public void setObject(int col, Object val, int type) throws SQLException {
        Type t = Value.typeForJdbcType(type);
        Value v = Value.fromObject(val);
        setParamValue(col, t.convert(v));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Object</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @param type the JDBC type of the parameter.
     * @param scale for numeric types, the precision of the value.
     * @exception SQLException may be thrown
     */
    public void setObject(int col, Object val, int type, int scale) 
        throws SQLException 
    {
        Value v = Value.fromObject(val);
        Type t = null;
        switch (type) {
        case Types.NUMERIC:
        case Types.DECIMAL:
            t = new TypeDecimal(32, scale);
            break;
        default:
            t = Value.typeForJdbcType(type);
        }
        setParamValue(col, t.convert(v));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>short</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setShort(int col, short val) throws SQLException {
        setParamValue(col, new ValueShort(val));
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>String</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setString(int col, String val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueString(val));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Time</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setTime(int col, Time val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueTime(val.getTime()));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Time</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @param cal a <code>Calendar<code> object that is used for converting
     *  the database date to the local timezone.  The database date is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @exception SQLException may be thrown
     */
    public void setTime(int col, Time val, Calendar cal) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            long t = val.getTime();
            cal.setTime(val);
            t -= (cal.get(Calendar.ZONE_OFFSET) +
                  cal.get(Calendar.DST_OFFSET));
            setParamValue(col, new ValueTime(t));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Timestamp</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setTimestamp(int col, Timestamp val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setParamValue(col, new ValueTimestamp(val));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Timestamp</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @param cal a <code>Calendar<code> object that is used for converting
     *  the database date to the local timezone.  The database date is
     *  adjusted based on the <code>Calendar</code> timezone and DST offset.
     * @exception SQLException may be thrown
     */
    public void setTimestamp(int col, Timestamp val, Calendar cal)
        throws SQLException 
    {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            long t = val.getTime();
            cal.setTime(val);
            t -= (cal.get(Calendar.ZONE_OFFSET) +
                  cal.get(Calendar.DST_OFFSET));
            Timestamp r = new Timestamp(t);
            r.setNanos(val.getNanos());
            setParamValue(col, new ValueTimestamp(r));
        }
    }

    /**
     * @deprecated
     */
    public void setUnicodeStream(int col, InputStream in, int length)
        throws SQLException 
    {
        setBinaryStream(col, in, length);
    }


    /**
     * @deprecated
     */
    public PreparedStatement(Connection conn, String sql,
                             int resultSetType,
                             int resultSetConcurrency) 
        throws SQLException, IOException
    {
        this(conn, sql);
        this.resultSetType = resultSetType;
        this.resultSetConcurrency = resultSetConcurrency;
    }
    
   //#ifndef JDK11
    /**
     * Set the statement parameter to the specified 
     * <code>ARRAY</code> value. 
     * This QED release doesn't support ARRAY types, so a 
     * "not implemented" exception is thrown
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException "not implemented"
     */
    public void setArray(int col, Array val) throws SQLException {
        throw new SQLException("not implemented", "0A000");
    }

    /**
     * Set the statement parameter to the specified 
     * <code>Blob</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setBlob(int col, Blob val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            if (val instanceof ValueBlob) {
                setParamValue(col, (ValueBlob)val);
            } else {
                setBinaryStream(col, val.getBinaryStream(),
                                (int)(val.length()));
            }
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>Clob</code> value.
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException may be thrown
     */
    public void setClob(int col, Clob val) throws SQLException {
        if (val == null) {
            setParamValue(col, ValueNull.valueNull);
        } else {
            setAsciiStream(col, val.getAsciiStream(), (int)(val.length()));
        }
    }
    
    /**
     * Set the statement parameter to the specified 
     * <code>REF</code> value.
     * This QED release doesn't support ARRAY types, so a 
     * "not implemented" exception is thrown
     *
     * @param col the parameter index
     * @param val the new value
     * @exception SQLException "not implemented"
     */
    public void setRef(int col, Ref val) throws SQLException {
        throw new SQLException("not implemented", "0A000");
    }
    
    //#endif
    
    //------------------------- JDBC 3.0 -----------------------------------
    //#ifdef JDK14

    /**
     * Sets the designated parameter to the given <code>java.net.URL</code>
     * value. 
     * The driver converts this to an SQL <code>DATALINK</code> value
     * when it sends it to the database.
     *
     * <p>QED simply converts the URL to a string</p>
     *
     * @param parameterIndex the first parameter is 1, the second is 2, ...
     * @param x the <code>java.net.URL</code> object to be set
     * @exception SQLException if a database access error occurs
     * @since 1.4
     */ 
    public void setURL(int parameterIndex, java.net.URL x)
        throws SQLException
    {
        setString(parameterIndex, x.toString());
    }
    

    /**
     * Retrieves the number, types and properties of this 
     * <code>PreparedStatement</code> object's parameters.
     *
     * <p><i>QED: Not implemented</i></p>
     *
     * @return a <code>ParameterMetaData</code> object that contains information
     *         about the number, types and properties of this 
     *         <code>PreparedStatement</code> object's parameters
     * @exception SQLException if a database access error occurs
     * @see ParameterMetaData
     * @since 1.4
     */
    public java.sql.ParameterMetaData getParameterMetaData()
        throws SQLException
    {
        throw new SQLException("Not implemented");
    }
    //#endif

    public String toString() {
        StringBuffer sb =
            new StringBuffer("com.quadcap.jdbc.PreparedStatement(");
        if (params != null) for (int i = 1; i <= params.size(); i++) {
            if (i > 1) sb.append(",");
            ParameterExpression e = getParam(i);
            Value v = e.getValue(null, null);
            sb.append(String.valueOf(v));
        }
        sb.append(")");
        return sb.toString();
    }
        
}