traverse

func (*ActionBuilder) Execute ¶

func (a *ActionBuilder) Execute(ctx context.Context) (map[string]interface{}, error)

Execute calls the action and returns the result as a map.

Execute sends an HTTP POST request to the action with optional body and parameter data. The request body is marshaled to JSON automatically. The response is parsed into a map.

If ActionBuilder.WithBody was called, that data is sent as the primary body. Otherwise, if parameters were added via ActionBuilder.Param, they are sent as JSON. If neither, an empty POST is sent.

Returns a map containing the action response, or an error if the call fails.

Example:

result, err := client.Action("ApproveOrder").
	WithBody(approvalData).
	Execute(ctx)

func (*ActionBuilder) Invoke ¶ added in v0.2.11

func (a *ActionBuilder) Invoke(ctx context.Context, result any) error

Invoke calls the action and unmarshals the response into result.

Invoke is the result-receiver variant of ActionBuilder.Execute. It sends an HTTP POST request to the OData action URL and unmarshals the response body into the value pointed to by result. result may be nil when no response body is expected.

If ActionBuilder.WithBody was called, that data forms the request body. Otherwise parameters added via ActionBuilder.Param are sent as JSON.

Returns an error if the HTTP call fails, the response status is not 2xx, or unmarshaling fails.

Example:

type ApprovalResult struct {
	Approved bool   `json:"approved"`
	Message  string `json:"message"`
}

var res ApprovalResult
err := client.Action("ApproveOrder").Param("orderID", 42).Invoke(ctx, &res)

func (*ActionBuilder) Param ¶

func (a *ActionBuilder) Param(key string, value interface{}) *ActionBuilder

Param adds a parameter to the action call.

Param appends a key-value parameter for the action. Parameters can be sent in the request body as JSON.

Returns the receiver for method chaining.

func (*ActionBuilder) WithBody ¶

func (a *ActionBuilder) WithBody(data interface{}) *ActionBuilder

WithBody sets the request body for the action.

WithBody sets the main request body data for the action. The data is automatically marshaled to JSON.

Returns the receiver for method chaining.

Example:

action.WithBody(map[string]interface{}{
	"orderID": 12345,
	"approvedBy": "Manager",
})

func (*AnnotatedEntity[T]) GetAnnotation ¶ added in v0.2.27

func (a *AnnotatedEntity[T]) GetAnnotation(name string, target any) error

GetAnnotation retrieves a typed annotation value by name and unmarshals it into target.

Returns an error if the annotation is not present or cannot be decoded into target.

Example:

var etag string
if err := result.GetAnnotation("@odata.etag", &etag); err != nil { ... }

func (*AsyncOpPoller) Wait ¶ added in v0.2.6

func (p *AsyncOpPoller) Wait(ctx context.Context) (*AsyncResult, error)

Wait polls the status URL until the operation completes or ctx is cancelled. Returns ErrAsyncOpFailed if the server signals failure, ErrAsyncOpTimeout if maxPolls is exhausted before completion.

func (*AsyncOpPoller) WithMaxPolls ¶ added in v0.2.6

func (p *AsyncOpPoller) WithMaxPolls(n int) *AsyncOpPoller

WithMaxPolls sets the maximum number of poll attempts before giving up. Use 0 for unlimited (rely on ctx cancellation).

func (*AsyncOpPoller) WithPollInterval ¶ added in v0.2.6

func (p *AsyncOpPoller) WithPollInterval(d time.Duration) *AsyncOpPoller

WithPollInterval sets the interval between poll attempts.

func (AsyncOpStatus) String ¶ added in v0.2.6

func (s AsyncOpStatus) String() string

String returns a human-readable name for the status.

func (*BatchOperation) SetBody ¶

func (op *BatchOperation) SetBody(data interface{}) error

SetBody sets the Body field, marshaling data if needed.

SetBody converts the provided data to JSON and stores it as a json.RawMessage in the Body field. Returns an error if JSON marshaling fails. Nil data results in a nil Body.

This helper maintains API compatibility while optimizing allocations by using raw JSON instead of unmarshaling on the server side.

func (*BatchRequest) BeginChangeset ¶

func (b *BatchRequest) BeginChangeset(id string) *BatchRequest

BeginChangeset starts a changeset (atomic transaction group).

BeginChangeset marks the beginning of a set of operations that should be executed atomically. All operations added after this call (until EndChangeset) belong to this changeset. Multiple changesets can exist in a single batch.

The id parameter is used to group related operations. If a changeset was already open, it is closed first.

Returns the receiver for method chaining.

Example:

batch.BeginChangeset("group-1").
	Create("Orders", order).
	Create("OrderItems", item1).
	EndChangeset()

func (*BatchRequest) Create ¶

func (b *BatchRequest) Create(entitySet string, data interface{}) *BatchRequest

Create adds a POST (create) operation to the batch.

Create inserts a new entity into the specified entity set. The data is marshaled to JSON automatically. If Create is called within a changeset (between BeginChangeset and EndChangeset), the operation becomes part of that transaction.

Returns the receiver for method chaining.

Example:

batch.Create("Orders", map[string]interface{}{"OrderID": 123, "Total": 99.99})

func (*BatchRequest) Delete ¶

func (b *BatchRequest) Delete(entitySet string, key interface{}) *BatchRequest

Delete adds a DELETE operation to the batch.

Delete removes an entity identified by its key. If called within a changeset, the deletion becomes part of that atomic transaction.

Returns the receiver for method chaining.

Example:

batch.Delete("Orders", 123)

func (*BatchRequest) EndChangeset ¶

func (b *BatchRequest) EndChangeset() *BatchRequest

EndChangeset ends the current changeset.

EndChangeset closes the active changeset, storing it for later execution. All subsequent operations will be standalone batch operations (not in a changeset) until another BeginChangeset is called.

Returns the receiver for method chaining.

Example:

batch.BeginChangeset("tx1").
	Create("Orders", orderData).
	EndChangeset().
	Get("Customers", 1)

func (*BatchRequest) Execute ¶

func (b *BatchRequest) Execute(ctx context.Context) (*BatchResponse, error)

Execute sends the batch request and returns all results at once.

Execute constructs a multipart/mixed HTTP request containing all batch operations and changesets, sends it to the OData service, and parses the response. The operation automatically closes any open changeset before execution.

All results are materialized into memory before returning. For large batches, consider using BatchRequest.ExecuteStream for memory-efficient incremental processing.

On error, returns a non-nil error. The returned BatchResponse contains individual results for each operation, even if some operations failed.

Example:

resp, err := batch.Execute(ctx)
if err != nil {
	log.Fatal(err)
}
for _, result := range resp.Results {
	fmt.Println(result.Status, result.Data)
}

func (*BatchRequest) ExecuteJSON ¶ added in v0.13.0

func (b *BatchRequest) ExecuteJSON(ctx context.Context) (*BatchResponse, error)

ExecuteJSON sends the batch request using the OData 4.01 JSON batch format.

ExecuteJSON is an alternative to BatchRequest.Execute that uses JSON encoding instead of multipart/mixed. The OData 4.01 JSON batch format is more compact, easier to debug, and supported by modern OData services.

OData 4.01 spec reference: section 18 (Batch Requests and Responses).

Operations within changesets are grouped using the "atomicityGroup" property. All operations in a changeset must succeed or all will be rolled back.

Example:

resp, err := client.Batch().
    Get("Products", 1).
    Get("Products", 2).
    ExecuteJSON(ctx)
if err != nil {
    log.Fatal(err)
}
for _, result := range resp.Results {
    fmt.Println(result.StatusCode, string(result.Body))
}

func (*BatchRequest) ExecuteJSONStream ¶ added in v0.13.0

func (b *BatchRequest) ExecuteJSONStream(ctx context.Context) <-chan BatchResult

ExecuteJSONStream sends the batch using JSON format and streams results via a channel.

ExecuteJSONStream is the streaming variant of BatchRequest.ExecuteJSON. It reads the entire JSON response but emits results to the channel one by one to allow concurrent processing.

Example:

for result := range batch.ExecuteJSONStream(ctx) {
    if result.Err != nil {
        log.Println("Operation failed:", result.Err)
        continue
    }
    fmt.Println(result.StatusCode, string(result.Body))
}

func (*BatchRequest) ExecuteStream ¶

func (b *BatchRequest) ExecuteStream(ctx context.Context) <-chan BatchResult

ExecuteStream sends the batch request and streams results incrementally via a channel.

ExecuteStream is more memory-efficient than BatchRequest.Execute for large batches. Results are parsed and sent to the returned channel as they arrive, allowing processing to begin before the entire response is received. The operation automatically closes any open changeset before execution.

The returned channel is buffered with capacity 8 and will be closed when all results have been sent or an error occurs. Errors are sent as BatchResult items with non-nil Err field.

Example:

results := batch.ExecuteStream(ctx)
for result := range results {
	if result.Err != nil {
		log.Println("Operation failed:", result.Err)
		continue
	}
	fmt.Println(result.Status, string(result.Body))
}

func (*BatchRequest) Get ¶

func (b *BatchRequest) Get(entitySet string, key interface{}) *BatchRequest

Get adds a GET operation to the batch.

Get retrieves a single entity by its key and adds the operation to the batch. The operation is read-only and cannot be part of a changeset.

Returns the receiver for method chaining.

Example:

batch.Get("Customers", 1)

func (*BatchRequest) Update ¶

func (b *BatchRequest) Update(entitySet string, key interface{}, data interface{}) *BatchRequest

