Reading and Writing DBF Files

Aspose.Cells provides full support for reading and writing DBF (dBASE) files. You can load existing dBASE III and dBASE IV files into a Workbook object, manipulate the data using the rich Aspose.Cells API, and save the workbook back to the DBF format for use with legacy database applications.

Introduction

DBF (DataBase File) is a legacy database file format originally introduced by dBASE in the early 1980s. Despite the age of the format, DBF files are still widely used in many industries for storing structured data, particularly in accounting, GIS, and other specialized applications. Aspose.Cells allows you to integrate these legacy files into modern C++ spreadsheet workflows seamlessly.

The library supports both reading and writing DBF files, giving you the ability to:

Import data from existing DBF files into Aspose.Cells Workbook objects for further processing or conversion to other formats.
Create new DBF files from scratch or by transforming data from other spreadsheet formats.
Maintain field definitions, data types, and record structures when transferring data in and out of the DBF format.

DBF files can also be opened directly in Microsoft Excel and other spreadsheet applications, making them a convenient bridge between legacy systems and modern spreadsheet tools.

Supported DBF Versions and Features

Aspose.Cells supports the following DBF format versions:

dBASE III — The original and most widely supported variant of the DBF format.
dBASE IV — An extended version that supports additional data types and larger field sizes.

Supported Features

The library provides comprehensive support for the following operations:

Reading DBF data into a Workbook object, with all records and field definitions preserved.
Writing workbook data back to DBF format for export to dBASE-compatible applications.
Handling common data types used in DBF files, including character, numeric, date, and logical fields.
Preserving field definitions such as field name, type, and length during read/write operations.

Limitations and Considerations

When working with DBF files, keep the following constraints in mind:

The maximum number of fields per file is 128.
The maximum record size is 4000 bytes.
Field names are limited to 10 characters, must be uppercase, and cannot contain spaces.
Date values in DBF files are stored in YYYYMMDD format.
Character encoding may vary depending on the source application (commonly Windows-1252 or OEM code pages).

Reading a DBF File

Aspose.Cells makes it straightforward to load data from a DBF file into a Workbook object. The library uses the LoadOptions class to specify the source format, ensuring that the data is interpreted correctly during the loading process.

Reading a DBF File with Aspose.Cells

To read a DBF file, you need to create a LoadOptions instance, set its LoadFormat property to LoadFormat.Dbf, and pass it to the Workbook constructor along with the file path. Once loaded, the data becomes accessible through the Worksheets collection, where you can iterate through cells, extract values, or manipulate the data as needed.

The following example demonstrates how to load an existing DBF file into Aspose.Cells, access its first worksheet, and read the cell values.

#include "Aspose.Cells.h"
#include <string>
#include <iostream>

using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    std::string dataDir = "Data/";
    std::string filePath = dataDir + "example.dbf";

    LoadOptions loadOptions(LoadFormat::Dbf);

    Workbook workbook(U16String(filePath.c_str()), loadOptions);

    Worksheet worksheet = workbook.GetWorksheets().Get(0);

    Cells cells = worksheet.GetCells();

    std::string sb = "";

    int maxRow = cells.GetMaxDataRow();
    int maxCol = cells.GetMaxDataColumn();

    for (int i = 0; i <= maxRow; i++) {
        for (int j = 0; j <= maxCol; j++) {
            Cell cell = cells.Get(i, j);
            U16String value = cell.GetStringValue();
            sb += "|";
            sb += value.ToUtf8();
        }
        sb += "|";
        sb += "\n";
    }

    std::cout << sb << std::endl;

    std::string outputPath = dataDir + "output.xlsx";
    workbook.Save(U16String(outputPath.c_str()), SaveFormat::Xlsx);

    std::cout << "DBF file loaded successfully. Converted XLSX saved at: " << outputPath << std::endl;

    Aspose::Cells::Cleanup();
    return 0;
}

You can open DBF files directly in Microsoft Excel by selecting the file in the Open dialog. Excel will treat the DBF file as a spreadsheet, displaying its records in a tabular layout. This is useful for quickly verifying the data after reading or writing it with Aspose.Cells.

Writing a DBF File

Writing data to a DBF file follows a similar pattern to saving any other spreadsheet format with Aspose.Cells. You create or load a Workbook, populate the worksheet with data, and then call the Save method while specifying SaveFormat.Dbf as the target format.

Writing a DBF File with Aspose.Cells

To create a DBF file, follow these steps:

Create a new Workbook instance.
Access the first worksheet from the Worksheets collection.
Populate the worksheet with your data, including headers in the first row and records in subsequent rows.
Call the Workbook.Save method, passing the file path and SaveFormat.Dbf as parameters.

The following example demonstrates how to create a new DBF file from scratch. It populates a worksheet with sample data containing different data types (strings, numbers, and dates) to illustrate how field types are handled when exporting to the DBF format.

#include "Aspose.Cells.h"
#include <string>
#include <filesystem>

using namespace Aspose::Cells;

