C++ ObNumber类代码示例

inline void ObNumber::div_uint32(const ObNumber &dividend, uint32_t divisor, ObNumber &quotient, ObNumber &remainder)
{
    OB_ASSERT(0 < dividend.nwords_);
    OB_ASSERT(MAX_NWORDS >= dividend.nwords_);
    OB_ASSERT(0 < divisor);
    int64_t carry = 0;
    for (int i = dividend.nwords_ - 1; i >= 0; --i)
    {
        carry = carry * BASE + dividend.words_[i];
        quotient.words_[i] = static_cast<uint32_t> (carry / divisor);
        carry = carry % divisor;
    }
    quotient.nwords_ = dividend.nwords_;
    quotient.remove_leading_zeroes();

    if (0 == carry)
    {
        remainder.set_zero(); // remainder is zero
    }
    else
    {
        remainder.words_[0] = static_cast<uint32_t> (carry);
        remainder.nwords_ = 1;
    }
}

 static int int_decimal(const ObObjCastParams &params, const ObExprObj &in, ObExprObj &out)
 {
     UNUSED(params);
     OB_ASSERT(in.get_type() == ObIntType);
     ObNumber num;
     num.from(in.get_int());
     out.set_decimal(num); // @todo optimize
     return OB_SUCCESS;
 }

 static int mtime_decimal(const ObObjCastParams &params, const ObExprObj &in, ObExprObj &out)
 {
     UNUSED(params);
     OB_ASSERT(in.get_type() == ObModifyTimeType);
     ObNumber num;
     num.from(static_cast<int64_t> (in.get_mtime()));
     out.set_decimal(num);
     return OB_SUCCESS;
 }

void ObObj::print_value(FILE* fd)
{
  switch (get_type())
  {
    case ObNullType:
      fprintf(fd, "nil");
      break;
    case ObIntType:
      fprintf(fd, "%ld", value_.int_val);
      break;
    case ObVarcharType:
      fprintf(fd, "%.*s", val_len_, value_.varchar_val);
      break;
    case ObFloatType:
      fprintf(fd, "%2f", value_.float_val);
      break;
    case ObDoubleType:
      fprintf(fd, "%2lf", value_.double_val);
      break;
    case ObDateTimeType:
      fprintf(fd, "%s", time2str(value_.time_val));
      break;
    case ObPreciseDateTimeType:
      fprintf(fd, "%s", time2str(value_.precisetime_val));
      break;
    case ObModifyTimeType:
      fprintf(fd, "%s", time2str(value_.modifytime_val));
      break;
    case ObCreateTimeType:
      fprintf(fd, "%s", time2str(value_.createtime_val));
      break;
    case ObSeqType:
      fprintf(fd, "seq");
      break;
    case ObExtendType:
      fprintf(fd, "%lde", value_.ext_val);
      break;
    case ObBoolType:
      fprintf(fd, "%c", value_.bool_val ? 'Y': 'N');
      break;
    case ObDecimalType:
      {
        char num_buf[ObNumber::MAX_PRINTABLE_SIZE];
        ObNumber num;
        get_decimal(num);
        num.to_string(num_buf, ObNumber::MAX_PRINTABLE_SIZE);
        fprintf(fd, "%s", num_buf);
        break;
      }
    default:
      break;
  }
}

int ObNumber::cast_to_int64(int64_t &i64) const
{
    int ret = OB_SUCCESS;
    i64 = 0;
    bool is_neg = is_negative();
    ObNumber pos_clone = *this;
    if (is_neg)
    {
        negate(*this, pos_clone);
    }

    ObNumber remainder;
    int vscale = vscale_;
    int digits[DOUBLE_PRECISION_NDIGITS];
    int digit_idx = DOUBLE_PRECISION_NDIGITS - 1;
    while (!pos_clone.is_zero())
    {
        div_uint32(pos_clone, 10, pos_clone, remainder);
        if (vscale > 0)
        {
            vscale--;
        }
        else
        {
            OB_ASSERT(digit_idx >= 0);
            if (remainder.is_zero())
            {
                digits[digit_idx--] = 0;
            }
            else
            {
                OB_ASSERT(1 == remainder.nwords_);
                OB_ASSERT(remainder.words_[0] < 10 && remainder.words_[0] > 0);
                digits[digit_idx--] = remainder.words_[0];
            }
        } // end while
    }
    OB_ASSERT(digit_idx >= -1);
    for (int i = digit_idx + 1; i < DOUBLE_PRECISION_NDIGITS; ++i)
    {
        i64 = i64 * 10 + digits[i];
    }
    if (is_neg)
    {
        i64 = -i64;
    }
    return ret;
}