Update adds a PATCH (update) operation to the batch.

Update modifies an existing entity identified by its key. The data is marshaled to JSON and sent as PATCH. If called within a changeset, the operation becomes part of that atomic transaction.

Returns the receiver for method chaining.

Example:

batch.Update("Orders", 123, map[string]interface{}{"Total": 150.00})

func (Binary) MarshalJSON ¶

func (b Binary) MarshalJSON() ([]byte, error)

MarshalJSON encodes binary data as a base64 JSON string.

MarshalJSON converts the raw binary bytes to a standard base64-encoded string (RFC 4648 §4) and wraps it in JSON quotes, matching the OData v4 Edm.Binary wire format.

func (*Binary) UnmarshalJSON ¶

func (b *Binary) UnmarshalJSON(data []byte) error

UnmarshalJSON decodes base64 encoded binary data.

UnmarshalJSON accepts a JSON string containing standard or URL-safe base64 encoded binary data and decodes it to the internal byte slice. OData v4 uses standard base64 (RFC 4648 §4); some SAP services use URL-safe base64 (RFC 4648 §5). Both are tried in order.

Returns an error if the input is not a valid JSON string or cannot be decoded as base64.

func (*CapabilitiesRegistry) Get ¶ added in v0.2.21

func (r *CapabilitiesRegistry) Get(entitySet string) EntityCapabilities

Get returns the capabilities for the named entity set.

func (*CapabilityError) Error ¶ added in v0.2.21

func (e *CapabilityError) Error() string

Error implements the error interface.

func (*Client) Action ¶

func (c *Client) Action(name string) *ActionBuilder

Action starts building a call to an OData Action (v4).

Action creates a new ActionBuilder for calling OData Actions. Actions may perform side effects and can include both request bodies and parameters.

Returns an ActionBuilder ready for body/parameter configuration and execution.

Example:

result, err := client.Action("ApproveOrder").
	WithBody(approvalData).
	Param("approverID", emp123).
	Execute(ctx)

func (*Client) BaseURL ¶

func (c *Client) BaseURL() string

BaseURL returns the base URL of the OData service that this Client is connected to.

BaseURL returns the configured service root URL, which serves as the base for all OData entity set operations. This is the URL passed to New() via WithBaseURL().

The returned URL typically has the form: https://odata.example.com/v4 or for SAP systems: https://sap.example.com/sap/opu/odata/sap/ZESX_PRODUCT/

Returns:

• The base URL string (always non-empty for a valid client)

Example:

url := client.BaseURL()
// Returns: "https://odata.example.com/v4"

func (*Client) Batch ¶

func (c *Client) Batch() *BatchRequest

Batch starts building a batch request.

Batch returns a new BatchRequest associated with the client, ready to add operations (Get, Create, Update, Delete) or changesets.

Example:

batch := client.Batch().
	Get("Customers", 1).
	Create("Orders", orderData)
resp, err := batch.Execute(ctx)

func (*Client) CircuitBreakerState ¶ added in v0.2.0

func (c *Client) CircuitBreakerState() relay.CircuitBreakerState

breaker: Closed (healthy), Open (failing, requests rejected), or Half-Open (probing for recovery).

Returns relay.StateClosed if the circuit breaker is not configured.

Example:

if client.CircuitBreakerState() == relay.StateOpen {
    log.Println("OData service unavailable - circuit is open")
}

func (*Client) Close ¶

func (c *Client) Close() error

Close closes the client and releases all associated resources.

Close gracefully shuts down the underlying HTTP client (relay.Client), terminating any active connections and releasing network resources. This should always be called when the client is no longer needed, preferably via defer for cleanup guarantee.

After Close is called, the client must not be reused. Attempting to make requests after Close will result in errors.

Returns an error if the shutdown process fails, though in most cases this is safe to ignore. However, it's still good practice to check and log errors:

if err := client.Close(); err != nil {
	log.Printf("error closing client: %v", err)
}

Typical usage with defer:

client, _ := traverse.New(traverse.WithBaseURL("..."))
defer client.Close()  // Ensures cleanup even if panic occurs
// Use client...

func (*Client) Create ¶

func (c *Client) Create(ctx context.Context, entitySet string, data interface{}) (map[string]interface{}, error)

Create creates a new entity in the specified entity set.

Create sends an HTTP POST request with the provided entity data to the service, creating a new record and returning the complete entity as created by the server. This includes any server-generated fields such as identity columns, default values, and computed fields.

Parameters:

• ctx: Context for request cancellation and timeout
• entitySet: Name of the entity set (e.g., "Products", "Orders")
• data: Entity data as map[string]interface{} or struct

Response: The method returns the complete created entity including server-generated fields. The response format differs by OData version:

• OData v2: Entity wrapped in {"d": {...}} response
• OData v4: Entity returned directly in response body

Error Cases:

• HTTP 400: Invalid data or constraint violations
• HTTP 409: Duplicate key or concurrency conflict
• Network errors: Connection failures

HTTP Status: 201 Created (success)

Example with Map:

newProduct := map[string]interface{}{
	"Name": "Premium Widget",
	"Price": 29.99,
	"Category": "Electronics",
}
created, err := client.Create(ctx, "Products", newProduct)
if err != nil {
	log.Fatal(err)
}
fmt.Printf("Created product with ID: %v\n", created["ID"])
fmt.Printf("Server name: %v\n", created["Name"])  // May differ if server applies defaults

Example with Struct:

type Product struct {
	Name  string  `json:"Name"`
	Price float64 `json:"Price"`
}
product := Product{Name: "Widget", Price: 9.99}
created, err := client.Create(ctx, "Products", product)

func (*Client) CrossJoin ¶ added in v0.2.23

func (c *Client) CrossJoin(entitySets ...string) *CrossJoinBuilder

CrossJoin creates a CrossJoinBuilder for the given entity sets.

At least two entity set names are required; the method panics if fewer than two are provided to surface the configuration error at init time rather than silently producing an invalid URL.

Example:

client.CrossJoin("Products", "Categories").
    Filter("Products/CategoryID eq Categories/ID")

func (*Client) Delete ¶

func (c *Client) Delete(ctx context.Context, entitySet string, key interface{}) error

Delete deletes an entity from the specified entity set.

Delete sends an HTTP DELETE request to remove the entity identified by the provided key. Once deleted, the entity can no longer be accessed through normal queries; it is permanently removed from the data store (subject to any database retention policies).

Key Encoding:

• String keys: Automatically quoted and escaped for OData URL encoding ('MAT001')
• Numeric keys: Converted to string representation (123)
• Invalid keys: Returns error during encoding

Concurrency Control:

• Returns ErrConcurrencyConflict if entity was modified elsewhere (ETag mismatch)
• The service may return HTTP 409 if concurrent modification is detected

Parameters:

• ctx: Context for request cancellation and timeout
• entitySet: Name of the entity set (e.g., "Products", "Orders")
• key: Entity key for identification (int or string)

HTTP Method: DELETE Response: HTTP 204 No Content on success (no body returned)

Error Cases:

• HTTP 404: Entity not found
• HTTP 409: Concurrency conflict (entity modified elsewhere)
• Network errors: Connection failures

Important Notes:

• Deletion is permanent; deleted data cannot be recovered
• Some services may use soft deletes (marking as deleted) instead of hard deletion
• Deleting a parent may cascade to child entities (depending on foreign key constraints)

Example - Delete by Numeric ID:

err := client.Delete(ctx, "Products", 123)
if err != nil {
	if errors.Is(err, traverse.ErrConcurrencyConflict) {
		log.Println("Product was modified by another user")
	} else {
		log.Fatal(err)
	}
}
log.Println("Product deleted successfully")

Example - Delete by String ID:

err := client.Delete(ctx, "Materials", "MAT001")
if err != nil {
	log.Fatal(err)
}

func (*Client) DeleteWithETag ¶ added in v0.2.5

func (c *Client) DeleteWithETag(ctx context.Context, entitySet string, key interface{}, etag ETag) error

DeleteWithETag deletes an entity guarded by an ETag. If etag is non-empty, an If-Match header is sent. HTTP 412 is translated to ErrConcurrencyConflict.

func (*Client) DeleteWithOptions ¶ added in v0.5.0

func (c *Client) DeleteWithOptions(ctx context.Context, entitySet string, key interface{}, opts ...DeleteOption) error

DeleteWithOptions deletes an entity, applying the provided DeleteOption values.

DeleteWithOptions extends the base Delete method with support for cascade delete, ETag conditions, and return-representation semantics.

Parameters:

• ctx: Request context for cancellation and timeout
• entitySet: Name of the entity set (e.g. "Orders")
• key: Entity key (int or string)
• opts: Zero or more DeleteOption values

Example:

err := client.DeleteWithOptions(ctx, "Orders", 1,
    traverse.WithDeleteCascade(),
    traverse.WithDeleteIfMatch(`W/"abc"`),
)

func (*Client) FetchPageAt ¶ added in v0.2.5

func (c *Client) FetchPageAt(ctx context.Context, rawURL string) (*Page, error)

FetchPageAt fetches and parses an OData page from an arbitrary URL. It is primarily used by Paginator to follow @odata.nextLink (or __next) URLs returned by the server between pages.

The rawURL must be a fully-qualified URL (absolute) or a path relative to the client base URL that the server returned.

func (*Client) From ¶

func (c *Client) From(entitySet string) *QueryBuilder

From creates a new QueryBuilder for querying the specified entity set.

From starts the construction of an OData query for the given entity set name. The returned QueryBuilder supports a fluent API for adding query parameters (filtering, selection, ordering, expansion, pagination) before execution.

