csvconnection.java

一种解析csv文件特别好的方法

     * @return a new <code>Statement</code> object that will generate
     *         <code>ResultSet</code> objects with the given type and
     *         concurrency
     * @exception SQLException if a database access error occurs
     *         or the given parameters are not <code>ResultSet</code>
     *         constants indicating type and concurrency
     */
    public Statement createStatement(int resultSetType, int resultSetConcurrency)
            throws SQLException {
        CsvStatement statement = new CsvStatement(this, resultSetType);
        statements.add(statement);
        return statement;
    }

    /**
     * Creates a <code>PreparedStatement</code> object that will generate
     * <code>ResultSet</code> objects with the given type and concurrency.
     * This method is the same as the <code>prepareStatement</code> method
     * above, but it allows the default result set
     * type and concurrency to be overridden.
     *
     * @param sql a <code>String</code> object that is the SQL statement to
     *            be sent to the database; may contain one or more ? IN
     *            parameters
     * @param resultSetType a result set type; one of
     *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,
     *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
     *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
     * @param resultSetConcurrency a concurrency type; one of
     *         <code>ResultSet.CONCUR_READ_ONLY</code> or
     *         <code>ResultSet.CONCUR_UPDATABLE</code>
     * @return a new PreparedStatement object containing the
     * pre-compiled SQL statement that will produce <code>ResultSet</code>
     * objects with the given type and concurrency
     * @exception SQLException if a database access error occurs
     *         or the given parameters are not <code>ResultSet</code>
     *         constants indicating type and concurrency
     */
    public PreparedStatement prepareStatement(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException {
        throw new UnsupportedOperationException(
                "Connection.prepareStatement(String, int, int) unsupported");
    }

    /**
     * Creates a <code>CallableStatement</code> object that will generate
     * <code>ResultSet</code> objects with the given type and concurrency.
     * This method is the same as the <code>prepareCall</code> method
     * above, but it allows the default result set
     * type and concurrency to be overridden.
     *
     * @param sql a <code>String</code> object that is the SQL statement to
     *            be sent to the database; may contain on or more ? parameters
     * @param resultSetType a result set type; one of
     *         <code>ResultSet.TYPE_FORWARD_ONLY</code>,
     *         <code>ResultSet.TYPE_SCROLL_INSENSITIVE</code>, or
     *         <code>ResultSet.TYPE_SCROLL_SENSITIVE</code>
     * @param resultSetConcurrency a concurrency type; one of
     *         <code>ResultSet.CONCUR_READ_ONLY</code> or
     *         <code>ResultSet.CONCUR_UPDATABLE</code>
     * @return a new <code>CallableStatement</code> object containing the
     * pre-compiled SQL statement that will produce <code>ResultSet</code>
     * objects with the given type and concurrency
     * @exception SQLException if a database access error occurs
     *         or the given parameters are not <code>ResultSet</code>
     *         constants indicating type and concurrency
     */
    public CallableStatement prepareCall(String sql, int resultSetType,
            int resultSetConcurrency) throws SQLException {
        throw new UnsupportedOperationException(
                "Connection.prepareCall(String, int, int) unsupported");
    }

    /**
     * Retrieves the <code>Map</code> object associated with this
     * <code>Connection</code> object.
     * Unless the application has added an entry, the type map returned
     * will be empty.
     *
     * @return the <code>java.util.Map</code> object associated
     *         with this <code>Connection</code> object
     * @exception SQLException if a database access error occurs
     * @see #setTypeMap
     */
    public Map getTypeMap() throws SQLException {
        throw new UnsupportedOperationException(
                "Connection.getTypeMap() unsupported");
    }

    /**
     * Installs the given <code>TypeMap</code> object as the type map for
     * this <code>Connection</code> object.  The type map will be used for the
     * custom mapping of SQL structured types and distinct types.
     *
     * @param map the <code>java.util.Map</code> object to install
     *        as the replacement for this <code>Connection</code>
     *        object's default type map
     * @exception SQLException if a database access error occurs or
     *        the given parameter is not a <code>java.util.Map</code>
     *        object
     * @see #getTypeMap
     */
    public void setTypeMap(Map map) throws SQLException {
        throw new UnsupportedOperationException(
                "Connection.setTypeMap(Map) unsupported");
    }

    //--------------------------JDBC 3.0-----------------------------
    /**
     * Changes the holdability of <code>ResultSet</code> objects
     * created using this <code>Connection</code> object to the given
     * holdability.
     *
     * @param holdability a <code>ResultSet</code> holdability constant; one of
     *        <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
     *        <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
     * @throws SQLException if a database access occurs, the given parameter
     *         is not a <code>ResultSet</code> constant indicating holdability,
     *         or the given holdability is not supported
     * @since 1.4
     * @see #getHoldability
     * @see java.sql.ResultSet
     */
    public void setHoldability(int holdability) throws SQLException {
        throw new UnsupportedOperationException("Connection.setHoldability(int) unsupported");
    }

    /**
     * Retrieves the current holdability of ResultSet objects created
     * using this Connection object.
     *
     * @return the holdability, one of <code>ResultSet.HOLD_CURSORS_OVER_COMMIT</code> or
     * <code>ResultSet.CLOSE_CURSORS_AT_COMMIT</code>
     * @throws SQLException if a database access occurs
     * @since 1.4
     * @see #setHoldability
     * @see java.sql.ResultSet
     */
    public int getHoldability() throws SQLException {
        throw new UnsupportedOperationException("Connection.getHoldability() unsupported");
    }

    /* Removed since this only builds under JDK 1.4
    public Savepoint setSavepoint() throws SQLException {
        throw new UnsupportedOperationException("Connection.setSavepoint() unsupported");
    }

    public Savepoint setSavepoint(String name) throws SQLException {
        throw new UnsupportedOperationException("Connection.setSavepoint(String) unsupported");
    }

    public void rollback(Savepoint savepoint) throws SQLException {
        throw new UnsupportedOperationException("Connection.rollback(Savepoint) unsupported");
    }

    public void releaseSavepoint(Savepoint savepoint) throws SQLException {
        throw new UnsupportedOperationException("Connection.releaseSavepoint(Savepoint) unsupported");
    }
     */

    public Statement createStatement(int resultSetType,
                                     int resultSetConcurrency,
                                     int resultSetHoldability) throws SQLException {
        throw new UnsupportedOperationException("Connection.createStatement(int,int,int) unsupported");
    }

    public PreparedStatement prepareStatement(String sql,
                                      int resultSetType,
                                      int resultSetConcurrency,
                                      int resultSetHoldability) throws SQLException {
        throw new UnsupportedOperationException("Connection.prepareStatement(String,int,int,int) unsupported");
    }

    public CallableStatement prepareCall(String sql,
                                         int resultSetType,
                                         int resultSetConcurrency,
                                         int resultSetHoldability) throws SQLException {
        throw new UnsupportedOperationException("Connection.prepareCall(String,int,int,int) unsupported");
    }

    public PreparedStatement prepareStatement(String sql, int autoGeneratedKeys) throws SQLException {
        throw new UnsupportedOperationException("Connection.prepareStatement(String,int) unsupported");
    }

    public PreparedStatement prepareStatement(String sql, int[] columnIndexes) throws SQLException {
        throw new UnsupportedOperationException("Connection.prepareStatement(String,int[]) unsupported");
    }

    public PreparedStatement prepareStatement(String sql, String[] columnNames) throws SQLException {
        throw new UnsupportedOperationException("Connection.prepareStatement(String,String[]) unsupported");
    }
    
		public void releaseSavepoint(Savepoint savePoint) throws SQLException{
			throw new UnsupportedOperationException("Connection.releaseSavepoint(Savepoint) unsupported");
		}
		
		public void rollback(Savepoint savePoint) throws SQLException{
			throw new UnsupportedOperationException("Connection.rollback(Savepoint) unsupported");
		}
		
		public Savepoint setSavepoint() throws SQLException{
			throw new UnsupportedOperationException("Connection.setSavepoint() unsupported");
		}
		
		public Savepoint setSavepoint(String str) throws SQLException{
			throw new UnsupportedOperationException("Connection.setSavepoint(String) unsupported");
		} 

    //---------------------------------------------------------------------
    // Properties
    //---------------------------------------------------------------------

    /**
     * Accessor method for the path property
     * @return current value for the path property
     */
    protected String getPath() {
        return path;
    }

    /**
     * Accessor method for the extension property
     * @return current value for the extension property
     */
    protected String getExtension() {
        return extension;
    }

    /**
     * Accessor method for the separator property
     * @return current value for the separator property
     */
    protected char getSeperator() {
        return separator;
    }

    /**
     * Accessor method for the suppressHeaders property
     * @return current value for the suppressHeaders property
     */
    protected boolean isSuppressHeaders() {
        return suppressHeaders;
    }

    /**
     * Accessor method for the charset property
     * @return current value for the suppressHeaders property
     */
    protected String getCharset() {
        return charset;
    }
}