sqlca.java

derby database source code.good for you.

/*

   Derby - Class org.apache.derby.client.am.Sqlca

   Copyright (c) 2001, 2005 The Apache Software Foundation or its licensors, where applicable.

   Licensed under the Apache License, Version 2.0 (the "License");
   you may not use this file except in compliance with the License.
   You may obtain a copy of the License at

      http://www.apache.org/licenses/LICENSE-2.0

   Unless required by applicable law or agreed to in writing, software
   distributed under the License is distributed on an "AS IS" BASIS,
   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
   See the License for the specific language governing permissions and
   limitations under the License.

*/

package org.apache.derby.client.am;

import org.apache.derby.client.net.Typdef;

public abstract class Sqlca {
    transient protected Connection connection_;
    java.sql.SQLException exceptionThrownOnStoredProcInvocation_;
    boolean messageTextRetrievedContainsTokensOnly_ = true;

    // data corresponding to SQLCA fields
    protected int sqlCode_;        // SQLCODE
    private String sqlErrmc_;       // A string with all error tokens delimited by sqlErrmcDelimiter
    protected String[] sqlErrmcTokens_; // A string array with each element
    // contain an error token
    protected String sqlErrp_;        // function name issuing error
    protected int[] sqlErrd_;        // 6 diagnostic Information
    protected char[] sqlWarn_;        // 11 warning Flags
    protected String sqlState_;       // SQLSTATE

    // raw sqlca data fields before unicode conversion
    protected byte[] sqlErrmcBytes_;
    protected byte[] sqlErrpBytes_;
    protected byte[] sqlWarnBytes_;
    protected byte[] sqlStateBytes_;

    protected int ccsid_;
    protected int sqlErrmcCcsid_;
    protected boolean containsSqlcax_ = true;
    protected long rowsetRowCount_;

    //public static final String sqlErrmcDelimiter = "\u00FF";
    private static final String sqlErrmcDelimiter__ = ";";

    // JDK stack trace calls e.getMessage(), so we must set some state on the sqlca that says return tokens only.
    private boolean returnTokensOnlyInMessageText_ = false;

    transient private final Agent agent_;

    private String cachedMessage;

    protected Sqlca(org.apache.derby.client.am.Connection connection) {
        connection_ = connection;
        agent_ = connection_ != null ? connection_.agent_ : null;
    }

    void returnTokensOnlyInMessageText(boolean returnTokensOnlyInMessageText) {
        returnTokensOnlyInMessageText_ = returnTokensOnlyInMessageText;
    }

    synchronized public int getSqlCode() {
        return sqlCode_;
    }

    synchronized public String getSqlErrmc() {
        if (sqlErrmc_ != null) {
            return sqlErrmc_;
        }

        // sqlErrmc string is dependent on sqlErrmcTokens array having been built
        if (sqlErrmcTokens_ == null) {
            getSqlErrmcTokens();
        }

        // sqlErrmc will be build only if sqlErrmcTokens has been build.
        // Otherwise, a null string will be returned.
        if (sqlErrmcTokens_ == null) {
            return null;
        }

        // create 0-length String if no tokens
        if (sqlErrmcTokens_.length == 0) {
            sqlErrmc_ = "";
            return sqlErrmc_;
        }

        // concatenate tokens with sqlErrmcDelimiter delimiters into one String
        StringBuffer buffer = new StringBuffer();
        int indx;
        for (indx = 0; indx < sqlErrmcTokens_.length - 1; indx++) {
            buffer.append(sqlErrmcTokens_[indx]);
            buffer.append(sqlErrmcDelimiter__);
        }
        // add the last token
        buffer.append(sqlErrmcTokens_[indx]);

        // save as a string
        sqlErrmc_ = buffer.toString();
        return sqlErrmc_;
    }

    synchronized public String[] getSqlErrmcTokens() {
        if (sqlErrmcTokens_ != null) {
            return sqlErrmcTokens_;
        }

        // processSqlErrmcTokens handles null sqlErrmcBytes_ case
        sqlErrmcTokens_ = processSqlErrmcTokens(sqlErrmcBytes_);
        return sqlErrmcTokens_;
    }

    synchronized public String getSqlErrp() {
        if (sqlErrp_ != null) {
            return sqlErrp_;
        }

        if (sqlErrpBytes_ == null) {
            return null;
        }

        try {
            sqlErrp_ = bytes2String(sqlErrpBytes_,
                    0,
                    sqlErrpBytes_.length);
            return sqlErrp_;
        } catch (java.io.UnsupportedEncodingException e) {
            // leave sqlErrp as null.
            return null;
        }
    }

    public int[] getSqlErrd() {
        if (sqlErrd_ != null) {
            return sqlErrd_;
        }

        sqlErrd_ = new int[6]; // create an int array.
        return sqlErrd_;
    }

    synchronized public char[] getSqlWarn() {
        if (sqlWarn_ != null) {
            return sqlWarn_;
        }

        try {
            if (sqlWarnBytes_ == null) {
                sqlWarn_ = new char[]{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '}; // 11 blank.
            } else {
                sqlWarn_ = bytes2String(sqlWarnBytes_, 0, sqlWarnBytes_.length).toCharArray();
            }
            return sqlWarn_;
        } catch (java.io.UnsupportedEncodingException e) {
            sqlWarn_ = new char[]{' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' ', ' '}; // 11 blank.
            return sqlWarn_;
        }
    }

    synchronized public String getSqlState() {
        if (sqlState_ != null) {
            return sqlState_;
        }

        if (sqlStateBytes_ == null) {
            return null;
        }

        try {
            sqlState_ = bytes2String(sqlStateBytes_,
                    0,
                    sqlStateBytes_.length);
            return sqlState_;
        } catch (java.io.UnsupportedEncodingException e) {
            // leave sqlState as null.
            return null;
        }
    }

    // Gets the formatted message, can throw an exception.
    synchronized public String getMessage() throws SqlException {
        // should this be traced to see if we are calling a stored proc?
        if (cachedMessage != null) {
            return cachedMessage;
        }

        if (connection_ == null || connection_.isClosedX() || returnTokensOnlyInMessageText_) {
            return getUnformattedMessage();
        }

        CallableStatement cs = null;
        synchronized (connection_) {
            try {
                cs = connection_.prepareMessageProc("call SYSIBM.SQLCAMESSAGE(?,?,?,?,?,?,?,?,?,?,?,?,?,?,?,?)");

                // SQLCode: SQL return code.
                cs.setIntX(1, getSqlCode());
                // SQLErrml: Length of SQL error message tokens.
                cs.setShortX(2, (short) ((getSqlErrmc() != null) ? getSqlErrmc().length() : 0));
                // SQLErrmc: SQL error message tokens as a String (delimited by semicolon ";").
                cs.setStringX(3, getSqlErrmc());
                // SQLErrp: Product signature.
                cs.setStringX(4, getSqlErrp());
                // SQLErrd: SQL internal error code.
                cs.setIntX(5, getSqlErrd()[0]);
                cs.setIntX(6, getSqlErrd()[1]);