int ObObj::set_decimal(const ObNumber &num, int8_t precision, int8_t scale, bool is_add /*= false*/)
{
  int ret = OB_SUCCESS;
  set_flag(is_add);
  meta_.type_ = ObDecimalType;
  meta_.dec_precision_ = static_cast<uint8_t>(precision) & META_PREC_MASK;
  meta_.dec_scale_ = static_cast<uint8_t>(scale) & META_SCALE_MASK;
  int8_t nwords = 0;
  int8_t vscale = 0;
  uint32_t words[ObNumber::MAX_NWORDS];
  ret = num.round_to(precision, scale, nwords, vscale, words);
  if (OB_SUCCESS == ret)
  {
    if (nwords <= 3)
    {
      meta_.dec_nwords_ = static_cast<uint8_t>(nwords - 1) & META_NWORDS_MASK;
      meta_.dec_vscale_ = static_cast<uint8_t>(vscale) & META_VSCALE_MASK;
      memcpy(reinterpret_cast<uint32_t*>(&val_len_), words, sizeof(uint32_t)*nwords);
    }
    else
    {
      //@todo, use ob_pool.h to allocate memory
      ret = OB_NOT_IMPLEMENT;
    }
  }
  return ret;
}

int ObNumber::negate(ObNumber &res) const
{
    int ret = OB_SUCCESS;
    if (this->nwords_ >= MAX_NWORDS)
    {
        jlog(WARNING, "value out of range to do negate");
        ret = JD_VALUE_OUT_OF_RANGE;
    }
    else
    {
        res = *this;
        res.extend_words(static_cast<int8_t> (this->nwords_ + 1));
        negate(res, res);
        res.remove_leading_zeroes();
    }
    return ret;
}

int ObNumber::round_to(int8_t precision, int8_t scale, int8_t &nwords, int8_t &vscale, uint32_t *words) const
{
    OB_ASSERT(precision >= scale && 0 <= scale && NULL != words);
    int ret = OB_SUCCESS;
    ObNumber clone = *this;
    bool is_neg = is_negative();
    if (is_neg)
    {
        negate(clone, clone);
    }
    if (clone.vscale_ > scale)
    {
        clone.right_shift(static_cast<int8_t> (clone.vscale_ - scale));
        clone.remove_leading_zeroes();
    }
    ObNumber clone_clone = clone;
    int8_t vprec = 0;
    ObNumber remainder;
    while (!clone_clone.is_zero())
    {
        div_uint32(clone_clone, 10, clone_clone, remainder);
        clone_clone.remove_leading_zeroes();
        ++vprec;
    }
    if (vprec > precision)
    {
        ret = JD_VALUE_OUT_OF_RANGE;
        jlog(WARNING, "value is not representable with the precision and scale, p=%hhd s=%hhd vp=%hhd vs=%hhd",
                precision, scale, vprec, this->vscale_);
    }
    else
    {
        if (is_neg)
        {
            negate(clone, clone);
        }
        nwords = clone.nwords_;
        vscale = clone.vscale_;
        for (int8_t i = 0; i < clone.nwords_; ++i)
        {
            words[i] = clone.words_[i];
        }
    }
    return ret;
}

 static int varchar_decimal(const ObObjCastParams &params, const ObExprObj &in, ObExprObj &out)
 {
     int ret = OB_SUCCESS;
     UNUSED(params);
     OB_ASSERT(in.get_type() == ObVarcharType);
     const string &varchar = in.get_varchar();
     ObNumber num;
     if (OB_SUCCESS != (ret = num.from(varchar.data(), varchar.length())))
     {
         jlog(WARNING, "failed to convert varchar to decimal, err=%d varchar=%.*s",
                 ret, varchar.length(), varchar.data());
     }
     else
     {
         out.set_decimal(num); // @todo optimize
     }
     return OB_SUCCESS;
 }

