A favor to ask of any C-OCI programmer to prove a DBMS bug....

Question

I am looking for someone good and kind enough to write a C+OCI
program that does this trivial thing:
Make a connection, prepare a statement for execution, with no
parameters, simply to execute "TRUNCATE TABLE MYTABLE".
Then the program should execute the statement. Then, it should
print out to stdout "TRUNCATED MYTABLE. Press <enter> to repeat",
and read stdin until it gets the newline, and then executes the
statement again.
This program will demonstrate the failure of the DBMS-client
contract. The user will start a SQL-PLUS session and create
that table, and insert rows (and commit). Then, in another
window, the user will start this C program, which will truncate
the table, and wait for further input. Then the user will verify
from SQL-plus that the table has been truncated. Then the
user use SQL-PLUS to add more rows to the table, and commit.
Then the user will press <ENTER> at the C program, making it
re-execute the TRUNCATE statement (apparently successfully)
and exit. The user should then see in SQL-PLUS that the second
batch of rows are still there.
Joe

Answer 1

Hi Joe,
I'm not sure I would call this a database bug, rather it seems more like a documentation bug/omission. In fact, the issue is correctly identified in the 11g OCI docs for the OCIStmtPrepare function:
http://download.oracle.com/docs/cd/B28359_01/appdev.111/b28395/oci17msc001.htm#i575144
In particular:
Before re-executing a DDL statement, call this function a second time.
It looks like the designed behavior is to ignore subsequent invocations of DDL without calling OCIStmtPrepare as a server round-trip does not appear to take place. So what you are seeing may not be the desired behavior, but it appears to be the expected behavior.
For example, a tkprof of the scenario you describe shows:
truncate table mytable
call     count       cpu    elapsed       disk      query    current        rows
Parse        1      0.00       0.00          0          0          0           0
Execute      1      0.00       0.01          0         57         13           0
Fetch        0      0.00       0.00          0          0          0           0
total        2      0.00       0.01          0         57         13           0Having said that, here's a (very) basic bit of OCI code to illustrate this...
DISCLAIMER(s): I am not an OCI programmer. I am a DBA and I sometimes live in the .NET world. This is very basic and contains bad practices such as hard-coding and no error checking.
#ifdef WIN32
#define _CRT_SECURE_NO_DEPRECATE 1
#endif
#include <stdio.h>
#include <string.h>
#include <oci.h>
int main (int argc, char *argv[])
  OCIEnv      *envhp = NULL;  /* OCI Environment handle     */
  OCIError    *errhp = NULL;  /* OCI Error handle           */
  OCISvcCtx   *svchp = NULL;  /* OCI Service Context handle */
  OCIServer   *srvhp = NULL;  /* OCI Server handle          */
  OCISession  *usrhp = NULL;  /* OCI User Session handle    */
  OCIStmt     *stmtp = NULL;  /* OCI Statement handle       */
  /* connection information */
  oratext *username = "scott";
  oratext *password = "tiger";
  oratext *database = "otndemo";
  /* the sql statement to execute */
  oratext *sqlstmt = "truncate table mytable";
  /* used to hold the results of each OCI call */
  sword result = 0; 
  /* used to hold input */
  char buf[80];
  /* Initialize and create a default environment  */ 
  result = OCIEnvCreate(&envhp, OCI_DEFAULT, (void *) 0, 0, 0, 0, (size_t) 0, (void **) 0);
  /* allocate an error handle */
  result = OCIHandleAlloc((void *) envhp, (void **) &errhp, OCI_HTYPE_ERROR, 0, (void **) 0);
  /* allocate a service context handle */
  result = OCIHandleAlloc((void *) envhp, (void **) &svchp, OCI_HTYPE_SVCCTX, 0, (void **) 0);
  /* allocate a server handle */
  result = OCIHandleAlloc((void *) envhp, (void **) &srvhp, OCI_HTYPE_SERVER, 0, (void **) 0);
  /* allocate a user session handle */
  result = OCIHandleAlloc((void *) envhp, (void **) &usrhp, OCI_HTYPE_SESSION, 0, (void **) 0);
  /* set user name attribute in user session handle */
  result = OCIAttrSet((void *) usrhp, OCI_HTYPE_SESSION, (void *) username, (ub4) strlen(username), OCI_ATTR_USERNAME, errhp);
  /* set password attribute in user session handle */
  result = OCIAttrSet((void *) usrhp, OCI_HTYPE_SESSION, (void *) password, (ub4) strlen(password), OCI_ATTR_PASSWORD, errhp);
  /* create a server context using the specified database */
  result = OCIServerAttach(srvhp, errhp, database , (sb4) strlen(database), OCI_DEFAULT);
  /* set the server attribute in the service context handle */
  result = OCIAttrSet((void *) svchp, OCI_HTYPE_SVCCTX, (void *) srvhp, (ub4) 0, OCI_ATTR_SERVER, errhp);
  /* open the session with the database */
  result = OCISessionBegin(svchp, errhp, usrhp, OCI_CRED_RDBMS, OCI_DEFAULT);
  /* set the user session attribute in the service context handle */
  result = OCIAttrSet((void *) svchp, OCI_HTYPE_SVCCTX, (void *) usrhp, (ub4) 0, OCI_ATTR_SESSION, errhp);
  /* allocate the statement handle */
  result = OCIHandleAlloc((void *) envhp, (void **) &stmtp, OCI_HTYPE_STMT, 0, (void **) 0);
  /* prepare the statement for execution */
  result = OCIStmtPrepare(stmtp, errhp, sqlstmt, (ub4) strlen((char *) sqlstmt), OCI_NTV_SYNTAX, OCI_DEFAULT);
  /* execute the statement */
  result = OCIStmtExecute(svchp, stmtp, errhp, (ub4) 1, (ub4) 0, (CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
  /* print prompt line to console window */
  (void) printf("TRUNCATED MYTABLE. Press <enter> to repeat ");
  /* not safe, but as this is a controlled test, it is a known item */
  (void) gets(buf);
  /* NOTE: preparing the statement again is required for DDL to work correctly */
  /* comment the following line to illustrate that ddl is not re-executed */
  result = OCIStmtPrepare(stmtp, errhp, sqlstmt, (ub4) strlen((char *) sqlstmt), OCI_NTV_SYNTAX, OCI_DEFAULT);
  /* execute the statement again */
  result = OCIStmtExecute(svchp, stmtp, errhp, (ub4) 1, (ub4) 0, (CONST OCISnapshot *) NULL, (OCISnapshot *) NULL, OCI_DEFAULT);
  /* free statement handle */
  result = OCIHandleFree((void *) stmtp, OCI_HTYPE_STMT);
  /* terminate the session with the database */
  result = OCISessionEnd(svchp, errhp, usrhp, OCI_DEFAULT);
  /* detach from the server */
  result = OCIServerDetach(srvhp, errhp, OCI_DEFAULT);
  /* deallocate the environment handle     */
  /* OCI will deallocate the child handles */
  result = OCIHandleFree((void *) envhp, OCI_HTYPE_ENV);
  return OCI_SUCCESS;
}Perhaps Jonah or Prajith will also see this thread and have a comment. They are both more well-versed in OCI than I...
Regards,
Mark
[EDIT]
Small edit for clarification on documentation link.