sql_string.h
上传用户:romrleung
上传日期:2022-05-23
资源大小:18897k
文件大小:10k
源码类别:

MySQL数据库

开发平台:

Visual C++

  1. /* Copyright (C) 2000 MySQL AB
  2.    This program is free software; you can redistribute it and/or modify
  3.    it under the terms of the GNU General Public License as published by
  4.    the Free Software Foundation; either version 2 of the License, or
  5.    (at your option) any later version.
  6.    This program is distributed in the hope that it will be useful,
  7.    but WITHOUT ANY WARRANTY; without even the implied warranty of
  8.    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  9.    GNU General Public License for more details.
  10.    You should have received a copy of the GNU General Public License
  11.    along with this program; if not, write to the Free Software
  12.    Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA  02111-1307  USA */
  13. /* This file is originally from the mysql distribution. Coded by monty */
  14. #ifdef USE_PRAGMA_INTERFACE
  15. #pragma interface /* gcc class implementation */
  16. #endif
  17. #ifndef NOT_FIXED_DEC
  18. #define NOT_FIXED_DEC 31
  19. #endif
  20. class String;
  21. int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
  22. String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  23. uint32 copy_and_convert(char *to, uint32 to_length, CHARSET_INFO *to_cs,
  24. const char *from, uint32 from_length,
  25. CHARSET_INFO *from_cs, uint *errors);
  26. class String
  27. {
  28.   char *Ptr;
  29.   uint32 str_length,Alloced_length;
  30.   bool alloced;
  31.   CHARSET_INFO *str_charset;
  32. public:
  33.   String()
  34.   { 
  35.     Ptr=0; str_length=Alloced_length=0; alloced=0; 
  36.     str_charset= &my_charset_bin; 
  37.   }
  38.   String(uint32 length_arg)
  39.   { 
  40.     alloced=0; Alloced_length=0; (void) real_alloc(length_arg); 
  41.     str_charset= &my_charset_bin;
  42.   }
  43.   String(const char *str, CHARSET_INFO *cs)
  44.   { 
  45.     Ptr=(char*) str; str_length=(uint) strlen(str); Alloced_length=0; alloced=0;
  46.     str_charset=cs;
  47.   }
  48.   String(const char *str,uint32 len, CHARSET_INFO *cs)
  49.   { 
  50.     Ptr=(char*) str; str_length=len; Alloced_length=0; alloced=0;
  51.     str_charset=cs;
  52.   }
  53.   String(char *str,uint32 len, CHARSET_INFO *cs)
  54.   { 
  55.     Ptr=(char*) str; Alloced_length=str_length=len; alloced=0;
  56.     str_charset=cs;
  57.   }
  58.   String(const String &str)
  59.   { 
  60.     Ptr=str.Ptr ; str_length=str.str_length ;
  61.     Alloced_length=str.Alloced_length; alloced=0; 
  62.     str_charset=str.str_charset;
  63.   }
  64.   static void *operator new(size_t size, MEM_ROOT *mem_root)
  65.   { return (void*) alloc_root(mem_root, (uint) size); }
  66.   static void operator delete(void *ptr_arg,size_t size)
  67.     {}
  68.   static void operator delete(void *ptr_arg, MEM_ROOT *mem_root)
  69.     {}
  70.   ~String() { free(); }
  71.   inline void set_charset(CHARSET_INFO *charset) { str_charset= charset; }
  72.   inline CHARSET_INFO *charset() const { return str_charset; }
  73.   inline uint32 length() const { return str_length;}
  74.   inline uint32 alloced_length() const { return Alloced_length;}
  75.   inline char& operator [] (uint32 i) const { return Ptr[i]; }
  76.   inline void length(uint32 len) { str_length=len ; }
  77.   inline bool is_empty() { return (str_length == 0); }
  78.   inline const char *ptr() const { return Ptr; }
  79.   inline char *c_ptr()
  80.   {
  81.     if (!Ptr || Ptr[str_length]) /* Should be safe */
  82.       (void) realloc(str_length);
  83.     return Ptr;
  84.   }
  85.   inline char *c_ptr_quick()
  86.   {
  87.     if (Ptr && str_length < Alloced_length)
  88.       Ptr[str_length]=0;
  89.     return Ptr;
  90.   }
  91.   inline char *c_ptr_safe()
  92.   {
  93.     if (Ptr && str_length < Alloced_length)
  94.       Ptr[str_length]=0;
  95.     else
  96.       (void) realloc(str_length);
  97.     return Ptr;
  98.   }
  99.   void set(String &str,uint32 offset,uint32 arg_length)
  100.   {
  101.     DBUG_ASSERT(&str != this);
  102.     free();
  103.     Ptr=(char*) str.ptr()+offset; str_length=arg_length; alloced=0;
  104.     if (str.Alloced_length)
  105.       Alloced_length=str.Alloced_length-offset;
  106.     else
  107.       Alloced_length=0;
  108.     str_charset=str.str_charset;
  109.   }
  110.   inline void set(char *str,uint32 arg_length, CHARSET_INFO *cs)
  111.   {
  112.     free();
  113.     Ptr=(char*) str; str_length=Alloced_length=arg_length ; alloced=0;
  114.     str_charset=cs;
  115.   }
  116.   inline void set(const char *str,uint32 arg_length, CHARSET_INFO *cs)
  117.   {
  118.     free();
  119.     Ptr=(char*) str; str_length=arg_length; Alloced_length=0 ; alloced=0;
  120.     str_charset=cs;
  121.   }
  122.   bool set_ascii(const char *str, uint32 arg_length);
  123.   inline void set_quick(char *str,uint32 arg_length, CHARSET_INFO *cs)
  124.   {
  125.     if (!alloced)
  126.     {
  127.       Ptr=(char*) str; str_length=Alloced_length=arg_length;
  128.     }
  129.     str_charset=cs;
  130.   }
  131.   bool set(longlong num, CHARSET_INFO *cs);
  132.   bool set(ulonglong num, CHARSET_INFO *cs);
  133.   bool set(double num,uint decimals, CHARSET_INFO *cs);
  134.   inline void free()
  135.   {
  136.     if (alloced)
  137.     {
  138.       alloced=0;
  139.       Alloced_length=0;
  140.       my_free(Ptr,MYF(0));
  141.       Ptr=0;
  142.       str_length=0; /* Safety */
  143.     }
  144.   }
  145.   inline bool alloc(uint32 arg_length)
  146.   {
  147.     if (arg_length < Alloced_length)
  148.       return 0;
  149.     return real_alloc(arg_length);
  150.   }
  151.   bool real_alloc(uint32 arg_length); // Empties old string
  152.   bool realloc(uint32 arg_length);
  153.   inline void shrink(uint32 arg_length) // Shrink buffer
  154.   {
  155.     if (arg_length < Alloced_length)
  156.     {
  157.       char *new_ptr;
  158.       if (!(new_ptr=(char*) my_realloc(Ptr,arg_length,MYF(0))))
  159.       {
  160. Alloced_length = 0;
  161. real_alloc(arg_length);
  162.       }
  163.       else
  164.       {
  165. Ptr=new_ptr;
  166. Alloced_length=arg_length;
  167.       }
  168.     }
  169.   }
  170.   inline void shrink_to_length()
  171.   {
  172.     Alloced_length= str_length;
  173.   }
  174.   bool is_alloced() { return alloced; }
  175.   inline String& operator = (const String &s)
  176.   {
  177.     if (&s != this)
  178.     {
  179.       /*
  180.         It is forbidden to do assignments like 
  181.         some_string = substring_of_that_string
  182.        */
  183.       DBUG_ASSERT(!s.uses_buffer_owned_by(this));
  184.       free();
  185.       Ptr=s.Ptr ; str_length=s.str_length ; Alloced_length=s.Alloced_length;
  186.       alloced=0;
  187.     }
  188.     return *this;
  189.   }
  190.   bool copy(); // Alloc string if not alloced
  191.   bool copy(const String &s); // Allocate new string
  192.   bool copy(const char *s,uint32 arg_length, CHARSET_INFO *cs); // Allocate new string
  193.   static bool needs_conversion(uint32 arg_length,
  194.           CHARSET_INFO *cs_from, CHARSET_INFO *cs_to,
  195.        uint32 *offset);
  196.   bool copy_aligned(const char *s, uint32 arg_length, uint32 offset,
  197.     CHARSET_INFO *cs);
  198.   bool set_or_copy_aligned(const char *s, uint32 arg_length, CHARSET_INFO *cs);
  199.   bool copy(const char*s,uint32 arg_length, CHARSET_INFO *csfrom,
  200.     CHARSET_INFO *csto, uint *errors);
  201.   bool append(const String &s);
  202.   bool append(const char *s);
  203.   bool append(const char *s,uint32 arg_length);
  204.   bool append(const char *s,uint32 arg_length, CHARSET_INFO *cs);
  205.   bool append(IO_CACHE* file, uint32 arg_length);
  206.   bool append_with_prefill(const char *s, uint32 arg_length, 
  207.    uint32 full_length, char fill_char);
  208.   int strstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  209.   int strrstr(const String &search,uint32 offset=0); // Returns offset to substring or -1
  210.   bool replace(uint32 offset,uint32 arg_length,const char *to,uint32 length);
  211.   bool replace(uint32 offset,uint32 arg_length,const String &to);
  212.   inline bool append(char chr)
  213.   {
  214.     if (str_length < Alloced_length)
  215.     {
  216.       Ptr[str_length++]=chr;
  217.     }
  218.     else
  219.     {
  220.       if (realloc(str_length+1))
  221. return 1;
  222.       Ptr[str_length++]=chr;
  223.     }
  224.     return 0;
  225.   }
  226.   bool fill(uint32 max_length,char fill);
  227.   void strip_sp();
  228.   inline void caseup() { my_caseup(str_charset,Ptr,str_length); }
  229.   inline void casedn() { my_casedn(str_charset,Ptr,str_length); }
  230.   friend int sortcmp(const String *a,const String *b, CHARSET_INFO *cs);
  231.   friend int stringcmp(const String *a,const String *b);
  232.   friend String *copy_if_not_alloced(String *a,String *b,uint32 arg_length);
  233.   uint32 numchars();
  234.   int charpos(int i,uint32 offset=0);
  235.   int reserve(uint32 space_needed)
  236.   {
  237.     return realloc(str_length + space_needed);
  238.   }
  239.   int reserve(uint32 space_needed, uint32 grow_by);
  240.   /*
  241.     The following append operations do NOT check alloced memory
  242.     q_*** methods writes values of parameters itself
  243.     qs_*** methods writes string representation of value
  244.   */
  245.   void q_append(const char c)
  246.   {
  247.     Ptr[str_length++] = c;
  248.   }
  249.   void q_append(const uint32 n)
  250.   {
  251.     int4store(Ptr + str_length, n);
  252.     str_length += 4;
  253.   }
  254.   void q_append(double d)
  255.   {
  256.     float8store(Ptr + str_length, d);
  257.     str_length += 8;
  258.   }
  259.   void q_append(double *d)
  260.   {
  261.     float8store(Ptr + str_length, *d);
  262.     str_length += 8;
  263.   }
  264.   void q_append(const char *data, uint32 data_len)
  265.   {
  266.     memcpy(Ptr + str_length, data, data_len);
  267.     str_length += data_len;
  268.   }
  269.   void write_at_position(int position, uint32 value)
  270.   {
  271.     int4store(Ptr + position,value);
  272.   }
  273.   void qs_append(const char *str, uint32 len);
  274.   void qs_append(double d);
  275.   void qs_append(double *d);
  276.   inline void qs_append(const char c)
  277.   {
  278.      Ptr[str_length]= c;
  279.      str_length++;
  280.   }
  281.   /* Inline (general) functions used by the protocol functions */
  282.   inline char *prep_append(uint32 arg_length, uint32 step_alloc)
  283.   {
  284.     uint32 new_length= arg_length + str_length;
  285.     if (new_length > Alloced_length)
  286.     {
  287.       if (realloc(new_length + step_alloc))
  288.         return 0;
  289.     }
  290.     uint32 old_length= str_length;
  291.     str_length+= arg_length;
  292.     return Ptr+ old_length; /* Area to use */
  293.   }
  294.   inline bool append(const char *s, uint32 arg_length, uint32 step_alloc)
  295.   {
  296.     uint32 new_length= arg_length + str_length;
  297.     if (new_length > Alloced_length && realloc(new_length + step_alloc))
  298.       return TRUE;
  299.     memcpy(Ptr+str_length, s, arg_length);
  300.     str_length+= arg_length;
  301.     return FALSE;
  302.   }
  303.   void print(String *print);
  304.   /* Swap two string objects. Efficient way to exchange data without memcpy. */
  305.   void swap(String &s);
  306.   inline bool uses_buffer_owned_by(const String *s) const
  307.   {
  308.     return (s->alloced && Ptr >= s->Ptr && Ptr < s->Ptr + s->str_length);
  309.   }
  310. };