The QueryBuilder provides:

• Filter(): Add OData $filter expressions
• Select(): Choose specific properties ($select)
• OrderBy(): Sort results ($orderby)
• Expand(): Include related entities ($expand)
• Top(): Limit result count ($top)
• Skip(): Skip records for pagination ($skip)
• Collect(): Execute and collect all results
• Stream(): Execute and stream results without buffering

The QueryBuilder uses method chaining for ergonomic query construction. All methods are optional-you can execute with just From() for a basic query.

Query Execution:

• Call Collect() to fetch all results at once
• Call Stream() for memory-efficient streaming of large datasets
• Call Count() to get the record count with $count
• Call Single() for a single-record query with error if 0 or >1 result

Thread Safety: Each QueryBuilder is independent and not thread-safe for concurrent modifications. Create separate QueryBuilders for concurrent queries.

Example:

qb := client.From("Products").
	Filter("Price gt 100").
	Select("ProductID", "Name", "Price").
	OrderBy("Name asc").
	Top(50)
results, _ := qb.Collect(context.Background())

Or for streaming:

stream := client.From("LargeDataSet").Stream(context.Background())
for result := range stream {
	processRecord(result.Value)
}

func (*Client) Function ¶

func (c *Client) Function(name string) *FunctionBuilder

Function starts building a call to an OData Function (v4).

Function creates a new FunctionBuilder for calling OData Functions. Functions are read-only operations that may take parameters and return data.

Returns a FunctionBuilder ready for parameter addition and execution.

Example:

result, err := client.Function("GetProductsByCategory").
	Param("category", "Electronics").
	Execute(ctx)

func (*Client) FunctionImport ¶

func (c *Client) FunctionImport(name string) *FunctionImportBuilder

FunctionImport starts building a call to an OData Function Import (v2).

FunctionImport creates a new FunctionImportBuilder for calling OData v2 Function Imports. Function Imports are similar to v4 Functions and use HTTP GET with URL-encoded parameters.

Returns a FunctionImportBuilder ready for parameter addition and execution.

Example:

result, err := client.FunctionImport("GetTop10Orders").Execute(ctx)

func (*Client) Metadata ¶

func (c *Client) Metadata(ctx context.Context) (*Metadata, error)

Metadata returns the OData $metadata service document, which contains the complete Entity Data Model (EDM) describing all entity types, properties, relationships, and operations.

Metadata fetches and caches the $metadata document, which defines:

• All entity types and their properties
• Navigation properties (relationships between entities)
• Associations and multiplicities
• Complex types and enumerations
• Function imports and action definitions
• Sap annotations and extensions for SAP systems

Caching Behavior:

The result is cached using sync.Once to ensure metadata is fetched only once per client lifetime, even with concurrent calls. Subsequent calls return the cached metadata without network requests, providing significant performance benefits for services with large metadata documents.

The cache key includes the base URL to support scenarios with multiple clients to different services. Custom cache implementations can be provided via WithMetadataCache().

Use Cases:

• Query validation: Check entity types before constructing queries
• Dynamic query building: Inspect available properties and relationships
• Type information: Determine property types for serialization/deserialization
• Navigation: Discover related entities through association mappings

Returns:

• *Metadata: Parsed EDM model describing the service schema
• error: Returns ErrMetadataInvalid if metadata cannot be parsed
• error: Returns network/HTTP errors if fetch fails

Example:

meta, err := client.Metadata(ctx)
if err != nil {
	log.Fatal(err)
}

// Find entity type definition
productType := meta.FindEntityType("Product")
for _, prop := range productType.Properties {
	fmt.Printf("Property: %s (Type: %s)\n", prop.Name, prop.Type)
}

// Use discovered metadata for dynamic query building
for _, navProp := range productType.NavigationProperties {
	fmt.Printf("Related: %s\n", navProp.Name)
}

Thread Safety: Metadata is thread-safe. Multiple goroutines can safely call Metadata() concurrently; only the first call fetches the metadata, while others wait for the result.

func (*Client) NewAsyncPoller ¶ added in v0.2.6

func (c *Client) NewAsyncPoller(statusURL string) *AsyncOpPoller

NewAsyncPoller creates an AsyncOpPoller for the given status URL. Default: 5s poll interval, 60 max polls (5 minutes total).

func (*Client) NewDeltaSync ¶

func (c *Client) NewDeltaSync(entitySet string) *DeltaSync

NewDeltaSync creates a new delta sync handler for an entity set.

NewDeltaSync initializes a DeltaSync for incremental synchronization of the specified entity set. The delta token is initially empty; call DeltaSync.Full first to obtain an initial token.

Returns a DeltaSync instance ready for use.

Example:

ds := client.NewDeltaSync("Customers")

func (*Client) PageSize ¶

func (c *Client) PageSize() int

PageSize returns the configured page size for pagination.

PageSize returns the number of records fetched per HTTP request when using $top-based pagination. This is the default page size for all queries unless overridden with QueryBuilder.Top().

Pagination Details:

• Controls the default $top parameter for OData queries
• Reduces per-request latency by controlling chunk size
• Larger values: Fewer requests but higher memory per request
• Smaller values: More requests but lower memory per request
• Typical value: 1000-5000 records (default: 1000)

This is configured via WithPageSize() when creating the client.

Returns:

• The page size in records (default: 1000)

Example:

pageSize := client.PageSize()
// Default returns 1000
// Can be overridden per query with QueryBuilder.Top()

func (*Client) ReadWithETag ¶ added in v0.2.5

func (c *Client) ReadWithETag(ctx context.Context, entitySet string, key interface{}) (*EntityWithETag, error)

ReadWithETag fetches a single entity by key and returns it together with the server ETag. The ETag can be passed to Client.UpdateWithETag, Client.ReplaceWithETag, or Client.DeleteWithETag to guard against concurrent modifications.

The ETag is extracted from the response ETag header. If the server does not return an ETag header, EntityWithETag.ETag.IsEmpty() returns true - the entity is still returned normally.

entity, err := client.ReadWithETag(ctx, "Products", 42)
if err != nil { ... }
// modify entity.Entity ...
err = client.UpdateWithETag(ctx, "Products", 42, changes, entity.ETag)

func (*Client) RelayClient ¶ added in v0.2.20

func (c *Client) RelayClient() *relay.Client

RelayClient returns the underlying relay.Client used for HTTP transport.

This provides access to relay's full request API for advanced use cases such as extension modules that need to issue raw HTTP calls (e.g. OData webhook subscription management) while reusing the same configured transport, auth, retry and circuit-breaker settings as the parent traverse.Client.

The returned client must not be closed independently - use Client.Close to shut down both the traverse and relay clients together.

func (*Client) Replace ¶

func (c *Client) Replace(ctx context.Context, entitySet string, key interface{}, data interface{}) error

Replace replaces an entire entity with new data using HTTP PUT.

Replace sends an HTTP PUT request with the complete new entity state to replace the existing entity. Unlike Update() which performs a partial merge (PATCH), Replace completely replaces all properties of the entity. Properties not explicitly provided in the data parameter are typically set to their default values or NULL, which can result in data loss if not all properties are included.

Use Cases:

• Complete entity replacement: When you have the full new state
• Wholesale updates: Replacing entire records from batch operations
• Consistency: Ensuring a known complete state after update

Compare with Update():

• Update (PATCH): Partial update, only changed fields
• Replace (PUT): Complete replacement, unspecified fields set to defaults

Parameters:

• ctx: Context for request cancellation and timeout
• entitySet: Name of the entity set (e.g., "Products")
• key: Entity key for identification (ID or primary key)
• data: Complete new entity state (all properties that should exist)

HTTP Method: PUT (HTTP 201-204 on success)

Response: Returns nil on success with HTTP 204 No Content. Returns ErrConcurrencyConflict if an ETag mismatch occurs (HTTP 409).

Warning: Replace can result in data loss if the data parameter doesn't include all required fields. Prefer Update() for partial updates unless you specifically need complete replacement.

Example - Complete Replacement:

newProduct := map[string]interface{}{
	"ID": 123,  // Must include key
	"Name": "Completely New Name",
	"Price": 49.99,
	"Stock": 50,
	"Active": true,
}
err := client.Replace(ctx, "Products", 123, newProduct)
if err != nil {
	log.Fatal(err)
}
log.Println("Product completely replaced")

func (*Client) ReplaceWithETag ¶ added in v0.2.5

func (c *Client) ReplaceWithETag(ctx context.Context, entitySet string, key interface{}, data interface{}, etag ETag) error

ReplaceWithETag performs a full replacement (PUT) guarded by an ETag. If etag is non-empty, an If-Match header is sent to guard against concurrent modifications (HTTP 412 -> ErrConcurrencyConflict).

func (*Client) ResetCircuitBreaker ¶ added in v0.2.0

func (c *Client) ResetCircuitBreaker()

ResetCircuitBreaker resets the circuit breaker to the Closed state, allowing requests to flow again immediately. This is useful after a manual intervention or during testing.

No-op if the circuit breaker is not configured.

func (*Client) Service ¶

func (c *Client) Service(ctx context.Context) (*ServiceDocument, error)

Service fetches the OData service document, which lists all available entity sets and operations.

Service makes an HTTP GET request to the service root URL (typically /odata/v4 or /sap/opu/odata/...) and returns a ServiceDocument containing all entity sets exposed by the service.

The Service Document:

