xquery

type BoundarySpace int

type Construction int

type EmptyOrder int

type MapModuleResolver struct {
	// Modules maps a target namespace to the module's source text.
	Modules map[string]string
}

type Module struct {
	// Namespace is the module's target namespace. It must match the "module
	// namespace" declaration in Source, which is checked on load: a store
	// keyed by a namespace the module does not declare would answer imports
	// with the wrong module. XQST0059 is the error, since from the import's
	// point of view no module with that namespace was found.
	Namespace string

	// Source is the library module's text.
	Source string

	// BaseURI is the static base URI of this module, used for the module's
	// own relative resolution. It may be empty.
	BaseURI string
}

type ModuleResolver interface {
	// Resolve returns the source of the library module whose target
	// namespace is namespace. The hints are the import's "at" locations,
	// resolved relative to base when they are not absolute.
	//
	// Returning a nil reader and a nil error means "no such module", which
	// the caller reports as XQST0059. It is not a way to succeed quietly:
	// a query whose import found nothing has an incomplete static context,
	// and evaluating against that is exactly what this package refuses to
	// do.
	Resolve(namespace string, hints []string, base string) (io.ReadCloser, string, error)
}

type Options struct {
	// BaseURI is the static base URI. It is stamped on constructed elements
	// and is what a relative reference resolves against.
	BaseURI string

	// DeclarationBaseURI is the URI of the resource the query text was read
	// from. It is used for one thing only: resolving a relative
	// "declare base-uri" against it, as §4.5 requires.
	//
	// It is deliberately separate from BaseURI. The two answer different
	// questions -- "what does a prolog declaration resolve against" and "what
	// does the query run under" -- and conflating them is what made every
	// earlier attempt at K2-BaseURIProlog-4 a net loss: one value for both
	// also stamped that value on constructed elements and on
	// fn:static-base-uri when the query declared nothing, which the suite's
	// base-URI-12/14/23/24 and K2-BaseURIFunc-30 all detect. Kept apart,
	// setting this one changes nothing except the resolution a declaration
	// asks for: a query with no "declare base-uri" is unaffected by it.
	DeclarationBaseURI string

	// BoundarySpace decides whether whitespace that only separates markup
	// survives into a constructed element. The zero value strips it, which is
	// what a query with no "declare boundary-space" gets.
	BoundarySpace BoundarySpace

	// Construction decides whether a copied node keeps its type annotation.
	// The zero value preserves it.
	Construction Construction

	// DefaultElementNamespace is applied to an unprefixed element name. It is
	// never applied to an attribute name.
	DefaultElementNamespace string

	// Namespaces are prefix bindings available to the query, as though its
	// prolog had declared them. The eight predeclared prefixes of §4.1 —
	// xml, xs, xsi, fn, local, math, map and array — are bound already, as is
	// err, which §3.16 binds so that "catch err:FODC0002" works with no
	// declaration. None of them need to appear here.
	Namespaces map[string]string

	// Modules are library modules available to "import module" (§4.12),
	// registered by target namespace with their source text.
	//
	// This is the module store the specification leaves to the
	// implementation, and it is the only way to import a module that grants
	// the query no reach whatever: the caller supplies the text, so nothing
	// is opened and nothing is fetched. An import with no "at" clause names
	// a namespace and nothing else, and resolves against this.
	//
	// The store is consulted before ModuleResolver, so a registered module
	// shadows any location a query might name for that namespace.
	Modules []Module

	// ModuleResolver locates a library module that Modules does not have.
	// When nil, NOTHING IS FETCHED: an "at" location is never opened, and an
	// import that the store cannot answer raises XQST0059.
	//
	// It is off by default for the reason xsd.Options.Resolver is — it hands
	// control of what this process reads to whoever wrote the query — and the
	// exposure here is worse than a schema's, because an "at" location is a
	// string chosen by the query's author and a query is the more commonly
	// untrusted input of the two. A host that sets this is granting the
	// queries it compiles the reach the resolver has, and should give one
	// that is rooted or table-driven rather than one that will open anything.
	//
	// MapModuleResolver answers from memory and follows no location at all.
	ModuleResolver ModuleResolver

	// MaxModules bounds how many library modules one compilation may load,
	// counting those reached transitively. A module that imports two modules
	// that each import two more is a fan-out with no natural bound, in the
	// same shape as a schema's include graph. Zero means DefaultMaxModules.
	//
	// Exceeding it FAILS the compilation with an error wrapping
	// xdm.ErrResourceLimit. It never yields a query compiled against the
	// modules that fitted: a partial static context is how an import comes to
	// look successful while half a library is missing.
	MaxModules int

	// MaxModuleBytes bounds the total source text one compilation may read
	// through ModuleResolver and Modules, cumulatively rather than per
	// module — a budget spent one module at a time is not spent at all. Zero
	// means DefaultMaxModuleBytes.
	//
	// Exceeding it fails the compilation with an error wrapping
	// xdm.ErrResourceLimit, on the same reasoning as MaxModules: a truncated
	// module is a module whose declarations are partly missing.
	MaxModuleBytes int64

	// Schemas are schemas available to "import schema" (§4.11), registered
	// by target namespace.
	//
	// This is the schema store the specification leaves to the
	// implementation, and it is the only way to import a schema that grants
	// the query no reach whatever: the caller supplies the components or the
	// text, so nothing is opened and nothing is fetched. An import with no
	// "at" clause names a namespace and nothing else, and resolves against
	// this.
	//
	// The store is consulted before SchemaResolver, so a registered schema
	// shadows any location a query might name for that namespace.
	Schemas []Schema

	// SchemaResolver locates a schema document that Schemas does not have.
	// When nil, NOTHING IS FETCHED: an "at" location is never opened, and an
	// import that the store cannot answer raises XQST0059.
	//
	// It is off by default for the same reason ModuleResolver is: an "at"
	// location is a string chosen by the query's author, and a query is
	// untrusted input. The same resolver is handed to xsd for the imported
	// schema's own xs:include and xs:import, so an imported schema can reach
	// no further than the query's import was granted.
	SchemaResolver SchemaResolver

	// MaxSchemaBytes bounds the total schema source text one compilation may
	// read through SchemaResolver and Schemas, cumulatively rather than per
	// import. Zero means DefaultMaxSchemaBytes.
	//
	// Exceeding it fails the compilation with an error wrapping
	// xdm.ErrResourceLimit rather than XQST0059: a truncated schema is a
	// schema whose components are partly missing, and compiling against a
	// partial static context is what this package refuses to do.
	MaxSchemaBytes int64
}

type Ordering int

type Query struct {
	// contains filtered or unexported fields
}

type Schema struct {
	// Namespace is the target namespace this schema supplies. An import of
	// this namespace resolves to this entry.
	//
	// It is matched against the import's target namespace rather than against
	// the schema's own targetNamespace attribute: a caller registering a
	// Schema has said which namespace it answers for, and Components is
	// already-assembled rather than a document to re-read.
	Namespace string

	// Components is the assembled schema. A caller that has one from
	// xsd.Load, xsd.LoadFile or xslt's Stylesheet.Schema can register it
	// directly, which is what makes a host able to share one schema between a
	// stylesheet and a query without loading it twice and risking the two
	// disagreeing.
	//
	// It may be nil, which registers the namespace as known and empty. That
	// is not a useless entry: §4.11 makes importing a namespace legal whether
	// or not the processor has components for it, and a nil entry is how a
	// host says "this namespace is expected and I have nothing for it"
	// without the import failing.
	Components *xsd.Schema

	// Source is schema document text to load, used when Components is nil.
	// It is the convenient half of the store: a caller with a schema document
	// in a string need not call xsd.Load itself.
	Source string

	// BaseURI is what Source's own relative references resolve against. It
	// may be empty.
	BaseURI string
}

type SchemaResolver = xsd.Resolver

type XQVersion int