int main() {
    Aspose::Cells::Startup();

    std::string outputDir = "C:/Output/";
    std::string filePath = outputDir + "output.dbf";

    if (!std::filesystem::exists(outputDir)) {
        std::filesystem::create_directories(outputDir);
    }

    Workbook workbook;
    Worksheet worksheet = workbook.GetWorksheets().Get(0);
    Cells cells = worksheet.GetCells();

    // Column headers
    cells.Get(0, 0).PutValue(u"ID");
    cells.Get(0, 1).PutValue(u"Name");
    cells.Get(0, 2).PutValue(u"Department");
    cells.Get(0, 3).PutValue(u"Salary");
    cells.Get(0, 4).PutValue(u"HireDate");

    // Data row 1
    cells.Get(1, 0).PutValue(101);
    cells.Get(1, 1).PutValue(u"John Smith");
    cells.Get(1, 2).PutValue(u"Engineering");
    cells.Get(1, 3).PutValue(75000.50);
    Date hireDate1{2020, 3, 15, 0, 0, 0, 0};
    cells.Get(1, 4).PutValue(hireDate1);

    // Data row 2
    cells.Get(2, 0).PutValue(102);
    cells.Get(2, 1).PutValue(u"Jane Doe");
    cells.Get(2, 2).PutValue(u"Marketing");
    cells.Get(2, 3).PutValue(68000.75);
    Date hireDate2{2019, 7, 22, 0, 0, 0, 0};
    cells.Get(2, 4).PutValue(hireDate2);

    // Data row 3
    cells.Get(3, 0).PutValue(103);
    cells.Get(3, 1).PutValue(u"Bob Johnson");
    cells.Get(3, 2).PutValue(u"Finance");
    cells.Get(3, 3).PutValue(82000.00);
    Date hireDate3{2021, 1, 10, 0, 0, 0, 0};
    cells.Get(3, 4).PutValue(hireDate3);

    // Data row 4
    cells.Get(4, 0).PutValue(104);
    cells.Get(4, 1).PutValue(u"Alice Brown");
    cells.Get(4, 2).PutValue(u"Human Resources");
    cells.Get(4, 3).PutValue(71000.25);
    Date hireDate4{2018, 11, 5, 0, 0, 0, 0};
    cells.Get(4, 4).PutValue(hireDate4);

    // Data row 5
    cells.Get(5, 0).PutValue(105);
    cells.Get(5, 1).PutValue(u"Charlie Wilson");
    cells.Get(5, 2).PutValue(u"Operations");
    cells.Get(5, 3).PutValue(79500.80);
    Date hireDate5{2022, 5, 30, 0, 0, 0, 0};
    cells.Get(5, 4).PutValue(hireDate5);

    // Set column widths for better readability
    worksheet.GetCells().SetColumnWidth(0, 8);
    worksheet.GetCells().SetColumnWidth(1, 20);
    worksheet.GetCells().SetColumnWidth(2, 20);
    worksheet.GetCells().SetColumnWidth(3, 12);
    worksheet.GetCells().SetColumnWidth(4, 14);

    workbook.Save(U16String(filePath.c_str()), SaveFormat::Dbf);

    Aspose::Cells::Cleanup();
    return 0;
}

When writing data to a DBF file, ensure that your data conforms to the format’s limitations. Field names should be no longer than 10 characters and should not contain spaces. Records exceeding 4000 bytes in total will not be saved correctly. Dates should be valid date values that can be represented in the YYYYMMDD format.

Data Type and Formatting Considerations

When transferring data between Aspose.Cells and the DBF format, understanding how data types map between the two systems is important for ensuring data integrity.

Cell Types to DBF Field Types

Aspose.Cells cell values are automatically converted to the appropriate DBF field types when saving:

Strings are mapped to character (C) fields.
Numeric values (integers and decimals) are mapped to numeric (N) fields.
Date values are mapped to date (D) fields in YYYYMMDD format.
Boolean values are mapped to logical (L) fields.

Encoding

DBF files may use different character encodings depending on the application that created them. Aspose.Cells handles encoding transparently in most cases, but if you encounter character display issues, you may need to verify the encoding of the source file.

Field Name Rules

DBF field names must adhere to the following rules:

Maximum length of 10 characters.
Must begin with a letter.
Cannot contain spaces or special characters.
Stored as uppercase regardless of the case used in input.

Verifying the Output

After writing a DBF file, you can verify the result by opening it in Microsoft Excel or any dBASE-compatible application. The data should appear in a tabular layout with the field names as column headers, and the records populated according to the data you provided.

Converting Between DBF and Other Formats

One of the most practical use cases for reading and writing DBF files with Aspose.Cells is converting data between the DBF format and modern spreadsheet formats such as XLSX, XLS, or CSV. Since Aspose.Cells supports a wide range of formats, you can easily load a DBF file and re-save it in any other supported format, or vice versa.

For example, you can read a DBF file, apply formatting or calculations using the Aspose.Cells API, and then save the result as an XLSX file for distribution to users who work with modern spreadsheet applications. Conversely, you can take data from an XLSX or CSV file and export it to DBF format for integration with legacy systems.

Convert Excel to CSV, TSV and TXT with C++ Convert Excel to PDF with C++