• Lists all available entity sets that can be queried
• Includes singleton entities and function imports
• Is version-aware: Parsed differently for OData v2 vs v4
• Is useful for dynamic service discovery without prior knowledge of entity set names

Response Format:

• OData v2: {"d": {"EntitySets": [{...}, ...]}} with "d" wrapper for CSRF protection
• OData v4: {"value": [{...}, ...]} at the root

Use Case:

This is typically called once during service initialization to discover available entity sets, or when the service schema is not known in advance. For known schemas, use From() directly.

Returns:

• *ServiceDocument: Contains all entity sets available in the service
• error: Network error, HTTP error, or parsing error

Example:

doc, err := client.Service(ctx)
if err != nil {
	log.Fatal(err)
}
for _, es := range doc.EntitySets {
	fmt.Printf("Entity Set: %s (URL: %s)\n", es.Name, es.URL)
}

// Now you can query known entity sets
results, _ := client.From(doc.EntitySets[0].Name).Collect(ctx)

func (*Client) Singleton ¶ added in v0.6.0

func (c *Client) Singleton(name string) *QueryBuilder

Singleton returns a QueryBuilder targeting a named singleton resource at the service root.

A singleton is a single-entity resource addressable directly by name, without a key predicate. It is defined in OData v4.0 spec section 11.2.4.

Microsoft Graph uses singletons extensively (e.g., "/me", "/organization"). SAP uses them for session-level resources.

The returned QueryBuilder supports the full query API including $select, $expand, $filter, and navigation to related collections via [From].

Example:

// Fetch the "me" singleton
me, err := client.Singleton("me").Page(ctx)

// Expand a navigation property from a singleton
result, err := client.Singleton("me").Expand("manager").Page(ctx)

// Navigate to a related collection on a singleton
for r := range client.Singleton("me").From("messages").Stream(ctx) {
    // process r.Value
}

func (*Client) Update ¶

func (c *Client) Update(ctx context.Context, entitySet string, key interface{}, data interface{}) error

Update updates an existing entity using a partial update (PATCH/MERGE operation).

Update sends an HTTP PATCH request (or HTTP MERGE for OData v2 compatibility) with the entity data. This performs a partial update where only provided properties are modified; omitted properties remain unchanged.

This is the standard way to update entities-use Replace() for complete entity replacement instead.

Parameters:

• ctx: Context for request cancellation and timeout
• entitySet: Name of the entity set (e.g., "Products", "Orders")
• key: Entity key for identification (typically an ID or primary key)
• data: Properties to update as map[string]interface{} or struct (only these fields change)

Key Formats:

• Single key: numeric ID (123) or string ID ('MAT001')
• Composite key: Not directly supported; use URL encoding if needed

HTTP Method:

• PATCH (standard) for OData v4
• MERGE (legacy) for OData v2

Response: Returns nil on success with HTTP 200 OK (with updated entity) or HTTP 204 No Content (standard). The method doesn't parse the response body for 204 responses.

Concurrency Control: Returns ErrConcurrencyConflict if:

• ETag mismatch (entity was modified elsewhere)
• HTTP 409 Conflict response

Example - Partial Update:

err := client.Update(ctx, "Products", 123, map[string]interface{}{
	"Price": 19.99,
	"LastModified": time.Now(),
})
if err != nil {
	if err == traverse.ErrConcurrencyConflict {
		log.Println("Entity was modified by another user")
	} else {
		log.Fatal(err)
	}
}
log.Println("Product updated successfully")

Example - Update Multiple Fields:

updates := map[string]interface{}{
	"Status": "Active",
	"Priority": 1,
	"Description": "Updated description",
}
err := client.Update(ctx, "Tasks", "TASK-001", updates)

func (*Client) UpdateWithETag ¶ added in v0.2.5

func (c *Client) UpdateWithETag(ctx context.Context, entitySet string, key interface{}, data interface{}, etag ETag) error

UpdateWithETag performs a partial update (PATCH/MERGE) guarded by an ETag. If etag is non-empty, an If-Match header is sent. The server will reject the update with HTTP 412 Precondition Failed if the entity was modified since the ETag was fetched; this is translated to ErrConcurrencyConflict.

Pass a zero ETag (or ETag{}) to skip the concurrency check.

entity, err := client.ReadWithETag(ctx, "Products", 42)
// ...
err = client.UpdateWithETag(ctx, "Products", 42, map[string]any{"Price": 9.99}, entity.ETag)

func (*Client) Upsert ¶ added in v0.2.5

func (c *Client) Upsert(ctx context.Context, entitySet string, key interface{}, data interface{}) error

Upsert creates a new entity or replaces an existing one using OData upsert semantics (PUT with If-None-Match: * header for create-or-replace).

Upsert behaviour depends on whether the entity already exists:

• If the entity does NOT exist: the server creates it (HTTP 201 Created).
• If the entity already exists: the server replaces it (HTTP 200/204).

This uses the OData upsert pattern (If-None-Match: *) as described in OData 4.01 section 11.4.4. Not all servers support this pattern; SAP OData services typically do via the PUT endpoint.

err := client.Upsert(ctx, "Products", 42, map[string]any{
    "ID":    42,
    "Name":  "Widget",
    "Price": 9.99,
})

func (*Client) Version ¶

func (c *Client) Version() ODataVersion

Version returns the OData protocol version (v2 or v4) configured for this Client.

Version returns the OData protocol version that the client is using for requests and response parsing. This is configured via WithODataVersion() when creating the client.

OData Version Differences:

• ODataV2: Legacy SAP standard, uses {"d": {"results": [...]}} response structure
• ODataV4: Current OASIS standard, uses {"value": [...]} response structure

The version affects:

• JSON response parsing (d.results vs value array)
• DateTime format handling
• Query operator availability
• Metadata structure interpretation

Returns:

• ODataV2 (value 2) or ODataV4 (value 4)

Example:

version := client.Version()
if version == traverse.ODataV4 {
	// Use OData v4-specific features
}

func (*CrossJoinBuilder) Collect ¶ added in v0.2.23

func (b *CrossJoinBuilder) Collect(ctx context.Context) ([]CrossJoinResult, error)

Collect executes the $crossjoin query and returns all result rows.

Collect follows @odata.nextLink pagination automatically, accumulating all pages before returning. For very large result sets, prefer iterating over pages manually with repeated Collect calls using CrossJoinBuilder.Param.

Example:

rows, err := client.CrossJoin("Products", "Categories").
    Filter("Products/CategoryID eq Categories/ID").
    Collect(ctx)
if err != nil {
    return err
}
for _, row := range rows {
    var p Product
    var c Category
    _ = row.Decode("Products", &p)
    _ = row.Decode("Categories", &c)
}

func (*CrossJoinBuilder) Expand ¶ added in v0.2.23

func (b *CrossJoinBuilder) Expand(navProps ...string) *CrossJoinBuilder

Expand requests inline expansion of navigation properties.

Each value must use the qualified form "EntitySetName/NavigationProperty".

Example:

.Expand("Products/Supplier")

func (*CrossJoinBuilder) Filter ¶ added in v0.2.23

func (b *CrossJoinBuilder) Filter(expr string) *CrossJoinBuilder

Filter adds an OData $filter expression to narrow the cross-join result.

The filter can reference properties from any of the joined entity sets using the qualified form "EntitySetName/PropertyName".

Example:

.Filter("Products/CategoryID eq Categories/ID and Products/Price gt 100.0")

func (*CrossJoinBuilder) Param ¶ added in v0.2.23

func (b *CrossJoinBuilder) Param(key, value string) *CrossJoinBuilder

Param adds a custom query parameter.

Use this for service-specific OData parameters not covered by the builder (e.g., SAP sap-client or service-defined preference hints).

func (*CrossJoinBuilder) Select ¶ added in v0.2.23

func (b *CrossJoinBuilder) Select(fields ...string) *CrossJoinBuilder

Select limits the properties returned for each entity set in the result.

Each selector must use the qualified form "EntitySetName/PropertyName".

Example:

.Select("Products/Name", "Products/Price", "Categories/Name")

func (CrossJoinResult) Decode ¶ added in v0.2.23

func (r CrossJoinResult) Decode(entitySet string, dest any) error

Decode unmarshals the entity from the specified entity set into dest.

Example:

var product Product
err := row.Decode("Products", &product)

func (DateTime) MarshalJSON ¶

func (d DateTime) MarshalJSON() ([]byte, error)

MarshalJSON encodes DateTime to OData v2 format: /Date(milliseconds)/.

MarshalJSON converts the internal time.Time to milliseconds since epoch and formats it as /Date(milliseconds)/.

func (DateTime) String ¶

func (d DateTime) String() string

String returns the time.Time string representation.

String converts DateTime to time.Time and returns its standard string format.

func (DateTime) Time ¶

func (d DateTime) Time() time.Time

Time converts DateTime to time.Time.

Time returns the underlying time.Time value for use with standard Go time operations.

func (*DateTime) UnmarshalJSON ¶

func (d *DateTime) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes OData DateTime format: /Date(milliseconds)/ or /Date(milliseconds±offset)/.

UnmarshalJSON parses the OData v2 DateTime format and extracts milliseconds since epoch. The timezone offset (if present) is ignored; the result is always in UTC.

Returns an error if the format is invalid or milliseconds cannot be parsed.

func (DateTimeOffset) MarshalJSON ¶

func (d DateTimeOffset) MarshalJSON() ([]byte, error)

MarshalJSON encodes to ISO 8601 (RFC 3339).

MarshalJSON converts DateTimeOffset to RFC 3339 format for JSON output.

