MySQL 之动态字符串处理

1. typedef struct st_dynamic_string
2. {
3. char *str;
4. size_t length,max_length,alloc_increment;
5. } DYNAMIC_STRING;

1. my_bool init_dynamic_string(DYNAMIC_STRING *str, const char *init_str,size_t init_alloc, size_t alloc_increment)
2. {
3. size_t length;
4. DBUG_ENTER("init_dynamic_string");
5.  
6. if (!alloc_increment)
7. alloc_increment=128;
8. length=1;
9. if (init_str && (length= strlen(init_str)+1) < init_alloc)
10. init_alloc=((length+alloc_increment-1)/alloc_increment)*alloc_increment;
11. if (!init_alloc)
12. init_alloc=alloc_increment;
13.  
14. if (!(str->str=(char*) my_malloc(init_alloc,MYF(MY_WME))))
15. DBUG_RETURN(TRUE);
16. str->length=length-1;
17. if (init_str)
18. memcpy(str->str,init_str,length);
19. str->max_length=init_alloc;
20. str->alloc_increment=alloc_increment;
21. DBUG_RETURN(FALSE);
22. }

1. my_bool dynstr_append_mem(DYNAMIC_STRING *str, const char *append,
2. size_t length)
3. {
4. char *new_ptr;
5. if (str->length+length >= str->max_length) //如果新增字符串后，总长度超过缓冲区大小
6. {
7. //需要分配多少个alloc_increment 大小的内存，才能存下新增后的字符串
8. size_t new_length=(str->length+length+str->alloc_increment)/
9. str->alloc_increment;
10. new_length*=str->alloc_increment;
11.  
12. if (!(new_ptr=(char*) my_realloc(str->str,new_length,MYF(MY_WME))))
13. return TRUE;
14. str->str=new_ptr;
15. str->max_length=new_length;
16. }
17. //将新分配的内容，append到str之后
18. memcpy(str->str + str->length,append,length);
19. str->length+=length; //扩容之后str新的长度
20. str->str[str->length]=0; /* Safety for C programs */ //字符串最后一个字符为’\0'
21. return FALSE;
22. }

1. my_bool dynstr_trunc(DYNAMIC_STRING *str, size_t n)
2. {
3. str->length-=n;
4. str->str[str->length]= '\0';
5. return FALSE;
6. }

1. char *strcend(register const char *s, register pchar c)
2. {
3. for (;;)
4. {
5. if (*s == (char) c) return (char*) s;
6. if (!*s++) return (char*) s-1;
7. }
8. }

1. my_bool dynstr_realloc(DYNAMIC_STRING *str, size_t additional_size)
2. {
3. DBUG_ENTER("dynstr_realloc");
4.  
5. if (!additional_size) DBUG_RETURN(FALSE);
6. if (str->length + additional_size > str->max_length) //如果新的字符串内容超过缓冲区的最大长度
7. {
8. str->max_length=((str->length + additional_size+str->alloc_increment-1)/
9. str->alloc_increment)*str->alloc_increment;
10. if (!(str->str=(char*) my_realloc(str->str,str->max_length,MYF(MY_WME))))
11. DBUG_RETURN(TRUE);
12. }
13. DBUG_RETURN(FALSE);
14. }

1. /*
2. Concatenates any number of strings, escapes any OS quote in the result then
3. surround the whole affair in another set of quotes which is finally appended
4. to specified DYNAMIC_STRING. This function is especially useful when
5. building strings to be executed with the system() function.
6.  
7. @param str Dynamic String which will have addtional strings appended.
8. @param append String to be appended.
9. @param ... Optional. Additional string(s) to be appended.
10.  
11. @note The final argument in the list must be NullS even if no additional
12. options are passed.
13.  
14. @return True = Success.
15. */
16.  
17. my_bool dynstr_append_os_quoted(DYNAMIC_STRING *str, const char *append, ...)
18. {
19.  
20. const char *quote_str= "\'";
21. const uint quote_len= 1;
22. my_bool ret= TRUE;
23. va_list dirty_text;
24.  
25. ret&= dynstr_append_mem(str, quote_str, quote_len); /* Leading quote */
26. va_start(dirty_text, append);
27. while (append != NullS)
28. {
29. const char *cur_pos= append;
30. const char *next_pos= cur_pos;
31.  
32. /* Search for quote in each string and replace with escaped quote */
33. while(*(next_pos= strcend(cur_pos, quote_str[0])) != '\0')
34. {
35. ret&= dynstr_append_mem(str, cur_pos, (uint) (next_pos - cur_pos));
36. ret&= dynstr_append_mem(str ,"\\", 1);
37. ret&= dynstr_append_mem(str, quote_str, quote_len);
38. cur_pos= next_pos + 1;
39. }
40. ret&= dynstr_append_mem(str, cur_pos, (uint) (next_pos - cur_pos));
41. append= va_arg(dirty_text, char *);
42. }
43. va_end(dirty_text);
44. ret&= dynstr_append_mem(str, quote_str, quote_len); /* Trailing quote */
45.  
46. return ret;
47. }