DataFlex

DataFlex is an object-oriented database management system and 4GL programming language designed for business applications, originally developed by Data Access Corporation.

What You Can Upload

• .DAT data files
• .TAG field-name files
• .FD or .DEF field definition files
• .VLD variable-length text data (memo fields)
• ZIP archive with complete file sets

What You Get Out

DataMeans converts your data into multiple modern formats:

How to Export / Obtain Files

1. Locate your DataFlex application's data directory
2. Copy all .DAT data files
3. Include .TAG files (contain field names)
4. Include .VLD files (memo data)
5. Include .FD or .DEF definition files if available
6. Create a ZIP with all files
7. Upload the ZIP to DataMeans

A single .DAT can also be uploaded on its own. Every record is read, but the field names are in the .TAG file, so without it the columns are named FIELD_1, FIELD_2 and so on.

Supported Features

• DataFlex 3.x tables. The reader is checked against a real 3.x table; 4.x files are read the same way but not yet checked on real ones
• Records read from where DataFlex stores them, at any record length: DataFlex packs them into 512-byte blocks, so a table is misread after its first block if it is read straight through
• Full table structure extraction
• Automatic data type mapping (ASCII, Numeric, Date, Overlap)
• Relations declared in the DataFlex files become foreign keys in the SQL files
• Unused record slots (every byte zero) are skipped, and the report says how many

Known Limitations

• DataFlex 2.3 files are refused: re-export them from DataFlex as 3.x
• Indexes (.K* files) are not carried over
• Dates are read as DataFlex documents them: a day number counted from January 0, year 0. No DataFlex file with a date column has been available to check them against, so compare a few dates with your application
• Numbers are checked only in the shape the real table has (four bytes, no decimal places). Decimal places and negative numbers follow the published layout and have not been checked against a real file, so compare a few against your application
• A record that has no value in any field (most likely a deleted one) is kept as an empty row and reported; how DataFlex marks a deleted record has not been checked against a real file
• Memo and text fields kept in .VLD files are read on a best-effort basis: the layout has not been checked against a real file, so check those columns
• Some legacy character encodings may need adjustment
• Very large tables (1M+ rows) may take extended processing time

Note on the Excel formats. An .xlsx sheet holds at most 1,048,575 rows of data and 16,384 columns, and a legacy .xls sheet 65,535 rows and 256 columns. Rather than ship a file that looks complete but is silently cut short, DataMeans leaves a table out of any Excel format it does not fit and notes it in the job report. The .xlsx copy is also left out for tables of more than 8,000,000 cells (1,048,575 rows of 12 columns is 12.6 million), which take too long and too much memory to write, and the .xls copy for tables of more than 150,000 cells, which the legacy format takes far too long to write. The CSV, JSON and SQL outputs always contain every row.

Overview

DataFlex is a fourth-generation language (4GL) and application development platform created by Data Access Corporation (now Data Access Worldwide) for building business database applications. It includes an embedded ISAM-style database engine that stores each table as a group of files sharing a common root name, while the same applications can also run against SQL backends such as Microsoft SQL Server, MySQL, and ODBC-accessible databases. DataFlex emphasizes rapid application development with its object-oriented 4GL, Data Dictionary classes that centralize business rules, and an integrated development environment for creating Windows and web software.

History and Background

