#include "bind.h"

#include <ctype.h>

#include <string.h>

#include "descriptor.h"

#include "environ.h"

#include "misc.h"

#include "multibyte.h"

#include "opensearch_apifunc.h"

#include "opensearch_types.h"

#include "qresult.h"

#include "statement.h"

RETCODE SQL_API OPENSEARCHAPI_BindCol(HSTMT hstmt, SQLUSMALLINT icol,

SQLSMALLINT fCType, PTR rgbValue,

SQLLEN cbValueMax, SQLLEN *pcbValue) {

StatementClass *stmt = (StatementClass *)hstmt;

CSTR func = "OPENSEARCHAPI_BindCol";

ARDFields *opts;

GetDataInfo *gdata_info;

BindInfoClass *bookmark;

RETCODE ret = SQL_SUCCESS;

MYLOG(OPENSEARCH_TRACE, "entering...\n");

MYLOG(OPENSEARCH_DEBUG, "**** : stmt = %p, icol = %d\n", stmt, icol);

MYLOG(OPENSEARCH_DEBUG, "**** : fCType=%d rgb=%p valusMax=" FORMAT_LEN " pcb=%p\n",

fCType, rgbValue, cbValueMax, pcbValue);

if (!stmt) {

SC_log_error(func, "", NULL);

return SQL_INVALID_HANDLE;

}

opts = SC_get_ARDF(stmt);

if (stmt->status == STMT_EXECUTING) {

SC_set_error(stmt, STMT_SEQUENCE_ERROR,

"Can't bind columns while statement is still executing.",

func);

return SQL_ERROR;

}

#ifdef __APPLE__

#pragma clang diagnostic push

#pragma clang diagnostic ignored "-Wkeyword-macro"

#endif // __APPLE__

#define return DONT_CALL_RETURN_FROM_HERE ? ? ?

#ifdef __APPLE__

#pragma clang diagnostic pop

#endif // __APPLE__

SC_clear_error(stmt);

/* If the bookmark column is being bound, then just save it */

if (icol == 0) {

bookmark = opts->bookmark;

if (rgbValue == NULL) {

if (bookmark) {

bookmark->buffer = NULL;

bookmark->used = bookmark->indicator = NULL;

}

} else {

/* Make sure it is the bookmark data type */

switch (fCType) {

case SQL_C_BOOKMARK:

case SQL_C_VARBOOKMARK:

break;

default:

SC_set_error(stmt, STMT_PROGRAM_TYPE_OUT_OF_RANGE,

"Bind column 0 is not of type SQL_C_BOOKMARK",

func);

MYLOG(

OPENSEARCH_ERROR,

"Bind column 0 is type %d not of type SQL_C_BOOKMARK\n",

fCType);

ret = SQL_ERROR;

goto cleanup;

}

bookmark = ARD_AllocBookmark(opts);

bookmark->buffer = rgbValue;

bookmark->used = bookmark->indicator = pcbValue;

bookmark->buflen = cbValueMax;

bookmark->returntype = fCType;

}

goto cleanup;

}

/*

if (icol > opts->allocated)

extend_column_bindings(opts, icol);

gdata_info = SC_get_GDTI(stmt);

if (icol > gdata_info->allocated)

extend_getdata_info(gdata_info, icol, FALSE);

/* check to see if the bindings were allocated */

if (!opts->bindings || !gdata_info->gdata) {

SC_set_error(stmt, STMT_NO_MEMORY_ERROR,

"Could not allocate memory for bindings.", func);

ret = SQL_ERROR;

goto cleanup;

}

/* use zero based col numbers from here out */

icol--;

/* Reset for SQLGetData */

GETDATA_RESET(gdata_info->gdata[icol]);

if (rgbValue == NULL) {

/* we have to unbind the column */

opts->bindings[icol].buflen = 0;

opts->bindings[icol].buffer = NULL;

opts->bindings[icol].used = opts->bindings[icol].indicator = NULL;

opts->bindings[icol].returntype = SQL_C_CHAR;

opts->bindings[icol].precision = 0;

opts->bindings[icol].scale = 0;

if (gdata_info->gdata[icol].ttlbuf)

free(gdata_info->gdata[icol].ttlbuf);

gdata_info->gdata[icol].ttlbuf = NULL;

gdata_info->gdata[icol].ttlbuflen = 0;

gdata_info->gdata[icol].ttlbufused = 0;

} else {

/* ok, bind that column */

opts->bindings[icol].buflen = cbValueMax;

opts->bindings[icol].buffer = rgbValue;

opts->bindings[icol].used = opts->bindings[icol].indicator = pcbValue;

opts->bindings[icol].returntype = fCType;

opts->bindings[icol].precision = 0;

switch (fCType) {

case SQL_C_NUMERIC:

opts->bindings[icol].precision = 32;

break;

case SQL_C_TIMESTAMP:

case SQL_C_INTERVAL_DAY_TO_SECOND:

case SQL_C_INTERVAL_HOUR_TO_SECOND:

case SQL_C_INTERVAL_MINUTE_TO_SECOND:

case SQL_C_INTERVAL_SECOND:

opts->bindings[icol].precision = 6;

break;

}

opts->bindings[icol].scale = 0;

MYLOG(OPENSEARCH_DEBUG, " bound buffer[%d] = %p\n", icol,

opts->bindings[icol].buffer);

}

cleanup:

#undef return

return ret;

}

