Add the $OmoracleBatchItemSize directive

This directive controls the amount of memory needed for properties in
the batch. Users should specify the largest value they expect in the
statement. As per Rainer's comment:

on MAX_BUFSIZE: I'd tend to make this configurable, because with
RFC5424 messages can be much longer and RFC5425 now recommends a
minimum maximum size of 8K.

So we let users to choose. Maybe we need a sensible default value to
make users' lifes easier?

Also, the old non-vector based interface is not supported anymore. I
broke it already when moving to this stage.

1 files changed, 29 insertions, 17 deletions

diff --git a/plugins/omoracle/omoracle.c b/plugins/omoracle/omoracle.c
index 3a1f141f..d6349d89 100644
--- a/plugins/omoracle/omoracle.c
+++ b/plugins/omoracle/omoracle.c
@@ -21,6 +21,13 @@
     $OmoracleBatchSize: Number of elements to send to the DB on each
     transaction.
 
+    $OmoracleBatchItemSize: Number of characters each property may
+    have. Make it as big as the longest value you expect for *any*
+    property in the sentence. For instance, if you expect 5 arguments
+    to the statement, 4 have 10 bytes and the 5th may be up to 3KB,
+    then specify $OmoracleBatchItemSize 3072. Please, remember to
+    leave space to the trailing \0!!
+
     $OmoracleStatement: Statement to be prepared and executed in
     batches. Please note that Oracle's prepared statements have their
     placeholders as ':identifier', and this module uses the colon to
@@ -89,6 +96,8 @@ struct oracle_batch
 	int n;
 	/* Number of arguments the statement takes */
 	int arguments;
+	/** Maximum size of each parameter */
+	int param_size;
 	/* Parameters to pass to the statement on this transaction */
 	char*** parameters;
 	/* Binding parameters */
@@ -125,12 +134,10 @@ static char* db_user;
 static char* db_password;
 /** Batch size. */
 static int batch_size;
+/** Size of each element in the batch. */
+static int batch_item_size;
 /** Statement to prepare and execute */
 static char* db_statement;
-/** Whether or not the core supports the newer array interface. The
- * module is able to work in both modes, but the newer is the
- * recommended one for performance reasons. */
-static int array_passing;
 
 /** Generic function for handling errors from OCI.
 
@@ -248,8 +255,7 @@ static int prepare_statement(instanceData* pData)
 			 OCIBindByPos(pData->statement,
 				      pData->batch.bindings+i,
 				      pData->error, i+1, NULL,
-				      MAX_BUFSIZE *
-				      sizeof ***pData->batch.parameters,
+				      pData->batch.param_size,
 				      SQLT_STR, NULL, NULL, NULL,
 				      0, 0,  OCI_DATA_AT_EXEC));
 		CHECKERR(pData->error,
@@ -290,6 +296,7 @@ CODESTARTcreateInstance
 
 	pData->batch.n = 0;
 	pData->batch.size = batch_size;
+	pData->batch.param_size = batch_item_size * sizeof ***pData->batch.parameters;
 	pData->batch.arguments = count_bind_parameters(pData->txt_statement);
 
 	/* I know, this can be done with a single malloc() call but this is
@@ -302,15 +309,14 @@ CODESTARTcreateInstance
 						    sizeof **pData->batch.parameters);
 		CHKmalloc(pData->batch.parameters[i]);
 		for (j = 0; j < pData->batch.size; j++) {
-			/* Each entry has at most MAX_BUFSIZE bytes
-			 * because OCI doesn't like null-terminated
-			 * strings when operating with batches, and
-			 * the maximum size of each entry must be
-			 * provided when binding
-			 * parameters. MAX_BUFSIZE is long enough for
-			 * usual entries. */
-			pData->batch.parameters[i][j] = calloc(MAX_BUFSIZE,
-							       sizeof ***pData->batch.parameters);
+			/* Each entry has at most
+			 * pData->batch.param_size bytes because OCI
+			 * doesn't like null-terminated strings when
+			 * operating with batches, and the maximum
+			 * size of each entry must be provided when
+			 * binding parameters. pData->batch.param_size
+			 * is long enough for usual entries. */
+			pData->batch.parameters[i][j] = malloc(pData->batch.param_size);
 			CHKmalloc(pData->batch.parameters[i][j]);
 		}
 	}
@@ -480,7 +486,7 @@ CODESTARTdoAction
 	for (i = 0; i < pData->batch.arguments && params[i]; i++) {
 		dbgprintf("batch[%d][%d]=%s\n", i, pData->batch.n, params[i]);
 		strncpy(pData->batch.parameters[i][pData->batch.n], params[i],
-			MAX_BUFSIZE);
+			pData->batch.param_size);
 		CHKmalloc(pData->batch.parameters[i][pData->batch.n]);
 	}
 	pData->batch.n++;
@@ -520,6 +526,7 @@ resetConfigVariables(uchar __attribute__((unused)) *pp,
 	if (db_statement != NULL)
 		free(db_statement);
 	db_name = db_user = db_password = db_statement = NULL;
+	batch_size = batch_item_size = 0;
 	RETiRet;
 }
 
@@ -549,6 +556,7 @@ CODEmodInit_QueryRegCFSLineHdlr
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "resetconfigvariables", 1,
 				   eCmdHdlrCustomHandler, resetConfigVariables,
 				   NULL, STD_LOADABLE_MODULE_ID));
+
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoracledbuser", 0,
 				   eCmdHdlrGetWord, NULL, &db_user,
 				   STD_LOADABLE_MODULE_ID));
@@ -563,11 +571,15 @@ CODEmodInit_QueryRegCFSLineHdlr
 				   STD_LOADABLE_MODULE_ID));
 	CHKiRet(pHostQueryEtryPt((uchar*)"OMSRgetSupportedTplOpts", &supported_options));
 	CHKiRet((*supported_options)(&opts));
-	if (!(array_passing = opts & OMSR_TPL_AS_ARRAY))
+	if (!(opts & OMSR_TPL_AS_ARRAY))
 		ABORT_FINALIZE(RS_RET_RSCORE_TOO_OLD);
 
 	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclestatement", 0,
 				   eCmdHdlrCustomHandler, get_db_statement,
 				   &db_statement, STD_LOADABLE_MODULE_ID));
 
+	CHKiRet(omsdRegCFSLineHdlr((uchar*) "omoraclebatchitemsize", 0,
+				   eCmdHdlrInt, NULL,
+				   &batch_item_size, STD_LOADABLE_MODULE_ID));
+
 ENDmodInit