i18nconnection.java

数据仓库工具

   * This method is the same as the <code>createStatement</code> method
   * above, but it allows the default result set
   * type and concurrency to be overridden.
   *
   * @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>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 {
    throw new UnsupportedOperationException(
        "Connection.createStatement(int, int) unsupported");
  }

  /**
   * 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");
  }

  //---------------------------------------------------------------------
  // 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 charset property
   * @return current value for the suppressHeaders property
   */
  protected String getCharset() {
    return charset;
  }

//  protected long getMaxFileSize() {
//    return maxFileSize;
//  }
//
//  protected String getLineBreakEscape() {
//    return lineBrakesEscape;
//  }
//
//  protected String getCarriageReturnEscape() {
//      return carriageReturnEscape;
//  }

//  protected String getDoubleQuotesEscape() {
//    return doubleQuotesEscape;
//  }

/**
 * @return String which represents nameColumn
 */
protected String getNameColumn() {
    return this.nameColumn;
}

/**
 * @return String which represents valueColumn
 */
protected String getValueColumn() {
    return this.valueColumn;
}

/**
 * @return String[] which represents valueColumn
 */
protected String[] getColumnNames() {
	String[] retString = new String[2];
	retString[0] = this.nameColumn;
	retString[1] = this.valueColumn;
	return retString;
}

}