c-treeDB Does Java the Record-Oriented Way

Relational databases were a standard solution long before Java was created in the Sun laboratories. Leveraging this technology was an easy choice at that time and JDBC became the de facto standard for many, if not most, data environments.

As with most “one-size-fits-all” solutions, a fully relational approach may not always be the most appropriate choice. This first surfaced in the object-relational dilemma, which was addressed with the persistence layer. (Expect exciting news about the way c‑treeACE will integrate into this soon!)

Currently, the “NoSQL” movement has shown alternatives are welcome advances to these long existing standards. Some of these recent non-relational alternatives also have a Java API. So what about c‑treeACE and Java?

c‑treeDB

When FairCom introduced a standard SQL interface incorporating c‑treeACE core technology, it was clear that an intermediate relational interface would be desirable. This standard interface was named c‑treeDB, referring to “c-treeACE database.” Concepts such as sessions, databases, tables, and fields, common to the relational world but nearly nonexistent in the ISAM world, were added and this became a new easy-to-use standard for record-oriented (ISAM) programming with c‑treeACE. Besides the popular C/C++ c‑treeDB interfaces, two other APIs were added based on c‑treeDB concepts: VCL for Delphi/CBuilder and a complete .NET assembly written in C#.

FairCom has long realized the importance of this interface for Java, and c‑treeDB Java now introduces this to the Java community. If you are familiar with c‑treeDB in any of the other languages, you will find it very easy and straightforward to incorporate c‑treeDB Java. If you are already familiar with Java and require database access, it is very likely that you use JDBC.

Example

The sample code below demonstrates the same program (c‑treeACE customer master tutorial 3) when using these different APIs. JDBC is presented for those familiar with Java’s JDBC, c‑treeDB C++ for those experienced with c‑treeACE, and the new c‑treeDB Java.

In each example, we perform an initialization, the table definition, searches and updates.

c‑treeACE SQL JDBC

static Connection conn;

static Statement stmt;

/* load the driver */

Class.forName ("ctree.jdbc.ctreeDriver");

/* connect to server */

conn = DriverManager.getConnection

 ("jdbc:ctree:6597@localhost:ctreeSQL", "ADMIN", "ADMIN");

/* disable commit after each single SQL statement */

conn.setAutoCommit(false);

/* create a statement handle */

stmt = conn.createStatement();

/* Table creation */

stmt.executeUpdate("CREATE TABLE custmast (" +

"custnumb CHAR(4), custname CHAR(47), " +

"custcity CHAR(47))" );

// index definition

stmt.executeUpdate("CREATE UNIQUE INDEX custnumb_idx ON custmast (custnumb)");

/* add records */

stmt.executeUpdate("INSERT INTO custmast VALUES " +

"'1000', 'Bryan Williams', 'Orange'");

/* persist record */

conn.commit();

/* find and modify a record */

stmt.executeUpdate("UPDATE custmast SET custname = " +

"'BRYAN WILLIAMS' where custnumb = '1000'");

conn.commit();

c‑treeDB C++

CTSession   *MySession = (CTSession *)0;

CTTable     *MyTable = (CTTable *)0;

CTRecord    *MyRecord = (CTRecord *)0;  /* defined as global variables */

/* Initialization: */

MySession = new CTSession(CTSESSION_CTREE);

MyTable =  new CTTable(MySession);

MyRecord =  new CTRecord(MyTable);

MySession->Logon("FAIRCOMS", "", "");

/* Table creation */

CTField field1 = MyTable->AddField("custnumb", CT_FSTRING, 4);

MyTable->AddField("custname", CT_STRING, 47);

MyTable->AddField("custcity", CT_STRING, 47);

// define index

CTIndex index1 = MyTable->AddIndex("custnumb_idx", CTINDEX_FIXED, NO, NO);

index1.AddSegment(field1, CTSEG_SCHSEG);

// create table

MyTable->Create("custmast", CTCREATE_NORMAL);

// open table

MyTable->Open("custmast", CTOPEN_NORMAL);

