~drizzle-trunk/drizzle/development

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
384
385
386
387
388
389
390
391
392
393
394
395
396
397
398
399
400
401
402
403
404
405
/* -*- mode: c++; c-basic-offset: 2; indent-tabs-mode: nil; -*-
 *  vim:expandtab:shiftwidth=2:tabstop=2:smarttab:
 *
 *  Copyright (C) 2008 Sun Microsystems
 *
 *  This program is free software; you can redistribute it and/or modify
 *  it under the terms of the GNU General Public License as published by
 *  the Free Software Foundation; version 2 of the License.
 *
 *  This program is distributed in the hope that it will be useful,
 *  but WITHOUT ANY WARRANTY; without even the implied warranty of
 *  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
 *  GNU General Public License for more details.
 *
 *  You should have received a copy of the GNU General Public License
 *  along with this program; if not, write to the Free Software
 *  Foundation, Inc., 51 Franklin St, Fifth Floor, Boston, MA  02110-1301  USA
 */

#ifndef DRIZZLE_SERVER_SQL_STRING_H
#define DRIZZLE_SERVER_SQL_STRING_H

/* This file is originally from the mysql distribution. Coded by monty */


#ifndef NOT_FIXED_DEC
#define NOT_FIXED_DEC			31
#endif

#include <drizzled/common.h>
#include <mysys/iocache.h>
#include <stdlib.h>
#include <string.h>

class String;

#if defined(__cplusplus)
extern "C" {
#endif

  int sortcmp(const String *a,const String *b, const CHARSET_INFO * const cs);
  int stringcmp(const String *a,const String *b);
  String *copy_if_not_alloced(String *a,String *b,uint32_t arg_length);
  uint32_t copy_and_convert(char *to, uint32_t to_length,
                            const CHARSET_INFO * const to_cs,
                            const char *from, uint32_t from_length,
                            const CHARSET_INFO * const from_cs,
                            uint32_t *errors);
  uint32_t well_formed_copy_nchars(const CHARSET_INFO * const to_cs,
                                   char *to, uint32_t to_length,
                                   const CHARSET_INFO * const from_cs,
                                   const char *from, uint32_t from_length,
                                   uint32_t nchars,
                                   const char **well_formed_error_pos,
                                   const char **cannot_convert_error_pos,
                                   const char **from_end_pos);
  size_t my_copy_with_hex_escaping(const CHARSET_INFO * const cs,
                                   char *dst, size_t dstlen,
                                   const char *src, size_t srclen);

#if defined(__cplusplus)
}
#endif

class String
{
  char *Ptr;
  uint32_t str_length,Alloced_length;
  bool alloced;
  const CHARSET_INFO *str_charset;

public:
  String()
  {
    Ptr=0; str_length=Alloced_length=0; alloced=0;
    str_charset= &my_charset_bin;
  }
  String(uint32_t length_arg)
  {
    alloced=0; Alloced_length=0; (void) real_alloc(length_arg);
    str_charset= &my_charset_bin;
  }
  String(const char *str, const CHARSET_INFO * const cs)
  {
    Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;
    str_charset=cs;
  }
  String(const char *str,uint32_t len, const CHARSET_INFO * const cs)
  {
    Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;
    str_charset=cs;
  }
  String(char *str,uint32_t len, const CHARSET_INFO * const cs)
  {
    Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;
    str_charset=cs;
  }
  String(const String &str)
  {
    Ptr=str.Ptr ; str_length=str.str_length ;
    Alloced_length=str.Alloced_length; alloced=0;
    str_charset=str.str_charset;
  }
  static void *operator new(size_t size, MEM_ROOT *mem_root)
  { return (void*) alloc_root(mem_root, (uint) size); }
  static void operator delete(void *, size_t)
  { TRASH(ptr_arg, size); }
  static void operator delete(void *, MEM_ROOT *)
  { /* never called */ }
  ~String() { free(); }

