Atlas Case Studies How we work Book a demo

Hard sources — not covered by free tools

Also parsed — certify what free tools miss

Campaign

Warehouses

Runtimes

Convert ODI mappings and packages to BigQuery SQL

ODI Smart Export XML parsed structurally. Mappings, Knowledge Modules, and Oracle SQL converted to BigQuery SQL, Scheduled Queries, and Cloud Composer DAGs. Full lineage, validated parity.

Architecture

Oracle ODI in. Google Cloud out.

Deterministic parsers read the estate and emit native Google Cloud code — not ODI mappings lifted into a hosted ODI.

Oracle ODI → MigryX parser → BigQuery + Dataform + Composer

Oracle ODI
MappingsInterfaces
PackagesSerial + loops
Load plansParallel steps
Knowledge modsLKM / IKM / CKM
MigryX Parser
Deterministic parseAI optional
Row-level parityBefore cutover
SQLX emitDataform models
DAG emitComposer
Google Cloud
BigQuerySet-based SQL
DataformGoverned models
Cloud ComposerReplaces scheduler
Cloud FunctionsNon-SQL tools
IAM + CLSLeast privilege
Git reposReproducible packs

AI is an optional add-on, off by default — the conversion runs end to end without it, air-gapped if your estate requires it.

Why BigQuery

Knowledge Modules cannot leverage serverless, columnar analytics

KMs replaced by BigQuery native capabilities

IKMs and LKMs generate Oracle-specific SQL that assumes row-based storage. BigQuery is columnar and serverless — native MERGE, partitioned INSERT, and automatic slot allocation replace the entire KM abstraction layer with zero infrastructure management.

Oracle partitioning replaced by BigQuery partitioning

ODI mappings rely on Oracle range/list/hash partitioning with manual partition management. BigQuery offers time-unit, ingestion-time, and integer-range partitioning with automatic partition pruning. No manual DDL, no partition maintenance windows.

Packages replaced by Scheduled Queries and Cloud Composer

ODI packages and load plans require an on-premise agent and WebLogic server. BigQuery Scheduled Queries handle simple pipelines natively. For complex DAGs, Cloud Composer (managed Airflow) provides branching, retries, and SLA monitoring without maintaining ODI infrastructure.

Parser output

ODI IKM SQL Append to BigQuery MERGE

An ODI mapping using IKM SQL to SQL Append with Oracle-specific functions — converted to BigQuery Standard SQL MERGE with native partitioning. No Knowledge Modules, no Oracle agent, no on-premise infrastructure.

ODI Mapping (IKM SQL to SQL Append)
<!-- ODI Mapping: Load_Claims_Fact -->
<Mapping name="Load_Claims_Fact">
  <Source schema="STAGING"
         table="STG_CLAIMS"/>
  <Target schema="DW"
         table="FACT_CLAIMS"/>
  <Join condition="SRC.CLAIM_ID = TGT.CLAIM_ID"/>
  <Filter>
    SRC.PROC_DT BETWEEN :START_DT AND :END_DT
  </Filter>
  <Expression target="CLAIM_STATUS">
    DECODE(STATUS,'O','Open','D','Denied',
           'P','Paid','S','Settled','Pending')
  </Expression>
  <Expression target="NET_AMOUNT">
    NVL(BILLED_AMT,0) - NVL(ADJUST_AMT,0)
  </Expression>
  <Expression target="PROC_YEAR">
    TO_CHAR(PROC_DT, 'YYYY')
  </Expression>
  <IKM name="IKM SQL to SQL Append"
       FLOW_CONTROL="true"
       COMMIT="true"/>
</Mapping>
MigryX
converts
BigQuery SQL
-- ODI IKM SQL to SQL Append → BigQuery MERGE

-- Partitioned target table (replaces Oracle partitioning)
-- CREATE TABLE dw.fact_claims (...)
-- PARTITION BY DATE_TRUNC(proc_dt, MONTH)
-- CLUSTER BY claim_status;