// add records

MyRecord->SetFieldAsString(0, "1000");

MyRecord->SetFieldAsString("custame", "Bryan Williams");

MyRecord->SetFieldAsString(2, "Orange");

// persist record

recordCustMast.Write();

// find and modify record

MySession->Lock(CTLOCK_WRITE_BLOCK);

MyRecord->Clear();

MyRecord->SetFieldAsString(0, "1000");

// find record by customer number

if (MyRecord->Find(CTFIND_EQ)) {

     MyRecord->SetFieldAsString(1, "BRYAN WILLIAMS");

     // rewrite record

     MyRecord->Write();

}

MySession->Unlock();

c‑treeDB Java

static CTSession MySession;

static CTTable MyTable;

static CTRecord MyRecord;   /* main java class properties */

/* Initialization: */

MySession = new CTSession(SESSION_TYPE.CTREE);

MyTable = new CTTable(MySession);

MyRecord = new CTRecord(MyTable);

MySession.Logon("FAIRCOMS", "", "");

/* Table creation */

CTField field1 = MyTable.AddField("mt_custnumb", FIELD_TYPE.CHARS, 4);

MyTable.AddField("mt_custname", FIELD_TYPE.VARCHAR, 47);

MyTable.AddField("mt_custcity", FIELD_TYPE.VARCHAR, 47);

// index definition

CTIndex index1 = MyTable.AddIndex("mt_custnumb_idx", KEY_TYPE.FIXED_INDEX, false, false);

index1.AddSegment(field1, SEG_MODE.SCHSEG);

// table creation

MyTable.Create("custmast", CREATE_MODE.NORMAL);

// open table

MyTable.Open("custmast", OPEN_MODE.NORMAL);

// add records

MyRecord.SetFieldAsString(0, "1000");

MyRecord.SetFieldAsString("custame", "Bryan Williams");

MyRecord.SetFieldAsString(2, "Orange");

// persist record

MyRecord.Write();

// find and modify a record

MySession.Lock(LOCK_MODE.WRITE_BLOCK);

MyRecord.Clear();

MyRecord.SetFieldAsString(0, "1000");

// find record by customer number

if (MyRecord.Find(FIND_MODE.EQUAL)) {

     MyRecord.SetFieldAsString(1, "BRYAN WILLIAMS");

     // rewrite record

     MyRecord.Write();

}

MySession.Unlock();

c‑treeDB Java looks a lot like c‑treeDB.NET! Indeed, these APIs are nearly kissing cousins of each other. FairCom has endeavored to keep as true to the Java environment as possible, retaining all of the c‑treeDB concepts and features.

Note: A complete set of all four tutorials is provided with c‑treeACE for each of the three APIs, as well as for many other supported APIs, both SQL and record-oriented.

Performance over SQL Models

If your application requires ultimate control of how your data is handled and Java is your language, you will not find a better approach than c‑treeDB Java. Imagine taking a general JDBC application and solving database bottlenecks (especially those related to input and data positioning/navigation) with a few simple low-level commands. That is the performance gain offered by c‑treeDB Java.

In a recent test, a thin layer on top of c‑treeDB Java was enough to reduce the CPU usage from 80% to 20% and provide a higher data throughput than a leading RDBMS system, running on IBM P6 hardware.

As always with c‑treeACE, you can mix and match both APIs – SQL and record-oriented – in the same application, over the same set of data. However, you are responsible at the application level to maintain relational aspects of the database from record-oriented handling when using the c‑treeDB Java API.

There are multiple use cases for non-relational databases. If your solution is already based on c‑treeACE and you need non-relational access to your data via Java, or if you’re developing new Java applications requiring a solid efficient database that is better performing than a relational engine, c‑treeDB Java may be your choice.

Contact your nearest FairCom office and talk to us about your specific needs, and let one of our experts work with you directly for how to best incorporate c‑treeACE technology into your next big project.

See Also

• https://www.faircom.com/doc/jtdb/overview-summary.html
• Oracle’s Java Site