Quick answer: One OpenAPI spec generates dialect-specific DDL, indexes, deterministic seed data, and deployment scripts for MySQL, SQL Server, and Oracle. The relational design is derived once from the schemas, then emitted in the dialect each database requires, rather than hand-writing and maintaining a separate design per engine. The generated SQL is for review and is never executed by the modeling package.
Why one source matters
Maintaining three hand-written designs is slow and invites drift. A change made to one dialect can be missed on the others, and a type or key that works on one engine may need a different form on the next. Building the relational model once and generating the dialect output keeps the three databases aligned against the same source.
The OpenAPI schemas are that source, and the derived entities, foreign keys, and link tables are shared before the dialect-specific rendering.
What each dialect receives
| Output | MySQL | SQL Server | Oracle |
|---|---|---|---|
| Table DDL | Yes | Yes | Yes |
| Indexes | Yes | Yes | Yes |
| Foreign keys | Yes | Yes | Yes |
| Deterministic seed data | Yes | Yes | Yes |
| Deployment script | Yes | Yes | Yes |
The same logical table is rendered with the data types and syntax the target engine expects, so the dialect differences are handled at generation rather than by separate manual edits.
How the generation works
- Derive the relational entities and keys from the schemas.
- Infer the link tables and resolve the open questions.
- Reconcile the model against the live database when a profile exists.
- Render the DDL, indexes, and seed data for each dialect.
- Produce the idempotent, forward-only deployment script.
- Review the output before running it.
The seed data is deterministic, so a fresh deployment produces the same starting values rather than random or environment-dependent rows, and the deployment script is idempotent so a repeated run does not create duplicate objects.
Take a table that stores a timestamp and a fixed-length code. The shared model declares the two fields once, and the generator renders each in the dialect the engine accepts: the date type and the string type take the form MySQL expects, then the equivalent forms for SQL Server and Oracle. The foreign keys and the indexes are emitted the same way, so a change to a field is made once and all three outputs move together. A reviewer still opens the dialect-specific rendering, because a type that maps cleanly on one engine can carry a length or precision difference on another, and the review happens before the forward-only script runs. None of the three sets executes itself, and the deterministic seed data keeps a fresh deployment identical across the engines.
Honest limits
The dialect output is generated for review, and the modeling package has no executing driver, so none of the three sets of DDL runs automatically. A dialect-specific edge case, such as a type that maps differently under a particular engine, still deserves a review against the target database rather than blind trust.
When the business logic is ambiguous, the result raises an open question rather than guessing across all three dialects, and the inferred link tables stay labeled until confirmed. This is the same boundary that keeps a static signal from being written as a guarantee.
Powerduck keeps the three dialects and the shared source model in the desktop, so the databases stay aligned while the execution remains a separate, reviewed step.
Frequently asked questions
Do I need a separate design for each database? No. The relational model is derived once and rendered as DDL for MySQL, SQL Server, and Oracle.
What handles dialect differences? The generator emits the data types and syntax each engine expects, rather than using one generic form.
Does the tool run the DDL? No. It is generated for review, and the deployment script is idempotent and forward-only when you run it.
The bottom line
A single OpenAPI spec can drive three databases, deriving the relational model once and generating dialect-specific DDL, indexes, seed data, and deployment scripts for MySQL, SQL Server, and Oracle. This keeps the engines aligned and removes the drift of three hand-written designs, while the SQL stays reviewed rather than executed and ambiguous logic stays an open question. One source, three dialects, and the execution decision stays with the team. Read more in the API data model guide.