  inline void set_charset(const CHARSET_INFO * const charset_arg)
  { str_charset= charset_arg; }
  inline const CHARSET_INFO *charset() const { return str_charset; }
  inline uint32_t length() const { return str_length;}
  inline uint32_t alloced_length() const { return Alloced_length;}
  inline char& operator [] (uint32_t i) const { return Ptr[i]; }
  inline void length(uint32_t len) { str_length=len ; }
  inline bool is_empty() { return (str_length == 0); }
  inline void mark_as_const() { Alloced_length= 0;}
  inline char *ptr() { return Ptr; }
  inline const char *ptr() const { return Ptr; }
  inline char *c_ptr()
  {
    if (!Ptr || Ptr[str_length])		/* Should be safe */
      (void) realloc(str_length);
    return Ptr;
  }
  inline char *c_ptr_quick()
  {
    if (Ptr && str_length < Alloced_length)
      Ptr[str_length]=0;
    return Ptr;
  }
  inline char *c_ptr_safe()
  {
    if (Ptr && str_length < Alloced_length)
      Ptr[str_length]=0;
    else
      (void) realloc(str_length);
    return Ptr;
  }
  void append_identifier(const char *name, uint32_t length);

  void set(String &str,uint32_t offset,uint32_t arg_length)
  {
    assert(&str != this);
    free();
    Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0;
    if (str.Alloced_length)
      Alloced_length=str.Alloced_length-offset;
    else
      Alloced_length=0;
    str_charset=str.str_charset;
  }
  inline void set(char *str,uint32_t arg_length, const CHARSET_INFO * const cs)
  {
    free();
    Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
    str_charset=cs;
  }
  inline void set(const char *str,uint32_t arg_length, const CHARSET_INFO * const cs)
  {
    free();
    Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
    str_charset=cs;
  }
  bool set_ascii(const char *str, uint32_t arg_length);
  inline void set_quick(char *str,uint32_t arg_length, const CHARSET_INFO * const cs)
  {
    if (!alloced)
    {
      Ptr=(char*) str; str_length=Alloced_length=arg_length;
    }
    str_charset=cs;
  }
  bool set_int(int64_t num, bool unsigned_flag, const CHARSET_INFO * const cs);
  bool set(int64_t num, const CHARSET_INFO * const cs)
  { return set_int(num, false, cs); }
  bool set(uint64_t num, const CHARSET_INFO * const cs)
  { return set_int((int64_t)num, true, cs); }
  bool set_real(double num,uint32_t decimals, const CHARSET_INFO * const cs);

  /*
    PMG 2004.11.12
    This is a method that works the same as perl's "chop". It simply
    drops the last character of a string. This is useful in the case
    of the federated storage handler where I'm building a unknown
    number, list of values and fields to be used in a sql insert
    statement to be run on the remote server, and have a comma after each.
    When the list is complete, I "chop" off the trailing comma

    ex.
      String stringobj;
      stringobj.append("VALUES ('foo', 'fi', 'fo',");
      stringobj.chop();
      stringobj.append(")");

    In this case, the value of string was:

    VALUES ('foo', 'fi', 'fo',
    VALUES ('foo', 'fi', 'fo'
    VALUES ('foo', 'fi', 'fo')

  */
  inline void chop()
  {
    Ptr[str_length--]= '\0';
  }

  inline void free()
  {
    if (alloced)
    {
      alloced=0;
      Alloced_length=0;
      ::free(Ptr);
      Ptr=0;
      str_length=0;				/* Safety */
    }
  }
  inline bool alloc(uint32_t arg_length)
  {
    if (arg_length < Alloced_length)
      return 0;
    return real_alloc(arg_length);
  }
  bool real_alloc(uint32_t arg_length);			// Empties old string
  bool realloc(uint32_t arg_length);
  inline void shrink(uint32_t arg_length)		// Shrink buffer
  {
    if (arg_length < Alloced_length)
    {
      char *new_ptr;
      if (!(new_ptr=(char*) ::realloc(Ptr,arg_length)))
      {
	Alloced_length = 0;
	real_alloc(arg_length);
      }
      else
      {
	Ptr=new_ptr;
	Alloced_length=arg_length;
      }
    }
  }
  bool is_alloced() { return alloced; }
  inline String& operator = (const String &s)
  {
    if (&s != this)
    {
      /*
        It is forbidden to do assignments like
        some_string = substring_of_that_string
       */
      assert(!s.uses_buffer_owned_by(this));
      free();
      Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
      alloced=0;
    }
    return *this;
  }

