LCOV - code coverage report
Current view: top level - sql/server - rel_prop.c (source / functions) Hit Total Coverage
Test: coverage.info Lines: 34 41 82.9 %
Date: 2021-10-13 02:24:04 Functions: 6 6 100.0 %

          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_relation.h"
      11             : #include "rel_prop.h"
      12             : #include "sql_string.h"
      13             : 
      14             : prop *
      15      521502 : prop_create( sql_allocator *sa, rel_prop kind, prop *pre )
      16             : {
      17      521502 :         prop *p = SA_NEW(sa, prop);
      18             : 
      19      521502 :         *p = (prop) {
      20             :                 .kind = kind,
      21             :                 .p = pre,
      22             :         };
      23      521502 :         return p;
      24             : }
      25             : 
      26             : prop *
      27     9875959 : prop_copy( sql_allocator *sa, prop *p )
      28             : {
      29             :         prop *np = NULL;
      30             : 
      31    10169843 :         for(; p; p = p->p) {
      32      293884 :                 np = prop_create(sa, p->kind, np);
      33      293884 :                 np->value = p->value;
      34             :         }
      35     9875959 :         return np;
      36             : }
      37             : 
      38             : prop *
      39         420 : prop_remove( prop *plist, prop *p )
      40             : {
      41             :         prop *op = plist;
      42             : 
      43         420 :         if (plist == p)
      44         420 :                 return p->p;
      45           0 :         for(; op; op = op->p) {
      46           0 :                 if (op->p == p) {
      47           0 :                         op->p = p->p;
      48           0 :                         break;
      49             :                 }
      50             :         }
      51             :         return plist;
      52             : }
      53             : 
      54             : prop *
      55    22788051 : find_prop( prop *p, rel_prop kind)
      56             : {
      57    24139762 :         while(p) {
      58     1966792 :                 if (p->kind == kind)
      59      615081 :                         return p;
      60     1351711 :                 p = p->p;
      61             :         }
      62             :         return p;
      63             : }
      64             : 
      65             : const char *
      66         624 : propkind2string( prop *p)
      67             : {
      68         624 :         switch(p->kind) {
      69             : #define PT(TYPE) case PROP_##TYPE : return #TYPE
      70             :                 PT(COUNT);
      71          66 :                 PT(JOINIDX);
      72           1 :                 PT(HASHIDX);
      73         431 :                 PT(HASHCOL);
      74         126 :                 PT(REMOTE);
      75           0 :                 PT(USED);
      76           0 :                 PT(GROUPINGS);
      77             :         }
      78           0 :         return "UNKNOWN";
      79             : }
      80             : 
      81             : char *
      82         624 : propvalue2string(sql_allocator *sa, prop *p)
      83             : {
      84             :         char buf [BUFSIZ];
      85             : 
      86         624 :         if (p->value) {
      87         613 :                 switch(p->kind) {
      88          66 :                 case PROP_JOINIDX: {
      89             :                    sql_idx *i = p->value;
      90             : 
      91          66 :                    snprintf(buf, BUFSIZ, "\"%s\".\"%s\".\"%s\"", sql_escape_ident(sa, i->t->s->base.name),
      92          66 :                                         sql_escape_ident(sa, i->t->base.name), sql_escape_ident(sa, i->base.name));
      93          66 :                    return sa_strdup(sa, buf);
      94             :                 }
      95         126 :                 case PROP_REMOTE: {
      96             :                         char *uri = p->value;
      97             : 
      98         126 :                         return sa_strdup(sa, uri);
      99             :                 }
     100             :                 default:
     101             :                         break;
     102             :                 }
     103          11 :         }
     104         432 :         return sa_strdup(sa, "");
     105             : }

Generated by: LCOV version 1.14