RETCODE SQL_API OPENSEARCHAPI_NumParams(HSTMT hstmt, SQLSMALLINT *pcpar) {

StatementClass *stmt = (StatementClass *)hstmt;

if (pcpar != NULL) {

*pcpar = 0;

} else {

SC_set_error(stmt, STMT_EXEC_ERROR, "Parameter count address is null",

"OPENSEARCHAPI_NumParams");

return SQL_ERROR;

}

return SQL_SUCCESS;

}

static BindInfoClass *create_empty_bindings(int num_columns) {

BindInfoClass *new_bindings;

int i;

new_bindings = (BindInfoClass *)malloc(num_columns * sizeof(BindInfoClass));

if (!new_bindings)

return NULL;

for (i = 0; i < num_columns; i++) {

new_bindings[i].buflen = 0;

new_bindings[i].buffer = NULL;

new_bindings[i].used = new_bindings[i].indicator = NULL;

}

return new_bindings;

}

void extend_parameter_bindings(APDFields *self, SQLSMALLINT num_params) {

ParameterInfoClass *new_bindings;

MYLOG(OPENSEARCH_TRACE,

"entering ... self=%p, parameters_allocated=%d, num_params=%d,%p\n",

self, self->allocated, num_params, self->parameters);

/*

if (self->allocated < num_params) {

new_bindings = (ParameterInfoClass *)realloc(

self->parameters, sizeof(ParameterInfoClass) * num_params);

if (!new_bindings) {

MYLOG(OPENSEARCH_DEBUG,

"unable to create %d new bindings from %d old bindings\n",

num_params, self->allocated);

if (self->parameters)

free(self->parameters);

self->parameters = NULL;

self->allocated = 0;

return;

}

memset(&new_bindings[self->allocated], 0,

sizeof(ParameterInfoClass) * (num_params - self->allocated));

self->parameters = new_bindings;

self->allocated = num_params;

}

MYLOG(OPENSEARCH_TRACE, "leaving %p\n", self->parameters);

}

void extend_iparameter_bindings(IPDFields *self, SQLSMALLINT num_params) {

ParameterImplClass *new_bindings;

MYLOG(OPENSEARCH_TRACE,

"entering ... self=%p, parameters_allocated=%d, num_params=%d\n",

self, self->allocated, num_params);

/*

if (self->allocated < num_params) {

new_bindings = (ParameterImplClass *)realloc(

self->parameters, sizeof(ParameterImplClass) * num_params);

if (!new_bindings) {

MYLOG(OPENSEARCH_DEBUG,

"unable to create %d new bindings from %d old bindings\n",

num_params, self->allocated);

if (self->parameters)

free(self->parameters);

self->parameters = NULL;

self->allocated = 0;

return;

}

memset(&new_bindings[self->allocated], 0,

sizeof(ParameterImplClass) * (num_params - self->allocated));

self->parameters = new_bindings;

self->allocated = num_params;

}

MYLOG(OPENSEARCH_TRACE, "leaving %p\n", self->parameters);

}

void reset_a_parameter_binding(APDFields *self, int ipar) {

MYLOG(OPENSEARCH_TRACE, "entering ... self=%p, parameters_allocated=%d, ipar=%d\n",

self, self->allocated, ipar);

if (ipar < 1 || ipar > self->allocated)

return;

ipar--;

self->parameters[ipar].buflen = 0;

self->parameters[ipar].buffer = NULL;

self->parameters[ipar].used = self->parameters[ipar].indicator = NULL;

self->parameters[ipar].CType = 0;

self->parameters[ipar].data_at_exec = FALSE;

self->parameters[ipar].precision = 0;

self->parameters[ipar].scale = 0;

}

void reset_a_iparameter_binding(IPDFields *self, int ipar) {

MYLOG(OPENSEARCH_TRACE, "entering ... self=%p, parameters_allocated=%d, ipar=%d\n",

self, self->allocated, ipar);

if (ipar < 1 || ipar > self->allocated)

return;

ipar--;

NULL_THE_NAME(self->parameters[ipar].paramName);

self->parameters[ipar].paramType = 0;

self->parameters[ipar].SQLType = 0;

self->parameters[ipar].column_size = 0;

self->parameters[ipar].decimal_digits = 0;

self->parameters[ipar].precision = 0;

self->parameters[ipar].scale = 0;

PIC_set_opensearch_type(self->parameters[ipar], 0);

}

int CountParameters(const StatementClass *self, Int2 *inputCount, Int2 *ioCount,

Int2 *outputCount) {

IPDFields *ipdopts = SC_get_IPDF(self);

int i, num_params, valid_count;

if (inputCount)

*inputCount = 0;

if (ioCount)

*ioCount = 0;

if (outputCount)

*outputCount = 0;

if (!ipdopts)

return -1;

num_params = self->num_params;

if (ipdopts->allocated < num_params)

num_params = ipdopts->allocated;

for (i = 0, valid_count = 0; i < num_params; i++) {

if (SQL_PARAM_OUTPUT == ipdopts->parameters[i].paramType) {

if (outputCount) {

(*outputCount)++;

valid_count++;

}

} else if (SQL_PARAM_INPUT_OUTPUT == ipdopts->parameters[i].paramType) {

if (ioCount) {

(*ioCount)++;

valid_count++;

}

} else if (inputCount) {

(*inputCount)++;

valid_count++;

}

}

return valid_count;

}

void APD_free_params(APDFields *apdopts, char option) {

MYLOG(OPENSEARCH_TRACE, "entering self=%p\n", apdopts);

if (!apdopts->parameters)

return;

if (option == STMT_FREE_PARAMS_ALL) {

free(apdopts->parameters);

apdopts->parameters = NULL;

apdopts->allocated = 0;

}

MYLOG(OPENSEARCH_TRACE, "leaving\n");

}

void PDATA_free_params(PutDataInfo *pdata, char option) {

int i;

MYLOG(OPENSEARCH_TRACE, "entering self=%p\n", pdata);

if (!pdata->pdata)

return;

for (i = 0; i < pdata->allocated; i++) {

if (pdata->pdata[i].EXEC_used) {

free(pdata->pdata[i].EXEC_used);

pdata->pdata[i].EXEC_used = NULL;

}

if (pdata->pdata[i].EXEC_buffer) {

free(pdata->pdata[i].EXEC_buffer);

pdata->pdata[i].EXEC_buffer = NULL;

}

}

if (option == STMT_FREE_PARAMS_ALL) {

free(pdata->pdata);

pdata->pdata = NULL;

pdata->allocated = 0;

}

MYLOG(OPENSEARCH_TRACE, "leaving\n");

}

void IPD_free_params(IPDFields *ipdopts, char option) {

MYLOG(OPENSEARCH_TRACE, "entering self=%p\n", ipdopts);

if (!ipdopts->parameters)

return;

if (option == STMT_FREE_PARAMS_ALL) {

free(ipdopts->parameters);

ipdopts->parameters = NULL;

ipdopts->allocated = 0;

}

MYLOG(OPENSEARCH_TRACE, "leaving\n");

}

void extend_column_bindings(ARDFields *self, SQLSMALLINT num_columns) {

BindInfoClass *new_bindings;

SQLSMALLINT i;

MYLOG(OPENSEARCH_TRACE,

"entering ... self=%p, bindings_allocated=%d, num_columns=%d\n", self,

self->allocated, num_columns);

/*

if (self->allocated < num_columns) {

new_bindings = create_empty_bindings(num_columns);

if (!new_bindings) {

MYLOG(OPENSEARCH_DEBUG,

"unable to create %d new bindings from %d old bindings\n",

num_columns, self->allocated);

if (self->bindings) {

free(self->bindings);

self->bindings = NULL;

}

self->allocated = 0;

return;

}

if (self->bindings) {

for (i = 0; i < self->allocated; i++)

new_bindings[i] = self->bindings[i];

free(self->bindings);

}

self->bindings = new_bindings;

self->allocated = num_columns;

}

/*

/* SQLBindCol(1..) ... SQLBindCol(10...) # got 10 bindings */

/* SQLExecDirect(...) # returns 5 cols */

/* SQLExecDirect(...) # returns 10 cols (now OK) */

MYLOG(OPENSEARCH_TRACE, "leaving %p\n", self->bindings);

}

void reset_a_column_binding(ARDFields *self, int icol) {

BindInfoClass *bookmark;

MYLOG(OPENSEARCH_TRACE, "entering ... self=%p, bindings_allocated=%d, icol=%d\n",

self, self->allocated, icol);

if (icol > self->allocated)

return;

/* use zero based col numbers from here out */

if (0 == icol) {

if (bookmark = self->bookmark, bookmark != NULL) {

bookmark->buffer = NULL;

bookmark->used = bookmark->indicator = NULL;

}

} else {

icol--;

/* we have to unbind the column */

self->bindings[icol].buflen = 0;

self->bindings[icol].buffer = NULL;

self->bindings[icol].used = self->bindings[icol].indicator = NULL;

self->bindings[icol].returntype = SQL_C_CHAR;

}

}

void ARD_unbind_cols(ARDFields *self, BOOL freeall) {

Int2 lf;

MYLOG(OPENSEARCH_ALL, "freeall=%d allocated=%d bindings=%p\n", freeall,

self->allocated, self->bindings);

for (lf = 1; lf <= self->allocated; lf++)

reset_a_column_binding(self, lf);

if (freeall) {

if (self->bindings)

free(self->bindings);

self->bindings = NULL;

self->allocated = 0;

}

}

void GDATA_unbind_cols(GetDataInfo *self, BOOL freeall) {

Int2 lf;

MYLOG(OPENSEARCH_ALL, "freeall=%d allocated=%d gdata=%p\n", freeall,

self->allocated, self->gdata);

if (self->fdata.ttlbuf) {

free(self->fdata.ttlbuf);

self->fdata.ttlbuf = NULL;

}

self->fdata.ttlbuflen = self->fdata.ttlbufused = 0;

GETDATA_RESET(self->fdata);

for (lf = 1; lf <= self->allocated; lf++)

reset_a_getdata_info(self, lf);

if (freeall) {

if (self->gdata)

free(self->gdata);

self->gdata = NULL;

self->allocated = 0;

}

}

void GetDataInfoInitialize(GetDataInfo *gdata_info) {

GETDATA_RESET(gdata_info->fdata);

gdata_info->fdata.ttlbuf = NULL;

gdata_info->fdata.ttlbuflen = gdata_info->fdata.ttlbufused = 0;

gdata_info->allocated = 0;

gdata_info->gdata = NULL;

}

static GetDataClass *create_empty_gdata(int num_columns) {

GetDataClass *new_gdata;

int i;

new_gdata = (GetDataClass *)malloc(num_columns * sizeof(GetDataClass));

if (!new_gdata)

return NULL;

for (i = 0; i < num_columns; i++) {

GETDATA_RESET(new_gdata[i]);

new_gdata[i].ttlbuf = NULL;

new_gdata[i].ttlbuflen = 0;

new_gdata[i].ttlbufused = 0;

}

return new_gdata;

}

void extend_getdata_info(GetDataInfo *self, SQLSMALLINT num_columns,

BOOL shrink) {

GetDataClass *new_gdata;

MYLOG(OPENSEARCH_TRACE,

"entering ... self=%p, gdata_allocated=%d, num_columns=%d\n", self,

self->allocated, num_columns);

/*

if (self->allocated < num_columns) {

new_gdata = create_empty_gdata(num_columns);

if (!new_gdata) {

MYLOG(OPENSEARCH_DEBUG, "unable to create %d new gdata from %d old gdata\n",

num_columns, self->allocated);

if (self->gdata) {

free(self->gdata);

self->gdata = NULL;

}

self->allocated = 0;

return;

}

if (self->gdata) {

SQLSMALLINT i;

for (i = 0; i < self->allocated; i++)

new_gdata[i] = self->gdata[i];

free(self->gdata);

}

self->gdata = new_gdata;

self->allocated = num_columns;

} else if (shrink && self->allocated > num_columns) {

int i;

for (i = self->allocated; i > num_columns; i--)

reset_a_getdata_info(self, i);

self->allocated = num_columns;

if (0 == num_columns) {

free(self->gdata);

self->gdata = NULL;

}

}

/*

MYLOG(OPENSEARCH_TRACE, "leaving %p\n", self->gdata);

}

void reset_a_getdata_info(GetDataInfo *gdata_info, int icol) {

if (icol < 1 || icol > gdata_info->allocated)

return;

icol--;

if (gdata_info->gdata[icol].ttlbuf) {

free(gdata_info->gdata[icol].ttlbuf);

gdata_info->gdata[icol].ttlbuf = NULL;

}

gdata_info->gdata[icol].ttlbuflen = gdata_info->gdata[icol].ttlbufused = 0;

GETDATA_RESET(gdata_info->gdata[icol]);

}

void PutDataInfoInitialize(PutDataInfo *pdata_info) {

pdata_info->allocated = 0;

pdata_info->pdata = NULL;

}

void extend_putdata_info(PutDataInfo *self, SQLSMALLINT num_params,

BOOL shrink) {

PutDataClass *new_pdata;

MYLOG(OPENSEARCH_TRACE,

"entering ... self=%p, parameters_allocated=%d, num_params=%d\n",

self, self->allocated, num_params);

/*

if (self->allocated < num_params) {

if (self->allocated <= 0 && self->pdata) {

MYLOG(OPENSEARCH_DEBUG, "??? pdata is not null while allocated == 0\n");

self->pdata = NULL;

}

new_pdata = (PutDataClass *)realloc(self->pdata,

sizeof(PutDataClass) * num_params);

if (!new_pdata) {

MYLOG(OPENSEARCH_DEBUG, "unable to create %d new pdata from %d old pdata\n",

num_params, self->allocated);

self->pdata = NULL;

self->allocated = 0;

return;

}

memset(&new_pdata[self->allocated], 0,

sizeof(PutDataClass) * (num_params - self->allocated));

self->pdata = new_pdata;

self->allocated = num_params;

} else if (shrink && self->allocated > num_params) {

int i;

for (i = self->allocated; i > num_params; i--)

reset_a_putdata_info(self, i);

self->allocated = num_params;

if (0 == num_params) {

free(self->pdata);

self->pdata = NULL;

}

}

MYLOG(OPENSEARCH_TRACE, "leaving %p\n", self->pdata);

}

void reset_a_putdata_info(PutDataInfo *pdata_info, int ipar) {

if (ipar < 1 || ipar > pdata_info->allocated)

return;

ipar--;

if (pdata_info->pdata[ipar].EXEC_used) {

free(pdata_info->pdata[ipar].EXEC_used);

pdata_info->pdata[ipar].EXEC_used = NULL;

}

if (pdata_info->pdata[ipar].EXEC_buffer) {

free(pdata_info->pdata[ipar].EXEC_buffer);

pdata_info->pdata[ipar].EXEC_buffer = NULL;

}

pdata_info->pdata[ipar].lobj_oid = 0;

}

void SC_param_next(const StatementClass *stmt, int *param_number,

ParameterInfoClass **apara, ParameterImplClass **ipara) {

int next;

IPDFields *ipdopts = SC_get_IPDF(stmt);

if (*param_number < 0)

next = stmt->proc_return;

else

next = *param_number + 1;

if (stmt->discard_output_params) {

for (; next < ipdopts->allocated

&& SQL_PARAM_OUTPUT == ipdopts->parameters[next].paramType;

next++)

;

}

*param_number = next;

if (ipara) {

if (next < ipdopts->allocated)

*ipara = ipdopts->parameters + next;

else

*ipara = NULL;

}

if (apara) {

APDFields *apdopts = SC_get_APDF(stmt);

if (next < apdopts->allocated)

*apara = apdopts->parameters + next;

else

*apara = NULL;

}

}