Contact Us
The Natural/Adabas Problem

Natural/Adabas predates SQL by a decade.
The shape doesnt transfer.

Natural/Adabas was designed in 1971 as an inverted-list system. It stores records differently than a relational database, and applications use access patterns that dont translate one-to-one to SQL.

The five structures that break naive migrations

Multiple-value fields (MU)

A single ADABAS record can hold many values for one field. In SQL: a one-to-many relationship needing its own child table. We generate the table, the foreign key, and the access code that reproduces the original behavior.

Periodic groups (PE)

Groups of fields that repeat together inside a record. These need their own table with parent reference and occurrence counter. Naive migrations flatten PE groups (data loss) or dump them as JSON (query nightmares).

Internal Sequence Number (ISN)

ADABAS ISNs are physical record locators, not stable primary keys. We translate ISN access into surrogate keys with proper indexing.

Superdescriptors, subdescriptors and hyperdescriptors

Composite index keys assembled from byte ranges of one or more fields, so the key has no column of its own in the record. We rebuild each one per target: an expression index on PostgreSQL, Oracle and Db2, and a persisted computed column with an index on SQL Server, which has no expression-index equivalent.

Direct/Adabas calls in COBOL and PL/I

Most Natural and ADABAS shops have COBOL or PL/I that issues ADABAS commands directly through the control block and the five buffers (L1 to L6 reads, L9 histogram, S1, S2, S4 finds, A1 update, N1 and N2 store, E1 delete, ET and BT). We rewrite those sites to JDBC with the same locking and transaction boundaries.

Any credible migration plan has to account for all five. The data model rebuild is the part that gets underestimated.

The Output

What the migrated stack looks like

Normalized relational schema, idiomatic Java, repeatable data load. How major ADABAS structures map:

ADABAS file
Relational table with surrogate primary key
MU field
Child table with foreign key and occurrence index
PE group
Child table per group, parent reference, occurrence counter
ISN
Surrogate key column with index
Natural FIND / READ
JPA repository methods or JDBC parameterized queries
COBOL ADABAS calls
JDBC blocks with equivalent locking and transaction semantics
ADABAS transaction
JDBC transaction or Spring @Transactional boundary
Predict definitions
JPA entity classes and database DDL

Compiles. Runs. Produces the same outputs against the same inputs at the same precision. A Java developer can read it without learning Natural/Adabas.

Approach

Deterministic translation. Gen AI for the work around it.

Two layers. Translation runs on DMS. Discovery and review run on Gen AI.

Compiler-driven translation

  • DMS toolkit, built since 1995.
  • Parses Natural, COBOL, and PL/I to abstract syntax trees.
  • Generates relational DDL from Natural/Adabas file definitions.
  • Same input, same output. Every rule auditable.

Gen AI for adjacent work

  • Business rule extraction from legacy Natural and COBOL.
  • Documentation for the new Java services.
  • Test case generation from observed access patterns.
  • Code review for developer handover.

The split matters because financial and government Natural/Adabas workloads cant tolerate silent semantic drift. Gen AI guessing what an L3 call means is a defect.

Natural/Adabas Coverage

Natural/Adabas versions, platforms,
and constructs we handle.

Versions and Platforms

ADABAS for Mainframe on z/OS and z/VSE (versions 7 and 8)

ADABAS on BS2000

ADABAS for Linux, Unix, and Windows

ADABAS C, the classic inverted-list engine, and ADABAS D, the separate relational product that later became SAP DB and MaxDB

ADABAS SQL Gateway (CONNX-based) sources

Constructs We Translate

Data structures

MU fields and PE groups including MU-within-PE nesting, elementary and sub-descriptors, superdescriptors, hyperdescriptors, phonetic descriptors, null suppression, and fields defined with the fixed-storage FI option

Utilities

ADASEL, ADAREP, ADAULD, ADACMP for data extraction

Natural integration

FIND, READ, HISTOGRAM, STORE, UPDATE, DELETE with their ADABAS underpinnings

Ecosystem
Core
Constructs

Record access

ISN-based access, L1/L2/L3 reads, S1/S2/S4 finds, ET/BT transactions

File metadata

DBID, FNR, file definitions from Predict or ADAREP

Access methods

Direct CALL ADABAS from COBOL, PL/I, and Assembler, across the control block, format buffer, record buffer, search buffer and value buffer: OP and CL session control, L1 to L6 record reads, L9 histogram, S1, S2, S4, S8 and S9 finds and sorts, A1 update, N1 and N2 store, E1 delete, ET and BT transaction control, and RC and RE command-ID release

