RFC C++ Interface

I know it's been a while since we last discussed a possible rewrite of
the C++ API but I now have some time to devote to it.

The following are my ideas for implementing the C++ API:

I need suggestions, additions, comments etc!

All classes will be defined in postgres namespace.

The desired usage would be as follows

//create a database object
postgres::db = database("host = somewhere.com user=someone
password=something dbname=mydb");

//synchronous connection returns TRUE upon success FALSE upon error
if( db.connect() ) {
string sql("SELECT * FROM foo");
postgres::result res = db.exec(sql);

if( !res.error() ) {
int numrows = res.numrows(); //used to obtain number of rows returned
//by previous sql statement
int numcols = res.numcols(); //used to obtain number of columns
//returned by previous sql statement
int field1;
char field2[size],field3[size];
long field4;

//results can be obtained within a for loop using numrows, numcols or as
//below
while( res.getrow() ) { //increment row

//result object has insert operator and array operator overloaded
res >> field1 >> field2; //result object will return datatypes not
//just chars
field3 = res[0];
field4 = res["fieldname"];
// .. do something with values ..
}

}
else {
cerr << res.display_error();
}

}
else {
cerr << db.display_error();
}

Alternatively one could access db asynchronously

//create a database object
postgres::db = database("host = somewhere.com user=someone
password=something dbname=mydb");

db.setasync(); //set asyncrhonous conection with back-end
//setsync does the opposite
while( !db.connect() && !db.error() ) {

//..do something

}
if( db.error() ) {
cerr << db.display_error();
exit(1);
}

string sql("SELECT * FROM foo");
postgres::result res = db.exec(sql);

while( !res.ready() && !res.error() ) {

//..do something

}

One could also set exceptions with

//create a database object
postgres::db = database("host = somewhere.com user=someone
password=something dbname=mydb");

db.setexception();

try {

db.connect();
string sql("SELECT * FROM foo");
postgres::result res = db.exec(sql);

}
catch( postgres::error& err ) {

//..do something
cerr << err.display_error();
}

The above examples make use of embedded sql being passed to the db object
via a string object. ( exec will be overloaded to accept a const char * as well).
I also envision a higher level which might prove usefull.

//create a database object
postgres::db = database("host = somewhere.com user=someone
password=something dbname=mydb");

postgres::table mytable = db.gettable("tablename");
//table can now be queried about characteristics of table
uint64_t numcols = mytable.numcols(); //need to find the max values and return an appropriate type
uint64_t numrows = mytable.numrows();
size_t colsize = mytable.colsize("column");

//obtain an inserter

postgres::inserter myinsert mytable.getinsert();
inserter.setcolumn("colname");

ifstream infile;
infile.open("myfile");
char data[32];

while (infile.getline(line,sizeof(data),'\t')) {
inserter << data;
}

the above can be extended to include update and delete functions as well

postgres::updater myupdate mytable.getupdate();
myupdate.setcolumn("colname");
myupdate.setcond("WHERE something = something");

ifstream infile;
infile.open("myfile");
char data[32];

while (infile.getline(line,sizeof(data),'\t')) {
myupdate << data;
}

Randy Jonasz
Software Engineer
Click2net Inc.
Web: http://www.click2net.com
Phone: (905) 271-3550

"You cannot possibly pay a philosopher what he's worth,
but try your best" -- Aristotle