← Back to branch summary

~drizzle-trunk/drizzle/development

« back to all changes in this revision

Viewing changes to drizzled/field/uuid.cc

Merge in Monty's rename patch.

Show diffs side-by-side

added added

removed removed

Lines of Context:
drizzled/field/uuid.cc
19
19
 */
20
20
 
21
21
 
22
 
#include <config.h>
 
22
#include "config.h"
23
23
 
24
24
#include <algorithm>
25
25
 
26
26
#include <uuid/uuid.h>
27
27
 
28
 
#include <drizzled/field/uuid.h>
 
28
#include "drizzled/field/uuid.h"
29
29
 
30
 
#include <drizzled/error.h>
31
 
#include <drizzled/internal/my_sys.h>
32
 
#include <drizzled/session.h>
33
 
#include <drizzled/table.h>
 
30
#include "drizzled/error.h"
 
31
#include "drizzled/internal/my_sys.h"
 
32
#include "drizzled/session.h"
 
33
#include "drizzled/table.h"
 
34
#include "drizzled/temporal.h"
34
35
 
35
36
namespace drizzled
36
37
{
59
60
int Uuid::store(const char *from, uint32_t length, const CHARSET_INFO * const )
60
61
{
61
62
  ASSERT_COLUMN_MARKED_FOR_WRITE;
62
 
  type::Uuid uu;
 
63
  uuid_st uu;
63
64
 
64
65
  if (is_set)
65
66
  {
67
68
    return 0;
68
69
  }
69
70
 
70
 
  if (length != type::Uuid::DISPLAY_LENGTH)
 
71
  if (length != uuid_st::DISPLAY_LENGTH)
71
72
  {
72
73
    my_error(ER_INVALID_UUID_VALUE, MYF(ME_FATALERROR));
73
74
    return 1;
91
92
  return 1;
92
93
}
93
94
 
94
 
int Uuid::store_decimal(const drizzled::type::Decimal*)
 
95
int Uuid::store_decimal(const drizzled::my_decimal*)
95
96
{
96
97
  ASSERT_COLUMN_MARKED_FOR_WRITE;
97
98
  my_error(ER_INVALID_UUID_VALUE, MYF(ME_FATALERROR));
103
104
  res.set_ascii(STRING_WITH_LEN("uuid"));
104
105
}
105
106
 
106
 
double Uuid::val_real() const
 
107
double Uuid::val_real()
107
108
{
108
109
  ASSERT_COLUMN_MARKED_FOR_READ;
109
110
  my_error(ER_INVALID_UUID_VALUE, MYF(ME_FATALERROR));
110
111
  return 0;
111
112
}
112
113
 
113
 
int64_t Uuid::val_int() const
 
114
int64_t Uuid::val_int()
114
115
{
115
116
  ASSERT_COLUMN_MARKED_FOR_READ;
116
117
  my_error(ER_INVALID_UUID_VALUE, MYF(ME_FATALERROR));
133
134
}
134
135
#endif
135
136
 
136
 
String *Uuid::val_str(String *val_buffer, String *) const
 
137
String *Uuid::val_str(String *val_buffer, String *)
137
138
{
138
139
  const CHARSET_INFO * const cs= &my_charset_bin;
139
 
  uint32_t mlength= (type::Uuid::DISPLAY_BUFFER_LENGTH) * cs->mbmaxlen;
140
 
  type::Uuid uu;
 
140
  uint32_t mlength= (uuid_st::DISPLAY_BUFFER_LENGTH) * cs->mbmaxlen;
 
141
  uuid_st uu;
141
142
 
142
143
  val_buffer->alloc(mlength);
143
144
  char *buffer=(char*) val_buffer->ptr();
147
148
  uu.unpack(ptr);
148
149
  uu.unparse(buffer);
149
150
 
150
 
  val_buffer->length(type::Uuid::DISPLAY_LENGTH);
 
151
  val_buffer->length(uuid_st::DISPLAY_LENGTH);
151
152
 
152
153
  return val_buffer;
153
154
}
154
155
 
155
156
void Uuid::sort_string(unsigned char *to, uint32_t length_arg)
156
157
{
157
 
  assert(length_arg == type::Uuid::LENGTH);
 
158
  assert(length_arg == uuid_st::LENGTH);
158
159
  memcpy(to, ptr, length_arg);
159
160
}
160
161
 
161
 
bool Uuid::get_date(type::Time &ltime, uint32_t ) const
 
162
bool Uuid::get_date(DRIZZLE_TIME *ltime, uint32_t )
162
163
{
163
 
  type::Uuid uu;
 
164
  uuid_st uu;
164
165
 
165
166
  uu.unpack(ptr);
166
167
 
167
168
  if (uu.isTimeType())
168
169
  {
 
170
    Timestamp temporal;
169
171
    struct timeval ret_tv;
170
172
 
171
 
    memset(&ret_tv, 0, sizeof(struct timeval));
 
173
    ret_tv.tv_sec= ret_tv.tv_usec= 0;
172
174
 
173
175
    uu.time(ret_tv);
174
176
 
175
 
    ltime.store(ret_tv);
 
177
    temporal.from_time_t(ret_tv.tv_sec);
 
178
 
 
179
    ltime->time_type= DRIZZLE_TIMESTAMP_DATETIME;
 
180
    ltime->year= temporal.years();
 
181
    ltime->month= temporal.months();
 
182
    ltime->day= temporal.days();
 
183
    ltime->hour= temporal.hours();
 
184
    ltime->minute= temporal.minutes();
 
185
    ltime->second= temporal.seconds();
 
186
    ltime->second_part= temporal.nseconds();
176
187
 
177
188
    return false;
178
189
  }
179
 
  ltime.reset();
 
190
  memset(ltime, 0, sizeof(DRIZZLE_TIME));
180
191
 
181
192
  return true;
182
193
}
183
194
 
184
 
bool Uuid::get_time(type::Time &ltime) const
 
195
bool Uuid::get_time(DRIZZLE_TIME *ltime)
185
196
{
186
197
  return get_date(ltime, 0);
187
198
}