  bool copy();					// Alloc string if not alloced
  bool copy(const String &s);			// Allocate new string
  bool copy(const char *s,uint32_t arg_length, const CHARSET_INFO * const cs);	// Allocate new string
  static bool needs_conversion(uint32_t arg_length,
  			       const CHARSET_INFO * const cs_from, const CHARSET_INFO * const cs_to,
			       uint32_t *offset);
  bool copy_aligned(const char *s, uint32_t arg_length, uint32_t offset,
		    const CHARSET_INFO * const cs);
  bool set_or_copy_aligned(const char *s, uint32_t arg_length, const CHARSET_INFO * const cs);
  bool copy(const char*s,uint32_t arg_length, const CHARSET_INFO * const csfrom,
	    const CHARSET_INFO * const csto, uint32_t *errors);
  bool append(const String &s);
  bool append(const char *s);
  bool append(const char *s,uint32_t arg_length);
  bool append(const char *s,uint32_t arg_length, const CHARSET_INFO * const cs);
  bool append(IO_CACHE* file, uint32_t arg_length);
  bool append_with_prefill(const char *s, uint32_t arg_length,
			   uint32_t full_length, char fill_char);
  int strstr(const String &search,uint32_t offset=0); // Returns offset to substring or -1
  int strrstr(const String &search,uint32_t offset=0); // Returns offset to substring or -1
  bool replace(uint32_t offset,uint32_t arg_length,const char *to,uint32_t length);
  bool replace(uint32_t offset,uint32_t arg_length,const String &to);
  inline bool append(char chr)
  {
    if (str_length < Alloced_length)
    {
      Ptr[str_length++]=chr;
    }
    else
    {
      if (realloc(str_length+1))
	return 1;
      Ptr[str_length++]=chr;
    }
    return 0;
  }
  bool fill(uint32_t max_length,char fill);
  friend int sortcmp(const String *a,const String *b, const CHARSET_INFO * const cs);
  friend int stringcmp(const String *a,const String *b);
  friend String *copy_if_not_alloced(String *a,String *b,uint32_t arg_length);
  uint32_t numchars();
  int charpos(int i,uint32_t offset=0);

  int reserve(uint32_t space_needed)
  {
    return realloc(str_length + space_needed);
  }
  int reserve(uint32_t space_needed, uint32_t grow_by);

  /*
    The following append operations do NOT check alloced memory
    q_*** methods writes values of parameters itself
    qs_*** methods writes string representation of value
  */
  void q_append(const char c)
  {
    Ptr[str_length++] = c;
  }
  void q_append(const uint32_t n)
  {
    int4store(Ptr + str_length, n);
    str_length += 4;
  }
  void q_append(double d)
  {
    float8store(Ptr + str_length, d);
    str_length += 8;
  }
  void q_append(double *d)
  {
    float8store(Ptr + str_length, *d);
    str_length += 8;
  }
  void q_append(const char *data, uint32_t data_len)
  {
    memcpy(Ptr + str_length, data, data_len);
    str_length += data_len;
  }

  void write_at_position(int position, uint32_t value)
  {
    int4store(Ptr + position,value);
  }

  void qs_append(const char *str, uint32_t len);
  void qs_append(double d);
  void qs_append(double *d);
  inline void qs_append(const char c)
  {
     Ptr[str_length]= c;
     str_length++;
  }
  void qs_append(int i);
  void qs_append(uint32_t i);

  /* Inline (general) functions used by the protocol functions */

  inline char *prep_append(uint32_t arg_length, uint32_t step_alloc)
  {
    uint32_t new_length= arg_length + str_length;
    if (new_length > Alloced_length)
    {
      if (realloc(new_length + step_alloc))
        return 0;
    }
    uint32_t old_length= str_length;
    str_length+= arg_length;
    return Ptr+ old_length;			/* Area to use */
  }

  inline bool append(const char *s, uint32_t arg_length, uint32_t step_alloc)
  {
    uint32_t new_length= arg_length + str_length;
    if (new_length > Alloced_length && realloc(new_length + step_alloc))
      return true;
    memcpy(Ptr+str_length, s, arg_length);
    str_length+= arg_length;
    return false;
  }
  void print(String *print);

  /* Swap two string objects. Efficient way to exchange data without memcpy. */
  void swap(String &s);

  inline bool uses_buffer_owned_by(const String *s) const
  {
    return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length);
  }
};

static inline bool check_if_only_end_space(const CHARSET_INFO * const cs, char *str,
                                           char *end)
{
  return str+ cs->cset->scan(cs, str, end, MY_SEQ_SPACES) == end;
}

extern "C++" {
bool operator==(const String &s1, const String &s2);
bool operator!=(const String &s1, const String &s2);
}

#endif /* DRIZZLE_SERVER_SQL_STRING_H */