Natural is covered here alongside the data migration. For the language on its own, see our Natural to Java migration page

Around the Data

Natural, COBOL, EntireX, ApplinX, JCL.

ADABAS rarely sits alone. Most of what surrounds it has to move at the same time:

Natural code

translates to Java with database calls rewritten to JDBC or JPA.

COBOL and PL/I
with ADABAS calls

get CALL ADABAS sites rewritten to SQL blocks. The rest follows our COBOL or PL/I to Java rules.

EntireX RPC services

move to Spring Boot services or REST endpoints. IBM acquired EntireX with webMethods on 1 July 2024.

Natural / Adabas

ApplinX terminal screens

translate to web UI scaffolding your team finishes. ApplinX moved to IBM in the same transaction.

Predict repository

becomes the schema source. JPA entities generated from the same metadata.

JCL and batch flows

translate to your chosen orchestrator. Spring Batch, Airflow, and Kubernetes CronJobs are common landings.

Process

Four phases. run in sequence with rolling delivery from phase 3 onward.

Phase 01 2 to 6 weeks

Assessment

Run ADABAS metadata and the surrounding source through DMS. Complexity report, MU/PE density, custom calls flagged.

Deliverable: Complexity report + fixed-price quote within 10 business days. The assessment is free.

Phase 02 4 to 12 weeks

Pilot

Migrate 5 to 10 ADABAS files plus the Natural and COBOL that touches them. Compare against the original for functional equivalence.

Deliverable: Working Java + relational schema + equivalence results. Measured against a 95% functional equivalence threshold.

Phase 03 3 to 12 months

Full migration

Migrate the rest of the codebase and data using rules calibrated during the pilot.

Deliverable: Rolling module deliveries every 4 to 6 weeks. Data load scripts run repeatedly for refresh.

Phase 04 1 to 6 months

Parallel Run & Cutover

New Java + relational stack runs alongside Natural and ADABAS, processing the same inputs and comparing outputs.

Deliverable: Zero-diff signoff. Cutover plan. ADABAS data archived.

FAQ

The questions our engineers get
asked the most

General questions

Natural and ADABAS MU fields become child tables with a foreign key to the parent and an occurrence index. PE groups also become child tables, one per group, with the same parent reference plus a sequence number. The generated Java repository methods reproduce the original access pattern so application code behaves the same against the relational schema as it did against Natural and ADABAS.

Natural and ADABAS to Java migration generates schemas for PostgreSQL, SQL Server, Oracle, Db2, Amazon Aurora, and Azure SQL. Target choice depends on your team's existing operations stack and cloud preference. The toolkit is target-aware: it generates appropriate types, functional indexes, and DDL for the database you pick during assessment.

A typical migration covering 500 ADABAS files and 1 million lines of surrounding Natural and COBOL runs 6 to 15 months end-to-end. Smaller installations (100 to 200 files) finish much faster.

Migration is scoped per project, not per line of code. Cost depends on codebase size, dialect coverage, how much surrounding code has to move with it, and the target architecture. The free assessment produces a fixed-price quote for the whole engagement, locked for 90 days, so the number is settled before any translation work starts.

Natural and ADABAS migration will deliver 100% functional equivalence in final delivery.

ADABAS is fast on its specific access patterns. A naive migration will be slower. Our process includes performance profiling during pilot and full migration. Queries that miss the original benchmark get rewritten before cutover, and indexing gets tuned per-table. Most production cutovers reach 1:1 or better throughput on the relational target.

Yes. Natural and ADABAS to Java migration covers COBOL and PL/I programs that issue direct ADABAS commands (L1, L2, L3, S1, S2, S4, ET, BT, A1, N1, N2). The CALL ADABAS sites get rewritten to JDBC blocks with equivalent transaction and locking semantics. The rest of the COBOL or PL/I follows our standard rules for those languages.

The free assessment delivers six artifacts in 10 business days: a complexity report (file count, MU and PE density, embedded call inventory), a relational data model preview, a sample migration of 2 to 3 ADABAS files plus the code that reads them, a risk register, a phased project plan, and a fixed-price quote locked for 90 days.

Dont let your last COBOL developer retire before your migration is planned.

COBOL headcount is falling 8% a year. Contractor rates are climbing 12 to 18% annually. Start with a free assessment. Decide afterward.