Skip to main content

Language Support Overview

TeaQL generates typed domain, query, expression, relation, aggregation and mutation APIs for seven language runtimes. They share one model and one semantic contract, while retaining idiomatic casing, async models and package layouts.

Run One School Model, Seven Runtimes for a common executable SQLite baseline. Its 2026-10-27 qualified receipt is 7/7 PASS: six published runtimes and Go WORKSPACE PASS — RELEASE PENDING. The status table and separate published-only receipt retain the Go release gap.

LanguageGuideVerified SQL databasesTypical fit
JavaJava StackPostgreSQL, MySQL, SQLite, Oracle, DB2, DM8, SAP HANA, SQL Server, DuckDBEnterprise services and the broadest database matrix
RustRust StackPostgreSQL, MySQL, SQLiteEfficient native services and explicit runtime composition
TypeScriptTypeScript GuidePostgreSQL, MySQL, SQLiteNode services plus a browser-safe federal client profile
SwiftSwift GuideSQLiteApple-platform applications and Swift services
PythonPython GuidePostgreSQL, MySQL, SQLiteAsync services, automation and data-oriented applications
C# / .NET.NET GuidePostgreSQL, MySQL, SQLite, SQL Server.NET services and native SQL Server integration
GoGo GuidePostgreSQL, MySQL, SQLiteSmall services and straightforward deployment

“Verified” means generated code was compiled and executed against a real database in the dated acceptance campaign. It is not a promise about every database version or a commercial support SLA. See the runtime/database matrix for evidence boundaries.

A complete path for each language​

Use one language's Order tutorial for the complete retained SQLite first-edit path. The Order workflow evidence already records seventeen core cases per language and separate isolation, stock, lifecycle and finite-soak scopes. The School programs remain a separate executable baseline.

LanguageRead/edit/page tutorialNative failure recovery
JavaOrder tutorialTroubleshooting
RustOrder tutorialTroubleshooting
TypeScriptOrder tutorialTroubleshooting
PythonOrder tutorialTroubleshooting
GoOrder tutorialTroubleshooting
C# / .NETOrder tutorialTroubleshooting
SwiftOrder tutorialTroubleshooting

Continue with the advanced Order mutation tutorials for seven-language line deletion, state transitions and version-conflict recovery.

The Order query tutorials cover continuous export, retained-ID pagination and full-set summaries in every language, with explicit fixture, store and planner/result differences.

For the v1.1 model upgrade, trusted context/session ownership and permission boundaries, use the seven-language Order isolation tutorials.

The Order API usage guide explains result carriers, loaded state, transaction ownership and paging choices. The seven-language coverage matrix separates completed documentation from remaining recipes, clean-machine packaging and planned ecosystem integrations. Java/Rust still have deeper reference and integration material; equal first-edit coverage does not imply equal coverage of every advanced topic.

Core Order uses published Java/Swift and qualified workspace builds for Go, TypeScript, Rust, Python and .NET. The later lifecycle/soak scope also qualifies the Java JDBC repair as WORKSPACE PASS — RELEASE PENDING. All existing School and generator pending-deployment markers remain attached to their scopes.

Every runtime has a language-native entry point and the same Begin/Prove/Extend journey. Java and Rust retain deeper stack guides behind those common entry points.

LanguageBeginProveExtend
JavaGenerate JavaFirst VerificationRuntime Extension Points
RustRust Quick StartFirst VerificationRuntime Extension Points
TypeScriptQuick StartFirst VerificationCustomization
SwiftQuick StartFirst VerificationCustomization
PythonQuick StartFirst VerificationCustomization
C# / .NETQuick StartFirst VerificationCustomization
GoQuick StartFirst VerificationCustomization

The seven-runtime contract is shared, but each path uses that ecosystem's project layout, toolchain, async/concurrency model, provider lifecycle, packaging expectations, and verification style. A user should not have to read five other language guides to ship the one runtime they chose.

The generator selections and independently published package versions are tracked separately in Latest Versions. Always prefer the dependency coordinates emitted by the generator for a newly generated workspace.

Shared native query profile​

All seven native runtimes support the same baseline query surface: scalar and relation predicates including nested child queries, typed projection and ordering, explicit relation selection, grouped aggregates, relation statistics, facets, ordinary and stateful pagination, and exact per-parent Top-N. The cross-language query contract defines the full catalog and its source anchors. This native-runtime statement does not imply that the separate TFP wire profile or every database provider has the same evidence level.

For a task-oriented explanation of reads, writes, grouped and relation statistics, Facets, and result shapes, start with Query, Mutation, Analytics, and Facets, then open the selected language's Scenarios page for native syntax.

For diagnosis, start with Debugging, Audit, and Observability, then open the selected language's Debugging page. Those pages distinguish safe SQL evidence, operator-only rendered SQL, RuntimeTelemetry, application audit, and tenant-policy verification instead of treating them as one logging stream.

Runtime infrastructure is a separate portability dimension. The Cache, Lock, and Cloud Runtime Infrastructure guide records Local/Redis cache, Local/Remote Lock, Nacos, Consul, health, metrics, and graceful-shutdown coverage without treating source presence as live-provider verification.

Shared contract​

Every runtime follows these rules:

  • plural and predicate names are decided centrally; target templates do not guess English;
  • human entities use whose/whoAre, while non-human entities use with/whichAre;
  • the public parameter name is context in every language; do not replace it with a runtime, service, data-service, or shortened alias;
  • list queries return typed entities in the runtime's SmartList, never raw database rows or the host language's bare list/array type;
  • non-empty comment and purpose must both be supplied before execution; either order is valid and they need not be adjacent;
  • mutations require an audit reason;
  • tenant, actor, permissions and policy come from trusted context, not dynamic client JSON;
  • SQL runtimes provide native COUNT, SUM and GROUP BY and exact per-parent Top-N; the runtime/provider policy selects a window plan or bounded probes;
  • the runtime emits a row/mutation audit event and a separately attributable masked application event.
  • save(context) returns the persisted typed entity and preserves loaded/null/not-loaded state;
  • a Runtime Module is a passive, composable manifest; installing it never changes a database;
  • schema reconciliation is an explicit startup or administrative call using that module;
  • RuntimeTelemetry is optional and no-op by default; sampling and audit delivery remain independent.

The conformance model defines ten Assist categories for every language: create, query, update, delete, list/page, expression, debug, tool API, runtime customization, and ensure schema. Their publication evidence levels are tracked separately; see Assist and Generated Workspaces. Use the TeaQL Agent Kit as the evolving Harness Engineering workflow when an AI coding agent consumes these generated contracts.

Java remains the naming and Request-semantics gold standard. Other targets preserve the same meaning with language-appropriate casing rather than translating method names by intuition.

Choosing a runtime​

Choose by application ecosystem and deployment needs, then verify the exact runtime/provider/driver combination you plan to ship. Do not select a database merely because a driver or template exists. Regenerate from the same model when comparing languages so public API differences remain reviewable.

The earlier six-language Order Search campaign executed 18 core language/database cells, 252 positive dynamic scenarios, governance gates, audited saves and real TypeScript-to-Rust federation. Read the acceptance article for the result and the provider compatibility reference for support terminology.

Continue with one model across seven runtimes​

The basic School check verifies bootstrap, creation and restart. The advanced School suite uses the same model for paging, relations, analytics, Facets, Top-N and audited mutations, with explicit per-runtime results and remaining release gaps.