• 1976: Data Access Corporation founded in Miami, Florida.
• 1981: DataFlex introduced at the COMDEX trade show as a 4GL for database applications.
• 1982: Initial commercial release; early versions run on CP/M, MS-DOS, TurboDOS, Unix, and VMS.
• 1987: DataFlex 2.3 emphasizes portability, running the same application code across CP/M, MS-DOS, and Unix systems.
• 1991: DataFlex 3.0 released with a modernized interface; variable-length data storage (.VLD files) is introduced.
• 1996: Visual DataFlex 4.0 released as the first Microsoft Windows version.
• 1998: DataFlex 3.2, the final character-mode release; the WebApp Server brings DataFlex applications to the web.
• 2007: Visual DataFlex 12.1 adds CodeJock-based visual controls and Office-style toolbars and menus.
• 2014: Visual DataFlex renamed DataFlex with release 18.0.
• 2017: DataFlex 2017 (19.0) adds JSON parsing support and mobile/web framework enhancements.
• 2019: DataFlex 2019 (19.1) adds an HTTP request handler for building REST and other HTTP services, plus web framework deep linking.
• 2021: DataFlex 2021 (20.0) introduces 64-bit compilation and full Unicode support.
• 2023: DataFlex 2023 (23.0) introduces FlexTron, embedding web controls in Windows desktop applications.
• 2024: DataFlex 2024 (24.0) adds the cWebDrawing vector-drawing web control and encrypted connections between application server nodes.
• 2025: DataFlex 2025 (25.0) adds dashboards, a navigation designer, and a web framework rewritten as ES6 classes.

File Format Specifications

The DataFlex embedded database stores each table as a group of operating-system files that share a common root name.

File Extensions:

• .DAT: Primary data file containing the table header and record data
• .Knn: Index files (.K1, .K2, etc.), one per index, holding key values and record numbers
• .HDR: Optional header-integrity file used to repair a corrupted .DAT header
• .TAG: Text file listing the names of the table's columns, used by the Table Editor and other tools
• .VLD: Variable-length data file used when compression is enabled; the .DAT file then holds pointers into it

File Structure:

• Tables: One table per .DAT file, identified by a common root name
• Indexes: Key values plus record numbers stored in separate .Kn files
• Header: Table definition held in the first 2,776 bytes of the .DAT file
• Records: String, number, and date columns are fixed-length; text and binary columns are variable-length
• Record Allocation: Row lengths are allocated in fixed steps (8–26 bytes, then a fixed series of increasingly spaced values from 28 to 256, then multiples of 128 bytes) up to the 16 KB maximum
• Limits: Up to 255 columns per table, 16,700,000 records per table, and a 16,384-byte maximum record size
• Column Names: Up to 32 characters, beginning with a letter, with underscore as the only punctuation permitted
• Filelist: FILELIST.CFG maps each table's file number, DataFlex name, display name, and physical name

Key Components:

• Embedded Engine: Self-contained table storage requiring no separate database server
• Table Editor: Visual tool for defining tables, columns, and indexes
• Data Dictionaries: Classes that centralize validation rules and business logic
• SQL Drivers: Connectivity for Microsoft SQL Server, IBM Db2, MySQL, and ODBC-accessible databases
• DataPump: Conversion tool that migrates embedded-format tables to SQL Server, MySQL, or PostgreSQL
• WebApp Server: Deployment platform for DataFlex web applications

Data Types and Structures

The DataFlex embedded database supports five physical data types, plus a legacy logical overlap type:

Database Objects:

• Tables: Primary data containers with columns and records
• Indexes: Up to 15 per table, each stored in its own .Kn file, with up to 16 segments per index and a 256-byte maximum key length
• Relationships: Parent-child links between table columns, enforced through Data Dictionaries
• Data Dictionaries: Reusable classes holding validation and business rules for each table
• Filelist Entries: Numbered table registrations used by the compiler and runtime
• Workspaces: Configuration grouping an application's source, data, and filelist locations

Version Differences

Compatibility Notes:

• OEM-format tables are retained for backward compatibility; vendor guidance is to convert them to ANSI/Unicode from DataFlex 2021 (20.0) onward
• The maximum size of a .DAT file was raised from 2 GB to 4 GB in 1999 for DataFlex 3.2 and Visual DataFlex 6
• When compression is enabled, the .DAT file holds only pointers, so .DAT and .VLD files must be kept synchronized in backups
• Overlap columns are obsolete; multi-segment relationships replaced them in DataFlex 11.0
• Later filelist revisions support up to 4,095 table entries, up from 255 in older revisions
• Applications using the embedded database can be moved to SQL backends through DataFlex's SQL drivers

Technical References

• DataFlex Documentation
• Wikipedia: DataFlex
• Logical Structure of a Database File
• DataFlex File Extensions (Database Managers)
• Data Access Worldwide Forums