LCOV - code coverage report
Current view: top level - src/backend/utils/adt - tsquery_rewrite.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 165 187 88.2 %
Date: 2019-09-22 07:07:17 Functions: 5 5 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * tsquery_rewrite.c
       4             :  *    Utilities for reconstructing tsquery
       5             :  *
       6             :  * Portions Copyright (c) 1996-2019, PostgreSQL Global Development Group
       7             :  *
       8             :  *
       9             :  * IDENTIFICATION
      10             :  *    src/backend/utils/adt/tsquery_rewrite.c
      11             :  *
      12             :  *-------------------------------------------------------------------------
      13             :  */
      14             : 
      15             : #include "postgres.h"
      16             : 
      17             : #include "catalog/pg_type.h"
      18             : #include "executor/spi.h"
      19             : #include "miscadmin.h"
      20             : #include "tsearch/ts_utils.h"
      21             : #include "utils/builtins.h"
      22             : 
      23             : 
      24             : /*
      25             :  * If "node" is equal to "ex", return a copy of "subs" instead.
      26             :  * If "ex" matches a subset of node's children, return a modified version
      27             :  * of "node" in which those children are replaced with a copy of "subs".
      28             :  * Otherwise return "node" unmodified.
      29             :  *
      30             :  * The QTN_NOCHANGE bit is set in successfully modified nodes, so that
      31             :  * we won't uselessly recurse into them.
      32             :  * Also, set *isfind true if we make a replacement.
      33             :  */
      34             : static QTNode *
      35        3168 : findeq(QTNode *node, QTNode *ex, QTNode *subs, bool *isfind)
      36             : {
      37             :     /* Can't match unless signature matches and node type matches. */
      38        3452 :     if ((node->sign & ex->sign) != ex->sign ||
      39         284 :         node->valnode->type != ex->valnode->type)
      40        2952 :         return node;
      41             : 
      42             :     /* Ignore nodes marked NOCHANGE, too. */
      43         216 :     if (node->flags & QTN_NOCHANGE)
      44          52 :         return node;
      45             : 
      46         164 :     if (node->valnode->type == QI_OPR)
      47             :     {
      48             :         /* Must be same operator. */
      49          72 :         if (node->valnode->qoperator.oper != ex->valnode->qoperator.oper)
      50           4 :             return node;
      51             : 
      52          68 :         if (node->nchild == ex->nchild)
      53             :         {
      54             :             /*
      55             :              * Simple case: when same number of children, match if equal.
      56             :              * (This is reliable when the children were sorted earlier.)
      57             :              */
      58          16 :             if (QTNEq(node, ex))
      59             :             {
      60             :                 /* Match; delete node and return a copy of subs instead. */
      61           8 :                 QTNFree(node);
      62           8 :                 if (subs)
      63             :                 {
      64           8 :                     node = QTNCopy(subs);
      65           8 :                     node->flags |= QTN_NOCHANGE;
      66             :                 }
      67             :                 else
      68           0 :                     node = NULL;
      69           8 :                 *isfind = true;
      70             :             }
      71             :         }
      72          52 :         else if (node->nchild > ex->nchild && ex->nchild > 0)
      73             :         {
      74             :             /*
      75             :              * AND and OR are commutative/associative, so we should check if a
      76             :              * subset of the children match.  For example, if node is A|B|C,
      77             :              * and ex is B|C, we have a match after we notionally convert node
      78             :              * to A|(B|C).  This does not work for NOT or PHRASE nodes, but we
      79             :              * can't get here for those node types because they have a fixed
      80             :              * number of children.
      81             :              *
      82             :              * Because we expect that the children are sorted, it suffices to
      83             :              * make one pass through the two lists to find the matches.
      84             :              */
      85             :             bool       *matched;
      86             :             int         nmatched;
      87             :             int         i,
      88             :                         j;
      89             : 
      90             :             /* Assert that the subset rule is OK */
      91             :             Assert(node->valnode->qoperator.oper == OP_AND ||
      92             :                    node->valnode->qoperator.oper == OP_OR);
      93             : 
      94             :             /* matched[] will record which children of node matched */
      95          52 :             matched = (bool *) palloc0(node->nchild * sizeof(bool));
      96          52 :             nmatched = 0;
      97          52 :             i = j = 0;
      98         312 :             while (i < node->nchild && j < ex->nchild)
      99             :             {
     100         208 :                 int         cmp = QTNodeCompare(node->child[i], ex->child[j]);
     101             : 
     102         208 :                 if (cmp == 0)
     103             :                 {
     104             :                     /* match! */
     105         128 :                     matched[i] = true;
     106         128 :                     nmatched++;
     107         128 :                     i++, j++;
     108             :                 }
     109          80 :                 else if (cmp < 0)
     110             :                 {
     111             :                     /* node->child[i] has no match, ignore it */
     112          80 :                     i++;
     113             :                 }
     114             :                 else
     115             :                 {
     116             :                     /* ex->child[j] has no match; we can give up immediately */
     117           0 :                     break;
     118             :                 }
     119             :             }
     120             : 
     121          52 :             if (nmatched == ex->nchild)
     122             :             {
     123             :                 /* collapse out the matched children of node */
     124          52 :                 j = 0;
     125         288 :                 for (i = 0; i < node->nchild; i++)
     126             :                 {
     127         236 :                     if (matched[i])
     128         128 :                         QTNFree(node->child[i]);
     129             :                     else
     130         108 :                         node->child[j++] = node->child[i];
     131             :                 }
     132             : 
     133             :                 /* and instead insert a copy of subs */
     134          52 :                 if (subs)
     135             :                 {
     136          52 :                     subs = QTNCopy(subs);
     137          52 :                     subs->flags |= QTN_NOCHANGE;
     138          52 :                     node->child[j++] = subs;
     139             :                 }
     140             : 
     141          52 :                 node->nchild = j;
     142             : 
     143             :                 /*
     144             :                  * At this point we might have a node with zero or one child,
     145             :                  * which should be simplified.  But we leave it to our caller
     146             :                  * (dofindsubquery) to take care of that.
     147             :                  */
     148             : 
     149             :                 /*
     150             :                  * Re-sort the node to put new child in the right place.  This
     151             :                  * is a bit bogus, because it won't matter for findsubquery's
     152             :                  * remaining processing, and it's insufficient to prepare the
     153             :                  * tree for another search (we would need to re-flatten as
     154             :                  * well, and we don't want to do that because we'd lose the
     155             :                  * QTN_NOCHANGE marking on the new child).  But it's needed to
     156             :                  * keep the results the same as the regression tests expect.
     157             :                  */
     158          52 :                 QTNSort(node);
     159             : 
     160          52 :                 *isfind = true;
     161             :             }
     162             : 
     163          52 :             pfree(matched);
     164             :         }
     165             :     }
     166             :     else
     167             :     {
     168             :         Assert(node->valnode->type == QI_VAL);
     169             : 
     170          92 :         if (node->valnode->qoperand.valcrc != ex->valnode->qoperand.valcrc)
     171           0 :             return node;
     172          92 :         else if (QTNEq(node, ex))
     173             :         {
     174          92 :             QTNFree(node);
     175          92 :             if (subs)
     176             :             {
     177          80 :                 node = QTNCopy(subs);
     178          80 :                 node->flags |= QTN_NOCHANGE;
     179             :             }
     180             :             else
     181             :             {
     182          12 :                 node = NULL;
     183             :             }
     184          92 :             *isfind = true;
     185             :         }
     186             :     }
     187             : 
     188         160 :     return node;
     189             : }
     190             : 
     191             : /*
     192             :  * Recursive guts of findsubquery(): attempt to replace "ex" with "subs"
     193             :  * at the root node, and if we failed to do so, recursively match against
     194             :  * child nodes.
     195             :  *
     196             :  * Delete any void subtrees resulting from the replacement.
     197             :  * In the following example '5' is replaced by empty operand:
     198             :  *
     199             :  *    AND       ->     6
     200             :  *   /   \
     201             :  *  5    OR
     202             :  *      /  \
     203             :  *     6    5
     204             :  */
     205             : static QTNode *
     206        3168 : dofindsubquery(QTNode *root, QTNode *ex, QTNode *subs, bool *isfind)
     207             : {
     208             :     /* since this function recurses, it could be driven to stack overflow. */
     209        3168 :     check_stack_depth();
     210             : 
     211             :     /* also, since it's a bit expensive, let's check for query cancel. */
     212        3168 :     CHECK_FOR_INTERRUPTS();
     213             : 
     214             :     /* match at the node itself */
     215        3168 :     root = findeq(root, ex, subs, isfind);
     216             : 
     217             :     /* unless we matched here, consider matches at child nodes */
     218        6184 :     if (root && (root->flags & QTN_NOCHANGE) == 0 &&
     219        3016 :         root->valnode->type == QI_OPR)
     220             :     {
     221             :         int         i,
     222        1128 :                     j = 0;
     223             : 
     224             :         /*
     225             :          * Any subtrees that are replaced by NULL must be dropped from the
     226             :          * tree.
     227             :          */
     228        3736 :         for (i = 0; i < root->nchild; i++)
     229             :         {
     230        2608 :             root->child[j] = dofindsubquery(root->child[i], ex, subs, isfind);
     231        2608 :             if (root->child[j])
     232        2596 :                 j++;
     233             :         }
     234             : 
     235        1128 :         root->nchild = j;
     236             : 
     237             :         /*
     238             :          * If we have just zero or one remaining child node, simplify out this
     239             :          * operator node.
     240             :          */
     241        1128 :         if (root->nchild == 0)
     242             :         {
     243           4 :             QTNFree(root);
     244           4 :             root = NULL;
     245             :         }
     246        1124 :         else if (root->nchild == 1 && root->valnode->qoperator.oper != OP_NOT)
     247             :         {
     248           8 :             QTNode     *nroot = root->child[0];
     249             : 
     250           8 :             pfree(root);
     251           8 :             root = nroot;
     252             :         }
     253             :     }
     254             : 
     255        3168 :     return root;
     256             : }
     257             : 
     258             : /*
     259             :  * Substitute "subs" for "ex" throughout the QTNode tree at root.
     260             :  *
     261             :  * If isfind isn't NULL, set *isfind to show whether we made any substitution.
     262             :  *
     263             :  * Both "root" and "ex" must have been through QTNTernary and QTNSort
     264             :  * to ensure reliable matching.
     265             :  */
     266             : QTNode *
     267         560 : findsubquery(QTNode *root, QTNode *ex, QTNode *subs, bool *isfind)
     268             : {
     269         560 :     bool        DidFind = false;
     270             : 
     271         560 :     root = dofindsubquery(root, ex, subs, &DidFind);
     272             : 
     273         560 :     if (isfind)
     274           0 :         *isfind = DidFind;
     275             : 
     276         560 :     return root;
     277             : }
     278             : 
     279             : Datum
     280          88 : tsquery_rewrite_query(PG_FUNCTION_ARGS)
     281             : {
     282          88 :     TSQuery     query = PG_GETARG_TSQUERY_COPY(0);
     283          88 :     text       *in = PG_GETARG_TEXT_PP(1);
     284          88 :     TSQuery     rewrited = query;
     285          88 :     MemoryContext outercontext = CurrentMemoryContext;
     286             :     MemoryContext oldcontext;
     287             :     QTNode     *tree;
     288             :     char       *buf;
     289             :     SPIPlanPtr  plan;
     290             :     Portal      portal;
     291             :     bool        isnull;
     292             : 
     293          88 :     if (query->size == 0)
     294             :     {
     295           0 :         PG_FREE_IF_COPY(in, 1);
     296           0 :         PG_RETURN_POINTER(rewrited);
     297             :     }
     298             : 
     299          88 :     tree = QT2QTN(GETQUERY(query), GETOPERAND(query));
     300          88 :     QTNTernary(tree);
     301          88 :     QTNSort(tree);
     302             : 
     303          88 :     buf = text_to_cstring(in);
     304             : 
     305          88 :     SPI_connect();
     306             : 
     307          88 :     if ((plan = SPI_prepare(buf, 0, NULL)) == NULL)
     308           0 :         elog(ERROR, "SPI_prepare(\"%s\") failed", buf);
     309             : 
     310          88 :     if ((portal = SPI_cursor_open(NULL, plan, NULL, NULL, true)) == NULL)
     311           0 :         elog(ERROR, "SPI_cursor_open(\"%s\") failed", buf);
     312             : 
     313          88 :     SPI_cursor_fetch(portal, true, 100);
     314             : 
     315         176 :     if (SPI_tuptable == NULL ||
     316         176 :         SPI_tuptable->tupdesc->natts != 2 ||
     317         176 :         SPI_gettypeid(SPI_tuptable->tupdesc, 1) != TSQUERYOID ||
     318          88 :         SPI_gettypeid(SPI_tuptable->tupdesc, 2) != TSQUERYOID)
     319           0 :         ereport(ERROR,
     320             :                 (errcode(ERRCODE_INVALID_PARAMETER_VALUE),
     321             :                  errmsg("ts_rewrite query must return two tsquery columns")));
     322             : 
     323         264 :     while (SPI_processed > 0 && tree)
     324             :     {
     325             :         uint64      i;
     326             : 
     327         616 :         for (i = 0; i < SPI_processed && tree; i++)
     328             :         {
     329         528 :             Datum       qdata = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 1, &isnull);
     330             :             Datum       sdata;
     331             : 
     332         528 :             if (isnull)
     333           0 :                 continue;
     334             : 
     335         528 :             sdata = SPI_getbinval(SPI_tuptable->vals[i], SPI_tuptable->tupdesc, 2, &isnull);
     336             : 
     337         528 :             if (!isnull)
     338             :             {
     339         528 :                 TSQuery     qtex = DatumGetTSQuery(qdata);
     340         528 :                 TSQuery     qtsubs = DatumGetTSQuery(sdata);
     341             :                 QTNode     *qex,
     342         528 :                            *qsubs = NULL;
     343             : 
     344         528 :                 if (qtex->size == 0)
     345             :                 {
     346           0 :                     if (qtex != (TSQuery) DatumGetPointer(qdata))
     347           0 :                         pfree(qtex);
     348           0 :                     if (qtsubs != (TSQuery) DatumGetPointer(sdata))
     349           0 :                         pfree(qtsubs);
     350           0 :                     continue;
     351             :                 }
     352             : 
     353         528 :                 qex = QT2QTN(GETQUERY(qtex), GETOPERAND(qtex));
     354             : 
     355         528 :                 QTNTernary(qex);
     356         528 :                 QTNSort(qex);
     357             : 
     358         528 :                 if (qtsubs->size)
     359         528 :                     qsubs = QT2QTN(GETQUERY(qtsubs), GETOPERAND(qtsubs));
     360             : 
     361         528 :                 oldcontext = MemoryContextSwitchTo(outercontext);
     362         528 :                 tree = findsubquery(tree, qex, qsubs, NULL);
     363         528 :                 MemoryContextSwitchTo(oldcontext);
     364             : 
     365         528 :                 QTNFree(qex);
     366         528 :                 if (qtex != (TSQuery) DatumGetPointer(qdata))
     367           0 :                     pfree(qtex);
     368         528 :                 QTNFree(qsubs);
     369         528 :                 if (qtsubs != (TSQuery) DatumGetPointer(sdata))
     370           0 :                     pfree(qtsubs);
     371             : 
     372         528 :                 if (tree)
     373             :                 {
     374             :                     /* ready the tree for another pass */
     375         528 :                     QTNClearFlags(tree, QTN_NOCHANGE);
     376         528 :                     QTNTernary(tree);
     377         528 :                     QTNSort(tree);
     378             :                 }
     379             :             }
     380             :         }
     381             : 
     382          88 :         SPI_freetuptable(SPI_tuptable);
     383          88 :         SPI_cursor_fetch(portal, true, 100);
     384             :     }
     385             : 
     386          88 :     SPI_freetuptable(SPI_tuptable);
     387          88 :     SPI_cursor_close(portal);
     388          88 :     SPI_freeplan(plan);
     389          88 :     SPI_finish();
     390             : 
     391          88 :     if (tree)
     392             :     {
     393          88 :         QTNBinary(tree);
     394          88 :         rewrited = QTN2QT(tree);
     395          88 :         QTNFree(tree);
     396          88 :         PG_FREE_IF_COPY(query, 0);
     397             :     }
     398             :     else
     399             :     {
     400           0 :         SET_VARSIZE(rewrited, HDRSIZETQ);
     401           0 :         rewrited->size = 0;
     402             :     }
     403             : 
     404          88 :     pfree(buf);
     405          88 :     PG_FREE_IF_COPY(in, 1);
     406          88 :     PG_RETURN_POINTER(rewrited);
     407             : }
     408             : 
     409             : Datum
     410          32 : tsquery_rewrite(PG_FUNCTION_ARGS)
     411             : {
     412          32 :     TSQuery     query = PG_GETARG_TSQUERY_COPY(0);
     413          32 :     TSQuery     ex = PG_GETARG_TSQUERY(1);
     414          32 :     TSQuery     subst = PG_GETARG_TSQUERY(2);
     415          32 :     TSQuery     rewrited = query;
     416             :     QTNode     *tree,
     417             :                *qex,
     418          32 :                *subs = NULL;
     419             : 
     420          32 :     if (query->size == 0 || ex->size == 0)
     421             :     {
     422           0 :         PG_FREE_IF_COPY(ex, 1);
     423           0 :         PG_FREE_IF_COPY(subst, 2);
     424           0 :         PG_RETURN_POINTER(rewrited);
     425             :     }
     426             : 
     427          32 :     tree = QT2QTN(GETQUERY(query), GETOPERAND(query));
     428          32 :     QTNTernary(tree);
     429          32 :     QTNSort(tree);
     430             : 
     431          32 :     qex = QT2QTN(GETQUERY(ex), GETOPERAND(ex));
     432          32 :     QTNTernary(qex);
     433          32 :     QTNSort(qex);
     434             : 
     435          32 :     if (subst->size)
     436          24 :         subs = QT2QTN(GETQUERY(subst), GETOPERAND(subst));
     437             : 
     438          32 :     tree = findsubquery(tree, qex, subs, NULL);
     439             : 
     440          32 :     QTNFree(qex);
     441          32 :     QTNFree(subs);
     442             : 
     443          32 :     if (!tree)
     444             :     {
     445           4 :         SET_VARSIZE(rewrited, HDRSIZETQ);
     446           4 :         rewrited->size = 0;
     447           4 :         PG_FREE_IF_COPY(ex, 1);
     448           4 :         PG_FREE_IF_COPY(subst, 2);
     449           4 :         PG_RETURN_POINTER(rewrited);
     450             :     }
     451             :     else
     452             :     {
     453          28 :         QTNBinary(tree);
     454          28 :         rewrited = QTN2QT(tree);
     455          28 :         QTNFree(tree);
     456             :     }
     457             : 
     458          28 :     PG_FREE_IF_COPY(query, 0);
     459          28 :     PG_FREE_IF_COPY(ex, 1);
     460          28 :     PG_FREE_IF_COPY(subst, 2);
     461          28 :     PG_RETURN_POINTER(rewrited);
     462             : }

Generated by: LCOV version 1.13