=== Applying patches on top of PostgreSQL commit ID 9d0adee8768852fc0e5713ec27cf52d46d97279d === /etc/rc.d/jail: WARNING: Per-jail configuration via jail_* variables is obsolete. Please consider migrating to /etc/jail.conf. Mon Sep 14 10:22:32 UTC 2026 On branch cf/4871 nothing to commit, working tree clean === using 'git am' to apply patch ./v19_0001-Introduce-IndexAmRoutine.ammorderbyopfirstcol.patch === Applying: Introduce IndexAmRoutine.ammorderbyopfirstcol Using index info to reconstruct a base tree... M contrib/bloom/blutils.c M doc/src/sgml/indexam.sgml M src/backend/access/brin/brin.c M src/backend/access/gin/ginutil.c M src/backend/access/gist/gist.c M src/backend/access/hash/hash.c M src/backend/access/nbtree/nbtree.c M src/backend/access/spgist/spgutils.c M src/backend/optimizer/path/indxpath.c M src/include/access/amapi.h M src/include/nodes/pathnodes.h Falling back to patching base and 3-way merge... Auto-merging src/include/nodes/pathnodes.h Auto-merging src/include/access/amapi.h CONFLICT (content): Merge conflict in src/include/access/amapi.h Auto-merging src/backend/optimizer/path/indxpath.c Auto-merging src/backend/access/spgist/spgutils.c CONFLICT (content): Merge conflict in src/backend/access/spgist/spgutils.c Auto-merging src/backend/access/nbtree/nbtree.c CONFLICT (content): Merge conflict in src/backend/access/nbtree/nbtree.c Auto-merging src/backend/access/hash/hash.c CONFLICT (content): Merge conflict in src/backend/access/hash/hash.c Auto-merging src/backend/access/gist/gist.c CONFLICT (content): Merge conflict in src/backend/access/gist/gist.c Auto-merging src/backend/access/gin/ginutil.c CONFLICT (content): Merge conflict in src/backend/access/gin/ginutil.c Auto-merging src/backend/access/brin/brin.c CONFLICT (content): Merge conflict in src/backend/access/brin/brin.c Auto-merging doc/src/sgml/indexam.sgml CONFLICT (content): Merge conflict in doc/src/sgml/indexam.sgml Auto-merging contrib/bloom/blutils.c CONFLICT (content): Merge conflict in contrib/bloom/blutils.c error: Failed to merge in the changes. hint: Use 'git am --show-current-patch=diff' to see the failed patch Patch failed at 0001 Introduce IndexAmRoutine.ammorderbyopfirstcol When you have resolved this problem, run "git am --continue". If you prefer to skip this patch, run "git am --skip" instead. To restore the original branch and stop patching, run "git am --abort". === using patch(1) to apply patch ./v19_0001-Introduce-IndexAmRoutine.ammorderbyopfirstcol.patch === patching file contrib/bloom/blutils.c Hunk #1 FAILED at 112. 1 out of 1 hunk FAILED -- saving rejects to file contrib/bloom/blutils.c.rej patching file doc/src/sgml/indexam.sgml Hunk #1 FAILED at 103. Hunk #2 succeeded at 987 (offset 55 lines). 1 out of 2 hunks FAILED -- saving rejects to file doc/src/sgml/indexam.sgml.rej patching file src/backend/access/brin/brin.c Hunk #1 FAILED at 253. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/brin/brin.c.rej patching file src/backend/access/gin/ginutil.c Hunk #1 FAILED at 43. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/gin/ginutil.c.rej patching file src/backend/access/gist/gist.c Hunk #1 FAILED at 65. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/gist/gist.c.rej patching file src/backend/access/hash/hash.c Hunk #1 FAILED at 63. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/hash/hash.c.rej patching file src/backend/access/nbtree/nbtree.c Hunk #1 FAILED at 107. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/nbtree/nbtree.c.rej patching file src/backend/access/spgist/spgutils.c Hunk #1 FAILED at 50. 1 out of 1 hunk FAILED -- saving rejects to file src/backend/access/spgist/spgutils.c.rej patching file src/backend/optimizer/path/indxpath.c Hunk #1 succeeded at 3725 (offset 695 lines). Hunk #2 succeeded at 3758 with fuzz 2 (offset 696 lines). patching file src/include/access/amapi.h Hunk #1 FAILED at 224. 1 out of 1 hunk FAILED -- saving rejects to file src/include/access/amapi.h.rej patching file src/include/nodes/pathnodes.h Hunk #1 succeeded at 1434 (offset 246 lines). Unstaged changes after reset: M doc/src/sgml/indexam.sgml M src/backend/optimizer/path/indxpath.c M src/include/nodes/pathnodes.h Removing contrib/bloom/blutils.c.rej Removing doc/src/sgml/indexam.sgml.rej Removing src/backend/access/brin/brin.c.rej Removing src/backend/access/gin/ginutil.c.rej Removing src/backend/access/gist/gist.c.rej Removing src/backend/access/hash/hash.c.rej Removing src/backend/access/nbtree/nbtree.c.rej Removing src/backend/access/spgist/spgutils.c.rej Removing src/include/access/amapi.h.rej === using 'git apply' to apply patch ./v19_0001-Introduce-IndexAmRoutine.ammorderbyopfirstcol.patch === Applied patch to 'contrib/bloom/blutils.c' with conflicts. Applied patch to 'doc/src/sgml/indexam.sgml' with conflicts. Applied patch to 'src/backend/access/brin/brin.c' with conflicts. Applied patch to 'src/backend/access/gin/ginutil.c' with conflicts. Applied patch to 'src/backend/access/gist/gist.c' with conflicts. Applied patch to 'src/backend/access/hash/hash.c' with conflicts. Applied patch to 'src/backend/access/nbtree/nbtree.c' with conflicts. Applied patch to 'src/backend/access/spgist/spgutils.c' with conflicts. Applied patch to 'src/backend/optimizer/path/indxpath.c' cleanly. Applied patch to 'src/include/access/amapi.h' with conflicts. Applied patch to 'src/include/nodes/pathnodes.h' cleanly. U contrib/bloom/blutils.c U doc/src/sgml/indexam.sgml U src/backend/access/brin/brin.c U src/backend/access/gin/ginutil.c U src/backend/access/gist/gist.c U src/backend/access/hash/hash.c U src/backend/access/nbtree/nbtree.c U src/backend/access/spgist/spgutils.c U src/include/access/amapi.h diff --cc contrib/bloom/blutils.c index 5111cdc6dd6,916734f675c..00000000000 --- a/contrib/bloom/blutils.c +++ b/contrib/bloom/blutils.c @@@ -102,62 -105,56 +102,115 @@@ makeDefaultBloomOptions(void Datum blhandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = BLOOM_NSTRATEGIES, + .amsupport = BLOOM_NPROC, + .amoptsprocnum = BLOOM_OPTIONS_PROC, + .amcanorder = false, + .amcanorderbyop = false, + .amcanhash = false, + .amconsistentequality = false, + .amconsistentordering = false, + .amcanbackward = false, + .amcanunique = false, + .amcanmulticol = true, + .amoptionalkey = true, + .amsearcharray = false, + .amsearchnulls = false, + .amstorage = false, + .amclusterable = false, + .ampredlocks = false, + .amcanparallel = false, + .amcanbuildparallel = false, + .amcaninclude = false, + .amusemaintenanceworkmem = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = blbuild, + .ambuildempty = blbuildempty, + .aminsert = blinsert, + .aminsertcleanup = NULL, + .ambulkdelete = blbulkdelete, + .amvacuumcleanup = blvacuumcleanup, + .amcanreturn = NULL, + .amcostestimate = blcostestimate, + .amgettreeheight = NULL, + .amoptions = bloptions, + .amproperty = NULL, + .ambuildphasename = NULL, + .amvalidate = blvalidate, + .amadjustmembers = NULL, + .ambeginscan = blbeginscan, + .amrescan = blrescan, + .amgettuple = NULL, + .amgetbitmap = blgetbitmap, + .amendscan = blendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + .amtranslatestrategy = NULL, + .amtranslatecmptype = NULL, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = BLOOM_NSTRATEGIES; + amroutine->amsupport = BLOOM_NPROC; + amroutine->amoptsprocnum = BLOOM_OPTIONS_PROC; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = false; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = false; + amroutine->amcanunique = false; + amroutine->amcanmulticol = true; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = false; + amroutine->amstorage = false; + amroutine->amclusterable = false; + amroutine->ampredlocks = false; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = false; + amroutine->amcaninclude = false; + amroutine->amusemaintenanceworkmem = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = blbuild; + amroutine->ambuildempty = blbuildempty; + amroutine->aminsert = blinsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = blbulkdelete; + amroutine->amvacuumcleanup = blvacuumcleanup; + amroutine->amcanreturn = NULL; + amroutine->amcostestimate = blcostestimate; + amroutine->amoptions = bloptions; + amroutine->amproperty = NULL; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = blvalidate; + amroutine->amadjustmembers = NULL; + amroutine->ambeginscan = blbeginscan; + amroutine->amrescan = blrescan; + amroutine->amgettuple = NULL; + amroutine->amgetbitmap = blgetbitmap; + amroutine->amendscan = blendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc doc/src/sgml/indexam.sgml index f48da318530,a69135cb780..00000000000 --- a/doc/src/sgml/indexam.sgml +++ b/doc/src/sgml/indexam.sgml @@@ -109,12 -103,11 +109,20 @@@ typedef struct IndexAmRoutin bool amcanorder; /* does AM support ORDER BY result of an operator on indexed column? */ bool amcanorderbyop; ++<<<<<<< ours + /* does AM support hashing using API consistent with the hash AM? */ + bool amcanhash; + /* do operators within an opfamily have consistent equality semantics? */ + bool amconsistentequality; + /* do operators within an opfamily have consistent ordering semantics? */ + bool amconsistentordering; ++======= + /* + * Does AM support only the one ORDER BY operator on first indexed column? + * amcanorderbyop is implied. + */ + bool amorderbyopfirstcol; ++>>>>>>> theirs /* does AM support backward scanning? */ bool amcanbackward; /* does AM support UNIQUE indexes? */ diff --cc src/backend/access/brin/brin.c index 5059da8dce7,c371f726979..00000000000 --- a/src/backend/access/brin/brin.c +++ b/src/backend/access/brin/brin.c @@@ -253,63 -246,57 +253,117 @@@ static void _brin_parallel_scan_and_bui Datum brinhandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = 0, + .amsupport = BRIN_LAST_OPTIONAL_PROCNUM, + .amoptsprocnum = BRIN_PROCNUM_OPTIONS, + .amcanorder = false, + .amcanorderbyop = false, + .amcanhash = false, + .amconsistentequality = false, + .amconsistentordering = false, + .amcanbackward = false, + .amcanunique = false, + .amcanmulticol = true, + .amoptionalkey = true, + .amsearcharray = false, + .amsearchnulls = true, + .amstorage = true, + .amclusterable = false, + .ampredlocks = false, + .amcanparallel = false, + .amcanbuildparallel = true, + .amcaninclude = false, + .amusemaintenanceworkmem = false, + .amsummarizing = true, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = brinbuild, + .ambuildempty = brinbuildempty, + .aminsert = brininsert, + .aminsertcleanup = brininsertcleanup, + .ambulkdelete = brinbulkdelete, + .amvacuumcleanup = brinvacuumcleanup, + .amcanreturn = NULL, + .amcostestimate = brincostestimate, + .amgettreeheight = NULL, + .amoptions = brinoptions, + .amproperty = NULL, + .ambuildphasename = NULL, + .amvalidate = brinvalidate, + .amadjustmembers = NULL, + .ambeginscan = brinbeginscan, + .amrescan = brinrescan, + .amgettuple = NULL, + .amgetbitmap = bringetbitmap, + .amendscan = brinendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + .amtranslatestrategy = NULL, + .amtranslatecmptype = NULL, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = 0; + amroutine->amsupport = BRIN_LAST_OPTIONAL_PROCNUM; + amroutine->amoptsprocnum = BRIN_PROCNUM_OPTIONS; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = false; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = false; + amroutine->amcanunique = false; + amroutine->amcanmulticol = true; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = true; + amroutine->amstorage = true; + amroutine->amclusterable = false; + amroutine->ampredlocks = false; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = true; + amroutine->amcaninclude = false; + amroutine->amusemaintenanceworkmem = false; + amroutine->amsummarizing = true; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = brinbuild; + amroutine->ambuildempty = brinbuildempty; + amroutine->aminsert = brininsert; + amroutine->aminsertcleanup = brininsertcleanup; + amroutine->ambulkdelete = brinbulkdelete; + amroutine->amvacuumcleanup = brinvacuumcleanup; + amroutine->amcanreturn = NULL; + amroutine->amcostestimate = brincostestimate; + amroutine->amoptions = brinoptions; + amroutine->amproperty = NULL; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = brinvalidate; + amroutine->amadjustmembers = NULL; + amroutine->ambeginscan = brinbeginscan; + amroutine->amrescan = brinrescan; + amroutine->amgettuple = NULL; + amroutine->amgetbitmap = bringetbitmap; + amroutine->amendscan = brinendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/backend/access/gin/ginutil.c index e7cba81d477,e9536fd9238..00000000000 --- a/src/backend/access/gin/ginutil.c +++ b/src/backend/access/gin/ginutil.c @@@ -38,61 -36,57 +38,115 @@@ Datum ginhandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = 0, + .amsupport = GINNProcs, + .amoptsprocnum = GIN_OPTIONS_PROC, + .amcanorder = false, + .amcanorderbyop = false, + .amcanhash = false, + .amconsistentequality = false, + .amconsistentordering = false, + .amcanbackward = false, + .amcanunique = false, + .amcanmulticol = true, + .amoptionalkey = true, + .amsearcharray = false, + .amsearchnulls = false, + .amstorage = true, + .amclusterable = false, + .ampredlocks = true, + .amcanparallel = false, + .amcanbuildparallel = true, + .amcaninclude = false, + .amusemaintenanceworkmem = true, + .amsummarizing = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = ginbuild, + .ambuildempty = ginbuildempty, + .aminsert = gininsert, + .aminsertcleanup = NULL, + .ambulkdelete = ginbulkdelete, + .amvacuumcleanup = ginvacuumcleanup, + .amcanreturn = NULL, + .amcostestimate = gincostestimate, + .amgettreeheight = NULL, + .amoptions = ginoptions, + .amproperty = NULL, + .ambuildphasename = ginbuildphasename, + .amvalidate = ginvalidate, + .amadjustmembers = ginadjustmembers, + .ambeginscan = ginbeginscan, + .amrescan = ginrescan, + .amgettuple = NULL, + .amgetbitmap = gingetbitmap, + .amendscan = ginendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = 0; + amroutine->amsupport = GINNProcs; + amroutine->amoptsprocnum = GIN_OPTIONS_PROC; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = false; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = false; + amroutine->amcanunique = false; + amroutine->amcanmulticol = true; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = false; + amroutine->amstorage = true; + amroutine->amclusterable = false; + amroutine->ampredlocks = true; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = false; + amroutine->amcaninclude = false; + amroutine->amusemaintenanceworkmem = true; + amroutine->amsummarizing = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = ginbuild; + amroutine->ambuildempty = ginbuildempty; + amroutine->aminsert = gininsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = ginbulkdelete; + amroutine->amvacuumcleanup = ginvacuumcleanup; + amroutine->amcanreturn = NULL; + amroutine->amcostestimate = gincostestimate; + amroutine->amoptions = ginoptions; + amroutine->amproperty = NULL; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = ginvalidate; + amroutine->amadjustmembers = ginadjustmembers; + amroutine->ambeginscan = ginbeginscan; + amroutine->amrescan = ginrescan; + amroutine->amgettuple = NULL; + amroutine->amgetbitmap = gingetbitmap; + amroutine->amendscan = ginendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/backend/access/gist/gist.c index 8565e225be7,f6ed5023ef0..00000000000 --- a/src/backend/access/gist/gist.c +++ b/src/backend/access/gist/gist.c @@@ -58,63 -58,57 +58,117 @@@ static void gistprunepage(Relation rel Datum gisthandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = 0, + .amsupport = GISTNProcs, + .amoptsprocnum = GIST_OPTIONS_PROC, + .amcanorder = false, + .amcanorderbyop = true, + .amcanhash = false, + .amconsistentequality = false, + .amconsistentordering = false, + .amcanbackward = false, + .amcanunique = false, + .amcanmulticol = true, + .amoptionalkey = true, + .amsearcharray = false, + .amsearchnulls = true, + .amstorage = true, + .amclusterable = true, + .ampredlocks = true, + .amcanparallel = false, + .amcanbuildparallel = false, + .amcaninclude = true, + .amusemaintenanceworkmem = false, + .amsummarizing = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = gistbuild, + .ambuildempty = gistbuildempty, + .aminsert = gistinsert, + .aminsertcleanup = NULL, + .ambulkdelete = gistbulkdelete, + .amvacuumcleanup = gistvacuumcleanup, + .amcanreturn = gistcanreturn, + .amcostestimate = gistcostestimate, + .amgettreeheight = NULL, + .amoptions = gistoptions, + .amproperty = gistproperty, + .ambuildphasename = NULL, + .amvalidate = gistvalidate, + .amadjustmembers = gistadjustmembers, + .ambeginscan = gistbeginscan, + .amrescan = gistrescan, + .amgettuple = gistgettuple, + .amgetbitmap = gistgetbitmap, + .amendscan = gistendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + .amtranslatestrategy = NULL, + .amtranslatecmptype = gisttranslatecmptype, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = 0; + amroutine->amsupport = GISTNProcs; + amroutine->amoptsprocnum = GIST_OPTIONS_PROC; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = true; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = false; + amroutine->amcanunique = false; + amroutine->amcanmulticol = true; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = true; + amroutine->amstorage = true; + amroutine->amclusterable = true; + amroutine->ampredlocks = true; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = false; + amroutine->amcaninclude = true; + amroutine->amusemaintenanceworkmem = false; + amroutine->amsummarizing = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = gistbuild; + amroutine->ambuildempty = gistbuildempty; + amroutine->aminsert = gistinsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = gistbulkdelete; + amroutine->amvacuumcleanup = gistvacuumcleanup; + amroutine->amcanreturn = gistcanreturn; + amroutine->amcostestimate = gistcostestimate; + amroutine->amoptions = gistoptions; + amroutine->amproperty = gistproperty; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = gistvalidate; + amroutine->amadjustmembers = gistadjustmembers; + amroutine->ambeginscan = gistbeginscan; + amroutine->amrescan = gistrescan; + amroutine->amgettuple = gistgettuple; + amroutine->amgetbitmap = gistgetbitmap; + amroutine->amendscan = gistendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/backend/access/hash/hash.c index b2e34d2d45e,5a090907bb3..00000000000 --- a/src/backend/access/hash/hash.c +++ b/src/backend/access/hash/hash.c @@@ -69,63 -56,57 +69,117 @@@ static BlockNumber hash_bulkdelete_read Datum hashhandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = HTMaxStrategyNumber, + .amsupport = HASHNProcs, + .amoptsprocnum = HASHOPTIONS_PROC, + .amcanorder = false, + .amcanorderbyop = false, + .amcanhash = true, + .amconsistentequality = true, + .amconsistentordering = false, + .amcanbackward = true, + .amcanunique = false, + .amcanmulticol = false, + .amoptionalkey = false, + .amsearcharray = false, + .amsearchnulls = false, + .amstorage = false, + .amclusterable = false, + .ampredlocks = true, + .amcanparallel = false, + .amcanbuildparallel = false, + .amcaninclude = false, + .amusemaintenanceworkmem = false, + .amsummarizing = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL, + .amkeytype = INT4OID, + + .ambuild = hashbuild, + .ambuildempty = hashbuildempty, + .aminsert = hashinsert, + .aminsertcleanup = NULL, + .ambulkdelete = hashbulkdelete, + .amvacuumcleanup = hashvacuumcleanup, + .amcanreturn = NULL, + .amcostestimate = hashcostestimate, + .amgettreeheight = NULL, + .amoptions = hashoptions, + .amproperty = NULL, + .ambuildphasename = NULL, + .amvalidate = hashvalidate, + .amadjustmembers = hashadjustmembers, + .ambeginscan = hashbeginscan, + .amrescan = hashrescan, + .amgettuple = hashgettuple, + .amgetbitmap = hashgetbitmap, + .amendscan = hashendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + .amtranslatestrategy = hashtranslatestrategy, + .amtranslatecmptype = hashtranslatecmptype, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = HTMaxStrategyNumber; + amroutine->amsupport = HASHNProcs; + amroutine->amoptsprocnum = HASHOPTIONS_PROC; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = false; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = true; + amroutine->amcanunique = false; + amroutine->amcanmulticol = false; + amroutine->amoptionalkey = false; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = false; + amroutine->amstorage = false; + amroutine->amclusterable = false; + amroutine->ampredlocks = true; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = false; + amroutine->amcaninclude = false; + amroutine->amusemaintenanceworkmem = false; + amroutine->amsummarizing = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL; + amroutine->amkeytype = INT4OID; + + amroutine->ambuild = hashbuild; + amroutine->ambuildempty = hashbuildempty; + amroutine->aminsert = hashinsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = hashbulkdelete; + amroutine->amvacuumcleanup = hashvacuumcleanup; + amroutine->amcanreturn = NULL; + amroutine->amcostestimate = hashcostestimate; + amroutine->amoptions = hashoptions; + amroutine->amproperty = NULL; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = hashvalidate; + amroutine->amadjustmembers = hashadjustmembers; + amroutine->ambeginscan = hashbeginscan; + amroutine->amrescan = hashrescan; + amroutine->amgettuple = hashgettuple; + amroutine->amgetbitmap = hashgetbitmap; + amroutine->amendscan = hashendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/backend/access/nbtree/nbtree.c index 0abdd7b49f5,2d65adb22f7..00000000000 --- a/src/backend/access/nbtree/nbtree.c +++ b/src/backend/access/nbtree/nbtree.c @@@ -117,63 -100,57 +117,117 @@@ static BTVacuumPosting btreevacuumposti Datum bthandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = BTMaxStrategyNumber, + .amsupport = BTNProcs, + .amoptsprocnum = BTOPTIONS_PROC, + .amcanorder = true, + .amcanorderbyop = false, + .amcanhash = false, + .amconsistentequality = true, + .amconsistentordering = true, + .amcanbackward = true, + .amcanunique = true, + .amcanmulticol = true, + .amoptionalkey = true, + .amsearcharray = true, + .amsearchnulls = true, + .amstorage = false, + .amclusterable = true, + .ampredlocks = true, + .amcanparallel = true, + .amcanbuildparallel = true, + .amcaninclude = true, + .amusemaintenanceworkmem = false, + .amsummarizing = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = btbuild, + .ambuildempty = btbuildempty, + .aminsert = btinsert, + .aminsertcleanup = NULL, + .ambulkdelete = btbulkdelete, + .amvacuumcleanup = btvacuumcleanup, + .amcanreturn = btcanreturn, + .amcostestimate = btcostestimate, + .amgettreeheight = btgettreeheight, + .amoptions = btoptions, + .amproperty = btproperty, + .ambuildphasename = btbuildphasename, + .amvalidate = btvalidate, + .amadjustmembers = btadjustmembers, + .ambeginscan = btbeginscan, + .amrescan = btrescan, + .amgettuple = btgettuple, + .amgetbitmap = btgetbitmap, + .amendscan = btendscan, + .ammarkpos = btmarkpos, + .amrestrpos = btrestrpos, + .amestimateparallelscan = btestimateparallelscan, + .aminitparallelscan = btinitparallelscan, + .amparallelrescan = btparallelrescan, + .amtranslatestrategy = bttranslatestrategy, + .amtranslatecmptype = bttranslatecmptype, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = BTMaxStrategyNumber; + amroutine->amsupport = BTNProcs; + amroutine->amoptsprocnum = BTOPTIONS_PROC; + amroutine->amcanorder = true; + amroutine->amcanorderbyop = false; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = true; + amroutine->amcanunique = true; + amroutine->amcanmulticol = true; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = true; + amroutine->amsearchnulls = true; + amroutine->amstorage = false; + amroutine->amclusterable = true; + amroutine->ampredlocks = true; + amroutine->amcanparallel = true; + amroutine->amcanbuildparallel = true; + amroutine->amcaninclude = true; + amroutine->amusemaintenanceworkmem = false; + amroutine->amsummarizing = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = btbuild; + amroutine->ambuildempty = btbuildempty; + amroutine->aminsert = btinsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = btbulkdelete; + amroutine->amvacuumcleanup = btvacuumcleanup; + amroutine->amcanreturn = btcanreturn; + amroutine->amcostestimate = btcostestimate; + amroutine->amoptions = btoptions; + amroutine->amproperty = btproperty; + amroutine->ambuildphasename = btbuildphasename; + amroutine->amvalidate = btvalidate; + amroutine->amadjustmembers = btadjustmembers; + amroutine->ambeginscan = btbeginscan; + amroutine->amrescan = btrescan; + amroutine->amgettuple = btgettuple; + amroutine->amgetbitmap = btgetbitmap; + amroutine->amendscan = btendscan; + amroutine->ammarkpos = btmarkpos; + amroutine->amrestrpos = btrestrpos; + amroutine->amestimateparallelscan = btestimateparallelscan; + amroutine->aminitparallelscan = btinitparallelscan; + amroutine->amparallelrescan = btparallelrescan; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/backend/access/spgist/spgutils.c index f2ee333f60d,2ba8cbc966b..00000000000 --- a/src/backend/access/spgist/spgutils.c +++ b/src/backend/access/spgist/spgutils.c @@@ -43,63 -43,57 +43,117 @@@ Datum spghandler(PG_FUNCTION_ARGS) { ++<<<<<<< ours + static const IndexAmRoutine amroutine = { + .type = T_IndexAmRoutine, + .amstrategies = 0, + .amsupport = SPGISTNProc, + .amoptsprocnum = SPGIST_OPTIONS_PROC, + .amcanorder = false, + .amcanorderbyop = true, + .amcanhash = false, + .amconsistentequality = false, + .amconsistentordering = false, + .amcanbackward = false, + .amcanunique = false, + .amcanmulticol = false, + .amoptionalkey = true, + .amsearcharray = false, + .amsearchnulls = true, + .amstorage = true, + .amclusterable = false, + .ampredlocks = false, + .amcanparallel = false, + .amcanbuildparallel = false, + .amcaninclude = true, + .amusemaintenanceworkmem = false, + .amsummarizing = false, + .amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP, + .amkeytype = InvalidOid, + + .ambuild = spgbuild, + .ambuildempty = spgbuildempty, + .aminsert = spginsert, + .aminsertcleanup = NULL, + .ambulkdelete = spgbulkdelete, + .amvacuumcleanup = spgvacuumcleanup, + .amcanreturn = spgcanreturn, + .amcostestimate = spgcostestimate, + .amgettreeheight = NULL, + .amoptions = spgoptions, + .amproperty = spgproperty, + .ambuildphasename = NULL, + .amvalidate = spgvalidate, + .amadjustmembers = spgadjustmembers, + .ambeginscan = spgbeginscan, + .amrescan = spgrescan, + .amgettuple = spggettuple, + .amgetbitmap = spggetbitmap, + .amendscan = spgendscan, + .ammarkpos = NULL, + .amrestrpos = NULL, + .amestimateparallelscan = NULL, + .aminitparallelscan = NULL, + .amparallelrescan = NULL, + .amtranslatestrategy = NULL, + .amtranslatecmptype = NULL, + }; + + PG_RETURN_POINTER(&amroutine); ++======= + IndexAmRoutine *amroutine = makeNode(IndexAmRoutine); + + amroutine->amstrategies = 0; + amroutine->amsupport = SPGISTNProc; + amroutine->amoptsprocnum = SPGIST_OPTIONS_PROC; + amroutine->amcanorder = false; + amroutine->amcanorderbyop = true; + amroutine->amorderbyopfirstcol = false; + amroutine->amcanbackward = false; + amroutine->amcanunique = false; + amroutine->amcanmulticol = false; + amroutine->amoptionalkey = true; + amroutine->amsearcharray = false; + amroutine->amsearchnulls = true; + amroutine->amstorage = true; + amroutine->amclusterable = false; + amroutine->ampredlocks = false; + amroutine->amcanparallel = false; + amroutine->amcanbuildparallel = false; + amroutine->amcaninclude = true; + amroutine->amusemaintenanceworkmem = false; + amroutine->amsummarizing = false; + amroutine->amparallelvacuumoptions = + VACUUM_OPTION_PARALLEL_BULKDEL | VACUUM_OPTION_PARALLEL_COND_CLEANUP; + amroutine->amkeytype = InvalidOid; + + amroutine->ambuild = spgbuild; + amroutine->ambuildempty = spgbuildempty; + amroutine->aminsert = spginsert; + amroutine->aminsertcleanup = NULL; + amroutine->ambulkdelete = spgbulkdelete; + amroutine->amvacuumcleanup = spgvacuumcleanup; + amroutine->amcanreturn = spgcanreturn; + amroutine->amcostestimate = spgcostestimate; + amroutine->amoptions = spgoptions; + amroutine->amproperty = spgproperty; + amroutine->ambuildphasename = NULL; + amroutine->amvalidate = spgvalidate; + amroutine->amadjustmembers = spgadjustmembers; + amroutine->ambeginscan = spgbeginscan; + amroutine->amrescan = spgrescan; + amroutine->amgettuple = spggettuple; + amroutine->amgetbitmap = spggetbitmap; + amroutine->amendscan = spgendscan; + amroutine->ammarkpos = NULL; + amroutine->amrestrpos = NULL; + amroutine->amestimateparallelscan = NULL; + amroutine->aminitparallelscan = NULL; + amroutine->amparallelrescan = NULL; + + PG_RETURN_POINTER(amroutine); ++>>>>>>> theirs } /* diff --cc src/include/access/amapi.h index 79240333530,21b5d3149f8..00000000000 --- a/src/include/access/amapi.h +++ b/src/include/access/amapi.h @@@ -247,12 -224,12 +247,21 @@@ typedef struct IndexAmRoutin bool amcanorder; /* does AM support ORDER BY result of an operator on indexed column? */ bool amcanorderbyop; ++<<<<<<< ours + /* does AM support hashing using API consistent with the hash AM? */ + bool amcanhash; + /* do operators within an opfamily have consistent equality semantics? */ + bool amconsistentequality; + /* do operators within an opfamily have consistent ordering semantics? */ + bool amconsistentordering; ++======= + + /* + * Does AM support only the one ORDER BY operator on first indexed column? + * amcanorderbyop is implied. + */ + bool amorderbyopfirstcol; ++>>>>>>> theirs /* does AM support backward scanning? */ bool amcanbackward; /* does AM support UNIQUE indexes? */