1/*-------------------------------------------------------------------------
2 *
3 * amapi.c
4 * Support routines for API for Postgres index access methods.
5 *
6 * Copyright (c) 2015-2019, PostgreSQL Global Development Group
7 *
8 *
9 * IDENTIFICATION
10 * src/backend/access/index/amapi.c
11 *
12 *-------------------------------------------------------------------------
13 */
14#include "postgres.h"
15
16#include "access/amapi.h"
17#include "access/htup_details.h"
18#include "catalog/pg_am.h"
19#include "catalog/pg_opclass.h"
20#include "utils/builtins.h"
21#include "utils/syscache.h"
22
23
24/*
25 * GetIndexAmRoutine - call the specified access method handler routine to get
26 * its IndexAmRoutine struct, which will be palloc'd in the caller's context.
27 *
28 * Note that if the amhandler function is built-in, this will not involve
29 * any catalog access. It's therefore safe to use this while bootstrapping
30 * indexes for the system catalogs. relcache.c relies on that.
31 */
32IndexAmRoutine *
33GetIndexAmRoutine(Oid amhandler)
34{
35 Datum datum;
36 IndexAmRoutine *routine;
37
38 datum = OidFunctionCall0(amhandler);
39 routine = (IndexAmRoutine *) DatumGetPointer(datum);
40
41 if (routine == NULL || !IsA(routine, IndexAmRoutine))
42 elog(ERROR, "index access method handler function %u did not return an IndexAmRoutine struct",
43 amhandler);
44
45 return routine;
46}
47
48/*
49 * GetIndexAmRoutineByAmId - look up the handler of the index access method
50 * with the given OID, and get its IndexAmRoutine struct.
51 *
52 * If the given OID isn't a valid index access method, returns NULL if
53 * noerror is true, else throws error.
54 */
55IndexAmRoutine *
56GetIndexAmRoutineByAmId(Oid amoid, bool noerror)
57{
58 HeapTuple tuple;
59 Form_pg_am amform;
60 regproc amhandler;
61
62 /* Get handler function OID for the access method */
63 tuple = SearchSysCache1(AMOID, ObjectIdGetDatum(amoid));
64 if (!HeapTupleIsValid(tuple))
65 {
66 if (noerror)
67 return NULL;
68 elog(ERROR, "cache lookup failed for access method %u",
69 amoid);
70 }
71 amform = (Form_pg_am) GETSTRUCT(tuple);
72
73 /* Check if it's an index access method as opposed to some other AM */
74 if (amform->amtype != AMTYPE_INDEX)
75 {
76 if (noerror)
77 {
78 ReleaseSysCache(tuple);
79 return NULL;
80 }
81 ereport(ERROR,
82 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
83 errmsg("access method \"%s\" is not of type %s",
84 NameStr(amform->amname), "INDEX")));
85 }
86
87 amhandler = amform->amhandler;
88
89 /* Complain if handler OID is invalid */
90 if (!RegProcedureIsValid(amhandler))
91 {
92 if (noerror)
93 {
94 ReleaseSysCache(tuple);
95 return NULL;
96 }
97 ereport(ERROR,
98 (errcode(ERRCODE_OBJECT_NOT_IN_PREREQUISITE_STATE),
99 errmsg("index access method \"%s\" does not have a handler",
100 NameStr(amform->amname))));
101 }
102
103 ReleaseSysCache(tuple);
104
105 /* And finally, call the handler function to get the API struct. */
106 return GetIndexAmRoutine(amhandler);
107}
108
109
110/*
111 * Ask appropriate access method to validate the specified opclass.
112 */
113Datum
114amvalidate(PG_FUNCTION_ARGS)
115{
116 Oid opclassoid = PG_GETARG_OID(0);
117 bool result;
118 HeapTuple classtup;
119 Form_pg_opclass classform;
120 Oid amoid;
121 IndexAmRoutine *amroutine;
122
123 classtup = SearchSysCache1(CLAOID, ObjectIdGetDatum(opclassoid));
124 if (!HeapTupleIsValid(classtup))
125 elog(ERROR, "cache lookup failed for operator class %u", opclassoid);
126 classform = (Form_pg_opclass) GETSTRUCT(classtup);
127
128 amoid = classform->opcmethod;
129
130 ReleaseSysCache(classtup);
131
132 amroutine = GetIndexAmRoutineByAmId(amoid, false);
133
134 if (amroutine->amvalidate == NULL)
135 elog(ERROR, "function amvalidate is not defined for index access method %u",
136 amoid);
137
138 result = amroutine->amvalidate(opclassoid);
139
140 pfree(amroutine);
141
142 PG_RETURN_BOOL(result);
143}
144