Jev query route compatibility

Check whether two query briefs can use the same route

Compare both query briefs with configured engine scopes. Determine whether one route fits both, separate routes are needed or a requirement is unsupported; the example does not execute queries.

Can these queries share a configured route?Live API
Try an example

Original synthetic input. Edit the task or evidence to make a new API request.

Source: Workflow inspiration on X

Source and example scope

The inputs, rubric and preview are original. This window demonstrates the stated decision only; it does not reproduce the source application or its measurements.

Review queryBriefs against configuredEngines.

Decision rules and labels
Co-routeSeparate routesUnsupported queryNeed requirements
A real response from the Jev API

Edit any input to explore a different decision. No request is sent until you run it.

Your next decision

Not run yet

Choose an example or write your own input, then run it to see the ranked choices.

Results are not stored by this site. Your submitted text is processed by the API provider.

The decision

How does Jev query route compatibility use the supplied evidence?

Jev query route compatibility compares two query requirements with a supplied engine configuration. The live window asks whether both can share one configured route, need separate routes, contain an unsupported requirement or need more input. Its output is a local compatibility note, not an executed query plan.

The three profiles are fictional and deliberately narrow. One accepts selective single-table reads, one accepts large multi-table aggregates and one accepts geospatial filters on a single table. None accepts writes. These are local declared scopes, not statements about any commercial engine. The model interprets the briefs against those scopes without predicting latency or cost.

An API-collected post describing Jev-based routing among configured query engines inspired this demonstration. The source mentions Iceberg as the shared table foundation. The official Iceberg documentation supplies table-format context; it does not define our fictional engine profiles or prove their capabilities. This page contributes an original two-request compatibility check with retained API observations.

Compare the shared-read, split-workload and missing-second examples. Two requests can each be supported without sharing an engine. A shared data format also does not establish that every configured route supports every operator. The window keeps those distinctions visible before an application decides how to dispatch work. No SQL text, database credential or network connection is required.

Original Jev query route compatibility workflow diagram showing supplied evidence, a typed decision and the local preview.
Original workflow illustration. The output is a local preview, not an executed action or source screenshot.
How it works

Try the example in four steps

Use the sample to understand the rule, then test your own input for query route compatibility.

  1. Illustration of adding the text or evidence for a decision

    Add the information to check

    Compare both query briefs with configured engine scopes.

  2. Illustration of defining a question and its allowed choices

    Confirm the question and labels

    Open the decision rules and keep the intended distinction between Co-route, Separate routes, Unsupported query, Need requirements. Edit the choices only when testing your own rule.

  3. Illustration of sending one input and comparing the returned choices

    Run the decision

    Use a sample first, then try your own input. Compare the selected label with the other returned probabilities.

  4. Illustration of reviewing a result and an uncertain item before using it

    Review the next step

    Review Need requirements before using a result. The label is a decision about the supplied information, not an executed action.

Our API test

What the six original inputs returned.

What the six original inputs returned.
Original test inputFixture expectationObserved labelLeading probability
Two selective readsCo-routeCo-route95%
A lookup and a warehouse aggregateSeparate routesSeparate routes98%
Two geospatial filtersCo-routeCo-route96%
One request modifies dataUnsupported queryUnsupported query83%
An unspecified second queryNeed requirementsNeed requirements100%
An unknown workload alongside a writeNeed requirementsNeed requirements95%
  • 6 of 6 original fixture expectations matched. Contrary outputs are preserved in the table and downloads; these checks are not held-out accuracy or production suitability.
  • Measured adapter round trips: 459-1184 ms. Estimated input cost: $0.00002940-$0.00002978 per request. These observations are not a latency guarantee or invoice.

6 actual Jev API calls on October 4, 2026. Original synthetic inputs check this rubric and handoff; they do not establish held-out accuracy. Probabilities are model outputs.Verified

Understand the results

Two selective reads

The first pair asks for two selective single-table reads.

Read the example notes

Both requirements fit the point-read profile, so a common configured scope exists. Co-route describes that overlap only. It does not merge the requests into one SQL statement, open a shared transaction or promise that running them together is faster. The printed packet retains a pending compatibility decision for a caller that will separately construct and validate any actual execution plan.

A lookup and a warehouse aggregate

The second pair combines a lookup with a large joined aggregate.

Read the example notes

Each fits one of the declared profiles, but the configuration intentionally gives them different scopes. Separate routes preserves that distinction. A model should not treat the word query or a shared table format as permission to use one route for both. The sample demonstrates compatibility of requirements, rather than the usual single-task choice of a model or tool profile.

Two geospatial briefs can share the geo-filter scope

Two geospatial briefs can share the geo-filter scope.

Read the example notes

The input explicitly includes a polygon predicate and a distance predicate on one table. The page does not parse their coordinates, validate spatial reference systems or choose an index. Those implementation requirements remain outside the semantic decision.

If a real profile supported only one of those operators, its catalog would need that narrower description and the original saved answer would no longer describe the edited request.

The update request requires a write

The update request requires a write.

Read the example notes

None of the fictional profiles permits writes, so Unsupported query records a clear capability gap. This outcome does not mean the underlying table format cannot support updates, nor does it describe a real engine's product limits. It describes only the supplied local configuration. The caller cannot reinterpret an unrelated read or aggregate profile as a write route simply because it received a complete API response.