func (DateTimeOffset) Time ¶

func (d DateTimeOffset) Time() time.Time

Time converts DateTimeOffset to time.Time.

Time returns the underlying time.Time value for use with standard Go time operations.

func (*DateTimeOffset) UnmarshalJSON ¶

func (d *DateTimeOffset) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes ISO 8601 format (RFC 3339).

UnmarshalJSON parses ISO 8601 formatted datetime strings. Supports both full timestamps with timezone (RFC 3339) and timestamps without timezone (treated as UTC).

Returns an error if the format cannot be parsed.

func (Decimal) MarshalJSON ¶

func (d Decimal) MarshalJSON() ([]byte, error)

MarshalJSON encodes decimal to JSON string (preserves precision).

MarshalJSON returns the decimal as a JSON string to preserve arbitrary precision during round-tripping. Nil values are encoded as null.

func (Decimal) String ¶

func (d Decimal) String() string

String returns the decimal string representation.

String returns the full precision string representation of the decimal. Returns "0" for nil values.

func (*Decimal) UnmarshalJSON ¶

func (d *Decimal) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes decimal values from JSON (string or numeric).

UnmarshalJSON accepts both string and numeric representations of decimal values. Strings are preferred for preserving arbitrary precision. Numeric literals are converted to string first for parsing.

Returns an error if the value cannot be parsed as a valid decimal number.

func (DeepInsertOptions) PreferHeader ¶ added in v0.2.8

func (o DeepInsertOptions) PreferHeader() string

PreferHeader generates the Prefer header value from the options. Returns an empty string if no options are set.

func (DeepUpdateOptions) PreferHeader ¶ added in v0.7.0

func (o DeepUpdateOptions) PreferHeader() string

PreferHeader generates the Prefer header value from the options. Returns an empty string if no options are set.

func (*DeltaSync) Full ¶

func (d *DeltaSync) Full(ctx context.Context, bufferSize ...int) (<-chan Result[map[string]interface{}], string, error)

Full performs a complete (initial) synchronization, returning all records.

Full returns a channel streaming all records from the entity set and automatically extracts the delta token from the server response metadata (DeltaLink). This token can be used for subsequent incremental syncs via DeltaSync.Incremental.

The method also stores the token internally for convenience, so you can call DeltaSync.Incremental without providing the token explicitly.

The bufferSize parameter controls the result channel capacity (default 256). For large record sizes or high network latency, increase this value to reduce blocking.

Returns:

• A receive-only channel of Result items containing all records
• The delta token for use in subsequent incremental syncs
• An error if the query fails

Example:

records, token, err := ds.Full(ctx)
if err != nil {
	log.Fatal(err)
}
for result := range records {
	if result.Err != nil {
		log.Println("Error:", result.Err)
		continue
	}
	processRecord(result.Value)
}
// Save token for next sync: ds.Incremental(ctx, token)

func (*DeltaSync) Incremental ¶

func (d *DeltaSync) Incremental(ctx context.Context, token string, bufferSize ...int) (<-chan DeltaResult, string, error)

Incremental performs an incremental sync using a delta token.

Incremental returns only records that have changed or been deleted since the provided delta token was issued. Changes include both new records and modifications to existing records. Deleted records are marked with Removed=true and include a Reason (typically "changed" or "deleted").

The token parameter specifies which delta point to start from. If empty, the internally stored token (from previous DeltaSync.Full or DeltaSync.Incremental) is used. Returns an error if no token is available.

A new delta token is extracted from the response and can be used for the next incremental sync. It's automatically stored internally as well.

The bufferSize parameter controls the result channel capacity (default 256).

Returns:

• A receive-only channel of DeltaResult items containing changed records
• The new delta token for use in subsequent incremental syncs
• An error if the query fails or no token is available

Example:

// First, get initial token from Full sync
_, token, _ := ds.Full(ctx)

// Later, sync only changes
for result := range ds.Incremental(ctx, token) {
	if result.Removed {
		deleteRecord(result.Value)
	} else {
		updateRecord(result.Value)
	}
}

func (*DeltaSync) SetToken ¶

func (d *DeltaSync) SetToken(token string)

SetToken sets the current delta token.

func (*DeltaSync) Token ¶

func (d *DeltaSync) Token() string

Token returns the current delta token.

func (*DeltaSyncAs[T]) Full ¶

func (d *DeltaSyncAs[T]) Full(ctx context.Context, bufferSize ...int) (<-chan Result[T], string, error)

Full is an alias for the JSON-format Full method. Deprecated: Use DeltaSyncJsonAs.Full or DeltaSyncXmlAs.Full instead.

func (*DeltaSyncAs[T]) Incremental ¶

func (d *DeltaSyncAs[T]) Incremental(ctx context.Context, token string, bufferSize ...int) (<-chan DeltaResultAs[T], string, error)

Incremental is an alias for the JSON-format Incremental method. Deprecated: Use DeltaSyncJsonAs.Incremental or DeltaSyncXmlAs.Incremental instead.

func (*DeltaSyncJsonAs[T]) Full ¶ added in v0.16.0

func (d *DeltaSyncJsonAs[T]) Full(ctx context.Context, bufferSize ...int) (<-chan Result[T], string, error)

Full performs a complete sync with type T using JSON format.

func (*DeltaSyncJsonAs[T]) Incremental ¶ added in v0.16.0

func (d *DeltaSyncJsonAs[T]) Incremental(ctx context.Context, token string, bufferSize ...int) (<-chan DeltaResultAs[T], string, error)

Incremental performs an incremental sync with type T using JSON format.

func (*DeltaSyncXmlAs[T]) Full ¶ added in v0.16.0

func (d *DeltaSyncXmlAs[T]) Full(ctx context.Context, bufferSize ...int) (<-chan Result[T], string, error)

Full performs a complete sync with type T using XML format.

func (*DeltaSyncXmlAs[T]) Incremental ¶ added in v0.16.0

func (d *DeltaSyncXmlAs[T]) Incremental(ctx context.Context, token string, bufferSize ...int) (<-chan DeltaResultAs[T], string, error)

Incremental performs an incremental sync with type T using XML format.

func (ETag) IsEmpty ¶ added in v0.2.5

func (e ETag) IsEmpty() bool

IsEmpty reports whether the ETag is unset.

func (ETag) IsWeak ¶ added in v0.2.5

func (e ETag) IsWeak() bool

IsWeak reports whether this is a weak ETag (prefixed with W/).

func (ETag) String ¶ added in v0.2.5

func (e ETag) String() string

String returns the raw ETag value.

func (*ExpandBuilder) Done ¶ added in v0.2.6

func (b *ExpandBuilder) Done() *QueryBuilder

Done finalizes the nested expand and returns the parent QueryBuilder.

func (*ExpandBuilder) Expand ¶ added in v0.2.6

func (b *ExpandBuilder) Expand(property string) *ExpandBuilder

Expand adds a further nested expand within this navigation property.

func (*ExpandBuilder) Filter ¶ added in v0.2.6

func (b *ExpandBuilder) Filter(expr string) *ExpandBuilder

Filter applies a filter expression to the expanded entities.

func (*ExpandBuilder) OrderBy ¶ added in v0.2.6

func (b *ExpandBuilder) OrderBy(expr string) *ExpandBuilder

OrderBy sets the sort order for expanded entities.

func (*ExpandBuilder) Select ¶ added in v0.2.6

func (b *ExpandBuilder) Select(fields ...string) *ExpandBuilder

Select limits the properties returned for the expanded entity.

func (*ExpandBuilder) Top ¶ added in v0.2.6

func (b *ExpandBuilder) Top(n int) *ExpandBuilder

Top limits the number of expanded entities returned.

func (*FilterBuilder) Contains ¶

func (f *FilterBuilder) Contains(substr string) *QueryBuilder

Contains creates a substring filter using the OData substringof function.

Contains filters for records where the field value contains the specified substring anywhere within the value (case-sensitive per OData spec).

Behavior: Matches partial strings at any position:

• "John Smith" contains "Smith" ✓
• "Smith, John" contains "Smith" ✓
• "smith" contains "Smith" ✗ (case-sensitive)

OData Implementation: Contains uses the substringof() function (OData standard):

OData: substringof('substring', FieldName)

Performance Note: Substring searches typically require full table scans without indexes. For large datasets, ensure database indexes exist or use more specific filters.

Chaining: Contains returns *QueryBuilder to combine with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Basic substring match:

query.Where("Name").Contains("John")
// OData: $filter=substringof('John', Name)
// Matches: "John", "John Smith", "Johnny", "Johanna", "Adjourn"

Email domain search:

query.Where("Email").Contains("@example.com")
// OData: $filter=substringof('@example.com', Email)
// Matches: "user@example.com", "admin@example.com"

Combined with other filters:

query.Where("Company").Contains("Inc").
	  Where("Status").Eq("Active")
// OData: $filter=substringof('Inc', Company) and Status eq 'Active'
// Active companies with "Inc" in name

Search functionality:

query.Where("Description").Contains("urgent").
	  Where("Priority").Gt(2)
// OData: $filter=substringof('urgent', Description) and Priority gt 2
// High-priority items with "urgent" in description

func (*FilterBuilder) EndsWith ¶

func (f *FilterBuilder) EndsWith(suffix string) *QueryBuilder

EndsWith creates a suffix match filter using the OData endswith function.

EndsWith filters for records where the field value ends with the specified suffix string (case-sensitive per OData spec).

Behavior: Matches only at the end of the field value:

