class JdbcSQLException extends SQLException {

    // /**
    // * If the SQL statement contains this text, then it is never added to the
    // * SQL exception. Hiding the SQL statement may be important if it contains a
    // * passwords, such as a CREATE LINKED TABLE statement.
    // */
    // public static final String HIDE_SQL = "--hide--";

    private static final long serialVersionUID = 1L;
    private final String originalMessage;
    private final Throwable cause;
    private final String stackTrace;
    private String message;
    private String sql;

    /**
     * Creates a SQLException.
     *
     * @param message the reason
     * @param sql the SQL statement
     * @param state the SQL state
     * @param errorCode the error code
     * @param cause the exception that was the reason for this exception
     * @param stackTrace the stack trace
     */
    public JdbcSQLException(String message, String sql, String state, int errorCode, Throwable cause,
            String stackTrace) {
        super(message, state, errorCode, cause);
        this.originalMessage = message;
        this.cause = cause;
        this.stackTrace = stackTrace;
        setSQL(sql, false);
        buildMessage();
    }

    /**
     * Get the detail error message.
     *
     * @return the message
     */
    @Override
    public String getMessage() {
        return message;
    }

    /**
     * INTERNAL
     */
    public String getOriginalMessage() {
        return originalMessage;
    }

    /**
     * INTERNAL
     */
    public Throwable getOriginalCause() {
        return cause;
    }

    /**
     * Returns the SQL statement.
     * SQL statements that contain '--hide--' are not listed.
     *
     * @return the SQL statement
     */
    public String getSQL() {
        return sql;
    }

    /**
     * INTERNAL
     */
    public void setSQL(String sql) {
        setSQL(sql, true);
    }

    private void setSQL(String sql, boolean build) {<FILL_FUNCTION_BODY>}

    private void buildMessage() {
        StringBuilder buff = new StringBuilder(originalMessage == null ? "- " : originalMessage);
        if (sql != null) {
            buff.append("; SQL statement:\n").append(sql);
        }
        buff.append(" [").append(getErrorCode()).append('-').append(Constants.BUILD_ID).append(']');
        message = buff.toString();
    }

    /**
     * Returns the class name, the message, and in the server mode, the stack
     * trace of the server
     *
     * @return the string representation
     */
    @Override
    public String toString() {
        if (stackTrace == null) {
            return super.toString();
        }
        return stackTrace;
    }

    /**
     * Prints the stack trace to the standard error stream.
     */
    @Override
    public void printStackTrace() {
        // The default implementation already does that,
        // but we do it again to avoid problems.
        // If it is not implemented, somebody might implement it
        // later on which would be a problem if done in the wrong way.
        printStackTrace(System.err);
    }

    /**
     * Prints the stack trace to the specified print writer.
     *
     * @param s the print writer
     */
    @Override
    public void printStackTrace(PrintWriter s) {
        if (s != null) {
            super.printStackTrace(s);
            // getNextException().printStackTrace(s) would be very very slow
            // if many exceptions are joined
            SQLException next = getNextException();
            for (int i = 0; i < 100 && next != null; i++) {
                s.println(next.toString());
                next = next.getNextException();
            }
            if (next != null) {
                s.println("(truncated)");
            }
        }
    }

    /**
     * Prints the stack trace to the specified print stream.
     *
     * @param s the print stream
     */
    @Override
    public void printStackTrace(PrintStream s) {
        if (s != null) {
            super.printStackTrace(s);
            // getNextException().printStackTrace(s) would be very very slow
            // if many exceptions are joined
            SQLException next = getNextException();
            for (int i = 0; i < 100 && next != null; i++) {
                s.println(next.toString());
                next = next.getNextException();
            }
            if (next != null) {
                s.println("(truncated)");
            }
        }
    }
}

        // if (sql != null && sql.contains(HIDE_SQL)) {
        // sql = "-";
        // }
        this.sql = sql;
        if (build) {
            buildMessage();
        }
    
<methods>public void <init>() ,public void <init>(java.lang.String) ,public void <init>(java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.String) ,public void <init>(java.lang.String, java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.String, int) ,public void <init>(java.lang.String, java.lang.String, java.lang.Throwable) ,public void <init>(java.lang.String, java.lang.String, int, java.lang.Throwable) ,public int getErrorCode() ,public java.sql.SQLException getNextException() ,public java.lang.String getSQLState() ,public Iterator<java.lang.Throwable> iterator() ,public void setNextException(java.sql.SQLException) <variables>private java.lang.String SQLState,private volatile java.sql.SQLException next,private static final AtomicReferenceFieldUpdater<java.sql.SQLException,java.sql.SQLException> nextUpdater,private static final long serialVersionUID,private int vendorCode