MERGE INTO `project.dw.fact_claims` AS tgt
USING (
  SELECT
    claim_id,
    proc_dt,
    CASE status
      WHEN 'O' THEN 'Open'
      WHEN 'D' THEN 'Denied'
      WHEN 'P' THEN 'Paid'
      WHEN 'S' THEN 'Settled'
      ELSE 'Pending'
    END AS claim_status,
    COALESCE(billed_amt, 0)
      - COALESCE(adjust_amt, 0) AS net_amount,
    CAST(FORMAT_DATE('%Y', proc_dt) AS STRING)
      AS proc_year
  FROM `project.staging.stg_claims`
  WHERE proc_dt BETWEEN @start_dt AND @end_dt
) AS src
ON tgt.claim_id = src.claim_id
WHEN MATCHED THEN UPDATE SET
  tgt.claim_status = src.claim_status,
  tgt.net_amount   = src.net_amount,
  tgt.proc_year    = src.proc_year,
  tgt.proc_dt      = src.proc_dt
WHEN NOT MATCHED THEN INSERT
  (claim_id, proc_dt, claim_status,
   net_amount, proc_year)
VALUES
  (src.claim_id, src.proc_dt, src.claim_status,
   src.net_amount, src.proc_year);

-- Scheduled Query replaces ODI package scheduling
-- Schedule: Every 2 hours via BigQuery Scheduled Queries
-- Parameters: @start_dt, @end_dt passed at runtime

IKM SQL to SQL Append replaced by BigQuery MERGE with automatic partition pruning. Oracle DECODE, NVL, and TO_CHAR converted to CASE, COALESCE, and FORMAT_DATE. Flow control handled by BigQuery Scheduled Queries or Cloud Composer retry policies.

Coverage

ODI to BigQuery — artifact mapping

ODI Artifact BigQuery Equivalent Notes
MappingBigQuery SQL scriptSource-to-target flow as Standard SQL
IKM (Integration KM)MERGE / INSERT SELECTIncremental, append, and full-refresh patterns
LKM (Loading KM)LOAD DATA / External tableGCS, Drive, Bigtable data ingestion
PackageScheduled Query / Composer DAGSimple chains or complex DAGs with Airflow
Load PlanCloud Composer DAGParallel/serial task groups with retry policies
ProcedureBigQuery scripting / routineMulti-statement SQL scripts with variables
VariableScript variable / query parameterDECLARE variables or @param syntax
Interface (pre-12c)SQL view + scripted procedureLegacy interfaces parsed and restructured
CKM (Check KM)Column-level constraintsNOT NULL and primary key constraints
Oracle partitioningBigQuery partitioning + clusteringTime-unit, ingestion-time, integer-range
RKM (Reverse KM)INFORMATION_SCHEMAMetadata discovery via BigQuery catalog views
JKM (Journalizing KM)CDC via BigQuery Change HistoryTABLE_SNAPSHOTS or streaming inserts replace triggers
Validation

Every conversion validated to row-level parity

Data Matching compares ODI mapping output against BigQuery script output — row by row, column by column. In the case study below, all 750 mappings were validated against Oracle production data with full reconciliation across three billing periods.

See how Data Matching works →
750
ODI mappings modernized
6X
Faster pipeline execution
45
Knowledge Modules replaced

Healthcare Company: ODI to BigQuery in 7 Months

750 ODI mappings converted to BigQuery Standard SQL scripts. 45 Knowledge Modules — IKMs, LKMs, CKMs — replaced by native BigQuery features: MERGE, LOAD DATA, External Tables, and column constraints. Oracle-specific partitioning schemes modernized to BigQuery time-unit partitioning with clustering. Load plans restructured as Cloud Composer DAGs. Nightly analytics batch reduced from 5 hours to 50 minutes on serverless compute.

Explore migration case studies →

What to bring to a Oracle Data Integrator assessment

Review a representative sample with us →

Explore other modernizations

Targets: Snowflake Databricks Google Cloud Azure AWS PySpark Polars Iceberg DBT SQLMesh
Sources: SAS Alteryx Talend Qlik DataStage Informatica COBOL Oracle Teradata SSIS