• "john.smith@example.com" endswith "@example.com" ✓
• "example.com" endswith "example.com" ✓
• "john.smith@example.com" endswith "@example.COM" ✗ (case-sensitive)

Efficiency: EndsWith may require full table scans unless database provides suffix indexes. More expensive than StartsWith for large datasets.

Use Cases:

• Email domains: EndsWith("@example.com")
• File extensions: EndsWith(".pdf"), EndsWith(".jpg")
• Phone number suffixes: EndsWith("-1234")
• URL patterns: EndsWith(".com"), EndsWith(".org")
• TLDs: EndsWith(".co.uk")

OData Implementation: EndsWith generates: endswith(FieldName, 'suffix')

Chaining: EndsWith returns *QueryBuilder to combine with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Email domain filter:

query.Where("Email").EndsWith("@company.com")
// OData: $filter=endswith(Email, '@company.com')
// Matches: "user@company.com", "admin@company.com"

File type filtering:

query.Where("Filename").EndsWith(".pdf")
// OData: $filter=endswith(Filename, '.pdf')
// Matches: "document.pdf", "report_2024.pdf"

Phone number area code:

query.Where("Phone").EndsWith("-2000")
// OData: $filter=endswith(Phone, '-2000')
// Matches: "555-1234-2000", "555-2000"

Combined with other filters:

query.Where("Email").EndsWith("@partner.com").
	  Where("Status").Eq("Active")
// OData: $filter=endswith(Email, '@partner.com') and Status eq 'Active'
// Active partner email addresses

func (*FilterBuilder) Eq ¶

func (f *FilterBuilder) Eq(value interface{}) *QueryBuilder

Eq creates an equality filter: field eq value.

Eq filters for records where the field exactly equals the specified value. This is the most common filter operation.

Type Handling: The value parameter is automatically converted to OData literal format:

• Strings: Quoted and escaped ('value' format)
• Numbers: Decimal notation (42, -3.14, etc.)
• Booleans: "true" or "false"
• DateTime: OData timestamp format
• null/nil: Converts to "null" for null checks

Chaining: Eq returns *QueryBuilder to chain with other filters or query methods:

query.Where("Status").Eq("Active").Where("Age").Gt(30)

Returns:

• *QueryBuilder: For method chaining

Examples:

Simple equality:

query.Where("Status").Eq("Active")
// OData: $filter=Status eq 'Active'

Numeric equality:

query.Where("ID").Eq(42)
// OData: $filter=ID eq 42

Boolean:

query.Where("IsDeleted").Eq(false)
// OData: $filter=IsDeleted eq false

Null check:

query.Where("DeletedAt").Eq(nil)
// OData: $filter=DeletedAt eq null

Chained with other filters:

query.Where("Status").Eq("Active").
	  Where("Priority").Gt(1).
	  Where("DueDate").Gt(today)

func (*FilterBuilder) Ge ¶

func (f *FilterBuilder) Ge(value interface{}) *QueryBuilder

Ge creates a greater-than-or-equal filter: field ge value.

Ge filters for records where the field value is greater than or equal to the specified value. Includes the boundary value unlike Gt.

Typical Uses:

• Minimum thresholds: Where("Score").Ge(80) for passing grades
• Date ranges: Where("CreatedDate").Ge(startDate)
• Cutoff values: Where("Priority").Ge(3)
• Age verification: Where("Age").Ge(18)

Boundary Behavior: Unlike Gt, Ge INCLUDES records that exactly equal the specified value. Ge(100) returns 100, 101, 102, ... while Gt(100) returns 101, 102, ...

Chaining: Ge returns *QueryBuilder for combining with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Minimum score threshold:

query.Where("Score").Ge(80)
// OData: $filter=Score ge 80
// Includes score=80 and above

Date range (start inclusive):

query.Where("CreatedDate").Ge(startDate)
// Returns records from startDate onward (inclusive)

Combined with less-than for range:

query.Where("Price").Ge(50).Where("Price").Le(200)
// OData: $filter=Price ge 50 and Price le 200
// Returns $50-$200 range (both boundaries included)

Inventory threshold:

query.Where("StockLevel").Ge(10)
// OData: $filter=StockLevel ge 10
// Returns items with 10 or more in stock

func (*FilterBuilder) Gt ¶

func (f *FilterBuilder) Gt(value interface{}) *QueryBuilder

Gt creates a greater-than filter: field gt value.

Gt filters for records where the field value is strictly greater than the specified value. Useful for numeric ranges, dates, and ordered comparisons.

Typical Uses:

• Price ranges: Where("Price").Gt(100)
• Date filtering: Where("CreatedDate").Gt(startDate)
• Numeric thresholds: Where("Age").Gt(18)
• Ordered sequences: Where("Sequence").Gt(currentSeq)

Type Support: Works with any OData type supporting numeric comparison:

• Integers: 42
• Decimals: 99.99
• Dates: time.Time (converted to OData timestamp)
• Enums: Numeric enum values
• Durations: In milliseconds or appropriate units

Chaining: Gt returns *QueryBuilder to combine with other filters and query methods.

Returns:

• *QueryBuilder: For method chaining

Examples:

Simple numeric threshold:

query.Where("Age").Gt(30)
// OData: $filter=Age gt 30
// Returns people over 30 years old

Date filtering:

query.Where("OrderDate").Gt(startOfMonth)
// OData: $filter=OrderDate gt <timestamp>
// Returns orders from start of month onward

Price range (combined with Lt):

query.Where("Price").Gt(10).Where("Price").Lt(100)
// OData: $filter=Price gt 10 and Price lt 100
// Returns products between $10 and $100

Complex filtering:

query.Where("Salary").Gt(50000).
	  Where("Department").Eq("Sales").
	  Where("HireDate").Gt(minDate)

func (*FilterBuilder) In ¶

func (f *FilterBuilder) In(values ...interface{}) *QueryBuilder

In creates a membership test filter for checking if a field value is in a set.

In generates an OData v4 "in" expression: field in (val1, val2, val3, ...) This is efficient for testing whether a value belongs to a known set.

OData Version: In is only available in OData v4. OData v2 requires using multiple Eq conditions joined with "or": (field eq val1) or (field eq val2) or (field eq val3)

Behavior: Returns all records where the field equals ANY of the provided values. Equivalent to: OR-ing multiple Eq conditions.

Empty Values: If In is called with no values, it returns the query unchanged (no filter added). This allows optional filtering: if len(categories) > 0 { q = q.Where("Cat").In(categories...) }

Performance: Much more efficient than multiple Where().Eq() calls:

• Single clause: Where("Status").In("Active", "Pending", "Review")
• vs multiple: Where("Status").Eq("Active").Where("Status").Eq("Pending")...
• Network: 1 query parameter vs 3
• Processing: Server can use IN index optimization

Type Handling: All value types are automatically converted to OData literals:

• Strings: Single-quoted ('value')
• Numbers: Decimal notation
• Booleans: true/false
• Dates: OData timestamp format

Chaining: In returns *QueryBuilder to combine with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Status filter (common use):

query.Where("Status").In("Active", "Pending", "Review")
// OData: $filter=Status in ('Active', 'Pending', 'Review')
// Matches any of three statuses

Category selection:

query.Where("CategoryID").In(1, 2, 3, 5)
// OData: $filter=CategoryID in (1, 2, 3, 5)
// Products in categories 1, 2, 3, or 5

Priority levels:

priorities := []int{1, 2, 3}  // High, Medium, Low
query.Where("Priority").In(append(priorities, 0)...)
// All high/medium/low plus unassigned

Optional filtering:

var allowedStatuses []string
q := client.From("Orders")
if len(allowedStatuses) > 0 {
	q = q.Where("Status").In(allowedStatuses...)
}
results, _ := q.Collect(ctx)

Combined with other filters:

query.Where("Region").In("North", "South", "West").
	  Where("SalesAmount").Gt(10000).
	  OrderByDesc("SalesAmount").
	  Top(100)
// High-value sales in three regions, sorted

func (*FilterBuilder) Le ¶

func (f *FilterBuilder) Le(value interface{}) *QueryBuilder

Le creates a less-than-or-equal filter: field le value.

Le filters for records where the field value is less than or equal to the specified value. Includes the boundary value unlike Lt.

Typical Uses:

• Maximum thresholds: Where("Duration").Le(60) for minute-long clips
• On-or-before dates: Where("EndDate").Le(quarterEnd)
• Upper limits: Where("PageSize").Le(1000)
• Age/date cutoffs: Where("Age").Le(65)

Boundary Behavior: Unlike Lt, Le INCLUDES records that exactly equal the specified value. Le(100) returns 100, 99, 98, ... while Lt(100) returns 99, 98, ...

Common Pattern: Combine with Ge for inclusive ranges: Where("Age").Ge(18).Where("Age").Le(65)

Chaining: Le returns *QueryBuilder for combining with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Maximum duration (inclusive):

query.Where("DurationSeconds").Le(300)
// OData: $filter=DurationSeconds le 300
// Videos 300 seconds or shorter

On-or-before date:

query.Where("EndDate").Le(today)
// Includes today and all past dates

Inclusive range:

query.Where("Price").Ge(50).Where("Price").Le(200)
// OData: $filter=Price ge 50 and Price le 200
// Exactly $50-$200 including boundaries

Age demographic:

query.Where("Age").Ge(13).Where("Age").Le(19)
// OData: $filter=Age ge 13 and Age le 19
// Ages 13 through 19 inclusive (teenagers)

func (*FilterBuilder) Lt ¶

func (f *FilterBuilder) Lt(value interface{}) *QueryBuilder

