Prove it behaves the same
SQL Tran runs your translated code against both source and target databases and compares the results. Row by row. Column by column.
After translation and deployment, there is one question that matters above all else: does the translated code behave exactly like the original?
Syntax errors are caught during creation. Behavioral differences are sneakier: a view that returns slightly different rows, a procedure that updates the wrong records, a function that rounds differently. They only surface through testing. SQL Tran's correctness testing framework answers the question definitively, for every object type.
How it works
Side-by-side execution, compared
SQL Tran connects to both environments simultaneously: your original source database and the target database where translated objects have been created. It runs each test and compares outcomes side by side.
When you need test inputs, its synthetic data generator follows your schema constraints and the way each routine uses its parameters. It creates realistic cases that exercise meaningful branches without requiring a full production-data copy. You get broader coverage sooner, with less setup and less exposure to sensitive data.
What gets tested
Every object type, validated
Tables
Reads data from both source and target, and verifies that both contain the exact same rows. Any discrepancy is flagged immediately.
Views
One test per view. Compares the data returned by executing the view on both source and target. Same query, same results expected.
Procedures
Compares return value data sets and all table side effects. Verifies that both the output and every table modification (inserts, updates, deletes) match between source and target.
Functions
Compares return values, scalar or data set results, between source and target. Functions cannot write to tables, so validation focuses on output correctness.
Choose your depth
A framework that provides both depth and breadth for your tests.
Start broad to measure the migration as a whole, or go straight to one object when a result needs investigation. Both paths use the same source-versus-target comparison.
Batch testing
Generate and run tests for every successfully created object at once. For a large database, batch testing turns thousands of comparisons into a project-wide confidence signal in minutes.
Individual testing
Open one procedure, view, or function and inspect its behavior in isolation. It is the fastest way to trace a mismatch, try a correction, and rerun the exact case that failed.
A note on data
SQL Tran tests code behavior AND data migration. It does not copy data from source to
target. That is the job of a data migration tool like Omni Loader. SQL Tran and Omni Loader use compatible mapping configurations, so the two tools work
seamlessly together when you need both code and data migration.
If the data is different, SQL Tran will flag any discrepancies in results when testing tables.
So you can be confident that any differences are due to translation issues, not data issues.
Use the built-in synthetic data generation feature to build a fully testable environment without copying production data. Synthetic data
generation creates realistic data sets that match your schema and constraints, so you can get
comprehensive test coverage without a full data migration up front.
Key benefits
- Run the same test against source and target databases at once, so both executions receive identical inputs and can be compared fairly.
- Compare returned rows and columns in detail, making small differences visible instead of hiding them inside a simple pass or fail result.
- Validate return values and table side effects for procedures, including the inserts, updates, and deletes they perform while running.
- Use batch testing for project-wide confidence, or isolate one object at a time when a mismatch needs focused investigation and a quick rerun.
Know your migration is correct, not just translated
Prove behavioral equivalence across every object in your database with automated correctness testing.