LCOV - code coverage report
Current view: top level - src/bin/psql - crosstabview.c (source / functions) Hit Total Coverage
Test: PostgreSQL 12beta2 Lines: 225 235 95.7 %
Date: 2019-06-18 07:06:57 Functions: 15 15 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*
       2             :  * psql - the PostgreSQL interactive terminal
       3             :  *
       4             :  * Copyright (c) 2000-2019, PostgreSQL Global Development Group
       5             :  *
       6             :  * src/bin/psql/crosstabview.c
       7             :  */
       8             : #include "postgres_fe.h"
       9             : 
      10             : #include "common.h"
      11             : #include "crosstabview.h"
      12             : #include "pqexpbuffer.h"
      13             : #include "psqlscanslash.h"
      14             : #include "settings.h"
      15             : 
      16             : #include "common/logging.h"
      17             : 
      18             : /*
      19             :  * Value/position from the resultset that goes into the horizontal or vertical
      20             :  * crosstabview header.
      21             :  */
      22             : typedef struct _pivot_field
      23             : {
      24             :     /*
      25             :      * Pointer obtained from PQgetvalue() for colV or colH. Each distinct
      26             :      * value becomes an entry in the vertical header (colV), or horizontal
      27             :      * header (colH). A Null value is represented by a NULL pointer.
      28             :      */
      29             :     char       *name;
      30             : 
      31             :     /*
      32             :      * When a sort is requested on an alternative column, this holds
      33             :      * PQgetvalue() for the sort column corresponding to <name>. If <name>
      34             :      * appear multiple times, it's the first value in the order of the results
      35             :      * that is kept. A Null value is represented by a NULL pointer.
      36             :      */
      37             :     char       *sort_value;
      38             : 
      39             :     /*
      40             :      * Rank of this value, starting at 0. Initially, it's the relative
      41             :      * position of the first appearance of <name> in the resultset. For
      42             :      * example, if successive rows contain B,A,C,A,D then it's B:0,A:1,C:2,D:3
      43             :      * When a sort column is specified, ranks get updated in a final pass to
      44             :      * reflect the desired order.
      45             :      */
      46             :     int         rank;
      47             : } pivot_field;
      48             : 
      49             : /* Node in avl_tree */
      50             : typedef struct _avl_node
      51             : {
      52             :     /* Node contents */
      53             :     pivot_field field;
      54             : 
      55             :     /*
      56             :      * Height of this node in the tree (number of nodes on the longest path to
      57             :      * a leaf).
      58             :      */
      59             :     int         height;
      60             : 
      61             :     /*
      62             :      * Child nodes. [0] points to left subtree, [1] to right subtree. Never
      63             :      * NULL, points to the empty node avl_tree.end when no left or right
      64             :      * value.
      65             :      */
      66             :     struct _avl_node *children[2];
      67             : } avl_node;
      68             : 
      69             : /*
      70             :  * Control structure for the AVL tree (binary search tree kept
      71             :  * balanced with the AVL algorithm)
      72             :  */
      73             : typedef struct _avl_tree
      74             : {
      75             :     int         count;          /* Total number of nodes */
      76             :     avl_node   *root;           /* root of the tree */
      77             :     avl_node   *end;            /* Immutable dereferenceable empty tree */
      78             : } avl_tree;
      79             : 
      80             : 
      81             : static bool printCrosstab(const PGresult *results,
      82             :                           int num_columns, pivot_field *piv_columns, int field_for_columns,
      83             :                           int num_rows, pivot_field *piv_rows, int field_for_rows,
      84             :                           int field_for_data);
      85             : static void avlInit(avl_tree *tree);
      86             : static void avlMergeValue(avl_tree *tree, char *name, char *sort_value);
      87             : static int  avlCollectFields(avl_tree *tree, avl_node *node,
      88             :                              pivot_field *fields, int idx);
      89             : static void avlFree(avl_tree *tree, avl_node *node);
      90             : static void rankSort(int num_columns, pivot_field *piv_columns);
      91             : static int  indexOfColumn(char *arg, const PGresult *res);
      92             : static int  pivotFieldCompare(const void *a, const void *b);
      93             : static int  rankCompare(const void *a, const void *b);
      94             : 
      95             : 
      96             : /*
      97             :  * Main entry point to this module.
      98             :  *
      99             :  * Process the data from *res according to the options in pset (global),
     100             :  * to generate the horizontal and vertical headers contents,
     101             :  * then call printCrosstab() for the actual output.
     102             :  */
     103             : bool
     104          88 : PrintResultsInCrosstab(const PGresult *res)
     105             : {
     106          88 :     bool        retval = false;
     107             :     avl_tree    piv_columns;
     108             :     avl_tree    piv_rows;
     109          88 :     pivot_field *array_columns = NULL;
     110          88 :     pivot_field *array_rows = NULL;
     111          88 :     int         num_columns = 0;
     112          88 :     int         num_rows = 0;
     113             :     int         field_for_rows;
     114             :     int         field_for_columns;
     115             :     int         field_for_data;
     116             :     int         sort_field_for_columns;
     117             :     int         rn;
     118             : 
     119          88 :     avlInit(&piv_rows);
     120          88 :     avlInit(&piv_columns);
     121             : 
     122          88 :     if (PQresultStatus(res) != PGRES_TUPLES_OK)
     123             :     {
     124           0 :         pg_log_error("\\crosstabview: statement did not return a result set");
     125           0 :         goto error_return;
     126             :     }
     127             : 
     128          88 :     if (PQnfields(res) < 3)
     129             :     {
     130           8 :         pg_log_error("\\crosstabview: query must return at least three columns");
     131           8 :         goto error_return;
     132             :     }
     133             : 
     134             :     /* Process first optional arg (vertical header column) */
     135          80 :     if (pset.ctv_args[0] == NULL)
     136          20 :         field_for_rows = 0;
     137             :     else
     138             :     {
     139          60 :         field_for_rows = indexOfColumn(pset.ctv_args[0], res);
     140          60 :         if (field_for_rows < 0)
     141           0 :             goto error_return;
     142             :     }
     143             : 
     144             :     /* Process second optional arg (horizontal header column) */
     145          80 :     if (pset.ctv_args[1] == NULL)
     146          20 :         field_for_columns = 1;
     147             :     else
     148             :     {
     149          60 :         field_for_columns = indexOfColumn(pset.ctv_args[1], res);
     150          60 :         if (field_for_columns < 0)
     151           4 :             goto error_return;
     152             :     }
     153             : 
     154             :     /* Insist that header columns be distinct */
     155          76 :     if (field_for_columns == field_for_rows)
     156             :     {
     157           4 :         pg_log_error("\\crosstabview: vertical and horizontal headers must be different columns");
     158           4 :         goto error_return;
     159             :     }
     160             : 
     161             :     /* Process third optional arg (data column) */
     162          72 :     if (pset.ctv_args[2] == NULL)
     163             :     {
     164             :         int         i;
     165             : 
     166             :         /*
     167             :          * If the data column was not specified, we search for the one not
     168             :          * used as either vertical or horizontal headers.  Must be exactly
     169             :          * three columns, or this won't be unique.
     170             :          */
     171          20 :         if (PQnfields(res) != 3)
     172             :         {
     173           0 :             pg_log_error("\\crosstabview: data column must be specified when query returns more than three columns");
     174           0 :             goto error_return;
     175             :         }
     176             : 
     177          20 :         field_for_data = -1;
     178          60 :         for (i = 0; i < PQnfields(res); i++)
     179             :         {
     180          60 :             if (i != field_for_rows && i != field_for_columns)
     181             :             {
     182          20 :                 field_for_data = i;
     183          20 :                 break;
     184             :             }
     185             :         }
     186             :         Assert(field_for_data >= 0);
     187             :     }
     188             :     else
     189             :     {
     190          52 :         field_for_data = indexOfColumn(pset.ctv_args[2], res);
     191          52 :         if (field_for_data < 0)
     192          12 :             goto error_return;
     193             :     }
     194             : 
     195             :     /* Process fourth optional arg (horizontal header sort column) */
     196          60 :     if (pset.ctv_args[3] == NULL)
     197          40 :         sort_field_for_columns = -1;    /* no sort column */
     198             :     else
     199             :     {
     200          20 :         sort_field_for_columns = indexOfColumn(pset.ctv_args[3], res);
     201          20 :         if (sort_field_for_columns < 0)
     202           0 :             goto error_return;
     203             :     }
     204             : 
     205             :     /*
     206             :      * First part: accumulate the names that go into the vertical and
     207             :      * horizontal headers, each into an AVL binary tree to build the set of
     208             :      * DISTINCT values.
     209             :      */
     210             : 
     211        6748 :     for (rn = 0; rn < PQntuples(res); rn++)
     212             :     {
     213             :         char       *val;
     214             :         char       *val1;
     215             : 
     216             :         /* horizontal */
     217        6692 :         val = PQgetisnull(res, rn, field_for_columns) ? NULL :
     218             :             PQgetvalue(res, rn, field_for_columns);
     219        6692 :         val1 = NULL;
     220             : 
     221        6792 :         if (sort_field_for_columns >= 0 &&
     222         100 :             !PQgetisnull(res, rn, sort_field_for_columns))
     223         100 :             val1 = PQgetvalue(res, rn, sort_field_for_columns);
     224             : 
     225        6692 :         avlMergeValue(&piv_columns, val, val1);
     226             : 
     227        6692 :         if (piv_columns.count > CROSSTABVIEW_MAX_COLUMNS)
     228             :         {
     229           4 :             pg_log_error("\\crosstabview: maximum number of columns (%d) exceeded",
     230             :                          CROSSTABVIEW_MAX_COLUMNS);
     231           4 :             goto error_return;
     232             :         }
     233             : 
     234             :         /* vertical */
     235        6688 :         val = PQgetisnull(res, rn, field_for_rows) ? NULL :
     236             :             PQgetvalue(res, rn, field_for_rows);
     237             : 
     238        6688 :         avlMergeValue(&piv_rows, val, NULL);
     239             :     }
     240             : 
     241             :     /*
     242             :      * Second part: Generate sorted arrays from the AVL trees.
     243             :      */
     244             : 
     245          56 :     num_columns = piv_columns.count;
     246          56 :     num_rows = piv_rows.count;
     247             : 
     248          56 :     array_columns = (pivot_field *)
     249          56 :         pg_malloc(sizeof(pivot_field) * num_columns);
     250             : 
     251          56 :     array_rows = (pivot_field *)
     252          56 :         pg_malloc(sizeof(pivot_field) * num_rows);
     253             : 
     254          56 :     avlCollectFields(&piv_columns, piv_columns.root, array_columns, 0);
     255          56 :     avlCollectFields(&piv_rows, piv_rows.root, array_rows, 0);
     256             : 
     257             :     /*
     258             :      * Third part: optionally, process the ranking data for the horizontal
     259             :      * header
     260             :      */
     261          56 :     if (sort_field_for_columns >= 0)
     262          20 :         rankSort(num_columns, array_columns);
     263             : 
     264             :     /*
     265             :      * Fourth part: print the crosstab'ed results.
     266             :      */
     267          56 :     retval = printCrosstab(res,
     268             :                            num_columns, array_columns, field_for_columns,
     269             :                            num_rows, array_rows, field_for_rows,
     270             :                            field_for_data);
     271             : 
     272             : error_return:
     273          88 :     avlFree(&piv_columns, piv_columns.root);
     274          88 :     avlFree(&piv_rows, piv_rows.root);
     275          88 :     pg_free(array_columns);
     276          88 :     pg_free(array_rows);
     277             : 
     278          88 :     return retval;
     279             : }
     280             : 
     281             : /*
     282             :  * Output the pivoted resultset with the printTable* functions.  Return true
     283             :  * if successful, false otherwise.
     284             :  */
     285             : static bool
     286          56 : printCrosstab(const PGresult *results,
     287             :               int num_columns, pivot_field *piv_columns, int field_for_columns,
     288             :               int num_rows, pivot_field *piv_rows, int field_for_rows,
     289             :               int field_for_data)
     290             : {
     291          56 :     printQueryOpt popt = pset.popt;
     292             :     printTableContent cont;
     293             :     int         i,
     294             :                 rn;
     295             :     char        col_align;
     296             :     int        *horiz_map;
     297          56 :     bool        retval = false;
     298             : 
     299          56 :     printTableInit(&cont, &popt.topt, popt.title, num_columns + 1, num_rows);
     300             : 
     301             :     /* Step 1: set target column names (horizontal header) */
     302             : 
     303             :     /* The name of the first column is kept unchanged by the pivoting */
     304          56 :     printTableAddHeader(&cont,
     305             :                         PQfname(results, field_for_rows),
     306             :                         false,
     307          56 :                         column_type_alignment(PQftype(results,
     308             :                                                       field_for_rows)));
     309             : 
     310             :     /*
     311             :      * To iterate over piv_columns[] by piv_columns[].rank, create a reverse
     312             :      * map associating each piv_columns[].rank to its index in piv_columns.
     313             :      * This avoids an O(N^2) loop later.
     314             :      */
     315          56 :     horiz_map = (int *) pg_malloc(sizeof(int) * num_columns);
     316         308 :     for (i = 0; i < num_columns; i++)
     317         252 :         horiz_map[piv_columns[i].rank] = i;
     318             : 
     319             :     /*
     320             :      * The display alignment depends on its PQftype().
     321             :      */
     322          56 :     col_align = column_type_alignment(PQftype(results, field_for_data));
     323             : 
     324         308 :     for (i = 0; i < num_columns; i++)
     325             :     {
     326             :         char       *colname;
     327             : 
     328         504 :         colname = piv_columns[horiz_map[i]].name ?
     329         280 :             piv_columns[horiz_map[i]].name :
     330          28 :             (popt.nullPrint ? popt.nullPrint : "");
     331             : 
     332         252 :         printTableAddHeader(&cont, colname, false, col_align);
     333             :     }
     334          56 :     pg_free(horiz_map);
     335             : 
     336             :     /* Step 2: set row names in the first output column (vertical header) */
     337         204 :     for (i = 0; i < num_rows; i++)
     338             :     {
     339         148 :         int         k = piv_rows[i].rank;
     340             : 
     341         296 :         cont.cells[k * (num_columns + 1)] = piv_rows[i].name ?
     342         156 :             piv_rows[i].name :
     343           8 :             (popt.nullPrint ? popt.nullPrint : "");
     344             :     }
     345          56 :     cont.cellsadded = num_rows * (num_columns + 1);
     346             : 
     347             :     /*
     348             :      * Step 3: fill in the content cells.
     349             :      */
     350         680 :     for (rn = 0; rn < PQntuples(results); rn++)
     351             :     {
     352             :         int         row_number;
     353             :         int         col_number;
     354             :         pivot_field *rp,
     355             :                    *cp;
     356             :         pivot_field elt;
     357             : 
     358             :         /* Find target row */
     359         288 :         if (!PQgetisnull(results, rn, field_for_rows))
     360         280 :             elt.name = PQgetvalue(results, rn, field_for_rows);
     361             :         else
     362           8 :             elt.name = NULL;
     363         288 :         rp = (pivot_field *) bsearch(&elt,
     364             :                                      piv_rows,
     365             :                                      num_rows,
     366             :                                      sizeof(pivot_field),
     367             :                                      pivotFieldCompare);
     368             :         Assert(rp != NULL);
     369         288 :         row_number = rp->rank;
     370             : 
     371             :         /* Find target column */
     372         288 :         if (!PQgetisnull(results, rn, field_for_columns))
     373         260 :             elt.name = PQgetvalue(results, rn, field_for_columns);
     374             :         else
     375          28 :             elt.name = NULL;
     376             : 
     377         288 :         cp = (pivot_field *) bsearch(&elt,
     378             :                                      piv_columns,
     379             :                                      num_columns,
     380             :                                      sizeof(pivot_field),
     381             :                                      pivotFieldCompare);
     382             :         Assert(cp != NULL);
     383         288 :         col_number = cp->rank;
     384             : 
     385             :         /* Place value into cell */
     386         288 :         if (col_number >= 0 && row_number >= 0)
     387             :         {
     388             :             int         idx;
     389             : 
     390             :             /* index into the cont.cells array */
     391         288 :             idx = 1 + col_number + row_number * (num_columns + 1);
     392             : 
     393             :             /*
     394             :              * If the cell already contains a value, raise an error.
     395             :              */
     396         288 :             if (cont.cells[idx] != NULL)
     397             :             {
     398           4 :                 pg_log_error("\\crosstabview: query result contains multiple data values for row \"%s\", column \"%s\"",
     399             :                              rp->name ? rp->name :
     400             :                              (popt.nullPrint ? popt.nullPrint : "(null)"),
     401             :                              cp->name ? cp->name :
     402             :                              (popt.nullPrint ? popt.nullPrint : "(null)"));
     403           8 :                 goto error;
     404             :             }
     405             : 
     406         568 :             cont.cells[idx] = !PQgetisnull(results, rn, field_for_data) ?
     407         292 :                 PQgetvalue(results, rn, field_for_data) :
     408           8 :                 (popt.nullPrint ? popt.nullPrint : "");
     409             :         }
     410             :     }
     411             : 
     412             :     /*
     413             :      * The non-initialized cells must be set to an empty string for the print
     414             :      * functions
     415             :      */
     416         768 :     for (i = 0; i < cont.cellsadded; i++)
     417             :     {
     418         716 :         if (cont.cells[i] == NULL)
     419         328 :             cont.cells[i] = "";
     420             :     }
     421             : 
     422          52 :     printTable(&cont, pset.queryFout, false, pset.logfile);
     423          52 :     retval = true;
     424             : 
     425             : error:
     426          56 :     printTableCleanup(&cont);
     427             : 
     428          56 :     return retval;
     429             : }
     430             : 
     431             : /*
     432             :  * The avl* functions below provide a minimalistic implementation of AVL binary
     433             :  * trees, to efficiently collect the distinct values that will form the horizontal
     434             :  * and vertical headers. It only supports adding new values, no removal or even
     435             :  * search.
     436             :  */
     437             : static void
     438         176 : avlInit(avl_tree *tree)
     439             : {
     440         176 :     tree->end = (avl_node *) pg_malloc0(sizeof(avl_node));
     441         176 :     tree->end->children[0] = tree->end->children[1] = tree->end;
     442         176 :     tree->count = 0;
     443         176 :     tree->root = tree->end;
     444         176 : }
     445             : 
     446             : /* Deallocate recursively an AVL tree, starting from node */
     447             : static void
     448       13260 : avlFree(avl_tree *tree, avl_node *node)
     449             : {
     450       13260 :     if (node->children[0] != tree->end)
     451             :     {
     452        6704 :         avlFree(tree, node->children[0]);
     453        6704 :         pg_free(node->children[0]);
     454             :     }
     455       13260 :     if (node->children[1] != tree->end)
     456             :     {
     457        6380 :         avlFree(tree, node->children[1]);
     458        6380 :         pg_free(node->children[1]);
     459             :     }
     460       13260 :     if (node == tree->root)
     461             :     {
     462             :         /* free the root separately as it's not child of anything */
     463         176 :         if (node != tree->end)
     464         120 :             pg_free(node);
     465             :         /* free the tree->end struct only once and when all else is freed */
     466         176 :         pg_free(tree->end);
     467             :     }
     468       13260 : }
     469             : 
     470             : /* Set the height to 1 plus the greatest of left and right heights */
     471             : static void
     472      150324 : avlUpdateHeight(avl_node *n)
     473             : {
     474      150324 :     n->height = 1 + (n->children[0]->height > n->children[1]->height ?
     475      150324 :                      n->children[0]->height :
     476      150324 :                      n->children[1]->height);
     477      150324 : }
     478             : 
     479             : /* Rotate a subtree left (dir=0) or right (dir=1). Not recursive */
     480             : static avl_node *
     481       16140 : avlRotate(avl_node **current, int dir)
     482             : {
     483       16140 :     avl_node   *before = *current;
     484       16140 :     avl_node   *after = (*current)->children[dir];
     485             : 
     486       16140 :     *current = after;
     487       16140 :     before->children[dir] = after->children[!dir];
     488       16140 :     avlUpdateHeight(before);
     489       16140 :     after->children[!dir] = before;
     490             : 
     491       16140 :     return after;
     492             : }
     493             : 
     494             : static int
     495      146068 : avlBalance(avl_node *n)
     496             : {
     497      146068 :     return n->children[0]->height - n->children[1]->height;
     498             : }
     499             : 
     500             : /*
     501             :  * After an insertion, possibly rebalance the tree so that the left and right
     502             :  * node heights don't differ by more than 1.
     503             :  * May update *node.
     504             :  */
     505             : static void
     506      134184 : avlAdjustBalance(avl_tree *tree, avl_node **node)
     507             : {
     508      134184 :     avl_node   *current = *node;
     509      134184 :     int         b = avlBalance(current) / 2;
     510             : 
     511      134184 :     if (b != 0)
     512             :     {
     513       11884 :         int         dir = (1 - b) / 2;
     514             : 
     515       11884 :         if (avlBalance(current->children[dir]) == -b)
     516        4256 :             avlRotate(&current->children[dir], !dir);
     517       11884 :         current = avlRotate(node, dir);
     518             :     }
     519      134184 :     if (current != tree->end)
     520      134184 :         avlUpdateHeight(current);
     521      134184 : }
     522             : 
     523             : /*
     524             :  * Insert a new value/field, starting from *node, reaching the correct position
     525             :  * in the tree by recursion.  Possibly rebalance the tree and possibly update
     526             :  * *node.  Do nothing if the value is already present in the tree.
     527             :  */
     528             : static void
     529      147564 : avlInsertNode(avl_tree *tree, avl_node **node, pivot_field field)
     530             : {
     531      147564 :     avl_node   *current = *node;
     532             : 
     533      147564 :     if (current == tree->end)
     534             :     {
     535       13204 :         avl_node   *new_node = (avl_node *)
     536             :         pg_malloc(sizeof(avl_node));
     537             : 
     538       13204 :         new_node->height = 1;
     539       13204 :         new_node->field = field;
     540       13204 :         new_node->children[0] = new_node->children[1] = tree->end;
     541       13204 :         tree->count++;
     542       13204 :         *node = new_node;
     543             :     }
     544             :     else
     545             :     {
     546      134360 :         int         cmp = pivotFieldCompare(&field, &current->field);
     547             : 
     548      134360 :         if (cmp != 0)
     549             :         {
     550      134184 :             avlInsertNode(tree,
     551             :                           cmp > 0 ? &current->children[1] : &current->children[0],
     552             :                           field);
     553      134184 :             avlAdjustBalance(tree, node);
     554             :         }
     555             :     }
     556      147564 : }
     557             : 
     558             : /* Insert the value into the AVL tree, if it does not preexist */
     559             : static void
     560       13380 : avlMergeValue(avl_tree *tree, char *name, char *sort_value)
     561             : {
     562             :     pivot_field field;
     563             : 
     564       13380 :     field.name = name;
     565       13380 :     field.rank = tree->count;
     566       13380 :     field.sort_value = sort_value;
     567       13380 :     avlInsertNode(tree, &tree->root, field);
     568       13380 : }
     569             : 
     570             : /*
     571             :  * Recursively extract node values into the names array, in sorted order with a
     572             :  * left-to-right tree traversal.
     573             :  * Return the next candidate offset to write into the names array.
     574             :  * fields[] must be preallocated to hold tree->count entries
     575             :  */
     576             : static int
     577         912 : avlCollectFields(avl_tree *tree, avl_node *node, pivot_field *fields, int idx)
     578             : {
     579         912 :     if (node == tree->end)
     580         512 :         return idx;
     581             : 
     582         400 :     idx = avlCollectFields(tree, node->children[0], fields, idx);
     583         400 :     fields[idx] = node->field;
     584         400 :     return avlCollectFields(tree, node->children[1], fields, idx + 1);
     585             : }
     586             : 
     587             : static void
     588          20 : rankSort(int num_columns, pivot_field *piv_columns)
     589             : {
     590             :     int        *hmap;           /* [[offset in piv_columns, rank], ...for
     591             :                                  * every header entry] */
     592             :     int         i;
     593             : 
     594          20 :     hmap = (int *) pg_malloc(sizeof(int) * num_columns * 2);
     595         104 :     for (i = 0; i < num_columns; i++)
     596             :     {
     597          84 :         char       *val = piv_columns[i].sort_value;
     598             : 
     599             :         /* ranking information is valid if non null and matches /^-?\d+$/ */
     600         168 :         if (val &&
     601          84 :             ((*val == '-' &&
     602          84 :               strspn(val + 1, "0123456789") == strlen(val + 1)) ||
     603          84 :              strspn(val, "0123456789") == strlen(val)))
     604             :         {
     605          84 :             hmap[i * 2] = atoi(val);
     606          84 :             hmap[i * 2 + 1] = i;
     607             :         }
     608             :         else
     609             :         {
     610             :             /* invalid rank information ignored (equivalent to rank 0) */
     611           0 :             hmap[i * 2] = 0;
     612           0 :             hmap[i * 2 + 1] = i;
     613             :         }
     614             :     }
     615             : 
     616          20 :     qsort(hmap, num_columns, sizeof(int) * 2, rankCompare);
     617             : 
     618         104 :     for (i = 0; i < num_columns; i++)
     619             :     {
     620          84 :         piv_columns[hmap[i * 2 + 1]].rank = i;
     621             :     }
     622             : 
     623          20 :     pg_free(hmap);
     624          20 : }
     625             : 
     626             : /*
     627             :  * Look up a column reference, which can be either:
     628             :  * - a number from 1 to PQnfields(res)
     629             :  * - a column name matching one of PQfname(res,...)
     630             :  *
     631             :  * Returns zero-based column number, or -1 if not found or ambiguous.
     632             :  *
     633             :  * Note: may modify contents of "arg" string.
     634             :  */
     635             : static int
     636         192 : indexOfColumn(char *arg, const PGresult *res)
     637             : {
     638             :     int         idx;
     639             : 
     640         192 :     if (arg[0] && strspn(arg, "0123456789") == strlen(arg))
     641             :     {
     642             :         /* if arg contains only digits, it's a column number */
     643          64 :         idx = atoi(arg) - 1;
     644         124 :         if (idx < 0 || idx >= PQnfields(res))
     645             :         {
     646           4 :             pg_log_error("\\crosstabview: column number %d is out of range 1..%d",
     647             :                          idx + 1, PQnfields(res));
     648           4 :             return -1;
     649             :         }
     650             :     }
     651             :     else
     652             :     {
     653             :         int         i;
     654             : 
     655             :         /*
     656             :          * Dequote and downcase the column name.  By checking for all-digits
     657             :          * before doing this, we can ensure that a quoted name is treated as a
     658             :          * name even if it's all digits.
     659             :          */
     660         128 :         dequote_downcase_identifier(arg, true, pset.encoding);
     661             : 
     662             :         /* Now look for match(es) among res' column names */
     663         128 :         idx = -1;
     664         608 :         for (i = 0; i < PQnfields(res); i++)
     665             :         {
     666         480 :             if (strcmp(arg, PQfname(res, i)) == 0)
     667             :             {
     668         116 :                 if (idx >= 0)
     669             :                 {
     670             :                     /* another idx was already found for the same name */
     671           0 :                     pg_log_error("\\crosstabview: ambiguous column name: \"%s\"", arg);
     672           0 :                     return -1;
     673             :                 }
     674         116 :                 idx = i;
     675             :             }
     676             :         }
     677         128 :         if (idx == -1)
     678             :         {
     679          12 :             pg_log_error("\\crosstabview: column name not found: \"%s\"", arg);
     680          12 :             return -1;
     681             :         }
     682             :     }
     683             : 
     684         176 :     return idx;
     685             : }
     686             : 
     687             : /*
     688             :  * Value comparator for vertical and horizontal headers
     689             :  * used for deduplication only.
     690             :  * - null values are considered equal
     691             :  * - non-null < null
     692             :  * - non-null values are compared with strcmp()
     693             :  */
     694             : static int
     695      135424 : pivotFieldCompare(const void *a, const void *b)
     696             : {
     697      135424 :     const pivot_field *pa = (const pivot_field *) a;
     698      135424 :     const pivot_field *pb = (const pivot_field *) b;
     699             : 
     700             :     /* test null values */
     701      135424 :     if (!pb->name)
     702          88 :         return pa->name ? -1 : 0;
     703      135336 :     else if (!pa->name)
     704          68 :         return 1;
     705             : 
     706             :     /* non-null values */
     707      135268 :     return strcmp(pa->name, pb->name);
     708             : }
     709             : 
     710             : static int
     711          96 : rankCompare(const void *a, const void *b)
     712             : {
     713          96 :     return *((const int *) a) - *((const int *) b);
     714             : }

Generated by: LCOV version 1.13