An unspecified second query

The missing-second input asks for speed without specifying the second workload.

Read the example notes

Need requirements prevents the neighbor's geospatial requirement from filling that gap. A performance adjective is not an operator description. The result waits for a concrete brief such as a selective lookup, a large join or a spatial filter. The probabilities remain available for review, but a high leading score cannot create the absent requirement or establish a database capability.

An unknown workload alongside a write

The last pair contains both an explicit write and an unspecified second workload.

Read the example notes

The declared question gives missing requirements priority, so the primary label requests more input. This is a deliberate single-status policy. A production planner may need independent results for each query plus a separate compatibility decision. That would require additional questions and validation. The local consumer preserves this example's actual one-label contract rather than hiding one issue behind a fabricated complete plan.

Source and example scope

Fixture expectations are authored before the calls. Any contrary model choice remains visible beside its expectation and complete distribution; no repeated judgment is used to obtain a preferred label.

Using the result in your application

Download the exact sample requests and saved observations below.

Read the example notes

Expected labels are original fixture checks and stay outside the request sent to Jev. The observation file preserves the complete probabilities and the hash of each exact request. Editing a task, rubric or candidate requires a fresh response; a matching sample name does not make an older answer current.

Using the result in your application

The JavaScript runner makes one independent SDK request for a chosen sample ID.

Read the example notes

It reads TYPESAFE_API_KEY privately from the environment and has no automatic retry. The Python consumer operates offline: it checks the rubric, labels, unique sample identities, request hashes and valid probability distributions before selecting a fixed local preview. A tied leading result remains pending for review.

Source and example scope

The page reports measured adapter round trips and estimated input cost for the recorded calls.

Read the example notes

Those values describe these requests, not a provider latency guarantee or a billing statement. Six deliberately authored fixtures can check the stated behavior, but they do not establish accuracy on an unseen dataset. Keep disagreements and missing-input examples when testing an integration.

Runnable offline example

Replay one request and inspect the saved preview.

View the code example
Replay commands
npm install @typesafe-ai/sdk@0.6.0
# Set TYPESAFE_API_KEY privately in your shell.
node run-choice-sample.mjs samples.json shared-read
python preview_choice_workflow_v2.py samples.json saved-api-results.json
Runnable offline example

The first request and its recorded local output.

View the code example
Exact first sample and local preview
{
  "input": {
    "task": "Compare the two query briefs for route compatibility. Treat the engine scopes as the complete local configuration.",
    "configuredEngines": [
      {
        "id": "point-read",
        "scope": "Selective single-table reads; no large multi-table aggregates, geospatial predicates or writes."
      },
      {
        "id": "warehouse",
        "scope": "Large multi-table aggregates; no geospatial predicates or writes. Selective single-table lookup is outside this configured scope."
      },
      {
        "id": "geo-filter",
        "scope": "Geospatial predicates on one table; no multi-table aggregates or writes. Non-geospatial lookup is outside this configured scope."
      }
    ],
    "queryBriefs": [
      "Read the current plan for a single specified workspace from one table.",
      "Look up one specified project by its identifier in one table."
    ]
  },
  "localOutput": {
    "sampleId": "shared-read",
    "leaders": [
      "Co-route"
    ],
    "probabilities": {
      "Co-route": 0.95,
      "Separate routes": 0,
      "Unsupported query": 0,
      "Need requirements": 0.05
    },
    "action": "preview_query_route_compatibility",
    "payload": {
      "decision": "Co-route"
    },
    "pending": true
  }
}
Scope of this demo

Where does this decision fit?

Useful with explicit supplied evidence

  • Interpret two query-workload briefs against three fictional configured engine scopes to decide common-route compatibility, separate routes, unsupported requirements or missing input. Print a pending note, not a selected model, SQL or database execution.
  • Inspecting the original task and a fixed output before integrating external tools.
  • Comparing an explicit expected label with the complete recorded distribution.

Needs separate implementation or evidence

  • Inferring facts absent from the supplied input.
  • Treating a semantic selection as authorization to act.
  • Executing an external action or generalizing six fixtures into an accuracy claim.
Example FAQ

Questions about this original decision workflow.

Keep relevance, compliance and execution separate.

Does Co-route mean the queries execute together?

No. It means the supplied requirements share at least one declared engine scope. The output does not merge SQL, select a transaction policy or run a database call. A real router must validate its configuration, authorization, parameters and execution plan separately.

Are the three profiles real database products?

No. They are original fictional profiles with intentionally narrow scopes. Their descriptions make the decision testable without attributing unsupported capabilities or limitations to a vendor. Iceberg documentation provides table-format background, while the request itself defines the available routes.

Why compare two requests instead of selecting an engine for one?

Two individually supported requests may need different routes. This example tests whether a common scope exists and preserves the difference between compatibility, unsupported requirements and missing input. It does not rank engines or optimize a workload.

Can the result predict query latency or spending?

No. The page records the adapter round trip and estimated input cost of its own Jev calls. Those values describe the classification request. They are not database execution timings, warehouse costs, billing statements or proof that co-routing improves performance.

Try a task from your own workflow

Change the supplied task or evidence here, then inspect the live response. Playground supports another explicit decision.