3 Using TTClasses

Example 3-1 Definition of a Connection Class

This is an example of a class that inherits its functionality from TTConnection.

class XYZConnection : public TTConnection {
private:
  TTCmd updateData;
  TTCmd insertData;
  TTCmd queryData;

public:
  XYZConnection();
  ~XYZConnection();
  virtual void Connect (const char* connStr,TTStatus&);
  void updateUser (TTStatus&);
  void addUser (char* nameP, TTStatus&);
  void queryUser (const char* nameP, int* valueP,
                  TTStatus&);
};

In the preceding example, an XYZConnection object is a connection to TimesTen that can be used to perform three application-specific operations: addUser(), updateUser(), and queryUser(). These operations are specific to the application (storing account balances, for example). The implementation of these three methods can use updateData(), insertData(), and queryData() provided in TTCmd to implement the specific functionality of the application.

To cause the SQL statements used by the application to be prepared, the XYZConnection class overloads the Connect() method provided by the TTConnection base class. The XYZConnection::Connect() method will call the Connect() method of the base class to establish the database connection, and also calls the Prepare() method for each TTCmd object to cause the SQL statements to be prepared for later use.

Example 3-2 Definition of a Connect() method

This example shows the XYZConnection::Connect() method.

void
XYZConnection::Connect(const char* connStr, TTStatus&
                       stat)
{
  TTStatus stat2;

  try {
    TTConnection::Connect(connStr, stat);
    updateData.Prepare(this,
                       "update mydata v
                       "set foo = ? where bar = ?",
                       stat);
    insertData.Prepare(this, 
                       "insert into mydata "
                       "values(?,0)", stat);
    queryData.Prepare(this,
                     "select i from mydata where name "
                     " = ?", stat);
    Commit(stat);
  }
  catch (TTStatus st) {
    cerr << "Error in XYZConnection::Connect: " << st
         << endl;
    Rollback(stat2);
  }
  return;
}

This Connect() method causes the XYZConnection to be made fully operational. The application-specific methods are fully functional after Connect() has been called.

This approach to application design works well with the design of the TTConnectionPool class. The application can create numerous objects of type XYZConnection and can add them to TTConnectionPool. By calling TTConnectionPool::ConnectAll(), the application can cause all connections in the pool to be connected to the database, as well as causing all SQL statements to be prepared, in a single line of code.

This approach to application design allows the database components of an application to be separated from the remainder of the application; only the XYZConnection class contains database-specific code.

An example of this type of design can be found in several of the sample programs that are included with TTClasses. The simplest example is sample.cpp.

Note that other configurations are possible. Some customers have extended this scheme further, so that SQL statements to be used in an application are listed in a table in the database, rather than being hard-coded in the application itself. This allows changes to database functionality to be implemented by making database changes rather than application changes.

Example 3-3 Printing TTClasses log information

ofstream output;
output.open("/tmp/ttclasses.log");
TTGlobal::setLogStream(output);
TTGlobal::setLogLevel(TTLog::TTLOG_WARN);

First-time users of TTClasses should spend a little time experimenting with TTClasses logging. You can change the sample.cpp program to use different log levels so you can see how errors are printed at log level ERROR and how huge amounts of logs are generated at log levels INFO and DEBUG.

See "TTGlobal" for more information about using the TTGlobal class for logging.