LCOV - differential code coverage report
Current view: top level - src/backend/utils/misc - help_config.c (source / functions) Coverage Total Hit UNC UIC UBC EUB DUB
Current: Differential Code Coverage HEAD vs 15 Lines: 0.0 % 33 0 1 22 10 22 1
Current Date: 2023-04-08 17:13:01 Functions: 0.0 % 3 0 1 2 2
Baseline: 15 Line coverage date bins:
Baseline Date: 2023-04-08 15:09:40 (120,180] days: 0.0 % 1 0 1
Legend: Lines: hit not hit (240..) days: 0.0 % 32 0 22 10 22
Function coverage date bins:
(240..) days: 0.0 % 5 0 1 2 2

 Age         Owner                  TLA  Line data    Source code
                                  1                 : /*-------------------------------------------------------------------------
                                  2                 :  * help_config.c
                                  3                 :  *
                                  4                 :  * Displays available options under grand unified configuration scheme
                                  5                 :  *
                                  6                 :  * Options whose flag bits are set to GUC_NO_SHOW_ALL, GUC_NOT_IN_SAMPLE,
                                  7                 :  * or GUC_DISALLOW_IN_FILE are not displayed, unless the user specifically
                                  8                 :  * requests that variable by name
                                  9                 :  *
                                 10                 :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
                                 11                 :  *
                                 12                 :  * IDENTIFICATION
                                 13                 :  *    src/backend/utils/misc/help_config.c
                                 14                 :  *
                                 15                 :  *-------------------------------------------------------------------------
                                 16                 :  */
                                 17                 : #include "postgres.h"
                                 18                 : 
                                 19                 : #include <limits.h>
                                 20                 : #include <unistd.h>
                                 21                 : 
                                 22                 : #include "utils/guc_tables.h"
                                 23                 : #include "utils/help_config.h"
                                 24                 : 
                                 25                 : 
                                 26                 : /*
                                 27                 :  * This union allows us to mix the numerous different types of structs
                                 28                 :  * that we are organizing.
                                 29                 :  */
                                 30                 : typedef union
                                 31                 : {
                                 32                 :     struct config_generic generic;
                                 33                 :     struct config_bool _bool;
                                 34                 :     struct config_real real;
                                 35                 :     struct config_int integer;
                                 36                 :     struct config_string string;
                                 37                 :     struct config_enum _enum;
                                 38                 : } mixedStruct;
                                 39                 : 
                                 40                 : 
                                 41                 : static void printMixedStruct(mixedStruct *structToPrint);
                                 42                 : static bool displayStruct(mixedStruct *structToDisplay);
                                 43                 : 
                                 44                 : 
                                 45                 : void
 7113 peter_e                    46 UBC           0 : GucInfoMain(void)
                                 47                 : {
                                 48                 :     struct config_generic **guc_vars;
                                 49                 :     int         numOpts,
                                 50                 :                 i;
                                 51                 : 
                                 52                 :     /* Initialize the GUC hash table */
 7219 tgl                        53               0 :     build_guc_variables();
                                 54                 : 
  177 tgl                        55 UNC           0 :     guc_vars = get_guc_variables(&numOpts);
 6885 tgl                        56 EUB             : 
 6892 bruce                      57 UIC           0 :     for (i = 0; i < numOpts; i++)
 7219 tgl                        58 EUB             :     {
 6892 bruce                      59 UIC           0 :         mixedStruct *var = (mixedStruct *) guc_vars[i];
 7219 tgl                        60 EUB             : 
 7113 peter_e                    61 UBC           0 :         if (displayStruct(var))
 7113 peter_e                    62 UIC           0 :             printMixedStruct(var);
                                 63                 :     }
 7219 tgl                        64 EUB             : 
 3940 peter_e                    65 UIC           0 :     exit(0);
                                 66                 : }
                                 67                 : 
                                 68                 : 
                                 69                 : /*
                                 70                 :  * This function will return true if the struct passed to it
                                 71                 :  * should be displayed to the user.
                                 72                 :  */
 7219 tgl                        73 EUB             : static bool
 7184 bruce                      74 UIC           0 : displayStruct(mixedStruct *structToDisplay)
 7219 tgl                        75 EUB             : {
 7113 peter_e                    76 UIC           0 :     return !(structToDisplay->generic.flags & (GUC_NO_SHOW_ALL |
                                 77                 :                                                GUC_NOT_IN_SAMPLE |
                                 78                 :                                                GUC_DISALLOW_IN_FILE));
                                 79                 : }
                                 80                 : 
                                 81                 : 
                                 82                 : /*
                                 83                 :  * This function prints out the generic struct passed to it. It will print out
                                 84                 :  * a different format, depending on what the user wants to see.
                                 85                 :  */
 7219 tgl                        86 EUB             : static void
 7184 bruce                      87 UIC           0 : printMixedStruct(mixedStruct *structToPrint)
 7219 tgl                        88 EUB             : {
 7113 peter_e                    89 UIC           0 :     printf("%s\t%s\t%s\t",
                                 90                 :            structToPrint->generic.name,
                                 91                 :            GucContext_Names[structToPrint->generic.context],
                                 92                 :            _(config_group_names[structToPrint->generic.group]));
 7219 tgl                        93 EUB             : 
 7219 tgl                        94 UIC           0 :     switch (structToPrint->generic.vartype)
                                 95                 :     {
 7219 tgl                        96 EUB             : 
 7219 tgl                        97 UBC           0 :         case PGC_BOOL:
 7113 peter_e                    98 UIC           0 :             printf("BOOLEAN\t%s\t\t\t",
                                 99                 :                    (structToPrint->_bool.reset_val == 0) ?
 7113 peter_e                   100 EUB             :                    "FALSE" : "TRUE");
 7219 tgl                       101 UIC           0 :             break;
 7219 tgl                       102 EUB             : 
 7219 tgl                       103 UBC           0 :         case PGC_INT:
 7113 peter_e                   104 UIC           0 :             printf("INTEGER\t%d\t%d\t%d\t",
                                105                 :                    structToPrint->integer.reset_val,
                                106                 :                    structToPrint->integer.min,
 7219 tgl                       107 EUB             :                    structToPrint->integer.max);
 7219 tgl                       108 UIC           0 :             break;
 7219 tgl                       109 EUB             : 
 7219 tgl                       110 UBC           0 :         case PGC_REAL:
 7113 peter_e                   111 UIC           0 :             printf("REAL\t%g\t%g\t%g\t",
                                112                 :                    structToPrint->real.reset_val,
                                113                 :                    structToPrint->real.min,
 7219 tgl                       114 EUB             :                    structToPrint->real.max);
 7219 tgl                       115 UIC           0 :             break;
 7219 tgl                       116 EUB             : 
 7219 tgl                       117 UBC           0 :         case PGC_STRING:
 7113 peter_e                   118 UIC           0 :             printf("STRING\t%s\t\t\t",
 5524 tgl                       119 EUB             :                    structToPrint->string.boot_val ? structToPrint->string.boot_val : "");
 7219 tgl                       120 UIC           0 :             break;
 7219 tgl                       121 EUB             : 
 5501 magnus                    122 UBC           0 :         case PGC_ENUM:
 5501 magnus                    123 UIC           0 :             printf("ENUM\t%s\t\t\t",
                                124                 :                    config_enum_lookup_by_value(&structToPrint->_enum,
 2118 tgl                       125 EUB             :                                                structToPrint->_enum.boot_val));
 5501 magnus                    126 UIC           0 :             break;
 5501 magnus                    127 EUB             : 
 7219 tgl                       128 UBC           0 :         default:
 6863                           129               0 :             write_stderr("internal error: unrecognized run-time parameter type\n");
 7219 tgl                       130 UIC           0 :             break;
                                131                 :     }
 7219 tgl                       132 EUB             : 
 7113 peter_e                   133 UIC           0 :     printf("%s\t%s\n",
                                134                 :            (structToPrint->generic.short_desc == NULL) ? "" : _(structToPrint->generic.short_desc),
 6620 bruce                     135 EUB             :            (structToPrint->generic.long_desc == NULL) ? "" : _(structToPrint->generic.long_desc));
 7219 tgl                       136 UIC           0 : }
        

Generated by: LCOV version v1.16-55-g56c0a2a