← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to server/item.cc

  • Committer: Brian Aker
  • Date: 2008-07-13 22:21:51 UTC
  • Revision ID: brian@tangent.org-20080713222151-fv2tcpbsc829j2oc
Ulonglong to uint64_t

Show diffs side-by-side

added added

removed removed

Lines of Context:
server/item.cc
97
97
  @todo
98
98
  what is '4' for scale?
99
99
*/
100
 
void Hybrid_type_traits_decimal::div(Hybrid_type *val, ulonglong u) const
 
100
void Hybrid_type_traits_decimal::div(Hybrid_type *val, uint64_t u) const
101
101
{
102
102
  int2my_decimal(E_DEC_FATAL_ERROR, u, true, &val->dec_buf[2]);
103
103
  /* XXX: what is '4' for scale? */
1826
1826
{
1827
1827
  // following assert is redundant, because fixed=1 assigned in constructor
1828
1828
  assert(fixed == 1);
1829
 
  str->set((ulonglong) value, &my_charset_bin);
 
1829
  str->set((uint64_t) value, &my_charset_bin);
1830
1830
  return str;
1831
1831
}
1832
1832
 
1835
1835
                      enum_query_type query_type __attribute__((__unused__)))
1836
1836
{
1837
1837
  // latin1 is good enough for numbers
1838
 
  str_value.set((ulonglong) value, default_charset());
 
1838
  str_value.set((uint64_t) value, default_charset());
1839
1839
  str->append(str_value);
1840
1840
}
1841
1841
 
2500
2500
      This works for example when user says SELECT ?+0.0 and supplies
2501
2501
      time value for the placeholder.
2502
2502
    */
2503
 
    return ulonglong2double(TIME_to_ulonglong(&value.time));
 
2503
    return uint64_t2double(TIME_to_uint64_t(&value.time));
2504
2504
  case NULL_VALUE:
2505
2505
    return 0.0;
2506
2506
  default:
2531
2531
                         str_value.length(), 10, (char**) 0, &dummy_err);
2532
2532
    }
2533
2533
  case TIME_VALUE:
2534
 
    return (longlong) TIME_to_ulonglong(&value.time);
 
2534
    return (longlong) TIME_to_uint64_t(&value.time);
2535
2535
  case NULL_VALUE:
2536
2536
    return 0; 
2537
2537
  default:
2558
2558
    return dec;
2559
2559
  case TIME_VALUE:
2560
2560
  {
2561
 
    longlong i= (longlong) TIME_to_ulonglong(&value.time);
 
2561
    longlong i= (longlong) TIME_to_uint64_t(&value.time);
2562
2562
    int2my_decimal(E_DEC_FATAL_ERROR, i, 0, dec);
2563
2563
    return dec;
2564
2564
  }
4565
4565
  char *end=(char*) str_value.ptr()+str_value.length(),
4566
4566
       *ptr=end-min(str_value.length(),sizeof(longlong));
4567
4567
 
4568
 
  ulonglong value=0;
 
4568
  uint64_t value=0;
4569
4569
  for (; ptr != end ; ptr++)
4570
 
    value=(value << 8)+ (ulonglong) (uchar) *ptr;
 
4570
    value=(value << 8)+ (uint64_t) (uchar) *ptr;
4571
4571
  return (longlong) value;
4572
4572
}
4573
4573
 
4576
4576
{
4577
4577
  // following assert is redundant, because fixed=1 assigned in constructor
4578
4578
  assert(fixed == 1);
4579
 
  ulonglong value= (ulonglong)val_int();
 
4579
  uint64_t value= (uint64_t)val_int();
4580
4580
  int2my_decimal(E_DEC_FATAL_ERROR, value, true, decimal_value);
4581
4581
  return (decimal_value);
4582
4582
}
4590
4590
    return field->store(str_value.ptr(), str_value.length(), 
4591
4591
                        collation.collation);
4592
4592
 
4593
 
  ulonglong nr;
 
4593
  uint64_t nr;
4594
4594
  uint32 length= str_value.length();
4595
4595
  if (length > 8)
4596
4596
  {
4597
4597
    nr= field->flags & UNSIGNED_FLAG ? ULONGLONG_MAX : LONGLONG_MAX;
4598
4598
    goto warn;
4599
4599
  }
4600
 
  nr= (ulonglong) val_int();
 
4600
  nr= (uint64_t) val_int();
4601
4601
  if ((length == 8) && !(field->flags & UNSIGNED_FLAG) && (nr > LONGLONG_MAX))
4602
4602
  {
4603
4603
    nr= LONGLONG_MAX;