Index access method not receiving an orderbys ScanKey

Can anyone tell me why my index access method isn't seeing an order_by ScanKey when there is a query with an ORDER BY clause that uses an operator that the access method supports?

(Apologies for the volume of code below. I just don't know what is important. This is all in Rust.)


CREATE OPERATOR pg_catalog.<===> (
    FUNCTION = rdb.userquery_match,
    LEFTARG = record,
    RIGHTARG = rdb.userqueryspec
);

CREATE OPERATOR pg_catalog.<<=>> (
    FUNCTION = rdb.test_sort_match,
    LEFTARG = record,
    RIGHTARG = rdb.TestSort
);

CREATE OPERATOR CLASS rdb_ops DEFAULT FOR TYPE record USING rdb AS
    OPERATOR 1 pg_catalog.<===> (record, rdb.userqueryspec),
    OPERATOR 2 pg_catalog.<<=>> (record, rdb.testsort) FOR ORDER BY pg_catalog.float_ops;


#[derive(Serialize, Deserialize, PostgresType, Debug)]
pub struct TestSort {
    foo: f32,
}

#[pg_extern(
sql = "CREATE FUNCTION rdb.test_sort_match(rec record, testsort rdb.TestSort) RETURNS bool IMMUTABLE STRICT PARALLEL SAFE  LANGUAGE c AS 'MODULE_PATHNAME', 'dummysort_match_wrapper';",
requires = [DummySortSpec]
)]
fn test_sort_match(_fcinfo: pg_sys::FunctionCallInfo, testsort: TestSort) -> f32 {
    testsort.foo + 2.0
}

#[pg_extern(immutable, strict, parallel_safe)]
fn get_testsort(foo: f32) -> TestSort {
    TestSort { foo }
}

Here's the query:

SELECT title
FROM products
WHERE products <===> rdb.userquery('teddy')
ORDER BY products <<=>> rdb.get_testsort(5.0);

The amhander gets and uses the WHERE clause just fine. The problem is that ambeginscan() and amrescan() both get a norderbys parameter equal to 0.

Doing an EXPLAIN on the query above yields this:

 Sort  (cost=1000027.67..1000028.92 rows=500 width=28)
   Sort Key: ((products.* <<=>> '{"foo":5.0}'::rdb.testsort))
   ->  Index Scan using product_idx on products  (cost=0.00..1000005.26 rows=500 width=28)
         Index Cond: (products.* <===> '{"query_str":"teddy", /* snip */ }'::rdb.userqueryspec)

So, the sort isn't getting passed to the index scan. Weirdly, the test_sort_match() method never gets invoked, so I'm not sure how the system thinks it's actually doing the sort.

The fact that the operators work on a RECORD type does not seem to be significant. If I swap it for a TEXT data type then I get the same behavior.

I'm sure I'm missing something small.

Here's the amhandler definition:

#[pg_extern(sql = "
    CREATE OR REPLACE FUNCTION amhandler(internal) RETURNS index_am_handler PARALLEL SAFE IMMUTABLE STRICT LANGUAGE c AS 'MODULE_PATHNAME', '@FUNCTION_NAME@';
    CREATE ACCESS METHOD rdb TYPE INDEX HANDLER amhandler;
")]
fn amhandler(_fcinfo: pg_sys::FunctionCallInfo) -> PgBox<pg_sys::IndexAmRoutine> {
    let mut amroutine =
        unsafe { PgBox::<pg_sys::IndexAmRoutine>::alloc_node(pg_sys::NodeTag::T_IndexAmRoutine) };

    amroutine.amstrategies = OPERATOR_COUNT;
    amroutine.amsupport = PROC_COUNT;
    amroutine.amoptsprocnum = OPTIONS_PROC;
    amroutine.amcanorder = false;
    amroutine.amcanorderbyop = true;
    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.amcaninclude = true;
    amroutine.amusemaintenanceworkmem = false;
    amroutine.amparallelvacuumoptions = 0;
    amroutine.amkeytype = pg_sys::InvalidOid;

    /* interface functions */
    amroutine.ambuild = Some(build::ambuild);
    amroutine.ambuildempty = Some(build::ambuildempty);
    amroutine.aminsert = Some(insert::aminsert);
    amroutine.ambulkdelete = Some(delete::ambulkdelete);
    amroutine.amvacuumcleanup = Some(delete::amvacuumcleanup);
    amroutine.amcanreturn = Some(scan::amcanreturn); /* test if can return a particular col in index-only scan */
    amroutine.amcostestimate = Some(amcostestimate);
    amroutine.amoptions = Some(index_options::amoptions);

    amroutine.amproperty = None;
    amroutine.ambuildphasename = None;
    amroutine.amvalidate = Some(amvalidate);
    // amroutine.amadjustmembers = None; omit so we can compile earlier versions

    amroutine.ambeginscan = Some(scan::ambeginscan);
    amroutine.amrescan = Some(scan::amrescan);
    amroutine.amgettuple = Some(scan::amgettuple);
    amroutine.amgetbitmap = None; // Some(scan::ambitmapscan);
    amroutine.amendscan = Some(scan::amendscan);

    amroutine.ammarkpos = None;
    amroutine.amrestrpos = None;

    /* interface functions to support parallel index scans */
    amroutine.amestimateparallelscan = None;
    amroutine.aminitparallelscan = None;
    amroutine.amparallelrescan = None;

    amroutine.into_pg_boxed()
}



--