Lt creates a less-than filter: field lt value.

Lt filters for records where the field value is strictly less than the specified value. Useful for upper bounds and before/prior comparisons.

Typical Uses:

• Upper price limits: Where("Price").Lt(100)
• Before dates: Where("DeadlineDate").Lt(today)
• Below thresholds: Where("DaysOverdue").Lt(7)
• Version checks: Where("BuildNumber").Lt(2000)

Boundary Behavior: Lt does NOT include the specified value. Lt(100) matches 99, 98, 97... Use Le() to include the boundary.

Chaining: Lt returns *QueryBuilder for combining with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Upper price limit (exclusive):

query.Where("Price").Lt(100)
// OData: $filter=Price lt 100
// Returns prices < $100 (99.99, 50, etc., but not 100)

Past events:

query.Where("EventDate").Lt(today)
// Returns events before today (yesterday and earlier)

Range query (both exclusive):

query.Where("Age").Gt(18).Where("Age").Lt(65)
// OData: $filter=Age gt 18 and Age lt 65
// Returns ages 19-64

Early warning system:

query.Where("DaysUntilExpiry").Lt(30)
// OData: $filter=DaysUntilExpiry lt 30
// Items expiring within 30 days

func (*FilterBuilder) Ne ¶

func (f *FilterBuilder) Ne(value interface{}) *QueryBuilder

Ne creates a not-equal filter: field ne value.

Ne filters for records where the field does NOT equal the specified value. Useful for excluding specific values or statuses.

Use Cases:

• Exclude deleted records: Where("Status").Ne("Deleted")
• Exclude null values: Where("Email").Ne(nil)
• Exclude specific user: Where("UserID").Ne(adminID)

Type Handling: Same automatic conversion as Eq() for all value types.

Chaining: Ne returns *QueryBuilder to chain with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Exclude status:

query.Where("Status").Ne("Deleted")
// OData: $filter=Status ne 'Deleted'

Exclude null:

query.Where("Email").Ne(nil)
// OData: $filter=Email ne null

Exclude numeric value:

query.Where("Quantity").Ne(0)
// OData: $filter=Quantity ne 0

Combined filtering (active non-deleted):

query.Where("Status").Eq("Active").
	  Where("Deleted").Ne(true)
// OData: $filter=Status eq 'Active' and Deleted ne true

func (*FilterBuilder) StartsWith ¶

func (f *FilterBuilder) StartsWith(prefix string) *QueryBuilder

StartsWith creates a prefix match filter using the OData startswith function.

StartsWith filters for records where the field value begins with the specified prefix string (case-sensitive per OData spec).

Behavior: Matches only at the beginning of the field value:

• "Product A" startswith "Product" ✓
• "Product A" startswith "product" ✗ (case-sensitive)
• "A Product" startswith "Product" ✗ (not at start)

Efficiency: StartsWith is more efficient than Contains for prefix matching and can use database indexes on string columns (B-tree prefix matching).

Use Cases:

• Category codes: StartsWith("A-") for category A codes
• Postal codes: StartsWith("90210") for specific zip code area
• Enum prefixes: StartsWith("STATUS_") for status fields
• Name filtering: StartsWith("John") for first names
• Auto-complete: StartsWith(userInput) for search suggestions

OData Implementation: StartsWith generates: startswith(FieldName, 'prefix')

Chaining: StartsWith returns *QueryBuilder to combine with other filters.

Returns:

• *QueryBuilder: For method chaining

Examples:

Product code filtering:

query.Where("ProductCode").StartsWith("ELEC-")
// OData: $filter=startswith(ProductCode, 'ELEC-')
// Matches: "ELEC-001", "ELEC-TV-50"

Name search (auto-complete):

query.Where("LastName").StartsWith("Smith")
// OData: $filter=startswith(LastName, 'Smith')
// Matches: "Smith", "Smithson", "Smithers" (but not "Smithy" capitalization)

Regional filtering:

query.Where("ZipCode").StartsWith("90210")
// OData: $filter=startswith(ZipCode, '90210')
// Matches: "90210", "90210-1234" (plus 4 format)

Combined with other filters:

query.Where("Email").StartsWith("admin").
	  Where("Department").Eq("IT")
// OData: $filter=startswith(Email, 'admin') and Department eq 'IT'
// IT admin email addresses

func (*FilterExpr) Build ¶ added in v0.2.14

func (f *FilterExpr) Build() string

Build returns the OData filter string.

Build finalizes the filter expression and returns the OData $filter string. This method does not modify the FilterExpr and can be called multiple times.

func (*FilterExpr) Contains ¶ added in v0.2.14

func (f *FilterExpr) Contains(value string) *FilterExpr

Contains creates a string contains filter: contains(field, value).

Contains checks if the field (string) contains the specified substring.

func (*FilterExpr) EndsWith ¶ added in v0.2.14

func (f *FilterExpr) EndsWith(value string) *FilterExpr

EndsWith creates a string ends-with filter: endswith(field, value).

EndsWith checks if the field (string) ends with the specified suffix.

func (*FilterExpr) Eq ¶ added in v0.2.14

func (f *FilterExpr) Eq(value interface{}) *FilterExpr

Eq creates an equality filter: field eq value.

func (*FilterExpr) Ge ¶ added in v0.2.14

func (f *FilterExpr) Ge(value interface{}) *FilterExpr

Ge creates a greater-than-or-equal filter: field ge value.

func (*FilterExpr) Gt ¶ added in v0.2.14

func (f *FilterExpr) Gt(value interface{}) *FilterExpr

Gt creates a greater-than filter: field gt value.

func (*FilterExpr) Le ¶ added in v0.2.14

func (f *FilterExpr) Le(value interface{}) *FilterExpr

Le creates a less-than-or-equal filter: field le value.

func (*FilterExpr) Lt ¶ added in v0.2.14

func (f *FilterExpr) Lt(value interface{}) *FilterExpr

Lt creates a less-than filter: field lt value.

func (*FilterExpr) Ne ¶ added in v0.2.14

func (f *FilterExpr) Ne(value interface{}) *FilterExpr

Ne creates an inequality filter: field ne value.

func (*FilterExpr) Reset ¶ added in v0.22.0

func (f *FilterExpr) Reset() *FilterExpr

Reset clears the filter expression, allowing the FilterExpr to be reused for building a new expression without allocating a new object.

Example:

expr := F("Name").Eq("Alice")
filter1 := expr.Build()  // "Name eq 'Alice'"
expr.Reset()
expr.Eq("Bob")
filter2 := expr.Build()  // "Name eq 'Bob'"

func (*FilterExpr) StartsWith ¶ added in v0.2.14

func (f *FilterExpr) StartsWith(value string) *FilterExpr

StartsWith creates a string starts-with filter: startswith(field, value).

StartsWith checks if the field (string) starts with the specified prefix.

func (*FilterExpr) String ¶ added in v0.2.14

func (f *FilterExpr) String() string

String implements the Stringer interface, returning the OData filter string.

String is equivalent to Build() and allows FilterExpr to be used with fmt.Print and other functions expecting Stringer.

func (*FunctionBuilder) Execute ¶

func (f *FunctionBuilder) Execute(ctx context.Context) (map[string]interface{}, error)

Execute calls the function and returns the result as a map.

Execute constructs the OData function URL with parameters, sends an HTTP GET request, and parses the response into a map. The response format is normalized by [parseResponseValue].

Returns a map containing the function result, or an error if the call fails or the response status is not 2xx.

Example:

result, err := client.Function("GetTopProducts").
	Param("count", 10).
	Execute(ctx)
// result contains the function response data

func (*FunctionBuilder) Invoke ¶ added in v0.2.11

func (f *FunctionBuilder) Invoke(ctx context.Context, result any) error

Invoke calls the function and unmarshals the response into result.

Invoke is the result-receiver variant of FunctionBuilder.Execute. It sends an HTTP GET request to the OData function URL (with inline parameters) and unmarshals the response body into the value pointed to by result.

result must be a non-nil pointer. Invoke uses JSON round-trip via [mapToJsonStruct] for the unmarshaling, so standard json struct tags are respected.

Returns an error if the HTTP call fails, the response status is not 2xx, or unmarshaling fails.

Example:

type StatsResult struct {
	Count int    `json:"count"`
	Label string `json:"label"`
}

var stats StatsResult
err := client.Function("GetStats").Param("top", 10).Invoke(ctx, &stats)

func (*FunctionBuilder) Param ¶

func (f *FunctionBuilder) Param(key string, value interface{}) *FunctionBuilder

Param adds a parameter to the function call.

Param appends a key-value parameter to the function. Parameters are encoded in the URL path (e.g., /GetProducts(category='Electronics',maxPrice=1000)).

Returns the receiver for method chaining.

Example:

f.Param("name", "John").Param("age", 30)

func (*FunctionImportBuilder) Execute ¶

func (f *FunctionImportBuilder) Execute(ctx context.Context) (map[string]interface{}, error)

Example:

result, err := client.FunctionImport("GetTop10Orders").Execute(ctx)

func (*FunctionImportBuilder) Invoke ¶ added in v0.2.19

func (f *FunctionImportBuilder) Invoke(ctx context.Context, result any) error

Invoke calls the function import and decodes the response into result.

For GET requests, parameters are encoded in the URL as FuncName(k=v,...). For POST requests, parameters are sent as a JSON body.

The response is unwrapped from the OData {"d":{...}} envelope when present before decoding into result. Pass nil to discard the response body.

Returns an error if the HTTP call fails, the status is not 2xx, or JSON decoding fails.

