Branch data     Line data    Source code

       1                 :             : /*-------------------------------------------------------------------------
       2                 :             :  *
       3                 :             :  * test_parser.c
       4                 :             :  *    Simple example of a text search parser
       5                 :             :  *
       6                 :             :  * Copyright (c) 2007-2026, PostgreSQL Global Development Group
       7                 :             :  *
       8                 :             :  * IDENTIFICATION
       9                 :             :  *    src/test/modules/test_parser/test_parser.c
      10                 :             :  *
      11                 :             :  *-------------------------------------------------------------------------
      12                 :             :  */
      13                 :             : #include "postgres.h"
      14                 :             : 
      15                 :             : #include "fmgr.h"
      16                 :             : 
      17                 :           1 : PG_MODULE_MAGIC;
      18                 :             : 
      19                 :             : /*
      20                 :             :  * types
      21                 :             :  */
      22                 :             : 
      23                 :             : /* self-defined type */
      24                 :             : typedef struct
      25                 :             : {
      26                 :             :     char       *buffer;         /* text to parse */
      27                 :             :     int         len;            /* length of the text in buffer */
      28                 :             :     int         pos;            /* position of the parser */
      29                 :             : } ParserState;
      30                 :             : 
      31                 :             : typedef struct
      32                 :             : {
      33                 :             :     int         lexid;
      34                 :             :     char       *alias;
      35                 :             :     char       *descr;
      36                 :             : } LexDescr;
      37                 :             : 
      38                 :             : /*
      39                 :             :  * functions
      40                 :             :  */
      41                 :           2 : PG_FUNCTION_INFO_V1(testprs_start);
      42                 :           2 : PG_FUNCTION_INFO_V1(testprs_getlexeme);
      43                 :           2 : PG_FUNCTION_INFO_V1(testprs_end);
      44                 :           2 : PG_FUNCTION_INFO_V1(testprs_lextype);
      45                 :             : 
      46                 :             : Datum
      47                 :           5 : testprs_start(PG_FUNCTION_ARGS)
      48                 :             : {
      49                 :           5 :     ParserState *pst = palloc0_object(ParserState);
      50                 :             : 
      51                 :           5 :     pst->buffer = (char *) PG_GETARG_POINTER(0);
      52                 :           5 :     pst->len = PG_GETARG_INT32(1);
      53                 :           5 :     pst->pos = 0;
      54                 :             : 
      55                 :           5 :     PG_RETURN_POINTER(pst);
      56                 :             : }
      57                 :             : 
      58                 :             : Datum
      59                 :          46 : testprs_getlexeme(PG_FUNCTION_ARGS)
      60                 :             : {
      61                 :          46 :     ParserState *pst = (ParserState *) PG_GETARG_POINTER(0);
      62                 :          46 :     char      **t = (char **) PG_GETARG_POINTER(1);
      63                 :          46 :     int        *tlen = (int *) PG_GETARG_POINTER(2);
      64                 :          46 :     int         startpos = pst->pos;
      65                 :             :     int         type;
      66                 :             : 
      67                 :          46 :     *t = pst->buffer + pst->pos;
      68                 :             : 
      69         [ +  + ]:          46 :     if (pst->pos < pst->len &&
      70         [ +  + ]:          41 :         (pst->buffer)[pst->pos] == ' ')
      71                 :             :     {
      72                 :             :         /* blank type */
      73                 :          18 :         type = 12;
      74                 :             :         /* go to the next non-space character */
      75         [ +  - ]:          36 :         while (pst->pos < pst->len &&
      76         [ +  + ]:          36 :                (pst->buffer)[pst->pos] == ' ')
      77                 :          18 :             (pst->pos)++;
      78                 :             :     }
      79                 :             :     else
      80                 :             :     {
      81                 :             :         /* word type */
      82                 :          28 :         type = 3;
      83                 :             :         /* go to the next space character */
      84         [ +  + ]:         165 :         while (pst->pos < pst->len &&
      85         [ +  + ]:         155 :                (pst->buffer)[pst->pos] != ' ')
      86                 :         137 :             (pst->pos)++;
      87                 :             :     }
      88                 :             : 
      89                 :          46 :     *tlen = pst->pos - startpos;
      90                 :             : 
      91                 :             :     /* we are finished if (*tlen == 0) */
      92         [ +  + ]:          46 :     if (*tlen == 0)
      93                 :           5 :         type = 0;
      94                 :             : 
      95                 :          46 :     PG_RETURN_INT32(type);
      96                 :             : }
      97                 :             : 
      98                 :             : Datum
      99                 :           5 : testprs_end(PG_FUNCTION_ARGS)
     100                 :             : {
     101                 :           5 :     ParserState *pst = (ParserState *) PG_GETARG_POINTER(0);
     102                 :             : 
     103                 :           5 :     pfree(pst);
     104                 :           5 :     PG_RETURN_VOID();
     105                 :             : }
     106                 :             : 
     107                 :             : Datum
     108                 :           1 : testprs_lextype(PG_FUNCTION_ARGS)
     109                 :             : {
     110                 :             :     /*
     111                 :             :      * Remarks: - we have to return the blanks for headline reason - we use
     112                 :             :      * the same lexids like Teodor in the default word parser; in this way we
     113                 :             :      * can reuse the headline function of the default word parser.
     114                 :             :      */
     115                 :           1 :     LexDescr   *descr = palloc_array(LexDescr, 2 + 1);
     116                 :             : 
     117                 :             :     /* there are only two types in this parser */
     118                 :           1 :     descr[0].lexid = 3;
     119                 :           1 :     descr[0].alias = pstrdup("word");
     120                 :           1 :     descr[0].descr = pstrdup("Word");
     121                 :           1 :     descr[1].lexid = 12;
     122                 :           1 :     descr[1].alias = pstrdup("blank");
     123                 :           1 :     descr[1].descr = pstrdup("Space symbols");
     124                 :           1 :     descr[2].lexid = 0;
     125                 :             : 
     126                 :           1 :     PG_RETURN_POINTER(descr);
     127                 :             : }