pdo.java

来自「RESIN 3.2 最新源码」· Java 代码 · 共 1,025 行 · 第 1/2 页

  }

  /**
   * Queries the database
   */
  public Value query(String query)
  {
    if (_conn == null)
      return BooleanValue.FALSE;

    try {
      closeStatements();

      PDOStatement pdoStatement = new PDOStatement(_env, _conn, query, false, null);
      _lastPDOStatement = pdoStatement;
      return _env.wrapJava(pdoStatement);
    } catch (SQLException e) {
      _error.error(e);

      return BooleanValue.FALSE;
    }
  }

  /**
   * Quotes the string
   */
  public String quote(String query, @Optional int parameterType)
  {
    return "'" + real_escape_string(query) + "'";
  }

  /**
   * Escapes the string.
   */
  public String real_escape_string(String str)
  {
    StringBuilder buf = new StringBuilder();

    final int strLength = str.length();

    for (int i = 0; i < strLength; i++) {
      char c = str.charAt(i);

      switch (c) {
      case '\u0000':
        buf.append('\\');
        buf.append('\u0000');
        break;
      case '\n':
        buf.append('\\');
        buf.append('n');
        break;
      case '\r':
        buf.append('\\');
        buf.append('r');
        break;
      case '\\':
        buf.append('\\');
        buf.append('\\');
        break;
      case '\'':
        buf.append('\\');
        buf.append('\'');
        break;
      case '"':
        buf.append('\\');
        buf.append('\"');
        break;
      case '\032':
        buf.append('\\');
        buf.append('Z');
        break;
      default:
        buf.append(c);
        break;
      }
    }

    return buf.toString();
  }

  /**
   * Rolls a transaction back.
   */
  public boolean rollBack()
  {
    if (_conn == null)
      return false;

    if (! _inTransaction)
      return false;

    _inTransaction = false;

    try {
      _conn.rollback();
      _conn.setAutoCommit(true);
      return true;
    }
    catch (SQLException e) {
      _error.error(e);
      return false;
    }
  }

  public boolean setAttribute(int attribute, Value value)
  {
    return setAttribute(attribute, value, false);
  }

  private boolean setAttribute(int attribute, Value value, boolean isInit)
  {
    switch (attribute) {
      case ATTR_AUTOCOMMIT:
        return setAutocommit(value.toBoolean());

      case ATTR_ERRMODE:
        return _error.setErrmode(value.toInt());

      case ATTR_CASE:
        return setCase(value.toInt());

      case ATTR_ORACLE_NULLS:
        return setOracleNulls(value.toInt());

      case ATTR_STRINGIFY_FETCHES:
        return setStringifyFetches(value.toBoolean());

      case ATTR_STATEMENT_CLASS:
        return setStatementClass(value);
    }

    if (isInit) {
      switch (attribute) {
        // XXX: there may be more of these
        case ATTR_TIMEOUT:
          return setTimeout(value.toInt());

        case ATTR_PERSISTENT:
          return setPersistent(value.toBoolean());
      }
    }

    // XXX: check what PHP does
    _error.unsupportedAttribute(attribute);
    return false;
  }

  /**
   * Sets the auto commit, if true commit every statement.
   * @return true on success, false on error.
   */
  private boolean setAutocommit(boolean autoCommit)
  {
    if (_conn == null)
      return false;

    try {
      _conn.setAutoCommit(autoCommit);
    }
    catch (SQLException e) {
      _error.error(e);
      return false;
    }

    return true;
  }

  /**
   * Force column names to a specific case.
   *
   * <dl>
   * <dt>{@link CASE_LOWER}
   * <dt>{@link CASE_NATURAL}
   * <dt>{@link CASE_UPPER}
   * </dl>
   */
  private boolean setCase(int value)
  {
    switch (value) {
      case CASE_LOWER:
      case CASE_NATURAL:
      case CASE_UPPER:
        throw new UnimplementedException();

      default:
        _error.unsupportedAttributeValue(value);
        return false;
    }
  }

  /**
   * Sets whether or not the convert nulls and empty strings, works for
   * all drivers.
   *
   * <dl>
   * <dt> {@link NULL_NATURAL}
   * <dd> no conversion
   * <dt> {@link NULL_EMPTY_STRING}
   * <dd> empty string is converted to NULL
   * <dt> {@link NULL_TO_STRING} NULL
   * <dd> is converted to an empty string.
   * </dl>
   *
   * @return true on success, false on error.
   */
  private boolean setOracleNulls(int value)
  {
    switch (value) {
      case NULL_NATURAL:
      case NULL_EMPTY_STRING:
      case NULL_TO_STRING:
        throw new UnimplementedException();
      default:
        _error.warning(L.l("unknown value `{0}'", value));
        _error.unsupportedAttributeValue(value);
        return false;
    }
  }

  private boolean setPersistent(boolean isPersistent)
  {
    return true;
  }

  private boolean setPrefetch(int prefetch)
  {
    throw new UnimplementedException();
  }

  /**
   * Sets a custom statement  class derived from PDOStatement.
   *
   * @param value an array(classname, array(constructor args)).
   *
   * @return true on success, false on error.
   */
  private boolean setStatementClass(Value value)
  {
    throw new UnimplementedException("ATTR_STATEMENT_CLASS");
  }

  /**
   * Convert numeric values to strings when fetching.
   *
   * @return true on success, false on error.
   */
  private boolean setStringifyFetches(boolean stringifyFetches)
  {
    throw new UnimplementedException();
  }

  private boolean setTimeout(int timeoutSeconds)
  {
    throw new UnimplementedException();
  }

  /**
   * Opens a connection based on the dsn.
   */
  private DataSource getDataSource(Env env, String dsn)
    throws Exception
  {
    if (dsn.startsWith("mysql:"))
      return getMysqlDataSource(env, dsn);
    if (dsn.startsWith("pgsql:"))
      return getPgsqlDataSource(env, dsn);
    else if (dsn.startsWith("java"))
      return getJndiDataSource(env, dsn);
    else if (dsn.startsWith("resin:"))
      return getResinDataSource(env, dsn);
    else {
      env.error(L.l("'{0}' is an unknown PDO data source.",
                    dsn));

      return null;
    }
  }

  /**
   * Opens a mysql connection based on the dsn.
   */
  private DataSource getMysqlDataSource(Env env, String dsn)
    throws Exception
  {
    HashMap<String,String> attr = parseAttr(dsn, dsn.indexOf(':'));

    // XXX: more robust to get attribute values as is done in getPgsqlDataSource

    String host = attr.get("host");
    String portStr = attr.get("port");
    String dbname = attr.get("dbname");
    String unixSocket = attr.get("unix_socket");

    if (unixSocket != null) {
      env.error(L.l("PDO mysql: does not support unix_socket"));
      return null;
    }

    if (host == null)
      host = "localhost";

    int port = 3306;
    
    if (portStr != null) {
      try {
        port = Integer.parseInt(portStr);
      } catch (NumberFormatException e) {
        log.log(Level.FINE, e.toString(), e);
      }
    }

    if (dbname == null)
      dbname = "test";

    // PHP doc does not sure user and password as attributes for mysql,
    // but in the pgsql doc  the dsn specified user and password override arguments
    // passed to constructor
    String user = attr.get("user");
    if (user != null)
      _user = user;

    String password = attr.get("password");
    if (password != null)
      _password = password;

    String driver = Mysqli.DRIVER;
    
    // XXX: mysql options?
    String url = Mysqli.getUrl(host, port, dbname, ENCODING,
                               false, false, false);
    
    return env.getDataSource(driver, url);
  }

  /**
   * Opens a postgres connection based on the dsn.
   */
  private DataSource getPgsqlDataSource(Env env, String dsn)
    throws Exception
  {
    HashMap<String,String> attr = parseAttr(dsn, dsn.indexOf(':'));

    String host = "localhost";
    String port = null;
    String dbname = "test";
    String user = null;
    String password = null;

    for (Map.Entry<String,String> entry : attr.entrySet()) {
      String key = entry.getKey();

      if ("host".equals(key))
        host = entry.getValue();
      else if ("port".equals(key))
        port = entry.getValue();
      else if ("dbname".equals(key))
        dbname = entry.getValue();
      else if ("user".equals(key))
        user = entry.getValue();
      else if ("password".equals(key))
        password = entry.getValue();
      else
        env.warning(L.l("unknown pgsql attribute '{0}'", key));
    }

    // confirmed with PHP doc,  the dsn specified user and password override
    // arguments passed to constructor
    if (user != null)
      _user = user;

    if (password != null)
      _password = password;

    String driver = "org.postgresql.Driver";

    StringBuilder url = new StringBuilder();
    url.append("jdbc:postgresql://");
    url.append(host);

    if (port != null)
      url.append(port);

    url.append('/');
    url.append(dbname);

    return env.getDataSource(driver, url.toString());
  }

  /**
   * Opens a resin connection based on the dsn.
   */
  private DataSource getResinDataSource(Env env, String dsn)
    throws Exception
  {
    String driver = "com.caucho.db.jdbc.ConnectionPoolDataSourceImpl";

    String url = "jdbc:" + dsn;

    return env.getDataSource(driver, url);
  }

  /**
   * Opens a connection based on the dsn.
   */
  private DataSource getJndiDataSource(Env env, String dsn)
  {
    DataSource ds = null;

    try {
      Context ic = new InitialContext();

      ds = (DataSource) ic.lookup(dsn);
    } catch (NamingException e) {
      log.log(Level.FINE, e.toString(), e);
    }

    if (ds == null)
      env.error(L.l("'{0}' is an unknown PDO JNDI data source.", dsn));

    return ds;
  }

  private HashMap<String,String> parseAttr(String dsn, int i)
  {
    HashMap<String,String> attr = new LinkedHashMap<String,String>();

    int length = dsn.length();

    for (; i < length; i++) {
      char ch = dsn.charAt(i);

      if (! Character.isJavaIdentifierStart(ch))
        continue;

      StringBuilder name = new StringBuilder();
      for (;
           i < length && Character.isJavaIdentifierPart((ch = dsn.charAt(i)));
           i++) {
        name.append(ch);
      }

      for (; i < length && ((ch = dsn.charAt(i)) == ' ' || ch == '='); i++) {
      }

      StringBuilder value = new StringBuilder();
      for (; i < length && (ch = dsn.charAt(i)) != ' ' && ch != ';'; i++) {
        value.append(ch);
      }

      attr.put(name.toString(), value.toString());
    }

    return attr;
  }

  public String toString()
  {
    // do not show password!
    if (_dsn == null)
      return "PDO[]";

    if (_dsn.indexOf("pass") < 0)
      return "PDO[" + _dsn + "]";

    int i = _dsn.lastIndexOf(':');

    if (i < 0)
      return "PDO[]";

    if (_dsn.startsWith("java"))
      return "PDO[" + _dsn + "]";

    StringBuilder str = new StringBuilder();
    str.append("PDO[");

    str.append(_dsn, 0, i + 1);

    HashMap<String,String> attr = parseAttr(_dsn, i);

    if (_user != null && ! "".equals(_user))
      attr.put("user", _user);

    boolean first = true;

    for (Map.Entry<String,String> entry : attr.entrySet()) {
      String key = entry.getKey();
      String value = entry.getValue();

      if ("password".equalsIgnoreCase(key))
        value = "XXXXX";
      else if ("passwd".equalsIgnoreCase(key))
        value = "XXXXX";
      else if ("pass".equalsIgnoreCase(key))
        value = "XXXXX";

      if (!first)
        str.append(' ');

      first = false;

      str.append(key);
      str.append("=");
      str.append(value);
    }

    str.append("]");

    return str.toString();
  }
}