VOID
opc_querycomp(
OPS_STATE *global)
{
DB_STATUS ret;
global->ops_gmask |= OPS_OPCEXCEPTION; /* mark facility as being in OPC */
#ifdef OPT_F033_OPF_TO_OPC
if (opt_strace(global->ops_cb, OPT_F033_OPF_TO_OPC) == TRUE)
{
char temp[OPT_PBLEN + 1];
bool init = 0;
if (global->ops_cstate.opc_prbuf == NULL)
{
global->ops_cstate.opc_prbuf = temp;
init++;
}
/* Trace all of 'global' */
if (global->ops_statement != NULL)
{
opt_state(global);
}
if (init)
{
global->ops_cstate.opc_prbuf = NULL;
}
}
#endif
if ( opt_strace(global->ops_cb, OPT_F071_QEP_WITHOUT_COST ) == TRUE && global->ops_subquery)
{
opt_cotree_without_stats( global );
}
/* If this is CREATE TABLE, check for primary, unique, foreign key
** constraints to use for default base table structure. */
if (global->ops_statement &&
global->ops_statement->pst_type == PST_CREATE_TABLE_TYPE &&
global->ops_statement->pst_specific.pst_createTable.
pst_createTableFlags == PST_CRT_TABLE)
{
QEU_CB *qeucb = global->ops_statement->pst_specific.pst_createTable.pst_createTableQEUCB;
DMU_CB *dmucb = (DMU_CB *) qeucb->qeu_d_cb;
bool checkit = FALSE;
if (BTtest(DMU_AUTOSTRUCT, dmucb->dmu_chars.dmu_indicators))
checkit = (dmucb->dmu_chars.dmu_flags & DMU_FLAG_AUTOSTRUCT) != 0;
else
checkit = opt_strace(global->ops_cb, OPT_F084_TBLAUTOSTRUCT ) ||
global->ops_cb->ops_alter.ops_autostruct != 0;
if (checkit)
opc_checkcons(global->ops_statement, dmucb);
}
/* On entry for rule processing, assume ops_qpinit == TRUE. There */
/* is no need to allocate a memory stream since we are contuing */
/* processing on the QP that was started by the triggering statement. */
if (global->ops_qpinit == FALSE)
{
/* First, lets open the stack ULM memory stream that OPC uses */
opu_Osmemory_open(global);
/* Tell QSF that we want to store an object; */
global->ops_qsfcb.qsf_obj_id.qso_type = QSO_QP_OBJ;
if (global->ops_procedure->pst_flags & PST_REPEAT_DYNAMIC)
{
char *p;
global->ops_qsfcb.qsf_obj_id.qso_lname = sizeof(DB_CURSOR_ID) + sizeof(i4);
MEfill(sizeof(global->ops_qsfcb.qsf_obj_id.qso_name), 0,
global->ops_qsfcb.qsf_obj_id.qso_name);
MEcopy((PTR)&global->ops_procedure->pst_dbpid.db_cursor_id[0],
sizeof (global->ops_procedure->pst_dbpid.db_cursor_id[0]),
(PTR)global->ops_qsfcb.qsf_obj_id.qso_name);
p = (char *) global->ops_qsfcb.qsf_obj_id.qso_name + 2*sizeof(i4);
if (global->ops_caller_cb->opf_locator)
MEcopy((PTR)"ql", sizeof("ql"), p);
else MEcopy((PTR)"qp", sizeof("qp"), p);
p = (char *) global->ops_qsfcb.qsf_obj_id.qso_name + sizeof(DB_CURSOR_ID);
I4ASSIGN_MACRO(global->ops_caller_cb->opf_udbid, *(i4 *) p);
}
else if ( global->ops_procedure->pst_isdbp == TRUE
|| ( global->ops_qheader != NULL
&& (global->ops_qheader->pst_mask1 & PST_RPTQRY)
)
)
{
global->ops_qsfcb.qsf_obj_id.qso_lname =
sizeof (global->ops_procedure->pst_dbpid);
MEcopy((PTR)&global->ops_procedure->pst_dbpid,
sizeof (global->ops_procedure->pst_dbpid),
(PTR)global->ops_qsfcb.qsf_obj_id.qso_name);
}
else
{
global->ops_qsfcb.qsf_obj_id.qso_lname = 0;
}
/* Also allow for the case where a concurrent clash causes a new
** object at an awkward point */
if ((ret = qsf_call(QSO_CREATE, &global->ops_qsfcb)) != E_DB_OK &&
!(ret == E_DB_ERROR &&
global->ops_qsfcb.qsf_error.err_code == E_QS001C_EXTRA_OBJECT) &&
!((global->ops_procedure->pst_flags & PST_SET_INPUT_PARAM) &&
global->ops_qsfcb.qsf_error.err_code == E_QS001C_EXTRA_OBJECT))
{
/* if object exists and we have a named query plan. */
if (global->ops_qsfcb.qsf_error.err_code
== E_QS000A_OBJ_ALREADY_EXISTS
)
{
/* Log query info */
QSO_OBID *obj = &global->ops_qsfcb.qsf_obj_id;
char *qrytype;
char *objtype;
char *objname;
char *qrytext;
char tmp[(DB_OWN_MAXNAME + DB_CURSOR_MAXNAME) + 3 + 1];
DB_STATUS status;
QSF_RCB qsf_rb;
PSQ_QDESC *qdesc;
if (global->ops_procedure->pst_isdbp == TRUE)
qrytype = "database procedure";
else if (global->ops_qheader != NULL
&& (global->ops_qheader->pst_mask1 & PST_RPTQRY)
)
qrytype = "repeat query";
else
qrytype = "non-repeat query";
objtype = "QSO_QP_OBJ";
if (obj->qso_lname == 0)
{
objname = "QSF object has no name";
}
else
{
char fmt[30];
DB_CURSOR_ID *curid;
char *user;
i4 *dbid;
curid = (DB_CURSOR_ID *)obj->qso_name;
user = curid->db_cur_name + DB_CURSOR_MAXNAME;
dbid = (i4 *)(user + DB_OWN_MAXNAME);
STprintf(fmt, ":%%lx:%%lx:%%.%ds:%%.%ds:%%lx:",
DB_CURSOR_MAXNAME, DB_OWN_MAXNAME);
STprintf(tmp, fmt, (i4)curid->db_cursor_id[0],
(i4)curid->db_cursor_id[1],
curid->db_cur_name, user, (i4)(*dbid));
objname = tmp;
}
qsf_rb.qsf_type = QSFRB_CB;
qsf_rb.qsf_ascii_id = QSFRB_ASCII_ID;
qsf_rb.qsf_length = sizeof(qsf_rb);
qsf_rb.qsf_owner = (PTR)DB_OPF_ID;
qsf_rb.qsf_obj_id.qso_handle = global->ops_caller_cb->opf_thandle;
qrytext = "Query text was not available.";
if (qsf_rb.qsf_obj_id.qso_handle != NULL)
{
status = qsf_call(QSO_INFO, &qsf_rb);
if (DB_SUCCESS_MACRO(status))
{
qdesc = (PSQ_QDESC*) qsf_rb.qsf_root;
qrytext = qdesc->psq_qrytext;
}
}
/* log an error */
opx_lerror((OPX_ERROR)E_OP089F_QSF_FAILCREATE, (i4)4,
(PTR)qrytype, (PTR)objtype, (PTR)objname, (PTR)qrytext);
}
opx_verror(ret, E_OP0882_QSF_CREATE,
global->ops_qsfcb.qsf_error.err_code);
}
/* Put the handle for the QEP into the callers CB;
** - will be used for deallocation in case of an error
** - both the object id and the lock id are needed in order to destroy
** the object
*/
STRUCT_ASSIGN_MACRO(global->ops_qsfcb.qsf_obj_id,
global->ops_caller_cb->opf_qep);
global->ops_qplk_id = global->ops_qsfcb.qsf_lk_id;
global->ops_qpinit = TRUE;
/* Allocate and initialize the QP. */
opc_iqp_init(global);
}
/* Continue the QP compilation by adding the current statement */
if (global->ops_statement != NULL)
{
opc_cqp_continue(global);
}
/* if it's time to stop compiling the query, then lets close stuff. */
/* The caller is responsible for making one additional call to OPC */
/* with ops_statement == NULL after all statements in the QP we are */
/* currently building have been compiled. Note that this is a change */
/* from the previous version of this routine which required the extra */
/* call only if a db procedure was being compiled. Such a call must */
/* also be made after the last statement in each rule list. This allows */
/* OPC to link all conditionals statements in the rule list together */
/* before continuing with the next user statement to be compiled. */
if (global->ops_statement == NULL)
{
/* We're finished compiling all of the statements, so lets finish
** the QP
*/
opc_fqp_finish(global);
/* The QP is only associated with the outer query, not a rule list */
if (!global->ops_inAfterRules && !global->ops_inBeforeRules)
{
/* Tell QSF what the root of the QEP is; */
global->ops_qsfcb.qsf_root = (PTR) global->ops_cstate.opc_qp;
if ((ret = qsf_call(QSO_SETROOT, &global->ops_qsfcb)) != E_DB_OK)
{
opx_verror(ret, E_OP0883_QSF_SETROOT,
global->ops_qsfcb.qsf_error.err_code);
}
if ((ret = qsf_call(QSO_UNLOCK, &global->ops_qsfcb)) != E_DB_OK)
{
opx_verror(ret, E_OP089E_QSF_UNLOCK,
global->ops_qsfcb.qsf_error.err_code);
}
/* Now lets close the stack ULM memory stream that OPC used */
opu_Csmemory_close(global);
}
}
global->ops_gmask &= (~OPS_OPCEXCEPTION); /* mark facility as leaving OPC */
}
static int _get(netdev_t *netdev, netopt_t opt, void *val, size_t max_len)
{
if (netdev == NULL) {
return -ENODEV;
}
cc2420_t *dev = (cc2420_t *)netdev;
int ext = netdev_ieee802154_get(&dev->netdev, opt, val, max_len);
if (ext > 0) {
return ext;
}
switch (opt) {
case NETOPT_ADDRESS:
assert(max_len >= sizeof(uint16_t));
cc2420_get_addr_short(dev, val);
return sizeof(uint16_t);
case NETOPT_ADDRESS_LONG:
assert(max_len >= 8);
cc2420_get_addr_long(dev, val);
return 8;
case NETOPT_NID:
assert(max_len >= sizeof(uint16_t));
return w_u16(val, cc2420_get_pan(dev));
case NETOPT_CHANNEL:
assert(max_len >= sizeof(uint16_t));
return w_u16(val, cc2420_get_chan(dev));
case NETOPT_TX_POWER:
assert(max_len >= sizeof(int16_t));
return w_i16(val, cc2420_get_txpower(dev));
case NETOPT_STATE:
assert(max_len >= sizeof(netopt_state_t));
*((netopt_state_t *)val) = cc2420_get_state(dev);
return sizeof(netopt_state_t);
case NETOPT_IS_CHANNEL_CLR:
return opt_state(val, cc2420_cca(dev));
case NETOPT_AUTOACK:
return opt_state(val, (dev->options & CC2420_OPT_AUTOACK));
case NETOPT_CSMA:
return opt_state(val, (dev->options & CC2420_OPT_CSMA));
case NETOPT_PRELOADING:
return opt_state(val, (dev->options & CC2420_OPT_PRELOADING));
case NETOPT_PROMISCUOUSMODE:
return opt_state(val, (dev->options & CC2420_OPT_PROMISCUOUS));
case NETOPT_RX_START_IRQ:
return opt_state(val, (dev->options & CC2420_OPT_TELL_RX_START));
case NETOPT_RX_END_IRQ:
return opt_state(val, (dev->options & CC2420_OPT_TELL_TX_END));
case NETOPT_TX_START_IRQ:
return opt_state(val, (dev->options & CC2420_OPT_TELL_RX_START));
case NETOPT_TX_END_IRQ:
return opt_state(val, (dev->options & CC2420_OPT_TELL_RX_END));
default:
return -ENOTSUP;
}
}
