Drizzled Public API Documentation

field.cc
1 /* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
2  * vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
3  *
4  * Copyright (C) 2010 Brian Aker
5  * Copyright (C) 2008 MySQL
6  *
7  * This program is free software; you can redistribute it and/or modify
8  * it under the terms of the GNU General Public License as published by
9  * the Free Software Foundation; either version 2 of the License, or
10  * (at your option) any later version.
11  *
12  * This program is distributed in the hope that it will be useful,
13  * but WITHOUT ANY WARRANTY; without even the implied warranty of
14  * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
15  * GNU General Public License for more details.
16  *
17  * You should have received a copy of the GNU General Public License
18  * along with this program; if not, write to the Free Software
19  * Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA 02110-1301 USA
20  */
21 
26 #include <config.h>
27 #include <cstdio>
28 #include <errno.h>
29 #include <float.h>
30 #include <drizzled/sql_select.h>
31 #include <drizzled/error.h>
32 #include <drizzled/field/str.h>
33 #include <drizzled/field/num.h>
34 #include <drizzled/field/blob.h>
35 #include <drizzled/field/boolean.h>
36 #include <drizzled/field/enum.h>
37 #include <drizzled/field/null.h>
38 #include <drizzled/field/date.h>
39 #include <drizzled/field/decimal.h>
40 #include <drizzled/field/real.h>
41 #include <drizzled/field/double.h>
42 #include <drizzled/field/int32.h>
43 #include <drizzled/field/int64.h>
44 #include <drizzled/field/num.h>
45 #include <drizzled/field/time.h>
46 #include <drizzled/field/epoch.h>
47 #include <drizzled/field/datetime.h>
48 #include <drizzled/field/microtime.h>
49 #include <drizzled/field/varstring.h>
50 #include <drizzled/field/uuid.h>
51 #include <drizzled/field/ipv6.h>
52 #include <drizzled/time_functions.h>
53 #include <drizzled/internal/m_string.h>
54 #include <drizzled/table.h>
55 #include <drizzled/util/test.h>
56 #include <drizzled/session.h>
57 #include <drizzled/current_session.h>
58 #include <drizzled/display.h>
59 #include <drizzled/typelib.h>
60 #include <drizzled/create_field.h>
61 
62 namespace drizzled {
63 
64 /*****************************************************************************
65  Instansiate templates and static variables
66 *****************************************************************************/
67 
68 static enum_field_types
69 field_types_merge_rules [enum_field_types_size][enum_field_types_size]=
70 {
71  /* DRIZZLE_TYPE_LONG -> */
72  {
73  //DRIZZLE_TYPE_LONG
74  DRIZZLE_TYPE_LONG,
75  //DRIZZLE_TYPE_DOUBLE
76  DRIZZLE_TYPE_DOUBLE,
77  //DRIZZLE_TYPE_NULL
78  DRIZZLE_TYPE_LONG,
79  //DRIZZLE_TYPE_TIMESTAMP
80  DRIZZLE_TYPE_VARCHAR,
81  //DRIZZLE_TYPE_LONGLONG
82  DRIZZLE_TYPE_LONGLONG,
83  //DRIZZLE_TYPE_DATETIME
84  DRIZZLE_TYPE_VARCHAR,
85  //DRIZZLE_TYPE_DATE
86  DRIZZLE_TYPE_VARCHAR,
87  //DRIZZLE_TYPE_VARCHAR
88  DRIZZLE_TYPE_VARCHAR,
89  //DRIZZLE_TYPE_DECIMAL
90  DRIZZLE_TYPE_DECIMAL,
91  //DRIZZLE_TYPE_ENUM
92  DRIZZLE_TYPE_VARCHAR,
93  //DRIZZLE_TYPE_BLOB
94  DRIZZLE_TYPE_BLOB,
95  //DRIZZLE_TYPE_TIME
96  DRIZZLE_TYPE_TIME,
97  //DRIZZLE_TYPE_BOOLEAN
98  DRIZZLE_TYPE_VARCHAR,
99  //DRIZZLE_TYPE_UUID
100  DRIZZLE_TYPE_VARCHAR,
101  //DRIZZLE_TYPE_MICROTIME
102  DRIZZLE_TYPE_VARCHAR,
103  //DRIZZLE_TYPE_IPV6
104  DRIZZLE_TYPE_VARCHAR,
105  },
106  /* DRIZZLE_TYPE_DOUBLE -> */
107  {
108  //DRIZZLE_TYPE_LONG
109  DRIZZLE_TYPE_DOUBLE,
110  //DRIZZLE_TYPE_DOUBLE
111  DRIZZLE_TYPE_DOUBLE,
112  //DRIZZLE_TYPE_NULL
113  DRIZZLE_TYPE_DOUBLE,
114  //DRIZZLE_TYPE_TIMESTAMP
115  DRIZZLE_TYPE_VARCHAR,
116  //DRIZZLE_TYPE_LONGLONG
117  DRIZZLE_TYPE_DOUBLE,
118  //DRIZZLE_TYPE_DATETIME
119  DRIZZLE_TYPE_VARCHAR,
120  //DRIZZLE_TYPE_DATE
121  DRIZZLE_TYPE_VARCHAR,
122  //DRIZZLE_TYPE_VARCHAR
123  DRIZZLE_TYPE_VARCHAR,
124  //DRIZZLE_TYPE_DECIMAL
125  DRIZZLE_TYPE_DOUBLE,
126  //DRIZZLE_TYPE_ENUM
127  DRIZZLE_TYPE_VARCHAR,
128  //DRIZZLE_TYPE_BLOB
129  DRIZZLE_TYPE_BLOB,
130  //DRIZZLE_TYPE_TIME
131  DRIZZLE_TYPE_TIME,
132  //DRIZZLE_TYPE_BOOLEAN
133  DRIZZLE_TYPE_VARCHAR,
134  //DRIZZLE_TYPE_UUID
135  DRIZZLE_TYPE_VARCHAR,
136  //DRIZZLE_TYPE_MICROTIME
137  DRIZZLE_TYPE_VARCHAR,
138  //DRIZZLE_TYPE_IPV6
139  DRIZZLE_TYPE_VARCHAR,
140  },
141  /* DRIZZLE_TYPE_NULL -> */
142  {
143  //DRIZZLE_TYPE_LONG
144  DRIZZLE_TYPE_LONG,
145  //DRIZZLE_TYPE_DOUBLE
146  DRIZZLE_TYPE_DOUBLE,
147  //DRIZZLE_TYPE_NULL
148  DRIZZLE_TYPE_NULL,
149  //DRIZZLE_TYPE_TIMESTAMP
150  DRIZZLE_TYPE_TIMESTAMP,
151  //DRIZZLE_TYPE_LONGLONG
152  DRIZZLE_TYPE_LONGLONG,
153  //DRIZZLE_TYPE_DATETIME
154  DRIZZLE_TYPE_DATETIME,
155  //DRIZZLE_TYPE_DATE
156  DRIZZLE_TYPE_DATE,
157  //DRIZZLE_TYPE_VARCHAR
158  DRIZZLE_TYPE_VARCHAR,
159  //DRIZZLE_TYPE_DECIMAL
160  DRIZZLE_TYPE_DECIMAL,
161  //DRIZZLE_TYPE_ENUM
162  DRIZZLE_TYPE_ENUM,
163  //DRIZZLE_TYPE_BLOB
164  DRIZZLE_TYPE_BLOB,
165  //DRIZZLE_TYPE_TIME
166  DRIZZLE_TYPE_TIME,
167  //DRIZZLE_TYPE_BOOLEAN
168  DRIZZLE_TYPE_BOOLEAN,
169  //DRIZZLE_TYPE_UUID
170  DRIZZLE_TYPE_UUID,
171  //DRIZZLE_TYPE_MICROTIME
172  DRIZZLE_TYPE_MICROTIME,
173  //DRIZZLE_TYPE_IPV6
174  DRIZZLE_TYPE_VARCHAR,
175  },
176  /* DRIZZLE_TYPE_TIMESTAMP -> */
177  {
178  //DRIZZLE_TYPE_LONG
179  DRIZZLE_TYPE_VARCHAR,
180  //DRIZZLE_TYPE_DOUBLE
181  DRIZZLE_TYPE_VARCHAR,
182  //DRIZZLE_TYPE_NULL
183  DRIZZLE_TYPE_TIMESTAMP,
184  //DRIZZLE_TYPE_TIMESTAMP
185  DRIZZLE_TYPE_TIMESTAMP,
186  //DRIZZLE_TYPE_LONGLONG
187  DRIZZLE_TYPE_VARCHAR,
188  //DRIZZLE_TYPE_DATETIME
189  DRIZZLE_TYPE_DATETIME,
190  //DRIZZLE_TYPE_DATE
191  DRIZZLE_TYPE_DATE,
192  //DRIZZLE_TYPE_VARCHAR
193  DRIZZLE_TYPE_VARCHAR,
194  //DRIZZLE_TYPE_DECIMAL
195  DRIZZLE_TYPE_VARCHAR,
196  //DRIZZLE_TYPE_ENUM
197  DRIZZLE_TYPE_VARCHAR,
198  //DRIZZLE_TYPE_BLOB
199  DRIZZLE_TYPE_BLOB,
200  //DRIZZLE_TYPE_TIME
201  DRIZZLE_TYPE_TIME,
202  //DRIZZLE_TYPE_BOOLEAN
203  DRIZZLE_TYPE_VARCHAR,
204  //DRIZZLE_TYPE_UUID
205  DRIZZLE_TYPE_VARCHAR,
206  //DRIZZLE_TYPE_MICROTIME
207  DRIZZLE_TYPE_VARCHAR,
208  //DRIZZLE_TYPE_IPV6
209  DRIZZLE_TYPE_VARCHAR,
210  },
211  /* DRIZZLE_TYPE_LONGLONG -> */
212  {
213  //DRIZZLE_TYPE_LONG
214  DRIZZLE_TYPE_LONGLONG,
215  //DRIZZLE_TYPE_DOUBLE
216  DRIZZLE_TYPE_DOUBLE,
217  //DRIZZLE_TYPE_NULL
218  DRIZZLE_TYPE_LONGLONG,
219  //DRIZZLE_TYPE_TIMESTAMP
220  DRIZZLE_TYPE_VARCHAR,
221  //DRIZZLE_TYPE_LONGLONG
222  DRIZZLE_TYPE_LONGLONG,
223  //DRIZZLE_TYPE_DATETIME
224  DRIZZLE_TYPE_VARCHAR,
225  //DRIZZLE_TYPE_DATE
226  DRIZZLE_TYPE_DATE,
227  //DRIZZLE_TYPE_VARCHAR
228  DRIZZLE_TYPE_VARCHAR,
229  //DRIZZLE_TYPE_DECIMAL DRIZZLE_TYPE_ENUM
230  DRIZZLE_TYPE_DECIMAL,
231  DRIZZLE_TYPE_VARCHAR,
232  //DRIZZLE_TYPE_BLOB
233  DRIZZLE_TYPE_BLOB,
234  //DRIZZLE_TYPE_TIME
235  DRIZZLE_TYPE_TIME,
236  //DRIZZLE_TYPE_BOOLEAN
237  DRIZZLE_TYPE_VARCHAR,
238  //DRIZZLE_TYPE_UUID
239  DRIZZLE_TYPE_VARCHAR,
240  //DRIZZLE_TYPE_MICROTIME
241  DRIZZLE_TYPE_VARCHAR,
242  //DRIZZLE_TYPE_IPV6
243  DRIZZLE_TYPE_VARCHAR,
244  },
245  /* DRIZZLE_TYPE_DATETIME -> */
246  {
247  //DRIZZLE_TYPE_LONG
248  DRIZZLE_TYPE_VARCHAR,
249  //DRIZZLE_TYPE_DOUBLE
250  DRIZZLE_TYPE_VARCHAR,
251  //DRIZZLE_TYPE_NULL
252  DRIZZLE_TYPE_DATETIME,
253  //DRIZZLE_TYPE_TIMESTAMP
254  DRIZZLE_TYPE_DATETIME,
255  //DRIZZLE_TYPE_LONGLONG
256  DRIZZLE_TYPE_VARCHAR,
257  //DRIZZLE_TYPE_DATETIME
258  DRIZZLE_TYPE_DATETIME,
259  //DRIZZLE_TYPE_DATE
260  DRIZZLE_TYPE_DATE,
261  //DRIZZLE_TYPE_VARCHAR
262  DRIZZLE_TYPE_VARCHAR,
263  //DRIZZLE_TYPE_DECIMAL
264  DRIZZLE_TYPE_VARCHAR,
265  //DRIZZLE_TYPE_ENUM
266  DRIZZLE_TYPE_VARCHAR,
267  //DRIZZLE_TYPE_BLOB
268  DRIZZLE_TYPE_BLOB,
269  //DRIZZLE_TYPE_TIME
270  DRIZZLE_TYPE_TIME,
271  //DRIZZLE_TYPE_BOOLEAN
272  DRIZZLE_TYPE_VARCHAR,
273  //DRIZZLE_TYPE_UUID
274  DRIZZLE_TYPE_VARCHAR,
275  //DRIZZLE_TYPE_MICROTIME
276  DRIZZLE_TYPE_VARCHAR,
277  //DRIZZLE_TYPE_IPV6
278  DRIZZLE_TYPE_VARCHAR,
279  },
280  /* DRIZZLE_TYPE_DATE -> */
281  {
282  //DRIZZLE_TYPE_LONG
283  DRIZZLE_TYPE_VARCHAR,
284  //DRIZZLE_TYPE_DOUBLE
285  DRIZZLE_TYPE_VARCHAR,
286  //DRIZZLE_TYPE_NULL
287  DRIZZLE_TYPE_DATE,
288  //DRIZZLE_TYPE_TIMESTAMP
289  DRIZZLE_TYPE_DATETIME,
290  //DRIZZLE_TYPE_LONGLONG
291  DRIZZLE_TYPE_VARCHAR,
292  //DRIZZLE_TYPE_DATETIME
293  DRIZZLE_TYPE_DATETIME,
294  //DRIZZLE_TYPE_DATE
295  DRIZZLE_TYPE_DATE,
296  //DRIZZLE_TYPE_VARCHAR
297  DRIZZLE_TYPE_VARCHAR,
298  //DRIZZLE_TYPE_DECIMAL
299  DRIZZLE_TYPE_VARCHAR,
300  //DRIZZLE_TYPE_ENUM
301  DRIZZLE_TYPE_VARCHAR,
302  //DRIZZLE_TYPE_BLOB
303  DRIZZLE_TYPE_BLOB,
304  //DRIZZLE_TYPE_TIME
305  DRIZZLE_TYPE_TIME,
306  //DRIZZLE_TYPE_BOOLEAN
307  DRIZZLE_TYPE_VARCHAR,
308  //DRIZZLE_TYPE_UUID
309  DRIZZLE_TYPE_VARCHAR,
310  //DRIZZLE_TYPE_MICROTIME
311  DRIZZLE_TYPE_VARCHAR,
312  //DRIZZLE_TYPE_IPV6
313  DRIZZLE_TYPE_VARCHAR,
314  },
315  /* DRIZZLE_TYPE_VARCHAR -> */
316  {
317  //DRIZZLE_TYPE_LONG
318  DRIZZLE_TYPE_VARCHAR,
319  //DRIZZLE_TYPE_DOUBLE
320  DRIZZLE_TYPE_VARCHAR,
321  //DRIZZLE_TYPE_NULL
322  DRIZZLE_TYPE_VARCHAR,
323  //DRIZZLE_TYPE_TIMESTAMP
324  DRIZZLE_TYPE_VARCHAR,
325  //DRIZZLE_TYPE_LONGLONG
326  DRIZZLE_TYPE_VARCHAR,
327  //DRIZZLE_TYPE_DATETIME
328  DRIZZLE_TYPE_VARCHAR,
329  //DRIZZLE_TYPE_DATE
330  DRIZZLE_TYPE_VARCHAR,
331  //DRIZZLE_TYPE_VARCHAR
332  DRIZZLE_TYPE_VARCHAR,
333  //DRIZZLE_TYPE_DECIMAL
334  DRIZZLE_TYPE_VARCHAR,
335  //DRIZZLE_TYPE_ENUM
336  DRIZZLE_TYPE_VARCHAR,
337  //DRIZZLE_TYPE_BLOB
338  DRIZZLE_TYPE_BLOB,
339  //DRIZZLE_TYPE_TIME
340  DRIZZLE_TYPE_TIME,
341  //DRIZZLE_TYPE_BOOLEAN
342  DRIZZLE_TYPE_VARCHAR,
343  //DRIZZLE_TYPE_UUID
344  DRIZZLE_TYPE_VARCHAR,
345  //DRIZZLE_TYPE_MICROTIME
346  DRIZZLE_TYPE_VARCHAR,
347  //DRIZZLE_TYPE_IPV6
348  DRIZZLE_TYPE_VARCHAR,
349  },
350  /* DRIZZLE_TYPE_DECIMAL -> */
351  {
352  //DRIZZLE_TYPE_LONG
353  DRIZZLE_TYPE_DECIMAL,
354  //DRIZZLE_TYPE_DOUBLE
355  DRIZZLE_TYPE_DOUBLE,
356  //DRIZZLE_TYPE_NULL
357  DRIZZLE_TYPE_DECIMAL,
358  //DRIZZLE_TYPE_TIMESTAMP
359  DRIZZLE_TYPE_VARCHAR,
360  //DRIZZLE_TYPE_LONGLONG
361  DRIZZLE_TYPE_DECIMAL,
362  //DRIZZLE_TYPE_DATETIME
363  DRIZZLE_TYPE_VARCHAR,
364  //DRIZZLE_TYPE_DATE
365  DRIZZLE_TYPE_VARCHAR,
366  //DRIZZLE_TYPE_VARCHAR
367  DRIZZLE_TYPE_VARCHAR,
368  //DRIZZLE_TYPE_DECIMAL
369  DRIZZLE_TYPE_DECIMAL,
370  //DRIZZLE_TYPE_ENUM
371  DRIZZLE_TYPE_VARCHAR,
372  //DRIZZLE_TYPE_BLOB
373  DRIZZLE_TYPE_BLOB,
374  //DRIZZLE_TYPE_TIME
375  DRIZZLE_TYPE_TIME,
376  //DRIZZLE_TYPE_BOOLEAN
377  DRIZZLE_TYPE_VARCHAR,
378  //DRIZZLE_TYPE_UUID
379  DRIZZLE_TYPE_VARCHAR,
380  //DRIZZLE_TYPE_MICROTIME
381  DRIZZLE_TYPE_VARCHAR,
382  //DRIZZLE_TYPE_IPV6
383  DRIZZLE_TYPE_VARCHAR,
384  },
385  /* DRIZZLE_TYPE_ENUM -> */
386  {
387  //DRIZZLE_TYPE_LONG
388  DRIZZLE_TYPE_VARCHAR,
389  //DRIZZLE_TYPE_DOUBLE
390  DRIZZLE_TYPE_VARCHAR,
391  //DRIZZLE_TYPE_NULL
392  DRIZZLE_TYPE_ENUM,
393  //DRIZZLE_TYPE_TIMESTAMP
394  DRIZZLE_TYPE_VARCHAR,
395  //DRIZZLE_TYPE_LONGLONG
396  DRIZZLE_TYPE_VARCHAR,
397  //DRIZZLE_TYPE_DATETIME
398  DRIZZLE_TYPE_VARCHAR,
399  //DRIZZLE_TYPE_DATE
400  DRIZZLE_TYPE_VARCHAR,
401  //DRIZZLE_TYPE_VARCHAR
402  DRIZZLE_TYPE_VARCHAR,
403  //DRIZZLE_TYPE_DECIMAL
404  DRIZZLE_TYPE_VARCHAR,
405  //DRIZZLE_TYPE_ENUM
406  DRIZZLE_TYPE_VARCHAR,
407  //DRIZZLE_TYPE_BLOB
408  DRIZZLE_TYPE_BLOB,
409  //DRIZZLE_TYPE_TIME
410  DRIZZLE_TYPE_TIME,
411  //DRIZZLE_TYPE_BOOLEAN
412  DRIZZLE_TYPE_VARCHAR,
413  //DRIZZLE_TYPE_UUID
414  DRIZZLE_TYPE_VARCHAR,
415  //DRIZZLE_TYPE_MICROTIME
416  DRIZZLE_TYPE_VARCHAR,
417  //DRIZZLE_TYPE_IPV6
418  DRIZZLE_TYPE_VARCHAR,
419  },
420  /* DRIZZLE_TYPE_BLOB -> */
421  {
422  //DRIZZLE_TYPE_LONG
423  DRIZZLE_TYPE_BLOB,
424  //DRIZZLE_TYPE_DOUBLE
425  DRIZZLE_TYPE_BLOB,
426  //DRIZZLE_TYPE_NULL
427  DRIZZLE_TYPE_BLOB,
428  //DRIZZLE_TYPE_TIMESTAMP
429  DRIZZLE_TYPE_BLOB,
430  //DRIZZLE_TYPE_LONGLONG
431  DRIZZLE_TYPE_BLOB,
432  //DRIZZLE_TYPE_DATETIME
433  DRIZZLE_TYPE_BLOB,
434  //DRIZZLE_TYPE_DATE
435  DRIZZLE_TYPE_BLOB,
436  //DRIZZLE_TYPE_VARCHAR
437  DRIZZLE_TYPE_BLOB,
438  //DRIZZLE_TYPE_DECIMAL
439  DRIZZLE_TYPE_BLOB,
440  //DRIZZLE_TYPE_ENUM
441  DRIZZLE_TYPE_BLOB,
442  //DRIZZLE_TYPE_BLOB
443  DRIZZLE_TYPE_BLOB,
444  //DRIZZLE_TYPE_TIME
445  DRIZZLE_TYPE_TIME,
446  //DRIZZLE_TYPE_BOOLEAN
447  DRIZZLE_TYPE_VARCHAR,
448  //DRIZZLE_TYPE_UUID
449  DRIZZLE_TYPE_VARCHAR,
450  //DRIZZLE_TYPE_MICROTIME
451  DRIZZLE_TYPE_VARCHAR,
452  //DRIZZLE_TYPE_IPV6
453  DRIZZLE_TYPE_VARCHAR,
454  },
455  /* DRIZZLE_TYPE_TIME -> */
456  {
457  //DRIZZLE_TYPE_LONG
458  DRIZZLE_TYPE_VARCHAR,
459  //DRIZZLE_TYPE_DOUBLE
460  DRIZZLE_TYPE_VARCHAR,
461  //DRIZZLE_TYPE_NULL
462  DRIZZLE_TYPE_TIME,
463  //DRIZZLE_TYPE_TIMESTAMP
464  DRIZZLE_TYPE_VARCHAR,
465  //DRIZZLE_TYPE_LONGLONG
466  DRIZZLE_TYPE_VARCHAR,
467  //DRIZZLE_TYPE_DATETIME
468  DRIZZLE_TYPE_VARCHAR,
469  //DRIZZLE_TYPE_DATE
470  DRIZZLE_TYPE_VARCHAR,
471  //DRIZZLE_TYPE_VARCHAR
472  DRIZZLE_TYPE_VARCHAR,
473  //DRIZZLE_TYPE_DECIMAL
474  DRIZZLE_TYPE_VARCHAR,
475  //DRIZZLE_TYPE_VARCHAR,
476  DRIZZLE_TYPE_VARCHAR,
477  //DRIZZLE_TYPE_BLOB
478  DRIZZLE_TYPE_BLOB,
479  //DRIZZLE_TYPE_TIME
480  DRIZZLE_TYPE_TIME,
481  //DRIZZLE_TYPE_BOOLEAN
482  DRIZZLE_TYPE_VARCHAR,
483  //DRIZZLE_TYPE_UUID
484  DRIZZLE_TYPE_UUID,
485  //DRIZZLE_TYPE_MICROTIME
486  DRIZZLE_TYPE_VARCHAR,
487  //DRIZZLE_TYPE_IPV6
488  DRIZZLE_TYPE_VARCHAR,
489  },
490  /* DRIZZLE_TYPE_BOOLEAN -> */
491  {
492  //DRIZZLE_TYPE_LONG
493  DRIZZLE_TYPE_VARCHAR,
494  //DRIZZLE_TYPE_DOUBLE
495  DRIZZLE_TYPE_VARCHAR,
496  //DRIZZLE_TYPE_NULL
497  DRIZZLE_TYPE_BOOLEAN,
498  //DRIZZLE_TYPE_TIMESTAMP
499  DRIZZLE_TYPE_VARCHAR,
500  //DRIZZLE_TYPE_LONGLONG
501  DRIZZLE_TYPE_VARCHAR,
502  //DRIZZLE_TYPE_DATETIME
503  DRIZZLE_TYPE_VARCHAR,
504  //DRIZZLE_TYPE_DATE
505  DRIZZLE_TYPE_VARCHAR,
506  //DRIZZLE_TYPE_VARCHAR
507  DRIZZLE_TYPE_VARCHAR,
508  //DRIZZLE_TYPE_DECIMAL
509  DRIZZLE_TYPE_VARCHAR,
510  //DRIZZLE_TYPE_VARCHAR,
511  DRIZZLE_TYPE_VARCHAR,
512  //DRIZZLE_TYPE_BLOB
513  DRIZZLE_TYPE_BLOB,
514  //DRIZZLE_TYPE_TIME
515  DRIZZLE_TYPE_TIME,
516  //DRIZZLE_TYPE_BOOLEAN
517  DRIZZLE_TYPE_BOOLEAN,
518  //DRIZZLE_TYPE_UUID
519  DRIZZLE_TYPE_VARCHAR,
520  //DRIZZLE_TYPE_MICROTIME
521  DRIZZLE_TYPE_VARCHAR,
522  //DRIZZLE_TYPE_IPV6
523  DRIZZLE_TYPE_VARCHAR,
524  },
525  /* DRIZZLE_TYPE_UUID -> */
526  {
527  //DRIZZLE_TYPE_LONG
528  DRIZZLE_TYPE_VARCHAR,
529  //DRIZZLE_TYPE_DOUBLE
530  DRIZZLE_TYPE_VARCHAR,
531  //DRIZZLE_TYPE_NULL
532  DRIZZLE_TYPE_UUID,
533  //DRIZZLE_TYPE_TIMESTAMP
534  DRIZZLE_TYPE_VARCHAR,
535  //DRIZZLE_TYPE_LONGLONG
536  DRIZZLE_TYPE_VARCHAR,
537  //DRIZZLE_TYPE_DATETIME
538  DRIZZLE_TYPE_VARCHAR,
539  //DRIZZLE_TYPE_DATE
540  DRIZZLE_TYPE_VARCHAR,
541  //DRIZZLE_TYPE_VARCHAR
542  DRIZZLE_TYPE_VARCHAR,
543  //DRIZZLE_TYPE_DECIMAL
544  DRIZZLE_TYPE_VARCHAR,
545  //DRIZZLE_TYPE_VARCHAR,
546  DRIZZLE_TYPE_VARCHAR,
547  //DRIZZLE_TYPE_BLOB
548  DRIZZLE_TYPE_BLOB,
549  //DRIZZLE_TYPE_TIME
550  DRIZZLE_TYPE_TIME,
551  //DRIZZLE_TYPE_BOOLEAN
552  DRIZZLE_TYPE_VARCHAR,
553  //DRIZZLE_TYPE_UUID
554  DRIZZLE_TYPE_UUID,
555  //DRIZZLE_TYPE_MICROTIME
556  DRIZZLE_TYPE_VARCHAR,
557  //DRIZZLE_TYPE_IPV6
558  DRIZZLE_TYPE_VARCHAR,
559  },
560  /* DRIZZLE_TYPE_MICROTIME -> */
561  {
562  //DRIZZLE_TYPE_LONG
563  DRIZZLE_TYPE_VARCHAR,
564  //DRIZZLE_TYPE_DOUBLE
565  DRIZZLE_TYPE_VARCHAR,
566  //DRIZZLE_TYPE_NULL
567  DRIZZLE_TYPE_MICROTIME,
568  //DRIZZLE_TYPE_TIMESTAMP
569  DRIZZLE_TYPE_VARCHAR,
570  //DRIZZLE_TYPE_LONGLONG
571  DRIZZLE_TYPE_VARCHAR,
572  //DRIZZLE_TYPE_DATETIME
573  DRIZZLE_TYPE_VARCHAR,
574  //DRIZZLE_TYPE_DATE
575  DRIZZLE_TYPE_VARCHAR,
576  //DRIZZLE_TYPE_VARCHAR
577  DRIZZLE_TYPE_VARCHAR,
578  //DRIZZLE_TYPE_DECIMAL
579  DRIZZLE_TYPE_VARCHAR,
580  //DRIZZLE_TYPE_VARCHAR,
581  DRIZZLE_TYPE_VARCHAR,
582  //DRIZZLE_TYPE_BLOB
583  DRIZZLE_TYPE_BLOB,
584  //DRIZZLE_TYPE_TIME
585  DRIZZLE_TYPE_TIME,
586  //DRIZZLE_TYPE_BOOLEAN
587  DRIZZLE_TYPE_VARCHAR,
588  //DRIZZLE_TYPE_UUID
589  DRIZZLE_TYPE_UUID,
590  //DRIZZLE_TYPE_MICROTIME
591  DRIZZLE_TYPE_MICROTIME,
592  //DRIZZLE_TYPE_IPV6
593  DRIZZLE_TYPE_VARCHAR,
594  },
595  /* DRIZZLE_TYPE_IPV6 -> */
596  {
597  //DRIZZLE_TYPE_LONG
598  DRIZZLE_TYPE_VARCHAR,
599  //DRIZZLE_TYPE_DOUBLE
600  DRIZZLE_TYPE_VARCHAR,
601  //DRIZZLE_TYPE_NULL
602  DRIZZLE_TYPE_IPV6,
603  //DRIZZLE_TYPE_TIMESTAMP
604  DRIZZLE_TYPE_VARCHAR,
605  //DRIZZLE_TYPE_LONGLONG
606  DRIZZLE_TYPE_VARCHAR,
607  //DRIZZLE_TYPE_DATETIME
608  DRIZZLE_TYPE_VARCHAR,
609  //DRIZZLE_TYPE_DATE
610  DRIZZLE_TYPE_VARCHAR,
611  //DRIZZLE_TYPE_VARCHAR
612  DRIZZLE_TYPE_VARCHAR,
613  //DRIZZLE_TYPE_DECIMAL
614  DRIZZLE_TYPE_VARCHAR,
615  //DRIZZLE_TYPE_VARCHAR,
616  DRIZZLE_TYPE_VARCHAR,
617  //DRIZZLE_TYPE_BLOB
618  DRIZZLE_TYPE_BLOB,
619  //DRIZZLE_TYPE_TIME
620  DRIZZLE_TYPE_TIME,
621  //DRIZZLE_TYPE_BOOLEAN
622  DRIZZLE_TYPE_VARCHAR,
623  //DRIZZLE_TYPE_UUID
624  DRIZZLE_TYPE_UUID,
625  //DRIZZLE_TYPE_MICROTIME
626  DRIZZLE_TYPE_MICROTIME,
627  //DRIZZLE_TYPE_IPV6
628  DRIZZLE_TYPE_VARCHAR,
629  },
630 };
631 
632 static Item_result field_types_result_type [enum_field_types_size]=
633 {
634  //DRIZZLE_TYPE_LONG
635  INT_RESULT,
636  //DRIZZLE_TYPE_DOUBLE
637  REAL_RESULT,
638  //DRIZZLE_TYPE_NULL
639  STRING_RESULT,
640  //DRIZZLE_TYPE_TIMESTAMP
641  STRING_RESULT,
642  //DRIZZLE_TYPE_LONGLONG
643  INT_RESULT,
644  //DRIZZLE_TYPE_DATETIME
645  STRING_RESULT,
646  //DRIZZLE_TYPE_DATE
647  STRING_RESULT,
648  //DRIZZLE_TYPE_VARCHAR
649  STRING_RESULT,
650  //DRIZZLE_TYPE_DECIMAL
651  DECIMAL_RESULT,
652  //DRIZZLE_TYPE_ENUM
653  STRING_RESULT,
654  //DRIZZLE_TYPE_BLOB
655  STRING_RESULT,
656  //DRIZZLE_TYPE_TIME
657  STRING_RESULT,
658  //DRIZZLE_TYPE_BOOLEAN
659  STRING_RESULT,
660  //DRIZZLE_TYPE_UUID
661  STRING_RESULT,
662  //DRIZZLE_TYPE_MICROTIME
663  STRING_RESULT,
664  //DRIZZLE_TYPE_IPV6
665  STRING_RESULT,
666 };
667 
669  const char *str,
670  const char *strend)
671 {
672  if (cs != &my_charset_bin)
673  str+= cs->cset->scan(cs, str, strend, MY_SEQ_SPACES);
674  return (str < strend);
675 }
676 
677 void *Field::operator new(size_t size)
678 {
679  return memory::sql_alloc(size);
680 }
681 
682 void *Field::operator new(size_t size, memory::Root *mem_root)
683 {
684  return mem_root->alloc(size);
685 }
686 
687 enum_field_types Field::field_type_merge(enum_field_types a,
688  enum_field_types b)
689 {
690  assert(a < enum_field_types_size);
691  assert(b < enum_field_types_size);
692  return field_types_merge_rules[a][b];
693 }
694 
695 Item_result Field::result_merge_type(enum_field_types field_type)
696 {
697  assert(field_type < enum_field_types_size);
698  return field_types_result_type[field_type];
699 }
700 
701 bool Field::eq(Field *field)
702 {
703  return (ptr == field->ptr && null_ptr == field->null_ptr &&
704  null_bit == field->null_bit);
705 }
706 
707 uint32_t Field::pack_length() const
708 {
709  return field_length;
710 }
711 
713 {
714  return pack_length();
715 }
716 
718 {
719  return pack_length();
720 }
721 
723 {
724  return pack_length();
725 }
726 
727 uint32_t Field::sort_length() const
728 {
729  return pack_length();
730 }
731 
732 uint32_t Field::max_data_length() const
733 {
734  return pack_length();
735 }
736 
737 int Field::reset(void)
738 {
739  memset(ptr, 0, pack_length());
740  return 0;
741 }
742 
743 void Field::reset_fields()
744 {}
745 
746 void Field::set_default()
747 {
748  ptrdiff_t l_offset= (ptrdiff_t) (table->getDefaultValues() - table->getInsertRecord());
749  memcpy(ptr, ptr + l_offset, pack_length());
750  if (null_ptr)
751  *null_ptr= ((*null_ptr & (unsigned char) ~null_bit) | (null_ptr[l_offset] & null_bit));
752 
753  if (this == table->next_number_field)
754  table->auto_increment_field_not_null= false;
755 }
756 
757 bool Field::binary() const
758 {
759  return true;
760 }
761 
762 bool Field::zero_pack() const
763 {
764  return true;
765 }
766 
767 enum ha_base_keytype Field::key_type() const
768 {
769  return HA_KEYTYPE_BINARY;
770 }
771 
772 uint32_t Field::key_length() const
773 {
774  return pack_length();
775 }
776 
777 enum_field_types Field::real_type() const
778 {
779  return type();
780 }
781 
782 int Field::cmp_max(const unsigned char *a, const unsigned char *b, uint32_t)
783 {
784  return cmp(a, b);
785 }
786 
787 int Field::cmp_binary(const unsigned char *a,const unsigned char *b, uint32_t)
788 {
789  return memcmp(a,b,pack_length());
790 }
791 
792 int Field::cmp_offset(uint32_t row_offset)
793 {
794  return cmp(ptr,ptr+row_offset);
795 }
796 
797 int Field::cmp_binary_offset(uint32_t row_offset)
798 {
799  return cmp_binary(ptr, ptr+row_offset);
800 }
801 
802 int Field::key_cmp(const unsigned char *a,const unsigned char *b)
803 {
804  return cmp(a, b);
805 }
806 
807 int Field::key_cmp(const unsigned char *str, uint32_t)
808 {
809  return cmp(ptr,str);
810 }
811 
812 uint32_t Field::decimals() const
813 {
814  return 0;
815 }
816 
817 bool Field::is_null(ptrdiff_t row_offset) const
818 {
819  return null_ptr ? (null_ptr[row_offset] & null_bit ? true : false) : table->null_row;
820 }
821 
822 bool Field::is_real_null(ptrdiff_t row_offset) const
823 {
824  return null_ptr && (null_ptr[row_offset] & null_bit);
825 }
826 
827 bool Field::is_null_in_record(const unsigned char *record) const
828 {
829  return null_ptr && test(record[(uint32_t) (null_ptr -table->getInsertRecord())] & null_bit);
830 }
831 
832 bool Field::is_null_in_record_with_offset(ptrdiff_t with_offset) const
833 {
834  return null_ptr && test(null_ptr[with_offset] & null_bit);
835 }
836 
837 void Field::set_null(ptrdiff_t row_offset)
838 {
839  if (null_ptr)
840  null_ptr[row_offset]|= null_bit;
841 }
842 
843 void Field::set_notnull(ptrdiff_t row_offset)
844 {
845  if (null_ptr)
846  null_ptr[row_offset]&= (unsigned char) ~null_bit;
847 }
848 
849 bool Field::maybe_null(void) const
850 {
851  return null_ptr != 0 || table->maybe_null;
852 }
853 
854 bool Field::real_maybe_null(void) const
855 {
856  return null_ptr != 0;
857 }
858 
859 bool Field::type_can_have_key_part(enum enum_field_types type)
860 {
861  switch (type)
862  {
863  case DRIZZLE_TYPE_VARCHAR:
864  case DRIZZLE_TYPE_BLOB:
865  return true;
866  default:
867  return false;
868  }
869 }
870 
871 int Field::warn_if_overflow(int op_result)
872 {
873  if (op_result == E_DEC_OVERFLOW)
874  {
875  set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_OUT_OF_RANGE, 1);
876  return E_DEC_OVERFLOW;
877  }
878  if (op_result == E_DEC_TRUNCATED)
879  {
880  set_warning(DRIZZLE_ERROR::WARN_LEVEL_WARN, ER_WARN_DATA_TRUNCATED, 1);
881  return E_DEC_TRUNCATED;
882  }
883  return 0;
884 }
885 
886 void Field::init(Table *table_arg)
887 {
888  orig_table= table= table_arg;
889 }
890 
892 Field::Field(unsigned char *ptr_arg,
893  uint32_t length_arg,
894  unsigned char *null_ptr_arg,
895  unsigned char null_bit_arg,
896  utype unireg_check_arg,
897  const char *field_name_arg) :
898  ptr(ptr_arg),
899  null_ptr(null_ptr_arg),
900  table(NULL),
901  orig_table(NULL),
902  field_name(field_name_arg),
903  key_start(0),
904  part_of_key(0),
905  part_of_key_not_clustered(0),
906  part_of_sortkey(0),
907  unireg_check(unireg_check_arg),
908  field_length(length_arg),
909  flags(null_ptr ? 0: NOT_NULL_FLAG),
910  field_index(0),
911  null_bit(null_bit_arg),
912  is_created_from_null_item(false)
913 {
914 }
915 
916 void Field::hash(uint32_t *nr, uint32_t *nr2) const
917 {
918  if (is_null())
919  {
920  *nr^= (*nr << 1) | 1;
921  }
922  else
923  {
924  uint32_t len= pack_length();
925  const charset_info_st * const cs= charset();
926  cs->coll->hash_sort(cs, ptr, len, nr, nr2);
927  }
928 }
929 
930 void Field::copy_from_tmp(int row_offset)
931 {
932  memcpy(ptr,ptr+row_offset,pack_length());
933  if (null_ptr)
934  {
935  *null_ptr= (unsigned char) ((null_ptr[0] &
936  (unsigned char) ~(uint32_t) null_bit) |
937  (null_ptr[row_offset] &
938  (unsigned char) null_bit));
939  }
940 }
941 
942 int Field::store_and_check(enum_check_fields check_level,
943  const char *to,
944  uint32_t length,
945  const charset_info_st * const cs)
946 
947 {
948  enum_check_fields old_check_level= table->in_use->count_cuted_fields;
949  table->in_use->count_cuted_fields= check_level;
950  int res= store(to, length, cs);
951  table->in_use->count_cuted_fields= old_check_level;
952  return res;
953 }
954 
955 unsigned char *Field::pack(unsigned char *to, const unsigned char *from, uint32_t max_length, bool)
956 {
957  uint32_t length= pack_length();
958  set_if_smaller(length, max_length);
959  memcpy(to, from, length);
960  return to+length;
961 }
962 
963 unsigned char *Field::pack(unsigned char *to, const unsigned char *from)
964 {
965  return this->pack(to, from, UINT32_MAX, table->getShare()->db_low_byte_first);
966 }
967 
968 const unsigned char *Field::unpack(unsigned char* to,
969  const unsigned char *from,
970  uint32_t param_data,
971  bool)
972 {
973  uint32_t length=pack_length();
974  int from_type= 0;
975  /*
976  If from length is > 255, it has encoded data in the upper bits. Need
977  to mask it out.
978  */
979  if (param_data > 255)
980  {
981  from_type= (param_data & 0xff00) >> 8U; // real_type.
982  param_data= param_data & 0x00ff; // length.
983  }
984 
985  if ((param_data == 0) ||
986  (length == param_data) ||
987  (from_type != real_type()))
988  {
989  memcpy(to, from, length);
990  return from+length;
991  }
992 
993  uint32_t len= (param_data && (param_data < length)) ?
994  param_data : length;
995 
996  memcpy(to, from, param_data > length ? length : len);
997  return (from + len);
998 }
999 
1000 const unsigned char *Field::unpack(unsigned char* to, const unsigned char *from)
1001 {
1002  return unpack(to, from, 0, table->getShare()->db_low_byte_first);
1003 }
1004 
1005 type::Decimal *Field::val_decimal(type::Decimal *) const
1006 {
1007  /* This never have to be called */
1008  assert(false);
1009  return 0;
1010 }
1011 
1012 
1013 void Field::make_field(SendField *field)
1014 {
1015  if (orig_table && orig_table->getShare()->getSchemaName() && *orig_table->getShare()->getSchemaName())
1016  {
1017  field->db_name= orig_table->getShare()->getSchemaName();
1018  field->org_table_name= orig_table->getShare()->getTableName();
1019  }
1020  else
1021  field->org_table_name= field->db_name= "";
1022  if (orig_table)
1023  {
1024  field->table_name= orig_table->getAlias();
1025  field->org_col_name= field_name;
1026  }
1027  else
1028  {
1029  field->table_name= "";
1030  field->org_col_name= "";
1031  }
1032  field->col_name= field_name;
1033  field->charsetnr= charset()->number;
1034  field->length= field_length;
1035  field->type= type();
1036  field->flags= table->maybe_null ? (flags & ~NOT_NULL_FLAG) : flags;
1037  field->decimals= 0;
1038 }
1039 
1040 int64_t Field::convert_decimal2int64_t(const type::Decimal *val, bool, int *err)
1041 {
1042  int64_t i;
1043  if (warn_if_overflow(val->val_int32(E_DEC_ERROR &
1044  ~E_DEC_OVERFLOW & ~E_DEC_TRUNCATED,
1045  false, &i)))
1046  {
1047  i= (val->sign() ? INT64_MIN : INT64_MAX);
1048  *err= 1;
1049  }
1050  return i;
1051 }
1052 
1053 uint32_t Field::fill_cache_field(CacheField *copy)
1054 {
1055  uint32_t store_length;
1056  copy->str=ptr;
1057  copy->length=pack_length();
1058  copy->blob_field=0;
1059  if (flags & BLOB_FLAG)
1060  {
1061  copy->blob_field=(Field_blob*) this;
1062  copy->strip=0;
1063  copy->length-= table->getShare()->sizeBlobPtr();
1064  return copy->length;
1065  }
1066  else
1067  {
1068  copy->strip=0;
1069  store_length= 0;
1070  }
1071  return copy->length+ store_length;
1072 }
1073 
1074 bool Field::get_date(type::Time &ltime, uint32_t fuzzydate) const
1075 {
1076  char buff[type::Time::MAX_STRING_LENGTH];
1077  String tmp(buff,sizeof(buff),&my_charset_bin);
1078 
1079  assert(getTable() and getTable()->getSession());
1080 
1081  String* res= val_str_internal(&tmp);
1082  return not res or str_to_datetime_with_warn(*getTable()->getSession(), *res, ltime, fuzzydate) <= type::DRIZZLE_TIMESTAMP_ERROR;
1083 }
1084 
1085 bool Field::get_time(type::Time &ltime) const
1086 {
1087  char buff[type::Time::MAX_STRING_LENGTH];
1088  String tmp(buff,sizeof(buff),&my_charset_bin);
1089 
1090  String* res= val_str_internal(&tmp);
1091  return not res or str_to_time_with_warn(*getTable()->getSession(), *res, ltime);
1092 }
1093 
1094 int Field::store_time(type::Time &ltime, type::timestamp_t)
1095 {
1096  String tmp;
1097  ltime.convert(tmp);
1098  return store(tmp.ptr(), tmp.length(), &my_charset_bin);
1099 }
1100 
1101 bool Field::optimize_range(uint32_t idx, uint32_t)
1102 {
1103  return test(table->index_flags(idx) & HA_READ_RANGE);
1104 }
1105 
1106 Field *Field::new_field(memory::Root *root, Table *new_table, bool)
1107 {
1108  Field* tmp= (Field*) root->memdup(this,size_of());
1109  if (tmp->table->maybe_null)
1110  tmp->flags&= ~NOT_NULL_FLAG;
1111  tmp->table= new_table;
1112  tmp->key_start.reset();
1113  tmp->part_of_key.reset();
1114  tmp->part_of_sortkey.reset();
1115  tmp->unireg_check= Field::NONE;
1116  tmp->flags&= (NOT_NULL_FLAG | BLOB_FLAG | UNSIGNED_FLAG | BINARY_FLAG | ENUM_FLAG);
1117  tmp->reset_fields();
1118  return tmp;
1119 }
1120 
1121 Field *Field::new_key_field(memory::Root *root, Table *new_table,
1122  unsigned char *new_ptr,
1123  unsigned char *new_null_ptr,
1124  uint32_t new_null_bit)
1125 {
1126  Field *tmp= new_field(root, new_table, table == new_table);
1127  tmp->ptr= new_ptr;
1128  tmp->null_ptr= new_null_ptr;
1129  tmp->null_bit= new_null_bit;
1130  return tmp;
1131 }
1132 
1134 {
1135  Field *tmp= (Field*) root->memdup(this,size_of());
1136  tmp->init(new_table);
1137  tmp->move_field_offset((ptrdiff_t) (new_table->getInsertRecord() - new_table->getDefaultValues()));
1138  return tmp;
1139 }
1140 
1141 uint32_t Field::is_equal(CreateField *new_field_ptr)
1142 {
1143  return new_field_ptr->sql_type == real_type();
1144 }
1145 
1146 bool Field::eq_def(Field *field)
1147 {
1148  return real_type() == field->real_type() && charset() == field->charset() && pack_length() == field->pack_length();
1149 }
1150 
1152 {
1153  if (!Field::eq_def(field))
1154  return 0;
1155 
1156  TYPELIB *from_lib=((Field_enum*) field)->typelib;
1157 
1158  if (typelib->count < from_lib->count)
1159  return 0;
1160 
1161  for (uint32_t i=0 ; i < from_lib->count ; i++)
1162  {
1163  if (my_strnncoll(field_charset,
1164  (const unsigned char*)typelib->type_names[i], strlen(typelib->type_names[i]),
1165  (const unsigned char*)from_lib->type_names[i], strlen(from_lib->type_names[i])))
1166  return 0;
1167  }
1168 
1169  return 1;
1170 }
1171 
1172 uint32_t calc_pack_length(enum_field_types type,uint32_t length)
1173 {
1174  switch (type)
1175  {
1176  case DRIZZLE_TYPE_VARCHAR: return (length + (length < 256 ? 1: 2));
1177  case DRIZZLE_TYPE_UUID: return field::Uuid::max_string_length();
1178  case DRIZZLE_TYPE_MICROTIME: return field::Microtime::max_string_length();
1179  case DRIZZLE_TYPE_TIMESTAMP: return field::Epoch::max_string_length();
1180  case DRIZZLE_TYPE_BOOLEAN: return field::Boolean::max_string_length();
1181  case DRIZZLE_TYPE_IPV6: return field::IPv6::max_string_length();
1182  case DRIZZLE_TYPE_DATE:
1183  case DRIZZLE_TYPE_ENUM:
1184  case DRIZZLE_TYPE_LONG: return 4;
1185  case DRIZZLE_TYPE_DOUBLE: return sizeof(double);
1186  case DRIZZLE_TYPE_TIME:
1187  case DRIZZLE_TYPE_DATETIME:
1188  case DRIZZLE_TYPE_LONGLONG: return 8; /* Don't crash if no int64_t */
1189  case DRIZZLE_TYPE_NULL: return 0;
1190  case DRIZZLE_TYPE_BLOB: return 4 + portable_sizeof_char_ptr;
1191  case DRIZZLE_TYPE_DECIMAL:
1192  break;
1193  }
1194 
1195  assert(0);
1196  abort();
1197 }
1198 
1199 uint32_t pack_length_to_packflag(uint32_t type)
1200 {
1201  switch (type)
1202  {
1203  case 1: return 1 << FIELDFLAG_PACK_SHIFT;
1204  case 2: assert(0);
1205  case 3: assert(0);
1206  case 4: return f_settype(DRIZZLE_TYPE_LONG);
1207  case 8: return f_settype(DRIZZLE_TYPE_LONGLONG);
1208  }
1209  assert(false);
1210  return 0; // This shouldn't happen
1211 }
1212 
1213 /*****************************************************************************
1214  Warning handling
1215 *****************************************************************************/
1216 
1217 bool Field::set_warning(DRIZZLE_ERROR::enum_warning_level level,
1218  drizzled::error_t code,
1219  int cuted_increment)
1220 {
1221  /*
1222  If this field was created only for type conversion purposes it
1223  will have table == NULL.
1224  */
1225  Session *session= table ? table->in_use : current_session;
1226  if (session->count_cuted_fields)
1227  {
1228  session->cuted_fields+= cuted_increment;
1229  push_warning_printf(session, level, code, ER(code), field_name,
1230  session->row_count);
1231  return 0;
1232  }
1233  return level >= DRIZZLE_ERROR::WARN_LEVEL_WARN;
1234 }
1235 
1236 
1237 void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1238  drizzled::error_t code,
1239  const char *str,
1240  uint32_t str_length,
1241  type::timestamp_t ts_type,
1242  int cuted_increment)
1243 {
1244  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1245 
1246  if ((session->abortOnWarning() and
1247  level >= DRIZZLE_ERROR::WARN_LEVEL_WARN) ||
1248  set_warning(level, code, cuted_increment))
1249  make_truncated_value_warning(*session, level, str_ref(str, str_length), ts_type, field_name);
1250 }
1251 
1252 void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1253  drizzled::error_t code,
1254  int64_t nr,
1255  type::timestamp_t ts_type,
1256  int cuted_increment)
1257 {
1258  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1259 
1260  if (session->abortOnWarning() or
1261  set_warning(level, code, cuted_increment))
1262  {
1263  char str_nr[DECIMAL_LONGLONG_DIGITS];
1264  char *str_end= internal::int64_t10_to_str(nr, str_nr, -10);
1265  make_truncated_value_warning(*session, level, str_ref(str_nr, (uint32_t) (str_end - str_nr)), ts_type, field_name);
1266  }
1267 }
1268 
1269 void Field::set_datetime_warning(DRIZZLE_ERROR::enum_warning_level level,
1270  const drizzled::error_t code,
1271  double nr,
1272  type::timestamp_t ts_type)
1273 {
1274  Session *session= (getTable() and getTable()->getSession()) ? getTable()->getSession() : current_session;
1275 
1276  if (session->abortOnWarning() or
1277  set_warning(level, code, 1))
1278  {
1279  /* DBL_DIG is enough to print '-[digits].E+###' */
1280  char str_nr[DBL_DIG + 8];
1281  uint32_t str_len= snprintf(str_nr, sizeof(str_nr), "%g", nr);
1282  make_truncated_value_warning(*session, level, str_ref(str_nr, str_len), ts_type, field_name);
1283  }
1284 }
1285 
1286 bool Field::isReadSet() const
1287 {
1288  return table->isReadSet(field_index);
1289 }
1290 
1291 bool Field::isWriteSet()
1292 {
1293  return table->isWriteSet(field_index);
1294 }
1295 
1296 void Field::setReadSet(bool arg)
1297 {
1298  if (arg)
1299  table->setReadSet(field_index);
1300  else
1301  table->clearReadSet(field_index);
1302 }
1303 
1304 void Field::setWriteSet(bool arg)
1305 {
1306  if (arg)
1307  table->setWriteSet(field_index);
1308  else
1309  table->clearWriteSet(field_index);
1310 }
1311 
1312 void Field::pack_num(uint64_t arg, unsigned char *destination)
1313 {
1314  if (not destination)
1315  destination= ptr;
1316 
1317  int64_tstore(destination, arg);
1318 }
1319 
1320 void Field::pack_num(uint32_t arg, unsigned char *destination)
1321 {
1322  if (not destination)
1323  destination= ptr;
1324 
1325  longstore(destination, arg);
1326 }
1327 
1328 uint64_t Field::unpack_num(uint64_t &destination, const unsigned char *arg) const
1329 {
1330  if (not arg)
1331  arg= ptr;
1332 
1333  int64_tget(destination, arg);
1334 
1335  return destination;
1336 }
1337 
1338 uint32_t Field::unpack_num(uint32_t &destination, const unsigned char *arg) const
1339 {
1340  if (not arg)
1341  arg= ptr;
1342 
1343  longget(destination, arg);
1344 
1345  return destination;
1346 }
1347 
1348 std::ostream& operator<<(std::ostream& output, const Field &field)
1349 {
1350  output << "Field:(";
1351  output << field.field_name;
1352  output << ", ";
1353  output << drizzled::display::type(field.real_type());
1354  output << ", { ";
1355 
1356  if (field.flags & NOT_NULL_FLAG)
1357  output << " NOT_NULL";
1358 
1359  if (field.flags & PRI_KEY_FLAG)
1360  output << ", PRIMARY KEY";
1361 
1362  if (field.flags & UNIQUE_KEY_FLAG)
1363  output << ", UNIQUE KEY";
1364 
1365  if (field.flags & MULTIPLE_KEY_FLAG)
1366  output << ", MULTIPLE KEY";
1367 
1368  if (field.flags & BLOB_FLAG)
1369  output << ", BLOB";
1370 
1371  if (field.flags & UNSIGNED_FLAG)
1372  output << ", UNSIGNED";
1373 
1374  if (field.flags & BINARY_FLAG)
1375  output << ", BINARY";
1376  output << "}, ";
1377  output << ")";
1378 
1379  return output; // for multiple << operators.
1380 }
1381 
1382 } /* namespace drizzled */
Field(unsigned char *ptr_arg, uint32_t length_arg, unsigned char *null_ptr_arg, unsigned char null_bit_arg, utype unireg_check_arg, const char *field_name_arg)
This is used as a table name when the table structure is not set up.
Definition: field.cc:892
virtual uint32_t pack_length() const
Definition: field.cc:707
virtual int store_time(type::Time &ltime, type::timestamp_t t_type)
Definition: field.cc:1094
bool set_warning(DRIZZLE_ERROR::enum_warning_level, drizzled::error_t code, int cuted_increment)
Definition: field.cc:1217
uint32_t row_count
Definition: session.h:447
static enum_field_types field_type_merge(enum_field_types, enum_field_types)
Definition: field.cc:687
uint16_t field_index
Definition: field.h:138
virtual uint32_t pack_length_in_rec() const
Definition: field.cc:712
void * memdup(const void *, size_t)
Duplicate the provided block into memory allocated from within the specified Root.
Definition: root.cc:366
uint32_t field_length
Definition: field.h:129
ha_rows cuted_fields
Definition: session.h:408
static Item_result result_merge_type(enum_field_types)
Definition: field.cc:695
TYPELIB * typelib
Definition: enum.h:40
virtual unsigned char * pack(unsigned char *to, const unsigned char *from, uint32_t max_length, bool low_byte_first)
Definition: field.cc:955
Table * orig_table
Definition: field.h:101
int64_t convert_decimal2int64_t(const type::Decimal *val, bool unsigned_flag, int *err)
Definition: field.cc:1040
virtual bool eq_def(Field *field)
Definition: field.cc:1146
virtual uint32_t used_length()
Definition: field.cc:722
Table * table
Definition: field.h:81
virtual uint32_t data_length()
Definition: field.cc:717
virtual const unsigned char * unpack(unsigned char *to, const unsigned char *from, uint32_t param_data, bool low_byte_first)
Definition: field.cc:968
int warn_if_overflow(int op_result)
Definition: field.cc:871
static void store_length(unsigned char *to, uint32_t length, uint32_t pack_length)
Definition: filesort.cc:753
Field * next_number_field
Definition: table.h:142
Session * in_use
Definition: table.h:123
unsigned char null_bit
Definition: field.h:152
bool test_if_important_data(const charset_info_st *const cs, const char *str, const char *strend)
Definition: field.cc:668
enum_field_types sql_type
Definition: create_field.h:40
static bool type_can_have_key_part(enum_field_types)
Definition: field.cc:859
Field * clone(memory::Root *, Table *)
Definition: field.cc:1133
unsigned char * null_ptr
Definition: field.h:72
const char * field_name
Definition: field.h:102
void set_datetime_warning(DRIZZLE_ERROR::enum_warning_level, drizzled::error_t code, const char *str, uint32_t str_len, type::timestamp_t ts_type, int cuted_increment)
Definition: field.cc:1237
virtual uint32_t max_data_length() const
Definition: field.cc:732
bool eq_def(Field *field)
Definition: field.cc:1151
unsigned char * ptr
Definition: field.h:71