int ObNumber::compare(const ObNumber &other) const
{
    int ret = 0;
    ObNumber res;
    if (OB_SUCCESS != this->sub(other, res))
    {
        // return 0 even if error occur
    }
    else if (res.is_negative())
    {
        ret = -1;
    }
    else if (!res.is_zero())
    {
        ret = 1;
    }
    return ret;
}

 static int double_decimal(const ObObjCastParams &params, const ObExprObj &in, ObExprObj &out)
 {
     int ret = OB_SUCCESS;
     UNUSED(params);
     OB_ASSERT(in.get_type() == ObDoubleType);
     static const int64_t MAX_DOUBLE_PRINT_SIZE = 64;
     char buf[MAX_DOUBLE_PRINT_SIZE];
     snprintf(buf, MAX_DOUBLE_PRINT_SIZE, "%f", in.get_double());
     ObNumber num;
     if (OB_SUCCESS != (ret = num.from(buf)))
     {
         jlog(WARNING, "failed to convert float to decimal, err=%d", ret);
     }
     else
     {
         out.set_decimal(num);
     }
     return ret;
 }

void ObNumber::round_fraction_part(int8_t scale)
{
    ObNumber *clone = this;
    ObNumber neg_this;
    bool is_neg = is_negative();
    if (is_neg)
    {
        negate(*this, neg_this);
        clone = &neg_this;
    }
    if (vscale_ > scale)
    {
        clone->right_shift(static_cast<int8_t> (vscale_ - scale));
    }
    if (is_neg)
    {
        negate(*clone, *this);
    }
    remove_leading_zeroes();
}

int ObObj::get_decimal(ObNumber &num, bool &is_add) const
{
  int ret = OB_OBJ_TYPE_ERROR;
  if (ObDecimalType == meta_.type_)
  {
    ret = OB_SUCCESS;
    is_add = (ADD == meta_.op_flag_);
    int8_t nwords = static_cast<int8_t>(meta_.dec_nwords_ + 1);
    int8_t vscale = meta_.dec_vscale_;
    if (nwords <= 3)
    {
      num.from(vscale, nwords, reinterpret_cast<const uint32_t*>(&val_len_));
    }
    else
    {
      num.from(vscale, nwords, value_.dec_words_);
    }
  }
  return ret;
}

int ObNumber::add(const ObNumber &other, ObNumber &res) const
{
    int ret = OB_SUCCESS;
    res.set_zero();
    ObNumber n1 = *this;
    ObNumber n2 = other;
    if (n1.vscale_ > SINGLE_PRECISION_NDIGITS)
    {
        n1.round_fraction_part(SINGLE_PRECISION_NDIGITS);
    }
    if (n2.vscale_ > SINGLE_PRECISION_NDIGITS)
    {
        n2.round_fraction_part(SINGLE_PRECISION_NDIGITS);
    }
    int8_t res_nwords = static_cast<int8_t> (std::max(n1.nwords_, n2.nwords_) + 1);
    if (res_nwords > MAX_NWORDS)
    {
        jlog(WARNING, "number out of range");
        ret = JD_VALUE_OUT_OF_RANGE;
    }
    else
    {
        n1.extend_words(res_nwords);
        n2.extend_words(res_nwords);
    }
    if (n1.vscale_ > n2.vscale_)
    {
        ret = n2.left_shift(static_cast<int8_t> (n1.vscale_ - n2.vscale_), false);
    }
    else if (n1.vscale_ < n2.vscale_)
    {
        ret = n1.left_shift(static_cast<int8_t> (n2.vscale_ - n1.vscale_), false);
    }
    if (OB_SUCCESS == ret)
    {
        add_words(n1, n2, res);
        res.remove_leading_zeroes();
    }
    return ret;
}

int ObNumber::mul(const ObNumber &other, ObNumber &res) const
{
    int ret = OB_SUCCESS;
    res.set_zero();
    if (!this->is_zero() && !other.is_zero())
    {
        ObNumber multiplicand = *this;
        ObNumber multiplier = other;
        bool res_is_neg = false;
        if (multiplicand.is_negative())
        {
            negate(multiplicand, multiplicand);
            res_is_neg = true;
        }
        if (multiplier.is_negative())
        {
            negate(multiplier, multiplier);
            res_is_neg = !res_is_neg;
        }
        if (multiplicand.vscale_ > SINGLE_PRECISION_NDIGITS)
        {
            multiplicand.round_fraction_part(SINGLE_PRECISION_NDIGITS);
        }
        if (multiplier.vscale_ > SINGLE_PRECISION_NDIGITS)
        {
            multiplier.round_fraction_part(SINGLE_PRECISION_NDIGITS);
        }
        res.vscale_ = static_cast<int8_t> (multiplicand.vscale_ + multiplier.vscale_);
        ret = mul_words(multiplicand, multiplier, res);
        res.remove_leading_zeroes();
        if (res_is_neg)
        {
            negate(res, res);
        }
    }
    return ret;
}