« back to all changes in this revision
Viewing changes to drizzled/dtcollation.cc
- browse files at revision 588
- compare with another revision
- compare with revision 202.1.16
- download diff
- download tarball
- view history from revision 588
- Committer: Brian Aker
- Date: 2008-11-16 02:13:14 UTC
- mfrom: (584.1.7 devel)
- Revision ID: brian@tangent.org-20081116021314-31uh0w1l0601cwd5
Merger from Monty
- files added:
- drizzled/dtcollation.cc
- files modified:
- client/client_priv.h
added
removed
drizzled/dtcollation.cc
1
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2
* vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3
*
4
* Copyright (C) 2008 Sun Microsystems
5
*
6
* This program is free software; you can redistribute it and/or modify
7
* it under the terms of the GNU General Public License as published by
8
* the Free Software Foundation; version 2 of the License.
9
*
10
* This program is distributed in the hope that it will be useful,
11
* but WITHOUT ANY WARRANTY; without even the implied warranty of
12
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
13
* GNU General Public License for more details.
14
*
15
* You should have received a copy of the GNU General Public License
16
* along with this program; if not, write to the Free Software
17
* Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
18
*/
19
20
#include <drizzled/server_includes.h>
21
#include <drizzled/definitions.h>
22
#include <mysys/my_sys.h>
23
#include <mystrings/m_ctype.h>
24
#include <drizzled/error.h>
25
26
#include <drizzled/dtcollation.h>
27
28
29
static bool
30
left_is_superset(const DTCollation &left, const DTCollation &right)
31
{
32
/* Allow convert to Unicode */
33
if (left.collation->state & MY_CS_UNICODE &&
34
(left.derivation < right.derivation ||
35
(left.derivation == right.derivation &&
36
!(right.collation->state & MY_CS_UNICODE))))
37
return true;
38
/* Allow convert from ASCII */
39
if (right.repertoire == MY_REPERTOIRE_ASCII &&
40
(left.derivation < right.derivation ||
41
(left.derivation == right.derivation &&
42
!(left.repertoire == MY_REPERTOIRE_ASCII))))
43
return true;
44
/* Disallow conversion otherwise */
45
return false;
46
}
47
48
49
DTCollation::DTCollation()
50
{
51
collation= &my_charset_bin;
52
derivation= DERIVATION_NONE;
53
repertoire= MY_REPERTOIRE_UNICODE30;
54
}
55
56
57
DTCollation::DTCollation(const CHARSET_INFO * const collation_arg,
58
Derivation derivation_arg)
59
{
60
collation= collation_arg;
61
derivation= derivation_arg;
62
set_repertoire_from_charset(collation_arg);
63
}
64
void DTCollation::set_repertoire_from_charset(const CHARSET_INFO * const cs)
65
{
66
repertoire= cs->state & MY_CS_PUREASCII ?
67
MY_REPERTOIRE_ASCII : MY_REPERTOIRE_UNICODE30;
68
}
69
70
71
void DTCollation::set(DTCollation &dt)
72
{
73
collation= dt.collation;
74
derivation= dt.derivation;
75
repertoire= dt.repertoire;
76
}
77
78
79
void DTCollation::set(const CHARSET_INFO * const collation_arg,
80
Derivation derivation_arg)
81
{
82
collation= collation_arg;
83
derivation= derivation_arg;
84
set_repertoire_from_charset(collation_arg);
85
}
86
87
88
void DTCollation::set(const CHARSET_INFO * const collation_arg,
89
Derivation derivation_arg,
90
uint32_t repertoire_arg)
91
{
92
collation= collation_arg;
93
derivation= derivation_arg;
94
repertoire= repertoire_arg;
95
}
96
97
98
void DTCollation::set(const CHARSET_INFO * const collation_arg)
99
{
100
collation= collation_arg;
101
set_repertoire_from_charset(collation_arg);
102
}
103
104
105
void DTCollation::set(Derivation derivation_arg)
106
{
107
derivation= derivation_arg;
108
}
109
110
111
bool DTCollation::aggregate(DTCollation &dt, uint32_t flags)
112
{
113
if (!my_charset_same(collation, dt.collation))
114
{
115
/*
116
We do allow to use binary strings (like BLOBS)
117
together with character strings.
118
Binaries have more precedence than a character
119
string of the same derivation.
120
*/
121
if (collation == &my_charset_bin)
122
{
123
if (derivation <= dt.derivation)
124
; // Do nothing
125
else
126
{
127
set(dt);
128
}
129
}
130
else if (dt.collation == &my_charset_bin)
131
{
132
if (dt.derivation <= derivation)
133
{
134
set(dt);
135
}
136
else
137
{
138
// Do nothing
139
}
140
}
141
else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
142
left_is_superset(*this, dt))
143
{
144
// Do nothing
145
}
146
else if ((flags & MY_COLL_ALLOW_SUPERSET_CONV) &&
147
left_is_superset(dt, *this))
148
{
149
set(dt);
150
}
151
else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
152
derivation < dt.derivation &&
153
dt.derivation >= DERIVATION_SYSCONST)
154
{
155
// Do nothing;
156
}
157
else if ((flags & MY_COLL_ALLOW_COERCIBLE_CONV) &&
158
dt.derivation < derivation &&
159
derivation >= DERIVATION_SYSCONST)
160
{
161
set(dt);
162
}
163
else
164
{
165
// Cannot apply conversion
166
set(0, DERIVATION_NONE, 0);
167
return 1;
168
}
169
}
170
else if (derivation < dt.derivation)
171
{
172
// Do nothing
173
}
174
else if (dt.derivation < derivation)
175
{
176
set(dt);
177
}
178
else
179
{
180
if (collation == dt.collation)
181
{
182
// Do nothing
183
}
184
else
185
{
186
if (derivation == DERIVATION_EXPLICIT)
187
{
188
set(0, DERIVATION_NONE, 0);
189
return 1;
190
}
191
if (collation->state & MY_CS_BINSORT)
192
return 0;
193
if (dt.collation->state & MY_CS_BINSORT)
194
{
195
set(dt);
196
return 0;
197
}
198
const CHARSET_INFO * const bin= get_charset_by_csname(collation->csname,
199
MY_CS_BINSORT,
200
MYF(0));
201
set(bin, DERIVATION_NONE);
202
}
203
}
204
repertoire|= dt.repertoire;
205
return 0;
206
}
207
208
209
bool DTCollation::set(DTCollation &dt1, DTCollation &dt2, uint32_t flags)
210
{ set(dt1); return aggregate(dt2, flags); }
211
212
213
const char *DTCollation::derivation_name() const
214
{
215
switch(derivation)
216
{
217
case DERIVATION_IGNORABLE: return "IGNORABLE";
218
case DERIVATION_COERCIBLE: return "COERCIBLE";
219
case DERIVATION_IMPLICIT: return "IMPLICIT";
220
case DERIVATION_SYSCONST: return "SYSCONST";
221
case DERIVATION_EXPLICIT: return "EXPLICIT";
222
case DERIVATION_NONE: return "NONE";
223
default: return "UNKNOWN";
224
}
225
}
226
227
228
bool agg_item_collations(DTCollation &c, const char *fname,
229
Item **av, uint32_t count,
230
uint32_t flags, int item_sep)
231
{
232
uint32_t i;
233
Item **arg;
234
c.set(av[0]->collation);
235
for (i= 1, arg= &av[item_sep]; i < count; i++, arg++)
236
{
237
if (c.aggregate((*arg)->collation, flags))
238
{
239
my_coll_agg_error(av, count, fname, item_sep);
240
return true;
241
}
242
}
243
if ((flags & MY_COLL_DISALLOW_NONE) &&
244
c.derivation == DERIVATION_NONE)
245
{
246
my_coll_agg_error(av, count, fname, item_sep);
247
return true;
248
}
249
return false;
250
}
251
252
253
bool agg_item_collations_for_comparison(DTCollation &c, const char *fname,
254
Item **av, uint32_t count,
255
uint32_t flags)
256
{
257
return (agg_item_collations(c, fname, av, count,
258
flags | MY_COLL_DISALLOW_NONE, 1));
259
}
260
261
262
bool agg_item_charsets(DTCollation &coll, const char *fname,
263
Item **args, uint32_t nargs, uint32_t flags,
264
int item_sep)
265
{
266
Item **arg, *safe_args[2];
267
268
memset(safe_args, 0, sizeof(safe_args));
269
270
if (agg_item_collations(coll, fname, args, nargs, flags, item_sep))
271
return true;
272
273
/*
274
For better error reporting: save the first and the second argument.
275
We need this only if the the number of args is 3 or 2:
276
- for a longer argument list, "Illegal mix of collations"
277
doesn't display each argument's characteristics.
278
- if nargs is 1, then this error cannot happen.
279
*/
280
if (nargs >=2 && nargs <= 3)
281
{
282
safe_args[0]= args[0];
283
safe_args[1]= args[item_sep];
284
}
285
286
Session *session= current_session;
287
bool res= false;
288
uint32_t i;
289
290
for (i= 0, arg= args; i < nargs; i++, arg+= item_sep)
291
{
292
Item* conv;
293
uint32_t dummy_offset;
294
if (!String::needs_conversion(0, (*arg)->collation.collation,
295
coll.collation,
296
&dummy_offset))
297
continue;
298
299
if (!(conv= (*arg)->safe_charset_converter(coll.collation)) &&
300
((*arg)->collation.repertoire == MY_REPERTOIRE_ASCII))
301
conv= new Item_func_conv_charset(*arg, coll.collation, 1);
302
303
if (!conv)
304
{
305
if (nargs >=2 && nargs <= 3)
306
{
307
/* restore the original arguments for better error message */
308
args[0]= safe_args[0];
309
args[item_sep]= safe_args[1];
310
}
311
my_coll_agg_error(args, nargs, fname, item_sep);
312
res= true;
313
break; // we cannot return here, we need to restore "arena".
314
}
315
if ((*arg)->type() == Item::FIELD_ITEM)
316
((Item_field *)(*arg))->no_const_subst= 1;
317
/*
318
If in statement prepare, then we create a converter for two
319
constant items, do it once and then reuse it.
320
If we're in execution of a prepared statement, arena is NULL,
321
and the conv was created in runtime memory. This can be
322
the case only if the argument is a parameter marker ('?'),
323
because for all true constants the charset converter has already
324
been created in prepare. In this case register the change for
325
rollback.
326
*/
327
session->change_item_tree(arg, conv);
328
/*
329
We do not check conv->fixed, because Item_func_conv_charset which can
330
be return by safe_charset_converter can't be fixed at creation
331
*/
332
conv->fix_fields(session, arg);
333
}
334
335
return res;
336
}
337
338
339
void my_coll_agg_error(DTCollation &c1,
340
DTCollation &c2, const char *fname)
341
{
342
my_error(ER_CANT_AGGREGATE_2COLLATIONS,MYF(0),
343
c1.collation->name,c1.derivation_name(),
344
c2.collation->name,c2.derivation_name(),
345
fname);
346
}
347
348
349
void my_coll_agg_error(DTCollation &c1,
350
DTCollation &c2,
351
DTCollation &c3,
352
const char *fname)
353
{
354
my_error(ER_CANT_AGGREGATE_3COLLATIONS,MYF(0),
355
c1.collation->name,c1.derivation_name(),
356
c2.collation->name,c2.derivation_name(),
357
c3.collation->name,c3.derivation_name(),
358
fname);
359
}
360
361
362
void my_coll_agg_error(Item** args, uint32_t count, const char *fname,
363
int item_sep)
364
{
365
if (count == 2)
366
my_coll_agg_error(args[0]->collation, args[item_sep]->collation, fname);
367
else if (count == 3)
368
my_coll_agg_error(args[0]->collation, args[item_sep]->collation,
369
args[2*item_sep]->collation, fname);
370
else
371
my_error(ER_CANT_AGGREGATE_NCOLLATIONS,MYF(0),fname);
372
}
373
Loggerhead is a web-based interface for Breezy
Version: 2.0.1