OCI_HashEntry * OCI_API OCI_HashLookup
(
OCI_HashTable *table,
const mtext *key,
boolean create
)
{
OCI_HashEntry *e = NULL, *e1 = NULL, *e2 = NULL;
unsigned int i;
OCI_CHECK_PTR(OCI_IPC_HASHTABLE, table, NULL);
OCI_CHECK_PTR(OCI_IPC_STRING, key, NULL);
i = OCI_HashCompute(table, key);
if (i < table->size)
{
for(e = table->items[i]; e != NULL; e = e->next)
{
if (mtscasecmp(e->key, key) == 0)
{
break;
}
}
if ((e == NULL) && (create == TRUE))
{
e = (OCI_HashEntry *) OCI_MemAlloc(OCI_IPC_HASHENTRY, sizeof(*e), (size_t) 1, TRUE);
if (e != NULL)
{
e->key = mtsdup(key);
e1 = e2 = table->items[i];
while (e1 != NULL)
{
e2 = e1;
e1 = e1->next;
}
if (e2 != NULL)
{
e2->next = e;
}
else
{
table->items[i] = e;
}
}
}
}
OCI_RESULT(e != NULL);
return e;
}
boolean OCI_HashAdd
(
OCI_HashTable *table,
const mtext *key,
OCI_Variant value,
unsigned int type
)
{
OCI_HashEntry * e = NULL;
OCI_HashValue * v = NULL, *v1 = NULL, *v2 = NULL;
OCI_CHECK(table == NULL, FALSE);
OCI_CHECK(key == NULL, FALSE);
OCI_CHECK(table->type != type, FALSE);
e = OCI_HashLookup(table, key, TRUE);
if (e != NULL)
{
v = (OCI_HashValue *) OCI_MemAlloc(OCI_IPC_HASHVALUE, sizeof(*v), (size_t) 1, TRUE);
if (v != NULL)
{
if (table->type == OCI_HASH_STRING && value.p_mtext != NULL)
{
v->value.p_mtext = mtsdup(value.p_mtext);
}
else if (table->type == OCI_HASH_INTEGER)
{
v->value.num = value.num;
}
else
{
v->value.p_void = value.p_void;
}
v1 = v2 = e->values;
while (v1 != NULL)
{
v2 = v1;
v1 = v1->next;
}
if (v2 != NULL)
{
v2->next = v;
}
else
{
e->values = v;
}
}
}
return (v != NULL);
}
OCI_Dequeue * OCI_API OCI_DequeueCreate
(
OCI_TypeInfo *typinf,
const mtext *name
)
{
OCI_Dequeue *dequeue = NULL;
boolean res = TRUE;
OCI_CHECK_INITIALIZED(NULL);
OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
OCI_CHECK_PTR(OCI_IPC_STRING, name, NULL);
/* allocate dequeue structure */
dequeue = (OCI_Dequeue *) OCI_MemAlloc(OCI_IPC_DEQUEUE, sizeof(*dequeue), (size_t) 1, TRUE);
if (dequeue != NULL)
{
dequeue->typinf = typinf;
dequeue->name = mtsdup(name);
/* allocate dequeue options descriptor */
res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid * ) dequeue->typinf->con->env,
(dvoid **) &dequeue->opth,
OCI_DTYPE_AQDEQ_OPTIONS,
(size_t) 0, (dvoid **) NULL));
/* create local message for OCI_DequeueGet() */
if (res == TRUE)
{
dequeue->msg = OCI_MsgCreate(dequeue->typinf);
}
res = (dequeue->msg != NULL);
}
else
{
res = FALSE;
}
/* check for failure */
if (res == FALSE)
{
OCI_DequeueFree(dequeue);
dequeue = NULL;
}
return dequeue;
}
OCI_Enqueue * OCI_API OCI_EnqueueCreate
(
OCI_Library *pOCILib,
OCI_TypeInfo *typinf,
const mtext *name
)
{
OCI_Enqueue *enqueue = NULL;
boolean res = TRUE;
OCI_CHECK_INITIALIZED2(pOCILib, NULL);
OCI_CHECK_PTR(pOCILib, OCI_IPC_TYPE_INFO, typinf, NULL);
OCI_CHECK_PTR(pOCILib, OCI_IPC_STRING, name, NULL);
/* allocate enqueue structure */
enqueue = (OCI_Enqueue *) OCI_MemAlloc2(pOCILib, OCI_IPC_ENQUEUE, sizeof(*enqueue), (size_t) 1, TRUE);
if (enqueue != NULL)
{
//printd(5, "OCI_EnqueueCreate() NAME> %s\n", name);
enqueue->typinf = typinf;
enqueue->name = mtsdup(pOCILib, name);
//printd(5, "OCI_EnqueueCreate() NAME2> %s; %p\n", enqueue->name, enqueue->typinf);
/* allocate enqueue options descriptor */
res = (OCI_SUCCESS == OCI_DescriptorAlloc2(pOCILib, (dvoid * ) pOCILib->env,
(dvoid **) &enqueue->opth,
OCI_DTYPE_AQENQ_OPTIONS,
(size_t) 0, (dvoid **) NULL));
//printd(5, "OCI_EnqueueCreate() RES=%d (%d)\n", res, FALSE);
}
else
{
res = FALSE;
}
/* check for failure */
if (res == FALSE)
{
OCI_EnqueueFree(pOCILib, enqueue);
enqueue = NULL;
}
return enqueue;
}
OCI_TypeInfo * OCI_API OCI_TypeInfoGet2(OCI_Library *pOCILib, OCI_Connection *con, const mtext *name,
unsigned int type, ExceptionSink* xsink)
{
OCI_TypeInfo *typinf = NULL;
OCI_Item *item = NULL;
OCIDescribe *dschp = NULL;
OCIParam *parmh1 = NULL;
OCIParam *parmh2 = NULL;
mtext *str = NULL;
//int etype = OCI_DESC_COLUMN;
int ptype = 0;
ub1 item_type = 0;
ub4 attr_type = 0;
ub4 num_type = 0;
boolean res = TRUE;
boolean found = FALSE;
ub2 i;
mtext obj_schema[OCI_SIZE_OBJ_NAME+1];
mtext obj_name[OCI_SIZE_OBJ_NAME+1];
OCI_CHECK_INITIALIZED2(pOCILib, NULL);
OCI_CHECK_PTRQ(pOCILib, OCI_IPC_CONNECTION, con, NULL, xsink);
OCI_CHECK_PTRQ(pOCILib, OCI_IPC_STRING, name, NULL, xsink);
if (type == OCI_TIF_TABLE)
item_type = OCI_PTYPE_TABLE;
else if (type == OCI_TIF_VIEW)
item_type = OCI_PTYPE_VIEW;
else if (type == OCI_TIF_TYPE)
item_type = OCI_PTYPE_TYPE;
else
return NULL;
obj_schema[0] = 0;
obj_name[0] = 0;
/* is the schema provided in the object name ? */
for (str = (mtext *) name; *str != 0; str++)
{
if (*str == MT('.'))
{
mtsncat(obj_schema, name, str-name);
mtsncat(obj_name, ++str, (size_t) OCI_SIZE_OBJ_NAME);
break;
}
}
/* if the schema is not provided, we just copy the object name */
if (obj_name[0] == 0)
{
mtsncat(obj_name, name, (size_t) OCI_SIZE_OBJ_NAME);
}
/* type name must be uppercase */
for (str = obj_name; *str != 0; str++)
*str = (mtext) mttoupper(*str);
/* schema name must be uppercase */
for (str = obj_schema; *str != 0; str++)
*str = (mtext) mttoupper(*str);
/* first try to find it in list */
item = con->tinfs->head;
/* walk along the list to find the type */
while (item != NULL)
{
typinf = (OCI_TypeInfo *) item->data;
if ((typinf != NULL) && (typinf->type == type))
{
if ((mtscasecmp(typinf->name, obj_name ) == 0) &&
(mtscasecmp(typinf->schema, obj_schema) == 0))
{
found = TRUE;
break;
}
}
item = item->next;
}
/* Not found, so create type object */
if (found == FALSE)
{
item = OCI_ListAppend(pOCILib, con->tinfs, sizeof(OCI_TypeInfo));
res = (item != NULL);
if (res == TRUE)
{
typinf = (OCI_TypeInfo *) item->data;
typinf->type = type;
typinf->con = con;
typinf->name = mtsdup(pOCILib, obj_name);
typinf->schema = mtsdup(pOCILib, obj_schema);
typinf->struct_size = 0;
res = (OCI_SUCCESS == OCI_HandleAlloc2(pOCILib, pOCILib->env,
(dvoid **) (void *) &dschp,
OCI_HTYPE_DESCRIBE, (size_t) 0,
(dvoid **) NULL));
}
if (res == TRUE)
{
if (type == OCI_TIF_TYPE)
{
void *ostr1 = NULL;
void *ostr2 = NULL;
int osize1 = -1;
int osize2 = -1;
attr_type = OCI_ATTR_LIST_TYPE_ATTRS;
num_type = OCI_ATTR_NUM_TYPE_ATTRS;
ptype = OCI_DESC_TYPE;
ostr1 = OCI_GetInputMetaString(pOCILib, typinf->schema, &osize1);
ostr2 = OCI_GetInputMetaString(pOCILib, typinf->name, &osize2);
OCI_CALL2Q
(
pOCILib, res, con,
OCITypeByName(pOCILib->env, con->err, con->cxt,
(text *) ostr1, (ub4) osize1,
(text *) ostr2, (ub4) osize2,
(text *) NULL, (ub4) 0,
OCI_DURATION_SESSION, OCI_TYPEGET_ALL,
&typinf->tdo),
xsink
)
OCI_CALL2Q
(
pOCILib, res, con,
OCIDescribeAny(con->cxt, con->err, (void *) typinf->tdo,
0, OCI_OTYPE_PTR, OCI_DEFAULT,
OCI_PTYPE_TYPE, dschp),
xsink
)
OCI_ReleaseMetaString(ostr1);
OCI_ReleaseMetaString(ostr2);
}
else
{
mtext buffer[(OCI_SIZE_OBJ_NAME*2) + 2];
size_t size = sizeof(buffer)/sizeof(mtext);
void *ostr1 = NULL;
int osize1 = -1;
attr_type = OCI_ATTR_LIST_COLUMNS;
num_type = OCI_ATTR_NUM_COLS;
ptype = OCI_DESC_TABLE;
str = buffer;
str[0] = 0;
if ((typinf->schema != NULL) && (typinf->schema[0] != 0))
{
str = mtsncat(buffer, typinf->schema, size);
size -= mtslen(typinf->schema);
str = mtsncat(str, MT("."), size);
size -= (size_t) 1;
}
mtsncat(str, typinf->name, size);
ostr1 = OCI_GetInputMetaString(pOCILib, str, &osize1);
OCI_CALL2Q
(
pOCILib, res, con,
OCIDescribeAny(con->cxt, con->err, (dvoid *) ostr1,
(ub4) osize1, OCI_OTYPE_NAME,
OCI_DEFAULT, item_type, dschp),
xsink
)
OCI_ReleaseMetaString(ostr1);
}
OCI_CALL2Q
(
pOCILib, res, con,
OCIAttrGet(dschp, OCI_HTYPE_DESCRIBE, &parmh1,
NULL, OCI_ATTR_PARAM, con->err),
xsink
)
/* do we need get more attributes for collections ? */
if (type == OCI_TIF_TYPE)
{
OCI_CALL2Q
(
pOCILib, res, con,
OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->tcode,
NULL, OCI_ATTR_TYPECODE, con->err),
xsink
)
}
if (typinf->tcode == SQLT_NCO)
{
typinf->nb_cols = 1;
ptype = OCI_DESC_COLLECTION;
//etype = OCI_DESC_TYPE;
parmh2 = parmh1;
OCI_CALL2Q
(
pOCILib, res, con,
OCIAttrGet(parmh1, OCI_DTYPE_PARAM, &typinf->ccode,
NULL, OCI_ATTR_COLLECTION_TYPECODE, con->err),
xsink
)
}
else
{
OCI_Pool * OCI_API OCI_PoolCreate
(
const mtext *db,
const mtext *user,
const mtext *pwd,
unsigned int type,
unsigned int mode,
unsigned int min_con,
unsigned int max_con,
unsigned int incr_con
)
{
OCI_Pool *pool = NULL;
OCI_Item *item = NULL;
boolean res = TRUE;
OCI_CHECK_MIN(NULL, NULL, max_con, 1, NULL);
/* let's be sure OCI_Initialize() has been called */
OCI_CHECK_INITIALIZED(NULL);
/* make sure that we do not have a XA session flag */
mode &= ~OCI_SESSION_XA;
/* create pool object */
item = OCI_ListAppend(OCILib.pools, sizeof(*pool));
if (item != NULL)
{
pool = (OCI_Pool *) item->data;
/* create internal lists */
pool->cons = OCI_ListCreate(OCI_IPC_CONNECTION);
if (OCI_LIB_THREADED)
{
/* create mutex for OCI_PoolGetConnection() */
pool->mutex = OCI_MutexCreateInternal();
res = (pool->mutex != NULL);
}
}
else
{
res = FALSE;
}
/* set attributes */
if (res == TRUE)
{
pool->mode = mode;
pool->min = min_con;
pool->max = max_con;
pool->incr = incr_con;
pool->db = mtsdup(db != NULL ? db : MT(""));
pool->user = mtsdup(user != NULL ? user : MT(""));
pool->pwd = mtsdup(pwd != NULL ? pwd : MT(""));
}
#if OCI_VERSION_COMPILE < OCI_9_2
type = OCI_POOL_CONNECTION;
#endif
#if OCI_VERSION_COMPILE >= OCI_9_0
if (res == TRUE)
{
if (type == OCI_POOL_CONNECTION)
{
pool->htype = OCI_HTYPE_CPOOL;
}
#if OCI_VERSION_COMPILE >= OCI_9_2
else
{
pool->htype = OCI_HTYPE_SPOOL;
}
#endif
}
if (OCILib.version_runtime >= OCI_9_0)
{
int osize_name = -1;
int osize_db = -1;
void *ostr_name = NULL;
void *ostr_db = NULL;
/* allocate error handle */
if (res == TRUE)
{
res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env,
(dvoid **) (void *) &pool->err,
(ub4) OCI_HTYPE_ERROR,
(size_t) 0,
(dvoid **) NULL));
}
/* allocate pool handle */
if (res == TRUE)
{
res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env,
(dvoid **) (void *) &pool->handle,
(ub4) pool->htype,
(size_t) 0,
(dvoid **) NULL));
}
/* allocate authentification handle only if needed */
#if OCI_VERSION_COMPILE >= OCI_11_1
if (res == TRUE)
{
if ((pool->htype == OCI_HTYPE_SPOOL) && (OCILib.version_runtime >= OCI_11_1))
{
int osize = -1;
void *ostr = OCI_GetInputMetaString(OCILIB_DRIVER_NAME, &osize);
/* allocate authentification handle */
res = (OCI_SUCCESS == OCI_HandleAlloc((dvoid *) OCILib.env,
(dvoid **) (void *) &pool->authp,
(ub4) OCI_HTYPE_AUTHINFO,
(size_t) 0,
(dvoid **) NULL));
/* set OCILIB's driver layer name attribute only for session pools here
For standalone connections and connection pool this attribute is set
in OCI_ConnectionLogon() */
OCI_CALL3
(
res, pool->err,
OCIAttrSet((dvoid *) pool->authp, (ub4) OCI_HTYPE_AUTHINFO,
(dvoid *) ostr, (ub4) osize,
(ub4) OCI_ATTR_DRIVER_NAME, pool->err)
)
OCI_ReleaseMetaString(ostr);
/* set auth handle on the session pool */
OCI_CALL3
(
res, pool->err,
OCIAttrSet((dvoid *) pool->handle, (ub4) OCI_HTYPE_SPOOL,
(dvoid *) pool->authp, (ub4) sizeof(pool->authp),
(ub4) OCI_ATTR_SPOOL_AUTH, pool->err)
)
}
}