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