gitlab-pg_query 1.3.1 → 2.0.4

data/README.md

@@ -1,10 +1,10 @@
-# pg_query [ ![](https://img.shields.io/gem/v/pg_query.svg)](https://rubygems.org/gems/pg_query) [ ![](https://img.shields.io/gem/dt/pg_query.svg)](https://rubygems.org/gems/pg_query) [ ![](https://travis-ci.org/lfittl/pg_query.svg?branch=master)](https://travis-ci.org/lfittl/pg_query)
+# pg_query [ ![](https://img.shields.io/gem/v/pg_query.svg)](https://rubygems.org/gems/pg_query) [ ![](https://img.shields.io/gem/dt/pg_query.svg)](https://rubygems.org/gems/pg_query)
 
 This Ruby extension uses the actual PostgreSQL server source to parse SQL queries and return the internal PostgreSQL parsetree.
 
 In addition the extension allows you to normalize queries (replacing constant values with ?) and parse these normalized queries into a parsetree again.
 
-When you build this extension, it builds parts of the PostgreSQL server source (see [libpg_query](https://github.com/lfittl/libpg_query)), and then statically links it into this extension.
+When you build this extension, it builds parts of the PostgreSQL server source (see [libpg_query](https://github.com/pganalyze/libpg_query)), and then statically links it into this extension.
 
 This is slightly crazy, but is the only reliable way of parsing all valid PostgreSQL queries.
 
@@ -25,17 +25,49 @@ Due to compiling parts of PostgreSQL, installation might take a while on slower
 ```ruby
 PgQuery.parse("SELECT 1")
 
-=> #<PgQuery:0x007fe92b27ea18
- @tree=
-  [{"SelectStmt"=>
-     {"targetList"=>
-       [{"ResTarget"=>
-          {"val"=>{"A_Const"=>{"val"=>{"Integer"=>{"ival"=>1}}, "location"=>7}},
-           "location"=>7}}],
-      "op"=>0,
-  }}],
- @query="SELECT 1",
- @warnings=[]>
+=> #<PgQuery::ParserResult:0x00007fb69a958820
+  @query="SELECT 1",
+  @tree=<PgQuery::ParseResult:
+    version: 130002,
+    stmts: [
+      <PgQuery::RawStmt:
+        stmt: <PgQuery::Node:
+          select_stmt: <PgQuery::SelectStmt:
+            distinct_clause: [],
+            target_list: [
+              <PgQuery::Node:
+                res_target: <PgQuery::ResTarget:
+                  name: "",
+                  indirection: [],
+                  val: <PgQuery::Node:
+                    a_const: <PgQuery::A_Const:
+                      val: <PgQuery::Node:
+                        integer: <PgQuery::Integer: ival: 1>
+                      >,
+                      location: 7
+                    >
+                  >,
+                  location: 7
+                >
+              >
+            ],
+            from_clause: [],
+            group_clause: [],
+            window_clause: [],
+            values_lists: [],
+            sort_clause: [],
+            limit_option: :LIMIT_OPTION_DEFAULT,
+            locking_clause: [],
+            op: :SETOP_NONE,
+            all: false
+          >
+        >,
+        stmt_location: 0,
+        stmt_len: 0
+      >
+    ]
+  >,
+  @warnings=[]>
 ```
 
 ### Modifying a parsed query and turning it into SQL again
@@ -43,35 +75,14 @@ PgQuery.parse("SELECT 1")
 ```ruby
 parsed_query = PgQuery.parse("SELECT * FROM users")
 
-=> #<PgQuery:0x007ff3e956c8b0
- @tree=
-  [{"SelectStmt"=>
-    {"targetList"=>
-      [{"ResTarget"=>
-        {"val"=>
-          {"ColumnRef"=> {"fields"=>[{"A_Star"=>{}}], "location"=>7}},
-         "location"=>7}
-      }],
-     "fromClause"=>
-      [{"RangeVar"=>
-        {"relname"=>"users",
-         "inhOpt"=>2,
-         "relpersistence"=>"p",
-         "location"=>14}}],
-   }}],
- @query="SELECT * FROM users",
- @warnings=[]>
-
 # Modify the parse tree in some way
-parsed_query.tree[0]['SelectStmt']['fromClause'][0]['RangeVar']['relname'] = 'other_users'
+parsed_query.tree.stmts[0].stmt.select_stmt.from_clause[0].range_var.relname = 'other_users'
 
 # Turn it into SQL again
 parsed_query.deparse
-=> "SELECT * FROM \"other_users\""
+=> "SELECT * FROM other_users"
 ```
 
-Note: The deparsing feature is experimental and does not support outputting all SQL yet.
-
 ### Parsing a normalized query
 
 ```ruby
@@ -83,29 +94,10 @@ PgQuery.normalize("SELECT 1 FROM x WHERE y = 'foo'")
 # Parsing a normalized query (pre-Postgres 10 style)
 PgQuery.parse("SELECT ? FROM x WHERE y = ?")
 
-=> #<PgQuery:0x007fb99455a438
- @tree=
-  [{"SelectStmt"=>
-     {"targetList"=>
-       [{"ResTarget"=>
-          {"val"=>{"ParamRef"=>{"location"=>7}},
-           "location"=>7}}],
-      "fromClause"=>
-       [{"RangeVar"=>
-          {"relname"=>"x",
-           "inhOpt"=>2,
-           "relpersistence"=>"p",
-           "location"=>14}}],
-      "whereClause"=>
-       {"A_Expr"=>
-         {"kind"=>0,
-          "name"=>[{"String"=>{"str"=>"="}}],
-          "lexpr"=>{"ColumnRef"=>{"fields"=>[{"String"=>{"str"=>"y"}}], "location"=>22}},
-          "rexpr"=>{"ParamRef"=>{"location"=>26}},
-          "location"=>24}},
-  }}],
- @query="SELECT ? FROM x WHERE y = ?",
- @warnings=[]>
+=> #<PgQuery::ParserResult:0x00007fb69a97a5d8
+  @query="SELECT ? FROM x WHERE y = ?",
+  @tree=<PgQuery::ParseResult: ...>,
+  @warnings=[]>
 ```
 
 ### Extracting tables from a query
@@ -129,21 +121,33 @@ PgQuery.parse("SELECT ? FROM x WHERE x.y = ? AND z = ?").filter_columns
 ```ruby
 PgQuery.parse("SELECT 1").fingerprint
 
-=> "8e1acac181c6d28f4a923392cf1c4eda49ee4cd2"
+=> "50fde20626009aba"
 
 PgQuery.parse("SELECT 2; --- comment").fingerprint
 
-=> "8e1acac181c6d28f4a923392cf1c4eda49ee4cd2"
+=> "50fde20626009aba"
 
-# Faster fingerprint method that is implemented inside the native library
+# Faster fingerprint method that is implemented inside the native C library
 PgQuery.fingerprint("SELECT ?")
 
-=> "8e1acac181c6d28f4a923392cf1c4eda49ee4cd2"
+=> "50fde20626009aba"
+```
+
+### Scanning a query into tokens
+
+```ruby
+PgQuery.scan('SELECT 1 --comment')
+
+=> [<PgQuery::ScanResult: version: 130002, tokens: [
+<PgQuery::ScanToken: start: 0, end: 6, token: :SELECT, keyword_kind: :RESERVED_KEYWORD>,
+<PgQuery::ScanToken: start: 7, end: 8, token: :ICONST, keyword_kind: :NO_KEYWORD>,
+<PgQuery::ScanToken: start: 9, end: 18, token: :SQL_COMMENT, keyword_kind: :NO_KEYWORD>]>,
+ []]
 ```
 
 ## Differences from Upstream PostgreSQL
 
-This gem is based on [libpg_query](https://github.com/lfittl/libpg_query),
+This gem is based on [libpg_query](https://github.com/pganalyze/libpg_query),
 which uses the latest stable PostgreSQL version, but with a patch applied
 to support parsing normalized queries containing `?` replacement characters.
 
@@ -151,15 +155,34 @@ to support parsing normalized queries containing `?` replacement characters.
 
 Currently tested and officially supported Ruby versions:
 
-* MRI 2.1
-* MRI 2.2
-* MRI 2.3
-* MRI 2.4
+* CRuby 2.5
+* CRuby 2.6
+* CRuby 2.7
+* CRuby 3.0
+
+Not supported:
+
+* JRuby: `pg_query` relies on a C extension, which is discouraged / not properly supported for JRuby
+* TruffleRuby: GraalVM [does not support sigjmp](https://www.graalvm.org/reference-manual/llvm/NativeExecution/), which is used by the Postgres error handling code (`pg_query` uses a copy of the Postgres parser & error handling code)
+
+## Developer tasks
+
+### Update libpg_query source
+
+In order to update to a newer Postgres parser, first update [libpg_query](https://github.com/pganalyze/libpg_query) to the new Postgres version and tag a release.
+
+Once that is done, follow the following steps:
+
+1. Update `LIB_PG_QUERY_TAG` and `LIB_PG_QUERY_SHA256SUM` in `Rakefile`
+
+2. Run `rake update_source` to update the source code
+
+3. Commit the `Rakefile` and the modified files in `ext/pg_query` to this source tree and make a PR
 
 
 ## Resources
 
-See [libpg_query](https://github.com/lfittl/libpg_query/blob/10-latest/README.md#resources) for pg_query in other languages, as well as products/tools built on pg_query.
+See [libpg_query](https://github.com/pganalyze/libpg_query/blob/13-latest/README.md#resources) for pg_query in other languages, as well as products/tools built on pg_query.
 
 ## Original Author
 

data/Rakefile

@@ -1,7 +1,12 @@
 require 'bundler/gem_tasks'
+require 'rake/clean'
 require 'rake/extensiontask'
 require 'rspec/core/rake_task'
 require 'rubocop/rake_task'
+require 'open-uri'
+
+LIB_PG_QUERY_TAG = '13-2.0.4'.freeze
+LIB_PG_QUERY_SHA256SUM = 'a67ef3e3b6c9cb1297f362888d6660dac165d3b020f78d23afe4293b8ceaf190'.freeze
 
 Rake::ExtensionTask.new 'pg_query' do |ext|
   ext.lib_dir = 'lib/pg_query'
@@ -12,12 +17,87 @@ RuboCop::RakeTask.new
 
 task spec: :compile
 
-task default: %i[lint spec]
+task default: %i[spec lint]
 task test: :spec
 task lint: :rubocop
 
-task :clean do
-  FileUtils.rm_rf File.join(__dir__, 'tmp/')
-  FileUtils.rm_f Dir.glob(File.join(__dir__, 'ext/pg_query/*.o'))
-  FileUtils.rm_f File.join(__dir__, 'lib/pg_query/pg_query.bundle')
+CLEAN << 'tmp/**/*'
+CLEAN << 'ext/pg_query/*.o'
+CLEAN << 'lib/pg_query/pg_query.bundle'
+
+task :update_source do
+  workdir = File.join(__dir__, 'tmp')
+  libdir = File.join(workdir, 'libpg_query-' + LIB_PG_QUERY_TAG)
+  filename = File.join(workdir, 'libpg_query-' + LIB_PG_QUERY_TAG + '.tar.gz')
+  testfilesdir = File.join(__dir__, 'spec/files')
+  extdir = File.join(__dir__, 'ext/pg_query')
+  extbakdir = File.join(workdir, 'extbak')
+
+  unless File.exist?(filename)
+    system("mkdir -p #{workdir}")
+    File.open(filename, 'wb') do |target_file|
+      URI.open('https://codeload.github.com/pganalyze/libpg_query/tar.gz/' + LIB_PG_QUERY_TAG, 'rb') do |read_file|
+        target_file.write(read_file.read)
+      end
+    end
+
+    checksum = Digest::SHA256.hexdigest(File.read(filename))
+
+    if checksum != LIB_PG_QUERY_SHA256SUM
+      raise "SHA256 of #{filename} does not match: got #{checksum}, expected #{LIB_PG_QUERY_SHA256SUM}"
+    end
+  end
+
+  unless Dir.exist?(libdir)
+    system("tar -xzf #{filename} -C #{workdir}") || raise('ERROR')
+  end
+
+  # Backup important files from ext dir
+  system("rm -fr #{extbakdir}")
+  system("mkdir -p #{extbakdir}")
+  system("cp -a #{extdir}/pg_query_ruby.{c,sym} #{extdir}/extconf.rb #{extbakdir}")
+
+  FileUtils.rm_rf extdir
+
+  # Reduce everything down to one directory
+  system("mkdir -p #{extdir}")
+  system("cp -a #{libdir}/src/* #{extdir}/")
+  system("mv #{extdir}/postgres/* #{extdir}/")
+  system("rmdir #{extdir}/postgres")
+  system("cp -a #{libdir}/pg_query.h #{extdir}/include")
+  # Make sure every .c file in the top-level directory is its own translation unit
+  system("mv #{extdir}/*{_conds,_defs,_helper}.c #{extdir}/include")
+  # Protobuf definitions
+  system("protoc --proto_path=#{libdir}/protobuf --ruby_out=#{File.join(__dir__, 'lib/pg_query')} #{libdir}/protobuf/pg_query.proto")
+  system("mkdir -p #{extdir}/include/protobuf")
+  system("cp -a #{libdir}/protobuf/*.h #{extdir}/include/protobuf")
+  system("cp -a #{libdir}/protobuf/*.c #{extdir}/")
+  # Protobuf library code
+  system("mkdir -p #{extdir}/include/protobuf-c")
+  system("cp -a #{libdir}/vendor/protobuf-c/*.h #{extdir}/include")
+  system("cp -a #{libdir}/vendor/protobuf-c/*.h #{extdir}/include/protobuf-c")
+  system("cp -a #{libdir}/vendor/protobuf-c/*.c #{extdir}/")
+  # xxhash library code
+  system("mkdir -p #{extdir}/include/xxhash")
+  system("cp -a #{libdir}/vendor/xxhash/*.h #{extdir}/include")
+  system("cp -a #{libdir}/vendor/xxhash/*.h #{extdir}/include/xxhash")
+  system("cp -a #{libdir}/vendor/xxhash/*.c #{extdir}/")
+  # Other support files
+  system("cp -a #{libdir}/testdata/* #{testfilesdir}")
+  # Copy back the custom ext files
+  system("cp -a #{extbakdir}/pg_query_ruby.{c,sym} #{extbakdir}/extconf.rb #{extdir}")
+
+  # Generate JSON field name helper (workaround until https://github.com/protocolbuffers/protobuf/pull/8356 is merged)
+  str = "module PgQuery\n  INTERNAL_PROTO_FIELD_NAME_TO_JSON_NAME = {\n"
+  cur_type = nil
+  File.read(File.join(libdir, 'protobuf/pg_query.proto')).each_line do |line|
+    if line[/^message (\w+)/]
+      cur_type = $1
+      next
+    end
+    next unless line[/(repeated )?\w+ (\w+) = \d+( \[json_name="(\w+)"\])?;/]
+    str += format("    [%s, :%s] => '%s',\n", cur_type, $2, $4 || $2)
+  end
+  str += "  }\nend\n"
+  File.write(File.join(__dir__, 'lib/pg_query/json_field_names.rb'), str)
 end

data/ext/pg_query/extconf.rb

@@ -3,48 +3,11 @@
 require 'digest'
 require 'mkmf'
 require 'open-uri'
+require 'pathname'
 
-LIB_PG_QUERY_TAG = '10-1.0.3'.freeze
+$objs = Dir.glob(File.join(__dir__, '*.c')).map { |f| Pathname.new(f).sub_ext('.o').to_s }
 
-workdir = Dir.pwd
-libdir = File.join(workdir, 'libpg_query-' + LIB_PG_QUERY_TAG)
-gemdir = File.join(__dir__, '../..')
-libfile = libdir + '/libpg_query.a'
-
-expected_sha256 = '1332761f31c198cb9825e6ccccda0b6a0e57daeb824870e8524df77f1592d149'
-filename = "#{workdir}/libpg_query.tar.gz"
-
-unless File.exist?(filename)
-  File.open(filename, 'wb') do |target_file|
-    URI.open('https://codeload.github.com/lfittl/libpg_query/tar.gz/' + LIB_PG_QUERY_TAG, 'rb') do |read_file|
-      target_file.write(read_file.read)
-    end
-  end
-
-  checksum = Digest::SHA256.hexdigest(File.read(filename))
-
-  if checksum != expected_sha256
-    raise "SHA256 of #{filename} does not match: got #{checksum}, expected #{expected_sha256}"
-  end
-end
-
-unless Dir.exist?(libdir)
-  system("tar -xzf #{filename}") || raise('ERROR')
-end
-
-unless Dir.exist?(libfile)
-  # Build libpg_query (and parts of PostgreSQL)
-  system("cd #{libdir}; #{ENV['MAKE'] || (RUBY_PLATFORM =~ /bsd/ ? 'gmake' : 'make')} build")
-end
-
-# Copy test files (this intentionally overwrites existing files!)
-system("cp #{libdir}/testdata/* #{gemdir}/spec/files/")
-
-$objs = ['pg_query_ruby.o']
-
-$LOCAL_LIBS << '-lpg_query'
-$LIBPATH << libdir
-$CFLAGS << " -I #{libdir} -O3 -Wall -fno-strict-aliasing -fwrapv -g"
+$CFLAGS << " -I#{File.join(__dir__, 'include')} -O3 -Wall -fno-strict-aliasing -fwrapv -fstack-protector -Wno-unused-function -Wno-unused-variable -g"
 
 SYMFILE = File.join(__dir__, 'pg_query_ruby.sym')
 if RUBY_PLATFORM =~ /darwin/

data/ext/pg_query/include/access/amapi.h

@@ -0,0 +1,246 @@
+/*-------------------------------------------------------------------------
+ *
+ * amapi.h
+ *	  API for Postgres index access methods.
+ *
+ * Copyright (c) 2015-2020, PostgreSQL Global Development Group
+ *
+ * src/include/access/amapi.h
+ *
+ *-------------------------------------------------------------------------
+ */
+#ifndef AMAPI_H
+#define AMAPI_H
+
+#include "access/genam.h"
+
+/*
+ * We don't wish to include planner header files here, since most of an index
+ * AM's implementation isn't concerned with those data structures.  To allow
+ * declaring amcostestimate_function here, use forward struct references.
+ */
+struct PlannerInfo;
+struct IndexPath;
+
+/* Likewise, this file shouldn't depend on execnodes.h. */
+struct IndexInfo;
+
+
+/*
+ * Properties for amproperty API.  This list covers properties known to the
+ * core code, but an index AM can define its own properties, by matching the
+ * string property name.
+ */
+typedef enum IndexAMProperty
+{
+	AMPROP_UNKNOWN = 0,			/* anything not known to core code */
+	AMPROP_ASC,					/* column properties */
+	AMPROP_DESC,
+	AMPROP_NULLS_FIRST,
+	AMPROP_NULLS_LAST,
+	AMPROP_ORDERABLE,
+	AMPROP_DISTANCE_ORDERABLE,
+	AMPROP_RETURNABLE,
+	AMPROP_SEARCH_ARRAY,
+	AMPROP_SEARCH_NULLS,
+	AMPROP_CLUSTERABLE,			/* index properties */
+	AMPROP_INDEX_SCAN,
+	AMPROP_BITMAP_SCAN,
+	AMPROP_BACKWARD_SCAN,
+	AMPROP_CAN_ORDER,			/* AM properties */
+	AMPROP_CAN_UNIQUE,
+	AMPROP_CAN_MULTI_COL,
+	AMPROP_CAN_EXCLUDE,
+	AMPROP_CAN_INCLUDE
+} IndexAMProperty;
+
+
+/*
+ * Callback function signatures --- see indexam.sgml for more info.
+ */
+
+/* build new index */
+typedef IndexBuildResult *(*ambuild_function) (Relation heapRelation,
+											   Relation indexRelation,
+											   struct IndexInfo *indexInfo);
+
+/* build empty index */
+typedef void (*ambuildempty_function) (Relation indexRelation);
+
+/* insert this tuple */
+typedef bool (*aminsert_function) (Relation indexRelation,
+								   Datum *values,
+								   bool *isnull,
+								   ItemPointer heap_tid,
+								   Relation heapRelation,
+								   IndexUniqueCheck checkUnique,
+								   struct IndexInfo *indexInfo);
+
+/* bulk delete */
+typedef IndexBulkDeleteResult *(*ambulkdelete_function) (IndexVacuumInfo *info,
+														 IndexBulkDeleteResult *stats,
+														 IndexBulkDeleteCallback callback,
+														 void *callback_state);
+
+/* post-VACUUM cleanup */
+typedef IndexBulkDeleteResult *(*amvacuumcleanup_function) (IndexVacuumInfo *info,
+															IndexBulkDeleteResult *stats);
+
+/* can indexscan return IndexTuples? */
+typedef bool (*amcanreturn_function) (Relation indexRelation, int attno);
+
+/* estimate cost of an indexscan */
+typedef void (*amcostestimate_function) (struct PlannerInfo *root,
+										 struct IndexPath *path,
+										 double loop_count,
+										 Cost *indexStartupCost,
+										 Cost *indexTotalCost,
+										 Selectivity *indexSelectivity,
+										 double *indexCorrelation,
+										 double *indexPages);
+
+/* parse index reloptions */
+typedef bytea *(*amoptions_function) (Datum reloptions,
+									  bool validate);
+
+/* report AM, index, or index column property */
+typedef bool (*amproperty_function) (Oid index_oid, int attno,
+									 IndexAMProperty prop, const char *propname,
+									 bool *res, bool *isnull);
+
+/* name of phase as used in progress reporting */
+typedef char *(*ambuildphasename_function) (int64 phasenum);
+
+/* validate definition of an opclass for this AM */
+typedef bool (*amvalidate_function) (Oid opclassoid);
+
+/* prepare for index scan */
+typedef IndexScanDesc (*ambeginscan_function) (Relation indexRelation,
+											   int nkeys,
+											   int norderbys);
+
+/* (re)start index scan */
+typedef void (*amrescan_function) (IndexScanDesc scan,
+								   ScanKey keys,
+								   int nkeys,
+								   ScanKey orderbys,
+								   int norderbys);
+
+/* next valid tuple */
+typedef bool (*amgettuple_function) (IndexScanDesc scan,
+									 ScanDirection direction);
+
+/* fetch all valid tuples */
+typedef int64 (*amgetbitmap_function) (IndexScanDesc scan,
+									   TIDBitmap *tbm);
+
+/* end index scan */
+typedef void (*amendscan_function) (IndexScanDesc scan);
+
+/* mark current scan position */
+typedef void (*ammarkpos_function) (IndexScanDesc scan);
+
+/* restore marked scan position */
+typedef void (*amrestrpos_function) (IndexScanDesc scan);
+
+/*
+ * Callback function signatures - for parallel index scans.
+ */
+
+/* estimate size of parallel scan descriptor */
+typedef Size (*amestimateparallelscan_function) (void);
+
+/* prepare for parallel index scan */
+typedef void (*aminitparallelscan_function) (void *target);
+
+/* (re)start parallel index scan */
+typedef void (*amparallelrescan_function) (IndexScanDesc scan);
+
+/*
+ * API struct for an index AM.  Note this must be stored in a single palloc'd
+ * chunk of memory.
+ */
+typedef struct IndexAmRoutine
+{
+	NodeTag		type;
+
+	/*
+	 * Total number of strategies (operators) by which we can traverse/search
+	 * this AM.  Zero if AM does not have a fixed set of strategy assignments.
+	 */
+	uint16		amstrategies;
+	/* total number of support functions that this AM uses */
+	uint16		amsupport;
+	/* opclass options support function number or 0 */
+	uint16		amoptsprocnum;
+	/* does AM support ORDER BY indexed column's value? */
+	bool		amcanorder;
+	/* does AM support ORDER BY result of an operator on indexed column? */
+	bool		amcanorderbyop;
+	/* does AM support backward scanning? */
+	bool		amcanbackward;
+	/* does AM support UNIQUE indexes? */
+	bool		amcanunique;
+	/* does AM support multi-column indexes? */
+	bool		amcanmulticol;
+	/* does AM require scans to have a constraint on the first index column? */
+	bool		amoptionalkey;
+	/* does AM handle ScalarArrayOpExpr quals? */
+	bool		amsearcharray;
+	/* does AM handle IS NULL/IS NOT NULL quals? */
+	bool		amsearchnulls;
+	/* can index storage data type differ from column data type? */
+	bool		amstorage;
+	/* can an index of this type be clustered on? */
+	bool		amclusterable;
+	/* does AM handle predicate locks? */
+	bool		ampredlocks;
+	/* does AM support parallel scan? */
+	bool		amcanparallel;
+	/* does AM support columns included with clause INCLUDE? */
+	bool		amcaninclude;
+	/* does AM use maintenance_work_mem? */
+	bool		amusemaintenanceworkmem;
+	/* OR of parallel vacuum flags.  See vacuum.h for flags. */
+	uint8		amparallelvacuumoptions;
+	/* type of data stored in index, or InvalidOid if variable */
+	Oid			amkeytype;
+
+	/*
+	 * If you add new properties to either the above or the below lists, then
+	 * they should also (usually) be exposed via the property API (see
+	 * IndexAMProperty at the top of the file, and utils/adt/amutils.c).
+	 */
+
+	/* interface functions */
+	ambuild_function ambuild;
+	ambuildempty_function ambuildempty;
+	aminsert_function aminsert;
+	ambulkdelete_function ambulkdelete;
+	amvacuumcleanup_function amvacuumcleanup;
+	amcanreturn_function amcanreturn;	/* can be NULL */
+	amcostestimate_function amcostestimate;
+	amoptions_function amoptions;
+	amproperty_function amproperty; /* can be NULL */
+	ambuildphasename_function ambuildphasename; /* can be NULL */
+	amvalidate_function amvalidate;
+	ambeginscan_function ambeginscan;
+	amrescan_function amrescan;
+	amgettuple_function amgettuple; /* can be NULL */
+	amgetbitmap_function amgetbitmap;	/* can be NULL */
+	amendscan_function amendscan;
+	ammarkpos_function ammarkpos;	/* can be NULL */
+	amrestrpos_function amrestrpos; /* can be NULL */
+
+	/* interface functions to support parallel index scans */
+	amestimateparallelscan_function amestimateparallelscan; /* can be NULL */
+	aminitparallelscan_function aminitparallelscan; /* can be NULL */
+	amparallelrescan_function amparallelrescan; /* can be NULL */
+} IndexAmRoutine;
+
+
+/* Functions in access/index/amapi.c */
+extern IndexAmRoutine *GetIndexAmRoutine(Oid amhandler);
+extern IndexAmRoutine *GetIndexAmRoutineByAmId(Oid amoid, bool noerror);
+
+#endif							/* AMAPI_H */