pdostatement.java

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

      {
        String value = _resultSet.getString(column);

        if (value == null || _resultSet.wasNull())
          return NullValue.NULL;
        else
          return _env.createString(value);
      }

      case Types.DOUBLE:
      {
        double value = _resultSet.getDouble(column);

        if (_resultSet.wasNull())
          return NullValue.NULL;
        else
          return (new DoubleValue(value)).toStringValue();
      }

      // XXX: lob

      default:
      {
        String value = _resultSet.getString(column);

        if (value == null || _resultSet.wasNull())
          return NullValue.NULL;
        else
          return _env.createString(value);
      }
    }

  }

  private ResultSetMetaData getResultSetMetaData()
    throws SQLException
  {
    if (_resultSetMetaData == null)
      _resultSetMetaData = _resultSet.getMetaData();

    return _resultSetMetaData;
  }

  /**
   * Returns an iterator of the values.
   */
  public Iterator<Value> iterator()
  {
    Value value = fetchAll(0, -1);

    if (value instanceof ArrayValue)
      return ((ArrayValue) value).values().iterator();
    else {
      Set<Value> emptySet = Collections.emptySet();
      return emptySet.iterator();
    }
  }

  String lastInsertId(String name)
  {
    if (!(name == null || name.length() == 0))
      throw new UnimplementedException("lastInsertId with name ");

    if (_lastInsertId != null)
      return _lastInsertId;

    String lastInsertId = null;

    Statement stmt;

    if (_preparedStatement != null)
      stmt = _preparedStatement;
    else
      stmt = _statement;

    ResultSet resultSet = null;

    try {
      resultSet = stmt.getGeneratedKeys();

      if (resultSet.next())
        lastInsertId = resultSet.getString(1);
    }
    catch (SQLException ex) {
      _error.error(ex);
    }
    finally {
      try {
        if (resultSet != null)
          resultSet.close();
      }
      catch (SQLException ex) {
        log.log(Level.WARNING, ex.toString(), ex);
      }
    }

    _lastInsertId = lastInsertId == null ? "0" : lastInsertId;

    return _lastInsertId;
  }

  public boolean nextRowset()
  {
    throw new UnimplementedException();
  }

  private int resolveParameter(Value parameter)
  {
    int index = -1;

    if (parameter instanceof LongValue) {
      // slight optimization for normal case
      index = parameter.toInt();
    }
    else {
      String name = parameter.toString();

      if (name.length() > 1 && name.charAt(0) == ':') {
        name = name.substring(1);
        if (_parameterNameMap != null)
          index = _parameterNameMap.get(name);
      }
      else
        index = parameter.toInt();
    }

    return index;
  }

  public int rowCount()
  {
    if (_resultSet == null)
      return 0;

    try {
      int row = _resultSet.getRow();

      try {
        _resultSet.last();

        return _resultSet.getRow();
      }
      finally {
        if (row == 0)
          _resultSet.beforeFirst();
        else
          _resultSet.absolute(row);
      }
    }
    catch (SQLException ex) {
      _error.error(ex);
      return 0;
    }
  }

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

  public boolean setAttribute(int attribute, Value value, boolean isFromConstructor)
  {
    if (isFromConstructor) {
      switch (attribute) {
        case PDO.CURSOR_FWDONLY:
        case PDO.CURSOR_SCROLL:
          return setCursor(attribute);
      }
    }

    _error.unsupportedAttribute(attribute);

    return false;
  }

  private boolean setCursor(int attribute)
  {
    switch (attribute) {
      case PDO.CURSOR_FWDONLY:
        throw new UnimplementedException();
      case PDO.CURSOR_SCROLL:
        throw new UnimplementedException();

      default:
        _error.unsupportedAttribute(attribute);
        return false;
    }
  }


  /**
   * Sets the fetch mode, the default is {@link PDO.FETCH_BOTH}.
   */
  public boolean setFetchMode(int fetchMode, Value[] args)
  {
    _fetchMode = PDO.FETCH_BOTH;
    _fetchModeArgs = NULL_VALUES;

    int fetchStyle = fetchMode;

    boolean isGroup = (fetchMode & PDO.FETCH_GROUP) != 0;
    boolean isUnique = (fetchMode & PDO.FETCH_UNIQUE) != 0;

    if (isGroup)
      throw new UnimplementedException("PDO.FETCH_GROUP");

    if (isUnique)
      throw new UnimplementedException("PDO.FETCH_UNIQUE");

    fetchStyle = fetchStyle & (~(PDO.FETCH_GROUP | PDO.FETCH_UNIQUE));

    boolean isClasstype = (fetchMode & PDO.FETCH_CLASSTYPE) != 0;
    boolean isSerialize = (fetchMode & PDO.FETCH_SERIALIZE) != 0;

    fetchStyle = fetchStyle & (~(PDO.FETCH_CLASSTYPE | PDO.FETCH_SERIALIZE));

    switch (fetchStyle) {
      case PDO.FETCH_ASSOC:
      case PDO.FETCH_BOTH:
      case PDO.FETCH_BOUND:
      case PDO.FETCH_LAZY:
      case PDO.FETCH_NAMED:
      case PDO.FETCH_NUM:
      case PDO.FETCH_OBJ:
        break;

      case PDO.FETCH_CLASS:
        if (args.length < 1 || args.length > 2)
          return false;

        if (_env.findClass(args[0].toString()) == null)
          return false;

        if (args.length == 2 && !(args[1].isNull() || args[1].isArray())) {
          _env.warning(L.l("constructor args must be an array"));

          return false;
        }

        break;

      case PDO.FETCH_COLUMN:
        if (args.length != 1)
          return false;

        break;

     case PDO.FETCH_FUNC:
       _error.warning(L.l("PDO::FETCH_FUNC can only be used with PDOStatement::fetchAll()"));
       return false;

      case PDO.FETCH_INTO:
        if (args.length != 1 || !args[0].isObject())
          return false;

        break;

      default:
        _error.warning(L.l("invalid fetch mode"));
        break;
    }

    _fetchModeArgs = args;
    _fetchMode = fetchMode;

    return true;
  }

  /**
   * @param index 1-based position number
   * @param value the value for the parameter
   *
   * @return true for success, false for failure
   */
  private boolean setLobParameter(int index, Value value, long length)
  {
    try {
      if (value == null || value.isNull()) {
        _preparedStatement.setObject(index, null);
      }
      else if (value instanceof StringValue) {
        if (length < 0) {
          _preparedStatement.setBinaryStream(index, value.toInputStream(), value.toString().length());
        }
        else
          _preparedStatement.setBinaryStream(index, value.toInputStream(), (int) length);
      }
      else {
        InputStream inputStream = value.toInputStream();

        if (inputStream == null) {
          _error.warning(L.l("type {0} ({1}) for parameter index {2} cannot be used for lob", value.getType(), value.getClass(), index));
          return false;
        }

        if (length < 0 && (value instanceof FileReadValue)) {
          length = ((FileReadValue) value).getLength();

          if (length <= 0)
            length = -1;
        }

        if (length < 0) {
          TempBuffer tempBuffer = TempBuffer.allocate();

          try {
            byte[] bytes = new byte[1024];

            int len;

            while ((len = inputStream.read(bytes, 0, 1024)) != -1)
              tempBuffer.write(bytes, 0, len);
          }
          catch (IOException ex) {
            _error.error(ex);
            return false;
          }

          TempReadStream tempReadStream = new TempReadStream(tempBuffer);
          tempReadStream.setFreeWhenDone(true);

          _preparedStatement.setBinaryStream(index, new ReadStream(tempReadStream), tempBuffer.getLength());
        }
        else
          _preparedStatement.setBinaryStream(index, inputStream, (int) length);
      }
    }
    catch (SQLException ex) {
      _error.error(ex);
      return false;
    }

    return true;
  }

  /**
   * @param index 1-based position number
   * @param value the value for the parameter
   *
   * @return true for success, false for failure
   */
  private boolean setParameter(int index, Value value, long length)
  {
    try {
      if (value instanceof DoubleValue) {
        _preparedStatement.setDouble(index, value.toDouble());
      }
      else if (value instanceof LongValue) {
	long v = value.toLong();

	_preparedStatement.setLong(index, v);
      }
      else if (value instanceof StringValue) {
        String string = value.toString();

        if (length >= 0)
          string = string.substring(0, (int) length);

        _preparedStatement.setString(index, string);
      }
      else if (value instanceof NullValue) {
        _preparedStatement.setObject(index, null);
      }
      else {
        _error.warning(L.l("unknown type {0} ({1}) for parameter index {2}", value.getType(), value.getClass(), index));
        return false;
      }
    }
    catch (SQLException ex) {
      _error.error(ex);
      return false;
    }

    return true;
  }

  public String toString()
  {
    return "PDOStatement[" + _query + "]";
  }

  /**
   * Bind a value from a resultSet to a variable.
   */
  private class BindColumn {
    private final String _columnAsName;
    private final Value _var;
    private final int _type;

    private int _column;
    private int _jdbcType;

    private boolean _isInit;
    private boolean _isValid;

    /**
     * @param column 1-based column index
     * @param var reference that receives the value
     * @param type a PARM_* type, -1 for default
     */
    private BindColumn(Value column, Value var, int type)
      throws SQLException
    {
      assert column != null;
      assert var != null;

      if (column.isNumberConvertible()) {
        _column = column.toInt();
        _columnAsName = null;
      }
      else {
        _columnAsName = column.toString();
      }

      _var = var;
      _type = type;

      if (_resultSet != null)
        init();
    }

    private boolean init()
      throws SQLException
    {
      if (_isInit)
        return true;

      ResultSetMetaData resultSetMetaData = getResultSetMetaData();

      int columnCount = resultSetMetaData.getColumnCount();

      if (_columnAsName != null) {

        for (int i = 1; i <= columnCount; i++) {
          String name = resultSetMetaData.getColumnName(i);
          if (name.equals(_columnAsName)) {
            _column = i;
            break;
          }
        }
      }

      _isValid = _column > 0 && _column <= columnCount;

      if (_isValid) {
        _jdbcType = resultSetMetaData.getColumnType(_column);
      }

      _isInit = true;

      return true;
    }

    public boolean bind()
      throws SQLException
    {
      if (!init())
        return false;

      if (!_isValid) {
        // this matches php behaviour
        _var.set(_env.getEmptyString());
      }
      else {
        Value value = getColumnValue(_column, _jdbcType, _type);

        _var.set(value);
      }

      return true;
    }
  }

  /**
   * Bind a value to a parameter when the statement is executed.
   */
  private class BindParam {
    private final int _index;
    private final Value _value;
    private final int _dataType;
    private final int _length;
    private final Value _driverOptions;

    public BindParam(Value parameter, Value value, int dataType, int length, Value driverOptions)
    {
      int index = resolveParameter(parameter);

      _index = index;
      _value = value;
      _dataType = dataType;
      _length = length;
      _driverOptions = driverOptions;
    }

    public boolean apply()
      throws SQLException
    {
      switch (_dataType) {
      case PDO.PARAM_BOOL:
      case PDO.PARAM_INT:
      case PDO.PARAM_STR:
	return setParameter(_index, _value.toValue(), _length);
      case PDO.PARAM_LOB:
	return setLobParameter(_index, _value.toValue(), _length);
      case PDO.PARAM_NULL:
	return setParameter(_index, NullValue.NULL, _length);
      case PDO.PARAM_STMT:
	throw new UnimplementedException("PDO.PARAM_STMT");
      default:
	throw new AssertionError();
      }
    }
  }
}