Example:

var stats Stats
err := client.FunctionImport("GetStats").Invoke(ctx, &stats)

func (*FunctionImportBuilder) InvokeCollection ¶ added in v0.2.19

func (f *FunctionImportBuilder) InvokeCollection(ctx context.Context, results any) error

InvokeCollection calls the function import and decodes a collection response.

It handles the following OData collection envelope formats:

• {"d":{"results":[...]}} - OData v2 collection
• {"results":[...]} - flat results array
• {"value":[...]} - OData v4 collection
• [...] - bare JSON array

results must be a pointer to a slice, or nil to discard.

Returns an error if the HTTP call fails, the status is not 2xx, or JSON decoding fails.

Example:

var orders []Order
err := client.FunctionImport("GetOrders").InvokeCollection(ctx, &orders)

func (*FunctionImportBuilder) Method ¶ added in v0.2.19

func (f *FunctionImportBuilder) Method(m string) *FunctionImportBuilder

Execute calls the function import and returns the result as a map.

Execute constructs the OData v2 function import URL with parameters, sends an HTTP GET request, and parses the response into a map. This is similar to FunctionBuilder.Execute but for OData v2 Function Imports.

Returns a map containing the function import result, or an error if the call fails. Method sets the HTTP method for the function import call (default is "GET").

Use Method("POST") for function imports that modify state or when parameters must be sent in the request body instead of the URL.

Returns the receiver for method chaining.

Example:

err := client.FunctionImport("ProcessQueue").Method("POST").Invoke(ctx, &result)

func (*FunctionImportBuilder) Param ¶

func (f *FunctionImportBuilder) Param(key string, value interface{}) *FunctionImportBuilder

Param adds a parameter to the function import.

Param appends a key-value parameter to the function import. Parameters are encoded in the URL path, similar to FunctionBuilder.Param.

Returns the receiver for method chaining.

func (GeographyLineString) MarshalJSON ¶ added in v0.10.0

func (ls GeographyLineString) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeographyLineString.

func (GeographyLineString) ODataLiteral ¶ added in v0.10.0

func (ls GeographyLineString) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeographyLineString. Format: geography'SRID=4326;LINESTRING(lon1 lat1,lon2 lat2,...)'

func (*GeographyLineString) UnmarshalJSON ¶ added in v0.10.0

func (ls *GeographyLineString) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeographyLineString.

func (GeographyMultiPoint) MarshalJSON ¶ added in v0.10.0

func (mp GeographyMultiPoint) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeographyMultiPoint.

func (*GeographyMultiPoint) UnmarshalJSON ¶ added in v0.10.0

func (mp *GeographyMultiPoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeographyMultiPoint.

func (GeographyPoint) MarshalJSON ¶ added in v0.10.0

func (p GeographyPoint) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeographyPoint. Produces GeoJSON Point: {"type":"Point","coordinates":[lon,lat]}

func (GeographyPoint) ODataLiteral ¶ added in v0.10.0

func (p GeographyPoint) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeographyPoint. Format: geography'SRID=4326;POINT(lon lat)'

func (*GeographyPoint) UnmarshalJSON ¶ added in v0.10.0

func (p *GeographyPoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeographyPoint.

func (GeographyPolygon) MarshalJSON ¶ added in v0.10.0

func (poly GeographyPolygon) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeographyPolygon.

func (GeographyPolygon) ODataLiteral ¶ added in v0.10.0

func (poly GeographyPolygon) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeographyPolygon. Format: geography'SRID=4326;POLYGON((ring1),(ring2),...)'

func (*GeographyPolygon) UnmarshalJSON ¶ added in v0.10.0

func (poly *GeographyPolygon) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeographyPolygon.

func (GeometryLineString) MarshalJSON ¶ added in v0.10.0

func (ls GeometryLineString) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeometryLineString.

func (GeometryLineString) ODataLiteral ¶ added in v0.10.0

func (ls GeometryLineString) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeometryLineString.

func (*GeometryLineString) UnmarshalJSON ¶ added in v0.10.0

func (ls *GeometryLineString) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeometryLineString.

func (GeometryMultiPoint) MarshalJSON ¶ added in v0.10.0

func (mp GeometryMultiPoint) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeometryMultiPoint.

func (*GeometryMultiPoint) UnmarshalJSON ¶ added in v0.10.0

func (mp *GeometryMultiPoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeometryMultiPoint.

func (GeometryPoint) MarshalJSON ¶ added in v0.10.0

func (p GeometryPoint) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeometryPoint. Produces GeoJSON Point: {"type":"Point","coordinates":[x,y]}

func (GeometryPoint) ODataLiteral ¶ added in v0.10.0

func (p GeometryPoint) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeometryPoint. Format: geometry'SRID=0;POINT(x y)'

func (*GeometryPoint) UnmarshalJSON ¶ added in v0.10.0

func (p *GeometryPoint) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeometryPoint.

func (GeometryPolygon) MarshalJSON ¶ added in v0.10.0

func (poly GeometryPolygon) MarshalJSON() ([]byte, error)

MarshalJSON implements json.Marshaler for GeometryPolygon.

func (GeometryPolygon) ODataLiteral ¶ added in v0.10.0

func (poly GeometryPolygon) ODataLiteral() string

ODataLiteral returns the OData URL literal for a GeometryPolygon.

func (*GeometryPolygon) UnmarshalJSON ¶ added in v0.10.0

func (poly *GeometryPolygon) UnmarshalJSON(data []byte) error

UnmarshalJSON implements json.Unmarshaler for GeometryPolygon.

func (*GraphError) Error ¶ added in v0.2.15

func (e *GraphError) Error() string

func (Guid) String ¶

func (g Guid) String() string

String returns the UUID string representation.

String converts the internal 16-byte representation to standard UUID format (8-4-4-4-12 hex digits).

func (*Guid) UnmarshalJSON ¶

func (g *Guid) UnmarshalJSON(b []byte) error

UnmarshalJSON decodes UUID format: xxxxxxxx-xxxx-xxxx-xxxx-xxxxxxxxxxxx.

UnmarshalJSON parses a UUID string and converts it to the internal 16-byte representation. The UUID must be in standard format with 8-4-4-4-12 hex digit groups.

Returns an error if the format is invalid or contains non-hexadecimal characters.

func (*LambdaBuilder) Field ¶ added in v0.2.8

func (b *LambdaBuilder) Field(name string) *LambdaCondition

Field begins a condition expression for the given field within the lambda. The field is referenced as varName/fieldName in the generated OData expression.

b.Field("name").Eq("admin")
// produces: t/name eq 'admin'  (when varName is "t")

func (*LambdaCondition) Contains ¶ added in v0.2.8

func (c *LambdaCondition) Contains(s string) *LambdaBuilder

Contains adds a contains() function condition.

func (*LambdaCondition) EndsWith ¶ added in v0.2.8

func (c *LambdaCondition) EndsWith(s string) *LambdaBuilder

EndsWith adds an endswith() function condition.

func (*LambdaCondition) Eq ¶ added in v0.2.8

func (c *LambdaCondition) Eq(v any) *LambdaBuilder

Eq adds an equality condition: path eq value.

func (*LambdaCondition) Ge ¶ added in v0.2.8

func (c *LambdaCondition) Ge(v any) *LambdaBuilder

Ge adds a greater-than-or-equal condition: path ge value.

func (*LambdaCondition) Gt ¶ added in v0.2.8

func (c *LambdaCondition) Gt(v any) *LambdaBuilder

Gt adds a greater-than condition: path gt value.

func (*LambdaCondition) Le ¶ added in v0.2.8

func (c *LambdaCondition) Le(v any) *LambdaBuilder

Le adds a less-than-or-equal condition: path le value.

func (*LambdaCondition) Lt ¶ added in v0.2.8

func (c *LambdaCondition) Lt(v any) *LambdaBuilder

Lt adds a less-than condition: path lt value.

func (*LambdaCondition) Ne ¶ added in v0.2.8

func (c *LambdaCondition) Ne(v any) *LambdaBuilder

Ne adds a not-equal condition: path ne value.

func (*LambdaCondition) StartsWith ¶ added in v0.2.8

func (c *LambdaCondition) StartsWith(s string) *LambdaBuilder

StartsWith adds a startswith() function condition.

func (*MemoryCache) Clear ¶

func (c *MemoryCache) Clear()

Clear removes all entries from the cache.

Clear iterates over all cached entries and deletes them, leaving the cache empty. Useful for cache invalidation or cleanup.

func (*MemoryCache) Get ¶

func (c *MemoryCache) Get(key string) (*Metadata, bool)

Get retrieves cached metadata by key.

Get returns the Metadata stored under the given key, or (nil, false) if not cached.

func (*MemoryCache) Set ¶

func (c *MemoryCache) Set(key string, metadata *Metadata)

Set stores metadata in the cache with the given key.

Set overwrites any existing entry for the key. The operation is atomic and safe for concurrent use.

func (*NoOpCache) Clear ¶

func (c *NoOpCache) Clear()

Clear is a no-op.

func (*NoOpCache) Get ¶

func (c *NoOpCache) Get(key string) (*Metadata, bool)

Get returns nil, false (cache miss).

func (*NoOpCache) Set ¶

func (c *NoOpCache) Set(key string, metadata *Metadata)

Set is a no-op.

func (*ODataError) Error ¶

func (e *ODataError) Error() string

Error implements the error interface.

Error formats the ODataError into a human-readable string for logging and display. It includes the code (if available), message, and traverse prefix.