pdostatement.java

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

    if (fetchMode == 0) {
      effectiveFetchMode = _fetchMode;
    }
    else {
      effectiveFetchMode = 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");

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

    switch (effectiveFetchMode) {
      case PDO.FETCH_COLUMN:
        break;

      case PDO.FETCH_LAZY:
        _error.warning(L.l("PDO::FETCH_LAZY can't be used with PDOStatement::fetchAll()"));
        return BooleanValue.FALSE;

      default:
        if (columnIndex != -1) {
          _error.warning(L.l("unexpected arguments"));
          return BooleanValue.FALSE;
        }
    }

    ArrayValueImpl rows = new ArrayValueImpl();

    while (true) {
      Value value = fetchImpl(effectiveFetchMode, columnIndex);

      if (_fetchErrorCode == FETCH_FAILURE) {
        rows.clear();
        return rows;
      }

      if (_fetchErrorCode == FETCH_EXHAUSTED)
        break;

      if (_fetchErrorCode == FETCH_CONTINUE)
        continue;

      rows.put(value);
    }

    return rows;
  }

  private Value fetchAssoc()
  {
    try {
      if (!advanceResultSet()) {
        _fetchErrorCode = FETCH_EXHAUSTED;
        
        return BooleanValue.FALSE;
      }

      if (_fetchModeArgs.length != 0) {
        _error.notice(L.l("unexpected arguments"));
        
        _fetchErrorCode = FETCH_FAILURE;
        
        return BooleanValue.FALSE;
      }

      ArrayValueImpl array = new ArrayValueImpl();

      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        String name = getResultSetMetaData().getColumnName(i);
        Value value = getColumnValue(i);

        array.put(_env.createString(name), value);
      }

      return array;
    }
    catch (SQLException ex) {
      _error.error(ex);
      
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }
  }

  private Value fetchBoth()
  {
    try {
      if (! advanceResultSet()) {
        _fetchErrorCode = FETCH_EXHAUSTED;
        
        return BooleanValue.FALSE;
      }

      if (_fetchModeArgs.length != 0) {
        _error.notice(L.l("unexpected arguments"));
        
        _fetchErrorCode = FETCH_FAILURE;
        
        return BooleanValue.FALSE;
      }

      ArrayValueImpl array = new ArrayValueImpl();

      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        String name = getResultSetMetaData().getColumnName(i);
        Value value = getColumnValue(i);

        array.put(_env.createString(name), value);
        array.put(new LongValue(i - 1), value);
      }

      return array;
    }
    catch (SQLException ex) {
      _error.error(ex);
      
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }
  }

  private Value fetchBound()
  {
    if (!advanceResultSet()) {
      _fetchErrorCode = FETCH_EXHAUSTED;
      
      return BooleanValue.FALSE;
    }

    _fetchErrorCode = FETCH_SUCCESS;
    
    return BooleanValue.TRUE;
  }

  private Value fetchClass()
  {
    String className;
    Value[] ctorArgs;

    if (_fetchModeArgs.length == 0 || _fetchModeArgs.length > 2)
      return fetchBoth();

    className = _fetchModeArgs[0].toString();

    if (_fetchModeArgs.length == 2) {
      if (_fetchModeArgs[1].isArray()) {
        // XXX: inefiicient, but args[1].getValueArray(_env) doesn't handle references
        ArrayValue argsArray = (ArrayValue) _fetchModeArgs[1];

        ctorArgs = new Value[argsArray.getSize()];

        int i = 0;

        for (Value key : argsArray.keySet())
          ctorArgs[i++] = argsArray.getRef(key);
      }
      else
        return fetchBoth();
    }
    else
      ctorArgs = NULL_VALUES;

    return fetchObject(className, ctorArgs);
  }

  /**
   * @param column 0-based column number
   */
  public Value fetchColumn(@Optional int column)
  {
    if (!advanceResultSet()) {
      _fetchErrorCode = FETCH_EXHAUSTED;
      
      return BooleanValue.FALSE;
    }

    if (column < 0 && _fetchModeArgs.length > 0)
      column = _fetchModeArgs[0].toInt();

    try {
      if (column < 0 || column >= getResultSetMetaData().getColumnCount()) {
        _fetchErrorCode = FETCH_CONTINUE;
        
        return BooleanValue.FALSE;
      }

      return getColumnValue(column + 1);
    }
    catch (SQLException ex) {
      _error.error(ex);
      
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }
  }

  private Value fetchFunc()
  {
    throw new UnimplementedException();
  }

  /**
   * Fetch the next row.
   *
   * @param fetchMode the mode, 0 to use the value set by {@link #setFetchMode}.
   * @return a value, BooleanValue.FALSE if there are no more rows or an error occurs.
   */
  private Value fetchImpl(int fetchMode, int columnIndex)
  {
    if (fetchMode == 0) {
      fetchMode = _fetchMode;

      fetchMode = fetchMode & (~(PDO.FETCH_GROUP | PDO.FETCH_UNIQUE));
    }
    else {
      if ((fetchMode & PDO.FETCH_GROUP) != 0) {
        _error.warning(L.l("FETCH_GROUP is not allowed"));
        return BooleanValue.FALSE;
      }
      else if ((fetchMode & PDO.FETCH_UNIQUE) != 0) {
        _error.warning(L.l("FETCH_UNIQUE is not allowed"));
        return BooleanValue.FALSE;
      }
    }

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

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

    _fetchErrorCode = FETCH_SUCCESS;
    
    switch (fetchMode) {
      case PDO.FETCH_ASSOC:
        return fetchAssoc();

      case PDO.FETCH_BOTH:
        return fetchBoth();

      case PDO.FETCH_BOUND:
        return fetchBound();

      case PDO.FETCH_COLUMN:
        return fetchColumn(columnIndex);

      case PDO.FETCH_CLASS:
        return fetchClass();

      case PDO.FETCH_FUNC:
        return fetchFunc();

      case PDO.FETCH_INTO:
        return fetchInto();

      case PDO.FETCH_LAZY:
        return fetchLazy();

      case PDO.FETCH_NAMED:
        return fetchNamed();

      case PDO.FETCH_NUM:
        return fetchNum();

      case PDO.FETCH_OBJ:
        return fetchObject();

    default:
      _error.warning(L.l("invalid fetch mode {0}",  fetchMode));
      closeCursor();
      return BooleanValue.FALSE;
    }
  }

  private Value fetchInto()
  {
    assert _fetchModeArgs.length > 0;
    assert _fetchModeArgs[0].isObject();

    Value var = _fetchModeArgs[0];

    if (!advanceResultSet()) {
      _fetchErrorCode = FETCH_EXHAUSTED;
      
      return BooleanValue.FALSE;
    }

    try {
      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        String name = getResultSetMetaData().getColumnName(i);
        Value value = getColumnValue(i);

        var.putField(_env, name, value);
      }
    }
    catch (SQLException ex) {
      _error.error(ex);
      
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }

    return var;
  }

  private Value fetchLazy()
  {
    // XXX: need to check why lazy is no different than object
    return fetchObject(null, NULL_VALUES);
  }

  private Value fetchNamed()
  {
    try {
      if (!advanceResultSet()) {
        _fetchErrorCode = FETCH_EXHAUSTED;
        
        return BooleanValue.FALSE;
      }

      ArrayValue array = new ArrayValueImpl();

      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        Value name = _env.createString(getResultSetMetaData().getColumnName(i));
        Value value = getColumnValue(i);

        Value existingValue = array.get(name);

        if (! (existingValue instanceof UnsetValue)) {

          if (! existingValue.isArray()) {
            ArrayValue arrayValue = new ArrayValueImpl();
            arrayValue.put(existingValue);
            array.put(name, arrayValue);
            existingValue = arrayValue;
          }

          existingValue.put(value);
        }
        else
          array.put(name, value);
      }

      return array;
    }
    catch (SQLException ex) {
      _error.error(ex);
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }
  }

  private Value fetchNum()
  {
    try {
      if (!advanceResultSet()) {
        _fetchErrorCode = FETCH_EXHAUSTED;
        
        return BooleanValue.FALSE;
      }

      if (_fetchModeArgs.length != 0) {
        _error.notice(L.l("unexpected arguments"));
        
        _fetchErrorCode = FETCH_FAILURE;
        
        return BooleanValue.FALSE;
      }

      ArrayValueImpl array = new ArrayValueImpl();

      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        Value value = getColumnValue(i);

        array.put(value);
      }

      return array;
    }
    catch (SQLException ex) {
      _error.error(ex);
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }
  }

  private Value fetchObject()
  {
    return fetchObject(null, NULL_VALUES);
  }

  public Value fetchObject(@Optional String className, @Optional Value[] args)
  {
    QuercusClass cl;

    if (className != null) {
      cl = _env.findAbstractClass(className);

      if (cl == null)
        return fetchBoth();
    }
    else {
      cl = null;

      if (args.length != 0) {
        advanceResultSet();
        _error.warning(L.l("unexpected arguments"));
        return BooleanValue.FALSE;
      }
    }

    if (!advanceResultSet()) {
      _fetchErrorCode = FETCH_EXHAUSTED;
      
      return BooleanValue.FALSE;
    }

    try {
      Value object;

      if (cl != null)
        object = cl.callNew(_env, args);
      else
        object = _env.createObject();

      int columnCount = getResultSetMetaData().getColumnCount();

      for (int i = 1; i <= columnCount; i++) {
        String name = getResultSetMetaData().getColumnName(i);
        Value value = getColumnValue(i);

        object.putField(_env, name, value);
      }

      return object;
    }
    catch (Throwable ex) {
      _error.error(ex);
      _fetchErrorCode = FETCH_FAILURE;
      
      return BooleanValue.FALSE;
    }

  }

  public Value getAttribute(int attribute)
  {
    _error.unsupportedAttribute(attribute);

    return BooleanValue.FALSE;
  }

  /**
   * @param column 0-based column index
   */
  public Value getColumnMeta(int column)
  {
    throw new UnimplementedException();
  }

  /**
   * @param column 1-based column index
   */
  private Value getColumnValue(int column)
    throws SQLException
  {
    return getColumnValue(column, -1, -1);
  }

  /**
   * @param column 1-based column index
   * @param jdbcType a jdbc type, or -1 if it is unknown
   * @param returnType a PDO.PARAM_* type, or -1
   */
  private Value getColumnValue(int column, int jdbcType, int returnType)
    throws SQLException
  {
    if (returnType != -1)
      throw new UnimplementedException("parm type " + returnType);

    if (jdbcType == -1)
      jdbcType = getResultSetMetaData().getColumnType(column);

    // XXX: needs tests

    switch (jdbcType) {
      case Types.NULL:
        return NullValue.NULL;

      case Types.BIT:
      case Types.TINYINT:
      case Types.SMALLINT:
      case Types.INTEGER:
      case Types.BIGINT: