The Symphony.dB namespace provide powerful relational database capabilities to your existing business applications.  Using the Symphony.dB namespace you can easily migrate your existing ISAM file based data access routines to powerful relational database management capabilities. The Symphony.dB namespace also provides you with powerful data-replication capabilities.

Symphony.dB supports PostgreSQL, Microsoft SQL Server, MySQL and Oracle databases.  Symphony.dB is also royalty free.

To easily replace your ISAM file based access with Symphny.dB to manage your data in one of the supported relational databases you can use the following as a guide.  RCP Consultants can assist with your migration from ISAM to relational database data management.

The Symphony.dB environment uses code-generated structure specific database management routines to map the data from your application "record" area to column based structured data.  Once these have been created you can utilise them to enable your application to manage the data in your chosen database.

The first step is to create an instance of the Symphony.dB DBAccess class. 

    database = new DBAccess("example", "DBMANAGER:DatabaseManager")

To open the "data table" as you would an ISAM file, use the OpenUpdate() or OpenInput() methods;

    error_flag = database.OpenUpdate(channel)

for update mode, or;

    error_flag = database.OpenInput(channel)

For input mode.  Once the "table" has been opened then you can manage the data within the table.  To read the data you can perform various functions, for example;

    error_flag = database.Find(keyValue, D_PRIMARY)
    error_flag = database.ReadFirst(keyOfRef, dataArea)
    error_flag = database.Read(keyValue, keyOfRef, dataArea)

You can store and update data in the table;

    error_flag = database.Store(dataArea)
    error_flag = database.Write(dataArea)

And to delete data from the table;

    error_flag = database.Delete()

The same rules apply as when processing data in an ISAM file - you must, for example, read a record from the table before you can update (Write()) or delete (Delete()) it.  The same "No-Current-Record" errors will be returned if not.

In addition to the standard ISAM style operations you can also query the database using Select style operations.  To perform a "select" query you could use the following example;

    itemDatabase = new dbAccess("item", "DBMANAGER:DatabaseManager")
    itemWhereClause = new WheredB()
    itemWhereClause.Add("code", WheredBConditions.StartsWith, %atrim(code_filters.code_filter))
    itemOrderBy = new OrderBydB("code")
    foreach itemAsString in itemDatabase.Select("code, description, status, def_source_type", itemWhereClause, itemOrderBy)
    begin
        item_list = itemAsString
    end

If your application uses generic file handling routines to access your flat ISAM data files the Symphony.dB framework provides a number of methods that can be used to easily migrate that code to accessing data in a relational database.  You can also migrate files one at a time without the need to convert the entire application database.

For example you can modify your generic "file open" routine to check for a specific fie and manage the data in the database for the file;

    if (%instr(1, internalFileName, "USERID.ISM"))
    begin
        ;;we are using PostgreSQL so let's open the table on the the file!
        error = Symphony.dB.DBAccess.GenericFileOpen(chan, file, mode)
        xreturn
    end

Now your "channel" references a database table and not a flat ISAM file you can perform the required operations on the data.  The generic routine used to read data, for example, could be changed as such;

    ;;Check if we are accessing data from a database
    if (Symphony.dB.DBAccess.GenericDBCheck(channel))
    begin
        keyNumber = 0
        if (^passed(key_no)) then
            ;;use the passed key number
            keyNumber = key_no
        else
            ;;find the key number given the key value
            keyNumber = Symphony.dB.DBAccess.GenericFileKeyCheck(channel, ^argtype(key), ^size(key))
        ;;read the "row" from the database
        err = Symphony.dB.DBAccess.GenericFileRead(channel, key, keyNumber, record)
        xreturn
    end

To store data, use;

    ;;Check if we are accessing data from a database
     if (Symphony.dB.DBAccess.GenericDBCheck(channel))
    begin
    
        ;;store the record data to the database table.
        error = Symphony.dB.DBAccess.GenericFileStore(channel, record)
        xreturn
    end

To update data use;

    ;;Check if we are accessing data from a database
    if (Symphony.dB.DBAccess.GenericDBCheck(channel))
    begin
        if(%passed(err))clear err
        error_no = Symphony.dB.DBAccess.GenericFileWrite(channel, record)
        if(%passed(err)) err = error_no
        xreturn
    end

and to delete data from the database table use;

    ;;check to see if this "Channel" is a database channel and not an ISAM channel
    if (Symphony.dB.DBAccess.GenericDBCheck(channel))
    begin
        err = Symphony.dB.DBAccess.GenericFileDelete(channel)
        xreturn
    end

The application code which uses your generic file processing routines does not need to change and continues to process the data in the same way.