TLA  Line data    Source code

       1                 : /*-------------------------------------------------------------------------
       2                 :  *
       3                 :  * extensible.c
       4                 :  *    Support for extensible node types
       5                 :  *
       6                 :  * Loadable modules can define what are in effect new types of nodes using
       7                 :  * the routines in this file.  All such nodes are flagged T_ExtensibleNode,
       8                 :  * with the extnodename field distinguishing the specific type.  Use
       9                 :  * RegisterExtensibleNodeMethods to register a new type of extensible node,
      10                 :  * and GetExtensibleNodeMethods to get information about a previously
      11                 :  * registered type of extensible node.
      12                 :  *
      13                 :  * Portions Copyright (c) 1996-2023, PostgreSQL Global Development Group
      14                 :  * Portions Copyright (c) 1994, Regents of the University of California
      15                 :  *
      16                 :  * IDENTIFICATION
      17                 :  *    src/backend/nodes/extensible.c
      18                 :  *
      19                 :  *-------------------------------------------------------------------------
      20                 :  */
      21                 : #include "postgres.h"
      22                 : 
      23                 : #include "nodes/extensible.h"
      24                 : #include "utils/hsearch.h"
      25                 : 
      26                 : static HTAB *extensible_node_methods = NULL;
      27                 : static HTAB *custom_scan_methods = NULL;
      28                 : 
      29                 : typedef struct
      30                 : {
      31                 :     char        extnodename[EXTNODENAME_MAX_LEN];
      32                 :     const void *extnodemethods;
      33                 : } ExtensibleNodeEntry;
      34                 : 
      35                 : /*
      36                 :  * An internal function to register a new callback structure
      37                 :  */
      38                 : static void
      39 UBC           0 : RegisterExtensibleNodeEntry(HTAB **p_htable, const char *htable_label,
      40                 :                             const char *extnodename,
      41                 :                             const void *extnodemethods)
      42                 : {
      43                 :     ExtensibleNodeEntry *entry;
      44                 :     bool        found;
      45                 : 
      46               0 :     if (*p_htable == NULL)
      47                 :     {
      48                 :         HASHCTL     ctl;
      49                 : 
      50               0 :         ctl.keysize = EXTNODENAME_MAX_LEN;
      51               0 :         ctl.entrysize = sizeof(ExtensibleNodeEntry);
      52                 : 
      53               0 :         *p_htable = hash_create(htable_label, 100, &ctl,
      54                 :                                 HASH_ELEM | HASH_STRINGS);
      55                 :     }
      56                 : 
      57               0 :     if (strlen(extnodename) >= EXTNODENAME_MAX_LEN)
      58               0 :         elog(ERROR, "extensible node name is too long");
      59                 : 
      60               0 :     entry = (ExtensibleNodeEntry *) hash_search(*p_htable,
      61                 :                                                 extnodename,
      62                 :                                                 HASH_ENTER, &found);
      63               0 :     if (found)
      64               0 :         ereport(ERROR,
      65                 :                 (errcode(ERRCODE_DUPLICATE_OBJECT),
      66                 :                  errmsg("extensible node type \"%s\" already exists",
      67                 :                         extnodename)));
      68                 : 
      69               0 :     entry->extnodemethods = extnodemethods;
      70               0 : }
      71                 : 
      72                 : /*
      73                 :  * Register a new type of extensible node.
      74                 :  */
      75                 : void
      76               0 : RegisterExtensibleNodeMethods(const ExtensibleNodeMethods *methods)
      77                 : {
      78               0 :     RegisterExtensibleNodeEntry(&extensible_node_methods,
      79                 :                                 "Extensible Node Methods",
      80               0 :                                 methods->extnodename,
      81                 :                                 methods);
      82               0 : }
      83                 : 
      84                 : /*
      85                 :  * Register a new type of custom scan node
      86                 :  */
      87                 : void
      88               0 : RegisterCustomScanMethods(const CustomScanMethods *methods)
      89                 : {
      90               0 :     RegisterExtensibleNodeEntry(&custom_scan_methods,
      91                 :                                 "Custom Scan Methods",
      92               0 :                                 methods->CustomName,
      93                 :                                 methods);
      94               0 : }
      95                 : 
      96                 : /*
      97                 :  * An internal routine to get an ExtensibleNodeEntry by the given identifier
      98                 :  */
      99                 : static const void *
     100               0 : GetExtensibleNodeEntry(HTAB *htable, const char *extnodename, bool missing_ok)
     101                 : {
     102               0 :     ExtensibleNodeEntry *entry = NULL;
     103                 : 
     104               0 :     if (htable != NULL)
     105               0 :         entry = (ExtensibleNodeEntry *) hash_search(htable,
     106                 :                                                     extnodename,
     107                 :                                                     HASH_FIND, NULL);
     108               0 :     if (!entry)
     109                 :     {
     110               0 :         if (missing_ok)
     111               0 :             return NULL;
     112               0 :         ereport(ERROR,
     113                 :                 (errcode(ERRCODE_UNDEFINED_OBJECT),
     114                 :                  errmsg("ExtensibleNodeMethods \"%s\" was not registered",
     115                 :                         extnodename)));
     116                 :     }
     117                 : 
     118               0 :     return entry->extnodemethods;
     119                 : }
     120                 : 
     121                 : /*
     122                 :  * Get the methods for a given type of extensible node.
     123                 :  */
     124                 : const ExtensibleNodeMethods *
     125               0 : GetExtensibleNodeMethods(const char *extnodename, bool missing_ok)
     126                 : {
     127               0 :     return (const ExtensibleNodeMethods *)
     128               0 :         GetExtensibleNodeEntry(extensible_node_methods,
     129                 :                                extnodename,
     130                 :                                missing_ok);
     131                 : }
     132                 : 
     133                 : /*
     134                 :  * Get the methods for a given name of CustomScanMethods
     135                 :  */
     136                 : const CustomScanMethods *
     137               0 : GetCustomScanMethods(const char *CustomName, bool missing_ok)
     138                 : {
     139               0 :     return (const CustomScanMethods *)
     140               0 :         GetExtensibleNodeEntry(custom_scan_methods,
     141                 :                                CustomName,
     142                 :                                missing_ok);
     143                 : }