storetest

type BuildFn func(source string) error

type Capabilities struct {
	Indexer      bool
	Searcher     bool
	HybridSearch bool
	// MediaDocuments declares lossless storage of document media alongside text.
	// A false value requires rejection of mixed content before external I/O.
	MediaDocuments bool
	IDDeleter      bool
	FilterDeleter  bool

	// Closer is true only for a store that created a resource of its own. A
	// store handed its client, session or pool releases nothing, so a false
	// flag forbids a Close method rather than permitting a no-op one: a no-op
	// Close claims there was something to release and that calling it released
	// it, which leaves a caller unable to tell the two kinds of store apart.
	Closer bool
}

type Compiler struct {
	Visit    func(filter.Predicate) error
	Snapshot func() any
}

type Options struct {
	// Unsupported lists cases the vendor cannot represent exactly. The suite
	// verifies that each one returns an error; capability gaps must never turn
	// into silent approximations or unexecuted tests.
	Unsupported []string

	// InterpolatesKeyPaths declares that this compiler writes a metadata key
	// into the query language as text rather than binding it as a value.
	//
	// It decides which way the suite reads a key the target language cannot
	// name. An indexed key is a string literal, so the caller chooses its
	// bytes; a compiler that pastes them into query text has the caller's key
	// read as syntax — profile['a:1 OR b'] compiled to Lucene as
	// profile.a:1 OR b, and the same shape reached Typesense's filter_by,
	// Vespa's YQL, an OData filter and a RediSearch tag clause. None of those
	// languages can quote a field name, so such a key has to be refused, and
	// the suite requires it.
	//
	// A compiler that binds the key instead — a SQL map subscript, a BSON
	// field name, a JSON object key — is not exposed, and the suite requires
	// the opposite: it must keep accepting any key, because refusing one would
	// take away a document it can otherwise filter perfectly well.
	InterpolatesKeyPaths bool

	// CompileText compiles a filter and returns the query text it produced.
	//
	// Set it when the compiler's whole output is text, because then a number
	// has to be written as a numeral and the digits are the only thing standing
	// between the caller's filter and a different one. Six compilers derived
	// those digits from a Go scalar and decided integer-ness with
	// float64(int64(value)) == value — an out-of-range float-to-int conversion
	// Go leaves implementation-defined — so at 2^63 arm64 emitted
	// 9223372036854775807 while amd64 emitted the right digits. Every existing
	// test passed: nothing compared the digits to anything.
	//
	// Leave it nil when the compiler binds values as arguments or builds a
	// provider structure. There is no numeral to get wrong then, and rendering
	// one for the suite's benefit would assert something the store never sends.
	CompileText func(source string) (string, error)

	// NumericDomainIsFloat64 declares that the provider's numeric fields are
	// doubles, so a numeral only has to denote the same double.
	//
	// RediSearch is the case: its NUMERIC range bounds are doubles, which is
	// why that store refuses an integer past 2^53 outright. An integer that a
	// double does hold exactly — 2^63, being a power of two — then comes out as
	// the shortest decimal that reads back as the same double, which is
	// 9223372036854776000 rather than 9223372036854775808. Demanding the
	// literal's digits there would demand precision the field cannot keep, so
	// the suite asks only that the numeral read back as the same double, which
	// still catches a digit lost or invented along the way.
	NumericDomainIsFloat64 bool
}