jdbcresultresource.java

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

          // else fall to boolean
        }

      case Types.BOOLEAN:
        {
          boolean b = rs.getBoolean(column);
          if (rs.wasNull())
            return NullValue.NULL;
          else
            return env.createString(b ? "t" : "f");
        }

      case Types.TINYINT:
      case Types.SMALLINT:
      case Types.INTEGER:
      case Types.BIGINT:
        {
          long value = rs.getLong(column);

          if (rs.wasNull())
            return NullValue.NULL;
          else
            return _env.createString(String.valueOf(value));
        }
      case Types.REAL:
      case Types.DOUBLE:
        {
          double value = rs.getDouble(column);

          if (rs.wasNull())
            return NullValue.NULL;
          else {
            StringValue sb = _env.createUnicodeBuilder();
            if (metaData.isCurrency(column)) {
              sb.append("$");
            }
            return sb.append(value);
          }
        }

      case Types.BLOB:
        {
          Object object = rs.getBlob(column);
          if (object.getClass().getName().equals("oracle.sql.BLOB")) {
            OracleOciLob ociLob = new OracleOciLob((Oracle) _conn,
                                                   OracleModule.OCI_D_LOB);
            ociLob.setLob(object);
            object = ociLob;
          }
          return env.wrapJava(object);
        }

      case Types.CLOB:
        {
          Object object = rs.getClob(column);
          if (object.getClass().getName().equals("oracle.sql.CLOB")) {
            OracleOciLob ociLob = new OracleOciLob((Oracle) _conn,
                                                   OracleModule.OCI_D_LOB);
            ociLob.setLob(object);
            object = ociLob;
          }
          return env.wrapJava(object);
        }

      case Types.LONGVARBINARY:
      case Types.VARBINARY:
      case Types.BINARY:
        {
          StringValue bb = env.createBinaryBuilder();

          InputStream is = rs.getBinaryStream(column);

          if (is == null) // || rs.wasNull())
            return NullValue.NULL;

	  try {
	    bb.appendReadAll(is, Long.MAX_VALUE / 2);
          } catch (RuntimeException e) {
            log.log(Level.WARNING, e.toString(), e);

            return NullValue.NULL;
          }

          return bb;
        }

      case Types.VARCHAR:
      case Types.LONGVARCHAR:
      {
        StringValue bb = env.createUnicodeBuilder();
        
        try {
          if (bb.isUnicode()) {
            Reader reader = rs.getCharacterStream(column);
            
            if (reader == null) // || rs.wasNull())
              return NullValue.NULL;
            
            bb.append(reader);
          }
          else {
            byte []bytes = null;
            
            if (metaData.getClass().getName().equals("com.mysql.jdbc.ResultSetMetaData")) {
              // calling getString() will decode using the database encoding
              String s = rs.getString(column);
              
              if (s == null)
                return NullValue.NULL;
              
              // php/1464, php/144f, php/144g
              // attempt to convert to latin1 bytes,
              // conversion may fail if there was a mismatch between database
              // encoding and latin1 (implying that the database didn't encode
              // the data that went into it)
              bytes = MysqlLatin1Utility.encode(s);
            }
            
            // php/144b
            if (bytes == null)
              bytes = rs.getBytes(column);

	    if (bytes != null)
	      bb.append(bytes);
            
            return bb;
          }
        } catch (RuntimeException e) {
          log.log(Level.WARNING, e.toString(), e);

          return NullValue.NULL;
        }

        return bb;
      }

      case Types.TIME:
	return getColumnTime(env, rs, column);
	
      case Types.TIMESTAMP:
	return getColumnTimestamp(env, rs, column);
	
      case Types.DATE:
	return getColumnDate(env, rs, column);
	
      default:
        {
          String strValue = rs.getString(column);

          if (strValue == null) // || rs.wasNull())
            return NullValue.NULL;
          else
            return env.createString(strValue);
        }
      }
    } catch (IOException e) {
      log.log(Level.FINE, e.toString(), e);
      
      return NullValue.NULL;
    } catch (SQLException e) {
      // php/141e
      log.log(Level.FINE, e.toString(), e);

      return NullValue.NULL;
    }
  }

  protected Value getColumnTime(Env env, ResultSet rs, int column)
    throws SQLException
  {
    Time time = rs.getTime(column);
    
    if (time == null)
      return NullValue.NULL;
    else
      return env.createString(String.valueOf(time));
  }

  protected Value getColumnDate(Env env, ResultSet rs, int column)
    throws SQLException
  {
    Date date = rs.getDate(column);
    
    if (date == null)
      return NullValue.NULL;
    else
      return env.createString(String.valueOf(date));
  }

  protected Value getColumnTimestamp(Env env, ResultSet rs, int column)
    throws SQLException
  {
    try {
      Timestamp timestamp = rs.getTimestamp(column);

      if (timestamp == null)
        return NullValue.NULL;
      else {
        String time = String.valueOf(timestamp);
        
        // the .0 nanoseconds at the end may not matter, but strip it out
        // anyways to match php (postgresql)
        if (time.endsWith(".0"))
          time = time.substring(0, time.length() - 2);
        
        return env.createString(time);
      }
    } catch (SQLException e) {
      if (log.isLoggable(Level.FINE))
	log.log(Level.FINE, e.toString(), e);

      // php/1f0a - mysql jdbc driver issue with zero timestamp
      return env.createString("0000-00-00 00:00:00");
    }
  }

  /**
   * Get the connection corresponding to this result resource.
   *
   * @return a JDBC connection resource
   */
  public JdbcConnectionResource getConnection()
  {
    return _conn;
  }

  /**
   * Get the field catalog name.
   *
   * @param fieldOffset the field number
   * @return the field catalog name
   */
  public Value getFieldCatalog(int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0)
        return BooleanValue.FALSE;
      else
        return _env.createString(md.getCatalogName(fieldOffset + 1));
    } catch (SQLException e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns column count.
   *
   * @return the number of columns in the result set
   */
  public int getFieldCount()
  {
    try {
      return getMetaData().getColumnCount();
    } catch (SQLException e) {
      throw new RuntimeException(e);
    }
  }

  /**
   * Return true is the field offset is valid, meaning it
   * is larger than 0 and is less that the max number
   * of fields in this result resource.
   */
  protected boolean isValidFieldOffset(int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (fieldOffset < 0 || md.getColumnCount() <= fieldOffset)
        return false;
      else
        return true;
    } catch (SQLException e) {
      log.log(Level.FINE, e.toString(), e);
      return false;
    }
  }

  /**
   * Return true if the String result at the
   * given index of the ResultSet contains
   * the substring.
   */

  protected boolean isInResultString(int columnIndex, String substring)
    throws SQLException
  {
    String resultString = _rs.getString(columnIndex);

    if (resultString == null)
      return false;

    int index = resultString.indexOf(substring);

    if (index == -1)
      return false;
    else
      return true;
  }

  /**
   * Get field length. This is the length of the field
   * as defined in the table declaration.
   *
   * @param env the PHP executing environment
   * @param fieldOffset the field number (0-based)
   * @return length of field for specified column
   */
  public Value getFieldLength(Env env, int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0) {
        env.invalidArgument("field", fieldOffset);
        return BooleanValue.FALSE;
      }
      else
        return new LongValue((long) md.getPrecision(fieldOffset + 1));

    } catch (SQLException e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns the column name.
   *
   * @param env the PHP executing environment
   * @param fieldOffset 0-based field offset
   *
   * @return a StringValue containing the column name
   */
  public Value getFieldName(Env env, int fieldOffset)
  {

    try {
      ResultSetMetaData md = getMetaData();
      
      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0) {
        env.invalidArgument("field", fieldOffset);
        return BooleanValue.FALSE;
      }
      else
        return env.createString(md.getColumnLabel(fieldOffset + 1));
    } catch (Exception e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns a StringValue containing the column Alias.
   *
   * @param fieldOffset 0-based field offset
   *
   * @return the column alias
   */
  public Value getFieldNameAlias(int fieldOffset)
  {

    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0)
        return BooleanValue.FALSE;
      else
        return _env.createString(md.getColumnLabel(fieldOffset + 1));
    } catch (Exception e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns the column name.
   *
   * @param env the PHP executing environment
   * @param fieldOffset 0-based field offset
   *
   * @return int(1) if the column is nullable, int(1) if it is not
   */
  public Value getFieldNotNull(Env env, int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0) {
        env.invalidArgument("field", fieldOffset);
        return BooleanValue.FALSE;
      }
      else
        if  (md.isNullable(fieldOffset + 1) == ResultSetMetaData.columnNoNulls)
          return LongValue.ONE;
        else
          return LongValue.ZERO;
    } catch (Exception e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Get field offset.
   *
   * @return the current field offset
   */
  public int getFieldOffset()
  {
    return _fieldOffset;
  }

  /**
   * Get field scale.
   *
   * @param fieldOffset the field offset
   * @return number of digits to the right of the decimal point
   */
  public Value getFieldScale(int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0)
        return BooleanValue.FALSE;
      else
        return new LongValue((long) md.getScale(fieldOffset + 1));

    } catch (SQLException e) {
      log.log(Level.FINE, e.toString(), e);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns the table corresponding to the field.
   *
   * @param env the PHP executing environment
   * @param fieldOffset the field number
   * @return the field table name
   */
  public Value getFieldTable(Env env, int fieldOffset)
  {
    try {
      ResultSetMetaData md = getMetaData();

      if (md.getColumnCount() <= fieldOffset || fieldOffset < 0) {
        env.invalidArgument("field", fieldOffset);
        return BooleanValue.FALSE;
      }
      else {