postgresmodule.java

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

  {
    try {

      // NOTE: pg_fetch_array has an interesting memory feature.
      // Calls to pg_fetch_array usually return the next row for
      // successive calls. There is an exception though.
      // The first time a NULL row is passed in, the previously
      // returned row is returned again. After that, successive
      // calls return the next row as usual.
      // We set a flag for this. See PostgresResult and php/4342

      if (row.isNull()) {
        if (result.getPassedNullRow()) {
          result.setPassedNullRow();
        } else {
          // Step the cursor back to the previous position
          ResultSet rs = result.getResultSet();
          rs.previous();
        }
      }

      // NOTE: row is of type Value because row is optional and there is
      // only one way to specify that 'row' will not be used:
      //
      // pg_fetch_array(result, NULL, resultType)
      //
      // The resultType will be used above though.
      //
      // For such a case, the marshalling code passes row in as NullValue.NULL
      // If we used 'int row' there would be no way to distinguish row 'zero'
      // from row 'null'.

      if (result == null)
        return  null;

      if (row.isLongConvertible() && row.toInt() >= 0) {
        if (!result.seek(env, row.toInt())) {
          env.warning(L.l("Unable to jump to row {0} on PostgreSQL result",
                          row.toInt()));
          return null;
        }
      }

      return result.fetchArray(env, resultType);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Fetch a row as an associative array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_assoc(Env env,
                                          @NotNull PostgresResult result,
                                          @Optional("-1") Value row)
  {
    try {
      if (! row.isNull() && row.toInt() >= 0) {
        result.seek(env, row.toInt());
      }

      return result.fetchAssoc(env);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Fetch a row as an object
   */
  public static Value pg_fetch_object(Env env,
                                      @NotNull PostgresResult result,
                                      @Optional("-1") Value row,
                                      @Optional int resultType)
  {
    try {

      //@todo use optional resultType
      if ((row != null) && (!row.equals(NullValue.NULL)) && (row.toInt() >= 0)) {
        result.seek(env, row.toInt());
      }

      Value resultValue =  result.fetchObject(env);

      // php/430l
      if (resultValue.isNull())
        return BooleanValue.FALSE;
      else
        return resultValue;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }

  /**
   * Returns values from a result resource
   */
  public static Value pg_fetch_result(Env env,
                                      @NotNull PostgresResult result,
                                      Value row,
                                      @Optional("-1") Value fieldNameOrNumber)
  {
    try {

      // NOTE: row is of type Value because there is a case where
      // row is optional. In such a case, the row value passed in
      // is actually the field number or field name.

      int rowNumber = -1;

      // Handle the case: optional row with mandatory fieldNameOrNumber.
      if (fieldNameOrNumber.isLongConvertible() &&
          (fieldNameOrNumber.toInt() < 0)) {
        fieldNameOrNumber = row;
        rowNumber = -1;
      } else {
        rowNumber = row.toInt();
      }

      if (rowNumber >= 0) {
        result.seek(env, rowNumber);
      }

      Value fetchRow = result.fetchRow(env);

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      return fetchRow.get(LongValue.create(fieldNumber));

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }
  
  /**
   * Returns values from a result resource
   */
  public static Value pg_result(Env env,
                                @NotNull PostgresResult result,
                                Value row,
                                @Optional("-1") Value fieldNameOrNumber)
  {
    return pg_fetch_result(env, result, row, fieldNameOrNumber);
  }

  /**
   * Get a row as an enumerated array
   */
  @ReturnNullAsFalse
  public static ArrayValue pg_fetch_row(Env env,
                                        @NotNull PostgresResult result,
                                        @Optional("-1") Value row)
  {
    try {

      if ((row != null) && (!row.equals(NullValue.NULL)) && (row.toInt() >= 0)) {
        result.seek(env, row.toInt());
      }

      return result.fetchRow(env);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * Test if a field is SQL NULL
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_is_null(Env env,
                                           @NotNull PostgresResult result,
                                           Value row,
                                           @Optional("-1") Value fieldNameOrNumber)
  {
    try {

      // NOTE: row is of type Value because there is a case where
      // row is optional. In such a case, the row value passed in
      // is actually the field number or field name.

      int rowNumber = -1;

      // Handle the case: optional row with mandatory fieldNameOrNumber.
      if (fieldNameOrNumber.isLongConvertible() &&
          (fieldNameOrNumber.toInt() == -1)) {
        fieldNameOrNumber = row;
        rowNumber = -1;
      } else {
        rowNumber = row.toInt();
      }

      if (rowNumber >= 0) {
        if (!result.seek(env, rowNumber)) {
          env.warning(L.l("Unable to jump to row {0} on PostgreSQL result",
                          rowNumber));
          return null;
        }
      }

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      Value field = pg_fetch_result(env,
                                    result,
                                    LongValue.MINUS_ONE,
                                    LongValue.create(fieldNumber));

      if (field == null || field.isNull())
        return LongValue.ONE;
      else
        return LongValue.ZERO;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_field_is_null() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_fieldisnull(Env env,
                                         @NotNull PostgresResult result,
                                         Value row,
                                         @Optional("-1") Value fieldNameOrNumber)
  {
    return pg_field_is_null(env, result, row, fieldNameOrNumber);
  }
  
  /**
   * Returns the name of a field
   */
  public static Value pg_field_name(Env env,
                                    @NotNull PostgresResult result,
                                    int fieldNumber)
  {
    try {

      if (result == null)
        return BooleanValue.FALSE;

      return result.getFieldName(env, fieldNumber);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return BooleanValue.FALSE;
    }
  }

  /**
   * pg_field_name() alias.
   */
  public static Value pg_fieldname(Env env,
                                   @NotNull PostgresResult result,
                                   int fieldNumber)
  {
    return pg_field_name(env, result, fieldNumber);
  }
  
  /**
   * Returns the field number of the named field
   *
   * @return the field number (0-based) or -1 on error
   */
  public static int pg_field_num(Env env,
                                 @NotNull PostgresResult result,
                                 String fieldName)
  {
    try {

      return result.getColumnNumber(fieldName);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * pg_field_num() alias.
   */
  public static int pg_fieldnum(Env env,
                                @NotNull PostgresResult result,
                                String fieldName)
  {
    return pg_field_num(env, result, fieldName);
  }
  
  /**
   * Returns the printed length
   */
  public static int pg_field_prtlen(Env env,
                                    @NotNull PostgresResult result,
                                    Value rowNumber,
                                    @Optional("-1") Value fieldNameOrNumber)
  {
    try {
      int row = rowNumber.toInt();

      if (fieldNameOrNumber.toString().equals("-1")) {
        fieldNameOrNumber = rowNumber;
        row = -1;
      }

      int fieldNumber = result.getColumnNumber(fieldNameOrNumber, 0);

      ResultSetMetaData metaData = result.getMetaData();
      String typeName = metaData.getColumnTypeName(fieldNumber+1);
      if (typeName.equals("bool")) {
        return 1;
      }

      Value value = pg_fetch_result(env,
                                    result,
                                    LongValue.create(row),
                                    LongValue.create(fieldNumber));

      // Step the cursor back to the original position
      // See php/430p
      result.getResultSet().previous();

      int len = value.toString().length();

      // XXX: check this...
      // if (typeName.equals("money")) {
      //  len++;
      // }

      return len;

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return -1;
    }
  }

  /**
   * pg_field_ptrlen() alias.
   */
  public static int pg_fieldprtlen(Env env,
                                   @NotNull PostgresResult result,
                                   Value rowNumber,
                                   @Optional("-1") Value fieldNameOrNumber)
  {
    return pg_field_prtlen(env, result, rowNumber, fieldNameOrNumber);
  }
  
  /**
   * Returns the internal storage size of the named field
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_size(Env env,
                                        @NotNull PostgresResult result,
                                        int fieldNumber)
  {
    try {

      ResultSetMetaData metaData = result.getMetaData();

      fieldNumber++;

      int dataType = metaData.getColumnType(fieldNumber);

      int size = -1;

      switch (dataType) {
      case Types.BIT:
        {
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("bool")) {
            size = 1;
          }
          break;
        }

      case Types.TINYINT:
        size = 1;
        break;

      case Types.SMALLINT:
        size = 2;
        break;

      case Types.DATE:
      case Types.FLOAT:
      case Types.INTEGER:
      case Types.REAL:
        size = 4;
        break;

      case Types.BIGINT:
      case Types.DOUBLE:
        {
          size = 8;
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("money")) {
            size = 4;
          }
        }
        break;

      case Types.TIME:
      case Types.TIMESTAMP:
        size = 8;
        // fall to specific cases

      default:
        {
          String typeName = metaData.getColumnTypeName(fieldNumber);
          if (typeName.equals("timetz") ||
              typeName.equals("interval")) {
            size = 12;
          } else if (typeName.equals("macaddr")) {
            size = 6;
          } else if (typeName.equals("point")) {
            size = 16;
          } else if (typeName.equals("circle")) {
            size = 24;
          } else if (typeName.equals("box") ||
                     typeName.equals("lseg")) {
            size = 32;
          }
        }
      }

      return LongValue.create(size);

    } catch (Exception ex) {
      log.log(Level.FINE, ex.toString(), ex);
      return null;
    }
  }

  /**
   * pg_field_size() alias.
   */
  @ReturnNullAsFalse
  public static LongValue pg_fieldsize(Env env,
                                       @NotNull PostgresResult result,
                                       int fieldNumber)
  {
    return pg_field_size(env, result, fieldNumber);
  }
  
  /**
   * Returns the name or oid of the tables field
   *
   * @return By default the tables name that field belongs to
   * is returned but if oid_only is set to TRUE,
   * then the oid will instead be returned.
   */
  @ReturnNullAsFalse
  public static String pg_field_table(Env env,
                                      @NotNull PostgresResult result,
                                      int fieldNumber,
                                      @Optional("false") boolean oidOnly)
  {
    // The Postgres JDBC driver doesn't have a concept of exposing to the client
    // what table maps to a particular select item in a result set, therefore the
    // driver cannot report anything useful to the caller. Thus the driver always
    // returns "" to ResultSetMetaData.getTableName(fieldNumber+1)

    env.stub("pg_field_table");

    return "";
  }

  /**
   * Returns the type ID (OID) for the corresponding field number
   */
  @ReturnNullAsFalse
  public static LongValue pg_field_type_oid(Env env,
                                            @NotNull PostgresResult result,
                                            int fieldNumber)
  {
    try {

      ResultSetMetaData metaData = result.getMetaData();

      String columnTypeName = metaData.getColumnTypeName(fieldNumber + 1);

      String metaQuery = ("SELECT oid FROM pg_type WHERE typname='" + columnTypeName + "'");

      result = pg_query(env, (Postgres) result.getConnection(), metaQuery);

      Value value = pg_fetch_result(env,
                                    result,