LCOV - code coverage report
Current view: top level - sql/common - sql_string.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 33 70 47.1 %
Date: 2021-10-13 02:24:04 Functions: 5 11 45.5 %

          Line data    Source code
       1             : /*
       2             :  * This Source Code Form is subject to the terms of the Mozilla Public
       3             :  * License, v. 2.0.  If a copy of the MPL was not distributed with this
       4             :  * file, You can obtain one at http://mozilla.org/MPL/2.0/.
       5             :  *
       6             :  * Copyright 1997 - July 2008 CWI, August 2008 - 2021 MonetDB B.V.
       7             :  */
       8             : 
       9             : #include "monetdb_config.h"
      10             : #include "sql_mem.h"
      11             : #include "gdk.h"
      12             : #include "sql_string.h"
      13             : #include "mal_exception.h"
      14             : 
      15             : /*
      16             :  * some string functions.
      17             :  */
      18             : 
      19             : /* implace cast to lower case string */
      20             : char *
      21    10429487 : mkLower(char *s)
      22             : {
      23             :         char *r = s;
      24             : 
      25    60585600 :         while (*s) {
      26    50156113 :                 *s = (char) tolower(*s);
      27    50156113 :                 s++;
      28             :         }
      29    10429487 :         return r;
      30             : }
      31             : 
      32             : static char *
      33           0 : mkUpper(char *s)
      34             : {
      35             :         char *r = s;
      36             : 
      37           0 :         while (*s) {
      38           0 :                 *s = (char) toupper(*s);
      39           0 :                 s++;
      40             :         }
      41           0 :         return r;
      42             : }
      43             : 
      44             : char *
      45       98654 : toLower(const char *s)
      46             : {
      47       98654 :         char *r = _STRDUP(s);
      48             : 
      49       98654 :         return r ? mkLower(r) : NULL;
      50             : }
      51             : 
      52             : char *
      53           0 : toUpper(const char *s)
      54             : {
      55           0 :         char *r = _STRDUP(s);
      56             : 
      57           0 :         return r ? mkUpper(r) : NULL;
      58             : }
      59             : 
      60             : /* concat s1,s2 into a new result string */
      61             : char *
      62           0 : strconcat(const char *s1, const char *s2)
      63             : {
      64           0 :         size_t i, j, l1 = strlen(s1);
      65           0 :         size_t l2 = strlen(s2) + 1;
      66           0 :         char *new_s = NEW_ARRAY(char, l1 + l2);
      67             : 
      68           0 :         if (new_s) {
      69           0 :                 for (i = 0; i < l1; i++) {
      70           0 :                         new_s[i] = s1[i];
      71             :                 }
      72           0 :                 for (j = 0; j < l2; j++, i++) {
      73           0 :                         new_s[i] = s2[j];
      74             :                 }
      75             :         }
      76           0 :         return new_s;
      77             : }
      78             : 
      79             : char *
      80           0 : strip_extra_zeros(char *s)
      81             : {
      82             :         char *res = s;
      83             : 
      84           0 :         for (; *s && isspace((unsigned char) *s); s++)
      85             :                 ;
      86             :         res = s;
      87             :         /* find end, and strip extra 0's */
      88           0 :         for (; *s; s++) ;
      89           0 :         s--;
      90           0 :         for (; *s && *s == '0' && s[-1] == '0'; s--)
      91             :                 ;
      92             :         s++;
      93           0 :         *s = 0;
      94           0 :         return res;
      95             : }
      96             : 
      97             : char *
      98           0 : sql_strdup(char *s)
      99             : {
     100           0 :         size_t l = strlen(s);
     101           0 :         char *r = NEW_ARRAY(char, l);
     102             : 
     103           0 :         if (r) {
     104           0 :                 memcpy(r, s + 1, l - 2);
     105           0 :                 r[l - 2] = 0;
     106             :         }
     107           0 :         return r;
     108             : }
     109             : 
     110             : char *
     111      119175 : sql_escape_str(sql_allocator *sa, char *s)
     112             : {
     113      119175 :         size_t l = strlen(s);
     114      119175 :         char *res, *r = SA_NEW_ARRAY(sa, char, (l * 2) + 1);
     115             : 
     116             :         res = r;
     117      119175 :         if (res) {
     118    27722964 :                 while (*s) {
     119    27603789 :                         if (*s == '\'' || *s == '\\') {
     120      236421 :                                 *r++ = '\\';
     121             :                         }
     122    27603789 :                         *r++ = *s++;
     123             :                 }
     124      119175 :                 *r = '\0';
     125             :         }
     126      119175 :         return res;
     127             : }
     128             : 
     129             : const char *
     130      500051 : sql_escape_ident(sql_allocator *sa, const char *s)
     131             : {
     132      500051 :         size_t l = strlen(s);
     133      500051 :         char *res, *r = SA_NEW_ARRAY(sa, char, (l * 2) + 1);
     134             : 
     135             :         res = r;
     136      500051 :         if (res) {
     137     1658581 :                 while (*s) {
     138     1158530 :                         if (*s == '"' || *s == '\\') {
     139          11 :                                 *r++ = '\\';
     140             :                         }
     141     1158530 :                         *r++ = *s++;
     142             :                 }
     143      500051 :                 *r = '\0';
     144             :         }
     145      500051 :         return res;
     146             : }
     147             : 
     148           0 : char *sql_message( const char *format, ... )
     149             : {
     150             :         char buf[BUFSIZ];
     151             :         va_list ap;
     152             : 
     153           0 :         va_start (ap,format);
     154           0 :         (void) vsnprintf( buf, BUFSIZ, format, ap);
     155           0 :         va_end (ap);
     156           0 :         return GDKstrdup(buf);
     157             : }
     158             : 
     159       29192 : char *sa_message( sql_allocator *sa, const char *format, ... )
     160             : {
     161             :         char buf[BUFSIZ];
     162             :         va_list ap;
     163             : 
     164       29192 :         va_start (ap,format);
     165       29192 :         (void) vsnprintf( buf, BUFSIZ, format, ap);
     166       29192 :         va_end (ap);
     167       29192 :         return sa_strdup(sa, buf);
     168             : }
     169             : 

Generated by: LCOV version 1.14