OCILIB (C Driver for Oracle) 3.9.2
D:/Perso/dev/ocilib/ocilib/src/dequeue.c
00001 /*
00002     +-----------------------------------------------------------------------------------------+
00003     |                                                                                         |
00004     |                               OCILIB - C Driver for Oracle                              |
00005     |                                                                                         |
00006     |                                (C Wrapper for Oracle OCI)                               |
00007     |                                                                                         |
00008     |                              Website : http://www.ocilib.net                            |
00009     |                                                                                         |
00010     |             Copyright (c) 2007-2011 Vincent ROGIER <vince.rogier@ocilib.net>            |
00011     |                                                                                         |
00012     +-----------------------------------------------------------------------------------------+
00013     |                                                                                         |
00014     |             This library is free software; you can redistribute it and/or               |
00015     |             modify it under the terms of the GNU Lesser General Public                  |
00016     |             License as published by the Free Software Foundation; either                |
00017     |             version 2 of the License, or (at your option) any later version.            |
00018     |                                                                                         |
00019     |             This library is distributed in the hope that it will be useful,             |
00020     |             but WITHOUT ANY WARRANTY; without even the implied warranty of              |
00021     |             MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU           |
00022     |             Lesser General Public License for more details.                             |
00023     |                                                                                         |
00024     |             You should have received a copy of the GNU Lesser General Public            |
00025     |             License along with this library; if not, write to the Free                  |
00026     |             Software Foundation, Inc., 675 Mass Ave, Cambridge, MA 02139, USA.          |
00027     |                                                                                         |
00028     +-----------------------------------------------------------------------------------------+
00029 */
00030 
00031 /* --------------------------------------------------------------------------------------------- *
00032  * $Id: dequeue.c, v 3.9.2 2011-07-13 00:00 Vincent Rogier $
00033  * --------------------------------------------------------------------------------------------- */
00034 
00035 #include "ocilib_internal.h"
00036 
00037 /* ********************************************************************************************* *
00038  *                            PUBLIC FUNCTIONS
00039  * ********************************************************************************************* */
00040 
00041 /* --------------------------------------------------------------------------------------------- *
00042  * OCI_DequeueCreate
00043  * --------------------------------------------------------------------------------------------- */
00044 
00045 OCI_Dequeue * OCI_API OCI_DequeueCreate
00046 (
00047     OCI_TypeInfo *typinf,
00048     const mtext  *name
00049 )
00050 {
00051     OCI_Dequeue *dequeue = NULL;
00052     boolean res          = TRUE;
00053 
00054     OCI_CHECK_INITIALIZED(NULL);
00055 
00056     OCI_CHECK_PTR(OCI_IPC_TYPE_INFO, typinf, NULL);
00057     OCI_CHECK_PTR(OCI_IPC_STRING, name, NULL);
00058 
00059     /* allocate dequeue structure */
00060 
00061     dequeue = (OCI_Dequeue *) OCI_MemAlloc(OCI_IPC_DEQUEUE, sizeof(*dequeue), (size_t) 1, TRUE);
00062 
00063     if (dequeue != NULL)
00064     {
00065         dequeue->typinf = typinf;
00066         dequeue->name   = mtsdup(name);
00067 
00068         /* allocate dequeue options descriptor */
00069 
00070         res = (OCI_SUCCESS == OCI_DescriptorAlloc((dvoid * ) dequeue->typinf->con->env,
00071                                                   (dvoid **) &dequeue->opth,
00072                                                   OCI_DTYPE_AQDEQ_OPTIONS,
00073                                                   (size_t) 0, (dvoid **) NULL));
00074 
00075         /* create local message for OCI_DequeueGet() */
00076 
00077         if (res == TRUE)
00078         {
00079             dequeue->msg = OCI_MsgCreate(dequeue->typinf);
00080         }
00081 
00082         res = (dequeue->msg != NULL);
00083     }
00084     else
00085     {
00086         res = FALSE;
00087     }
00088 
00089     /* check for failure */
00090 
00091     if (res == FALSE)
00092     {
00093         OCI_DequeueFree(dequeue);
00094         dequeue = NULL;
00095     }
00096 
00097     return dequeue;
00098 }
00099 
00100 /* --------------------------------------------------------------------------------------------- *
00101  * OCI_DequeueFree
00102  * --------------------------------------------------------------------------------------------- */
00103 
00104 boolean OCI_API OCI_DequeueFree
00105 (
00106     OCI_Dequeue *dequeue
00107 )
00108 {
00109     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00110 
00111     /* free local message  */
00112 
00113     if (dequeue->msg != NULL)
00114     {
00115         OCI_MsgFree(dequeue->msg);
00116     }
00117 
00118     /* free local agent  */
00119 
00120     if (dequeue->agent != NULL)
00121     {
00122         OCI_AgentFree(dequeue->agent);
00123     }
00124 
00125     /* free OCI descriptor */
00126 
00127     OCI_DescriptorFree((dvoid *) dequeue->opth, OCI_DTYPE_AQDEQ_OPTIONS);
00128 
00129     /* free strings  */
00130 
00131     OCI_FREE(dequeue->name);
00132     OCI_FREE(dequeue->pattern);
00133     OCI_FREE(dequeue->consumer);
00134 
00135     /* free misc. */
00136 
00137     OCI_FREE(dequeue->agent_list);
00138 
00139     OCI_FREE(dequeue);
00140 
00141     return TRUE;
00142 }
00143 
00144 /* --------------------------------------------------------------------------------------------- *
00145  * OCI_DequeueListen
00146  * --------------------------------------------------------------------------------------------- */
00147 
00148 OCI_Agent * OCI_API OCI_DequeueListen
00149 (
00150     OCI_Dequeue *dequeue,
00151     int          timeout
00152 )
00153 {
00154     boolean res        = TRUE;
00155     OCI_Agent *agent   = NULL;
00156     OCIAQAgent *handle = NULL;
00157 
00158     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00159 
00160     /* listen only if OCI_DequeueSetAgentList has been called */
00161 
00162     if (dequeue->agent_list != NULL)
00163     {
00164         sword ret;
00165         sb4 code;
00166 
00167         ret =  OCIAQListen(dequeue->typinf->con->cxt, dequeue->typinf->con->err,
00168                            dequeue->agent_list, (ub4) dequeue->agent_count,
00169                            (sb4) timeout, &handle, OCI_DEFAULT);
00170 
00171         /* check returned error code */
00172 
00173         if (ret == OCI_ERROR)
00174         {
00175             OCIErrorGet((dvoid *) dequeue->typinf->con->err, (ub4) 1,
00176                         (OraText *) NULL, &code, (OraText *) NULL, (ub4) 0,
00177                         (ub4) OCI_HTYPE_ERROR);
00178 
00179             /* raise error only if the call has not been timed out */
00180 
00181             if (code != OCI_ERR_AQ_LISTEN_TIMEOUT)
00182             {
00183                 OCI_ExceptionOCI(dequeue->typinf->con->err, dequeue->typinf->con, NULL, FALSE);
00184 
00185                 res = FALSE;
00186             }
00187         }
00188 
00189         /* init local agent object */
00190 
00191         if ((res == TRUE) && (ret == OCI_SUCCESS) && (handle != NULL))
00192         {
00193             agent = OCI_AgentInit(dequeue->typinf->con, &dequeue->agent, handle, NULL, NULL);
00194         }
00195     }
00196 
00197     OCI_RESULT(res);
00198 
00199     return agent;
00200 }
00201 
00202 /* --------------------------------------------------------------------------------------------- *
00203  * OCI_DequeueGet
00204  * --------------------------------------------------------------------------------------------- */
00205 
00206 OCI_Msg * OCI_API OCI_DequeueGet
00207 (
00208     OCI_Dequeue *dequeue
00209 )
00210 {
00211     boolean   res      = TRUE;
00212     void     *ostr     = NULL;
00213     int       osize    = -1;
00214     OCI_Msg  *msg      = NULL;
00215     sword     ret      = OCI_SUCCESS;
00216     void     *p_ind    = NULL;
00217 
00218     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00219 
00220     /* reset message */
00221 
00222     res = OCI_MsgReset(dequeue->msg);
00223 
00224     if (res == TRUE)
00225     {
00226         ostr  = OCI_GetInputMetaString(dequeue->name, &osize);
00227 
00228         if (dequeue->typinf->tcode == OCI_UNKNOWN)
00229         {
00230             p_ind = &dequeue->msg->ind;
00231         }
00232 
00233         /* dequeue message */
00234 
00235         ret = OCIAQDeq(dequeue->typinf->con->cxt, dequeue->typinf->con->err,
00236                        ostr, dequeue->opth, dequeue->msg->proph, dequeue->typinf->tdo,
00237                        &dequeue->msg->payload, (void **) &p_ind, &dequeue->msg->id, OCI_DEFAULT);
00238 
00239         OCI_ReleaseMetaString(ostr);
00240 
00241         /* check returned error code */
00242 
00243         if (ret == OCI_ERROR)
00244         {
00245             sb4 code = 0;
00246 
00247             OCIErrorGet((dvoid *) dequeue->typinf->con->err, (ub4) 1,
00248                         (OraText *) NULL, &code, (OraText *) NULL, (ub4) 0,
00249                         (ub4) OCI_HTYPE_ERROR);
00250 
00251             /* raise error only if the call has not been timed out */
00252 
00253             if (code != OCI_ERR_AQ_DEQUEUE_TIMEOUT)
00254             {
00255                 OCI_ExceptionOCI(dequeue->typinf->con->err, dequeue->typinf->con, NULL, FALSE);
00256 
00257                 res = FALSE;
00258             }
00259         }
00260     }
00261 
00262     /* reset message */
00263 
00264     if ((res == TRUE) && (ret == OCI_SUCCESS))
00265     {
00266         /* get payload */
00267 
00268         if (dequeue->typinf->tcode != OCI_UNKNOWN)
00269         {
00270             if ((p_ind != NULL) && ((*(OCIInd *) p_ind) != OCI_IND_NULL))
00271             {
00272                 dequeue->msg->ind = *(OCIInd *) p_ind;
00273 
00274                 dequeue->msg->obj = OCI_ObjectInit(dequeue->typinf->con,
00275                                                    (OCI_Object **) &dequeue->msg->obj,
00276                                                    dequeue->msg->payload, dequeue->typinf,
00277                                                    NULL, -1, TRUE);
00278 
00279                 res = dequeue->msg->obj != NULL;
00280             }
00281         }
00282     }
00283 
00284     /* on success return internla message handle */
00285 
00286     if ((res == TRUE) && (ret == OCI_SUCCESS))
00287     {
00288         msg = dequeue->msg;
00289     }
00290 
00291     OCI_RESULT(res);
00292 
00293     return msg;
00294 }
00295 
00296 /* --------------------------------------------------------------------------------------------- *
00297  * OCI_DequeueGetConsumerName
00298  * --------------------------------------------------------------------------------------------- */
00299 
00300 const mtext * OCI_API OCI_DequeueGetConsumer
00301 (
00302     OCI_Dequeue *dequeue
00303 )
00304 {
00305     boolean res = TRUE;
00306 
00307     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00308 
00309     if (dequeue->consumer == NULL)
00310     {
00311         res = OCI_StringGetFromAttrHandle(dequeue->typinf->con,
00312                                           dequeue->opth,
00313                                           OCI_DTYPE_AQDEQ_OPTIONS,
00314                                           OCI_ATTR_CONSUMER_NAME,
00315                                           &dequeue->consumer);
00316     }
00317 
00318     OCI_RESULT(res);
00319 
00320     return dequeue->consumer;
00321 }
00322 
00323 /* --------------------------------------------------------------------------------------------- *
00324  * OCI_DequeueSetConsumerName
00325  * --------------------------------------------------------------------------------------------- */
00326 
00327 boolean OCI_API OCI_DequeueSetConsumer
00328 (
00329     OCI_Dequeue *dequeue,
00330     const mtext *consumer
00331 )
00332 {
00333     boolean res = TRUE;
00334 
00335     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00336 
00337     res =  OCI_StringSetToAttrHandle(dequeue->typinf->con,
00338                                      dequeue->opth,
00339                                      OCI_DTYPE_AQDEQ_OPTIONS,
00340                                      OCI_ATTR_CONSUMER_NAME,
00341                                      &dequeue->consumer,
00342                                      consumer);
00343 
00344     OCI_RESULT(res);
00345 
00346     return res;
00347 }
00348 
00349 /* --------------------------------------------------------------------------------------------- *
00350  * OCI_DequeueGetCorrelation
00351  * --------------------------------------------------------------------------------------------- */
00352 
00353 const mtext * OCI_API OCI_DequeueGetCorrelation
00354 (
00355     OCI_Dequeue *dequeue
00356 )
00357 {
00358     boolean res = TRUE;
00359 
00360     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, NULL);
00361 
00362     if (dequeue->pattern == NULL)
00363     {
00364         res = OCI_StringGetFromAttrHandle(dequeue->typinf->con,
00365                                           dequeue->opth,
00366                                           OCI_DTYPE_AQDEQ_OPTIONS,
00367                                           OCI_ATTR_CORRELATION,
00368                                           &dequeue->pattern);
00369     }
00370 
00371     OCI_RESULT(res);
00372 
00373     return dequeue->pattern;
00374 }
00375 
00376 /* --------------------------------------------------------------------------------------------- *
00377  * OCI_DequeueSetCorrelation
00378  * --------------------------------------------------------------------------------------------- */
00379 
00380 boolean OCI_API OCI_DequeueSetCorrelation
00381 (
00382     OCI_Dequeue *dequeue,
00383     const mtext *pattern
00384 )
00385 {
00386     boolean res = TRUE;
00387 
00388     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00389 
00390     res =  OCI_StringSetToAttrHandle(dequeue->typinf->con,
00391                                      dequeue->opth,
00392                                      OCI_DTYPE_AQDEQ_OPTIONS,
00393                                      OCI_ATTR_CORRELATION,
00394                                      &dequeue->pattern,
00395                                      pattern);
00396 
00397     OCI_RESULT(res);
00398 
00399     return res;
00400 }
00401 
00402 /* --------------------------------------------------------------------------------------------- *
00403  * OCI_DequeueGetRelativeMsgID
00404  * --------------------------------------------------------------------------------------------- */
00405 
00406 boolean OCI_API OCI_DequeueGetRelativeMsgID
00407 (
00408     OCI_Dequeue  *dequeue,
00409     void         *id,
00410     unsigned int *len
00411 )
00412 {
00413     boolean res   = TRUE;
00414     OCIRaw *value = NULL;
00415 
00416     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00417     OCI_CHECK_PTR(OCI_IPC_VOID,    id,      FALSE);
00418     OCI_CHECK_PTR(OCI_IPC_VOID,    len,     FALSE);
00419 
00420     OCI_CALL2
00421     (
00422         res, dequeue->typinf->con,
00423 
00424         OCIAttrGet((dvoid *) dequeue->opth,
00425                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00426                    (dvoid *) &value,
00427                    (ub4   *) NULL,
00428                    (ub4    ) OCI_ATTR_DEQ_MSGID,
00429                    dequeue->typinf->con->err)
00430     )
00431 
00432     if (value != NULL)
00433     {
00434         ub4 raw_len = 0;
00435 
00436         raw_len = OCIRawSize(dequeue->typinf->con->env, value);
00437 
00438         if (*len > raw_len)
00439             *len = raw_len;
00440 
00441         memcpy(id, OCIRawPtr(dequeue->typinf->con->env, value), (size_t) (*len));
00442     }
00443     else
00444     {
00445         *len = 0;
00446     }
00447 
00448     OCI_RESULT(res);
00449 
00450     return res;
00451 }
00452 
00453 /* --------------------------------------------------------------------------------------------- *
00454  * OCI_DequeueSetRelativeMsgID
00455  * --------------------------------------------------------------------------------------------- */
00456 
00457 boolean OCI_API OCI_DequeueSetRelativeMsgID
00458 (
00459     OCI_Dequeue  *dequeue,
00460     const void   *id,
00461     unsigned int  len
00462 )
00463 {
00464     boolean res   = TRUE;
00465     OCIRaw *value = NULL;
00466 
00467     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00468 
00469     OCI_CALL2
00470     (
00471         res, dequeue->typinf->con,
00472 
00473         OCIRawAssignBytes(dequeue->typinf->con->env, dequeue->typinf->con->err,
00474                           (ub1*) id, (ub4) len, (OCIRaw **) &value)
00475     )
00476 
00477     OCI_CALL2
00478     (
00479         res, dequeue->typinf->con,
00480 
00481         OCIAttrSet((dvoid *) dequeue->opth,
00482                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00483                    (dvoid *) &value,
00484                    (ub4    ) 0,
00485                    (ub4    ) OCI_ATTR_DEQ_MSGID,
00486                    dequeue->typinf->con->err)
00487     )
00488 
00489     OCI_RESULT(res);
00490 
00491     return res;
00492 }
00493 
00494 /* --------------------------------------------------------------------------------------------- *
00495  * OCI_DequeueGetVisibility
00496  * --------------------------------------------------------------------------------------------- */
00497 
00498 unsigned int OCI_API OCI_DequeueGetVisibility
00499 (
00500     OCI_Dequeue *dequeue
00501 )
00502 {
00503     boolean res = TRUE;
00504     ub4 ret     = 0;
00505 
00506     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00507 
00508     OCI_CALL2
00509     (
00510         res, dequeue->typinf->con,
00511 
00512         OCIAttrGet((dvoid *) dequeue->opth,
00513                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00514                    (dvoid *) &ret,
00515                    (ub4   *) NULL,
00516                    (ub4    ) OCI_ATTR_VISIBILITY,
00517                    dequeue->typinf->con->err)
00518     )
00519 
00520     OCI_RESULT(res);
00521 
00522     return (int) ret;
00523 }
00524 
00525 /* --------------------------------------------------------------------------------------------- *
00526  * OCI_DequeueSetVisibility
00527  * --------------------------------------------------------------------------------------------- */
00528 
00529 boolean OCI_API OCI_DequeueSetVisibility
00530 (
00531     OCI_Dequeue *dequeue,
00532     unsigned int visibility
00533 )
00534 {
00535     boolean res = TRUE;
00536     ub4 value   = (ub4) visibility;
00537 
00538     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00539 
00540     OCI_CALL2
00541     (
00542         res, dequeue->typinf->con,
00543 
00544         OCIAttrSet((dvoid *) dequeue->opth,
00545                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00546                    (dvoid *) &value,
00547                    (ub4    ) 0,
00548                    (ub4    ) OCI_ATTR_VISIBILITY,
00549                    dequeue->typinf->con->err)
00550     )
00551 
00552     OCI_RESULT(res);
00553 
00554     return res;
00555 }
00556 
00557 /* --------------------------------------------------------------------------------------------- *
00558  * OCI_DequeueGetMode
00559  * --------------------------------------------------------------------------------------------- */
00560 
00561 unsigned int OCI_API OCI_DequeueGetMode
00562 (
00563     OCI_Dequeue *dequeue
00564 )
00565 {
00566     boolean res = TRUE;
00567     ub4 ret     = 0;
00568 
00569     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00570 
00571     OCI_CALL2
00572     (
00573         res, dequeue->typinf->con,
00574 
00575         OCIAttrGet((dvoid *) dequeue->opth,
00576                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00577                    (dvoid *) &ret,
00578                    (ub4   *) NULL,
00579                    (ub4    ) OCI_ATTR_DEQ_MODE,
00580                    dequeue->typinf->con->err)
00581     )
00582 
00583     OCI_RESULT(res);
00584 
00585     return (int) ret;
00586 }
00587 
00588 /* --------------------------------------------------------------------------------------------- *
00589  * OCI_DequeueSetMode
00590  * --------------------------------------------------------------------------------------------- */
00591 
00592 boolean OCI_API OCI_DequeueSetMode
00593 (
00594     OCI_Dequeue *dequeue,
00595     unsigned int mode
00596 )
00597 {
00598     boolean res = TRUE;
00599     ub4 value   = (ub4) mode;
00600 
00601     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00602 
00603     OCI_CALL2
00604     (
00605         res, dequeue->typinf->con,
00606 
00607         OCIAttrSet((dvoid *) dequeue->opth,
00608                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00609                    (dvoid *) &value,
00610                    (ub4    ) 0,
00611                    (ub4    ) OCI_ATTR_DEQ_MODE,
00612                    dequeue->typinf->con->err)
00613     )
00614 
00615     OCI_RESULT(res);
00616 
00617     return res;
00618 }
00619 
00620 /* --------------------------------------------------------------------------------------------- *
00621  * OCI_DequeueGetNavigation
00622  * --------------------------------------------------------------------------------------------- */
00623 
00624 unsigned int OCI_API OCI_DequeueGetNavigation
00625 (
00626     OCI_Dequeue *dequeue
00627 )
00628 {
00629     boolean res = TRUE;
00630     ub4 ret     = 0;
00631 
00632     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00633 
00634     OCI_CALL2
00635     (
00636         res, dequeue->typinf->con,
00637 
00638         OCIAttrGet((dvoid *) dequeue->opth,
00639                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00640                    (dvoid *) &ret,
00641                    (ub4   *) NULL,
00642                    (ub4    ) OCI_ATTR_NAVIGATION,
00643                    dequeue->typinf->con->err)
00644     )
00645 
00646     OCI_RESULT(res);
00647 
00648     return (int) ret;
00649 }
00650 
00651 /* --------------------------------------------------------------------------------------------- *
00652  * OCI_DequeueSetNavigation
00653  * --------------------------------------------------------------------------------------------- */
00654 
00655 boolean OCI_API OCI_DequeueSetNavigation
00656 (
00657     OCI_Dequeue *dequeue,
00658     unsigned int position
00659 )
00660 {
00661     boolean res = TRUE;
00662     ub4 value   = (ub4) position;
00663 
00664     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00665 
00666     OCI_CALL2
00667     (
00668         res, dequeue->typinf->con,
00669 
00670         OCIAttrSet((dvoid *) dequeue->opth,
00671                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00672                    (dvoid *) &value,
00673                    (ub4    ) 0,
00674                    (ub4    ) OCI_ATTR_NAVIGATION,
00675                    dequeue->typinf->con->err)
00676     )
00677 
00678     OCI_RESULT(res);
00679 
00680     return res;
00681 }
00682 
00683 /* --------------------------------------------------------------------------------------------- *
00684  * OCI_DequeueGetWaitTime
00685  * --------------------------------------------------------------------------------------------- */
00686 
00687 int OCI_API OCI_DequeueGetWaitTime
00688 (
00689     OCI_Dequeue *dequeue
00690 )
00691 {
00692     boolean res = TRUE;
00693     sb4 ret     = 0;
00694 
00695     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, 0);
00696 
00697     OCI_CALL2
00698     (
00699         res, dequeue->typinf->con,
00700 
00701         OCIAttrGet((dvoid *) dequeue->opth,
00702                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00703                    (dvoid *) &ret,
00704                    (ub4   *) NULL,
00705                    (ub4    )  OCI_ATTR_WAIT,
00706                    dequeue->typinf->con->err)
00707     )
00708 
00709     OCI_RESULT(res);
00710 
00711     return (int) ret;
00712 }
00713 
00714 /* --------------------------------------------------------------------------------------------- *
00715  * OCI_DequeueSetWaitTime
00716  * --------------------------------------------------------------------------------------------- */
00717 
00718 boolean OCI_API OCI_DequeueSetWaitTime
00719 (
00720     OCI_Dequeue *dequeue,
00721     int          timeout
00722 )
00723 {
00724     boolean res = TRUE;
00725     sb4 value   = (ub4) timeout;
00726 
00727     OCI_CHECK_PTR(OCI_IPC_DEQUEUE, dequeue, FALSE);
00728 
00729     OCI_CALL2
00730     (
00731         res, dequeue->typinf->con,
00732 
00733         OCIAttrSet((dvoid *) dequeue->opth,
00734                    (ub4    ) OCI_DTYPE_AQDEQ_OPTIONS,
00735                    (dvoid *) &value,
00736                    (ub4    ) 0,
00737                    (ub4    )  OCI_ATTR_WAIT,
00738                    dequeue->typinf->con->err)
00739     )
00740 
00741     OCI_RESULT(res);
00742 
00743     return res;
00744 }
00745 
00746 /* --------------------------------------------------------------------------------------------- *
00747  * OCI_DequeueSetAgentList
00748  * --------------------------------------------------------------------------------------------- */
00749 
00750 boolean OCI_API OCI_DequeueSetAgentList
00751 (
00752     OCI_Dequeue *dequeue,
00753     OCI_Agent  **consumers,
00754     unsigned int count
00755 )
00756 {
00757     boolean res = TRUE;
00758 
00759     OCI_CHECK_PTR(OCI_IPC_ENQUEUE, dequeue, FALSE);
00760 
00761     OCI_FREE(dequeue->agent_list);
00762 
00763     if ((consumers != NULL) && (count > 0))
00764     {
00765         dequeue->agent_list = (OCIAQAgent **) OCI_MemAlloc(OCI_IPC_ARRAY,  sizeof(OCIAQAgent *),
00766                                                            count, FALSE);
00767 
00768         if (dequeue->agent_list != NULL)
00769         {
00770             unsigned int i;
00771 
00772             for(i = 0; i < count; i++)
00773             {
00774                 dequeue->agent_list[i] = consumers[i]->handle;
00775             }
00776 
00777             dequeue->agent_count = (ub4) count;
00778         }
00779         else
00780         {
00781             res = FALSE;
00782         }
00783     }
00784 
00785     OCI_RESULT(res);
00786 
00787     return res;
00788 }