/*{
** Name: OPC_EEXCATTS - Build atts from eqcs that go to exchange
** buffer
**
** Description:
{@comment_line@}...
**
** Inputs:
[@PARAM_DESCR@]...
**
** Outputs:
[@PARAM_DESCR@]...
** Returns:
** {@return_description@}
** Exceptions:
** [@description_or_none@]
**
** Side Effects:
** [@description_or_none@]
**
** History:
** 13-nov-03 (inkdo01)
** Written for parallel query processing (cloned from opcsorts.c).
** 7-Apr-2004 (schka24)
** Set attr default stuff just in case someone looks at it.
[@history_template@]...
*/
static VOID
opc_eexatts(
OPS_STATE *global,
OPE_BMEQCLS *eeqcmp,
OPC_EQ *ceq,
DMF_ATTR_ENTRY ***patts, /* ptr to a ptr to an array of ptrs
to atts */
i4 *pacount )
{
OPS_SUBQUERY *subqry = global->ops_cstate.opc_subqry;
DMF_ATTR_ENTRY **atts;
DMF_ATTR_ENTRY *att;
i4 attno;
OPZ_AT *at = global->ops_cstate.opc_subqry->ops_attrs.opz_base;
OPE_IEQCLS eqcno;
*pacount = BTcount((char *)eeqcmp, (i4)subqry->ops_eclass.ope_ev);
if (*pacount == 0)
return; /* count(*) or sommat - no atts to materialize */
atts = (DMF_ATTR_ENTRY **) opu_qsfmem(global,
*pacount * sizeof (DMF_ATTR_ENTRY *));
for (attno = 0, eqcno = -1;
(eqcno = BTnext((i4)eqcno, (char *)eeqcmp,
(i4)subqry->ops_eclass.ope_ev)) != -1;
attno += 1
)
{
att = (DMF_ATTR_ENTRY *) opu_qsfmem(global, sizeof (DMF_ATTR_ENTRY));
STprintf(att->attr_name.db_att_name, "a%x", eqcno);
STmove(att->attr_name.db_att_name, ' ',
sizeof(att->attr_name.db_att_name), att->attr_name.db_att_name);
att->attr_type = ceq[eqcno].opc_eqcdv.db_datatype;
att->attr_size = ceq[eqcno].opc_eqcdv.db_length;
att->attr_precision = ceq[eqcno].opc_eqcdv.db_prec;
att->attr_flags_mask = 0;
SET_CANON_DEF_ID(att->attr_defaultID, DB_DEF_NOT_DEFAULT);
att->attr_defaultTuple = NULL;
atts[attno] = att;
}
*patts = atts;
}
/*{
** Name: psy_dpermit - Define a permit.
**
** INTERNAL PSF call format: status = psy_dpermit(&psy_cb, sess_cb);
**
** EXTERNAL call format: status = psy_call(PSY_DPERMIT, &psy_cb, sess_cb);
**
** Description:
** Given all of the parameters necessary to CREATE/DEFINE a permit on a
** table or view, this function will store the permission in the system
** catalogs. This will include storing the query tree in the tree table,
** storing the text of the query in the iiqrytext table (really done by
** QEF), storing a row in the protect table, and issuing an "alter table"
** operation to DMF to indicate that there are permissions on the given
** table.
**
** Inputs:
** psy_cb
** .psy_qrytext Id of query text as stored in QSF.
** .psy_cols[] Array of columns on which to grant
** permission
** .psy_numcols Number of columns listed above; 0 means
** give permission on all columns
** .psy_intree QSF id of query tree representing the
** where clause in the permit
** .psy_opctl Bit map of defined operations
** .psy_opmap Bit map of permitted operations
** .psy_user Name of user who will get permission
** .psy_terminal Terminal at which permission is given
** (blank if none specified)
** .psy_timbgn Time of day at which the permission
** begins (minutes since 00:00)
** .psy_timend Time of day at which the permission ends
** (minutes since 00:00)
** .psy_daybgn Day of week at which the permission
** begins (0 = Sunday)
** .psy_dayend Day of week at which the permission ends
** (0 = Sunday)
** .psy_grant
** PSY_CPERM CREATE/DEFINE PERMIT
** .psy_tblq head of table queue
** .psy_colq head of column queue
** .psy_usrq head of user queue
** .psy_qlen length of first iiqrytext
** .psy_flags useful info
** PSY_EXCLUDE_COLUMNS user specified a list of columns to
** which privilege should not apply
** sess_cb Pointer to session control block
** (Can be NULL)
**
** Outputs:
** psy_cb
** .psy_txtid Id of query text as stored in the
** iiqrytext system relation.
** .psy_error Filled in if error happens
** Returns:
** E_DB_OK Function completed normally.
** E_DB_WARN Function completed with warning(s);
** E_DB_ERROR Function failed; non-catastrophic error
** E_DB_FATAL Function failed; catastrophic error
** Exceptions:
** none
**
** Side Effects:
** Stores text of query in iiqrytext relation, query tree in tree
** relation, row in protect relation identifying the permit. Does
** an alter table DMF operation to indicate that there are permissions
** on the table.
**
** History:
** 02-oct-85 (jeff)
** written
** 03-sep-86 (seputis)
** changed some psy_cb. to psy_cb->
** added .db_att_id reference
** changed rdr_cb. rdr_cb->
** 02-dec-86 (daved)
** bug fixing. check for permit on tables owned by user and not
** view.
** 29-apr-87 (stec)
** Implemented changes for GRANT statement.
** 10-may-88 (stec)
** Make changes for db procs.
** 03-oct-88 (andre)
** Modified call to pst_rgent to pass 0 as a query mode since it is
** clearly not PSQ_DESTROY
** 06-feb-89 (ralph)
** Added support for 300 attributes:
** Use DB_COL_BITS in place of DB_MAX_COLS
** Loop over domset array using DB_COL_WORDS
** 06-mar-89 (ralph)
** GRANT Enhancements, Phase 1:
** Initialize new DB_PROTECTION fields, dbp_seq and dbp_gtype
** 03-apr-89 (ralph)
** GRANT Enhancements, Phase 2:
** Use DBGR_USER when initializing dbp_gtype
** 08-may-89 (ralph)
** Initialize reserved field to blanks (was \0)
** 04-jun-89 (ralph)
** Initialize dbp_fill1 to zero
** Fix unix portability problems
** 02-nov-89 (neil)
** Alerters: Allowed privileges for events.
** 1-mar-90 (andre)
** If processing a GRANT on tables, check if
** ALL-TO-ALL or RETRIEVE-TO-ALL has already been granted, and if so,
** mark psy_mask appropriately.
** If user tried to CREATE ALL/RETRIEVE-TO-ALL, and one already exists,
** skip to the exit.
** 12-mar-90 (andre)
** set rdr_2types_mask to 0.
** 22-may-90 (teg)
** init rdr_instr to RDF_NO_INSTR
** 08-aug-90 (ralph)
** Initialize new fields in iiprotect tuple
** 14-dec-90 (ralph)
** Disallow use of GRANT by non-DBA if xORANGE
** 11-jan-90 (ralph)
** Allow user "$ingres" to use GRANT if xORANGE.
** This was done for CREATEDB (UPGRADEFE).
** 20-feb-91 (andre)
** For CREATE/DEFINE PERMIT, grantee type was stored in
** psy_cb->psy_gtype.
** 24-jun-91 (andre)
** IIPROTECT tuples for table permits will contain exactly one
** privilege. IIQRYTEXT template built for table-wide privileges
** contains a placeholder for a privilege name which will be filled in
** with each of the table-wide privileges being granted, one at a time.
** PSY_CB.psy_opmap will be set to correspond with privilege name
** stored in the IIQRYTEXT permit.
** 16-jul-91 (andre)
** responsibility for splitting permit tuples will passed on to
** qeu_cprot(). If a permit specified only one privilege, we will
** substitute the appropriate privilege name here and will not ask
** qeu_cprot() to split tuples.
** 06-aug-91 (andre)
** before proceeding to CREATE a permit on a view owned by the current
** user, we will call psy_tbl_grant_check() to ensure that this user
** may create a permit on his view. If the object is not owned by the
** current user, we will not try to verify that the user may
** CREATE/DEFINE a permit since (until the relevant FE changes are
** made) we intend to continue allowing any user with CATUPD to
** CREATE/DEFINE permits on catalogs and the dba will be allowed to
** CREATE/DEFINE permits on extended catalogs
** 11-nov-91 (rblumer)
** merged from 6.4: 26-feb-91 (andre)
** PST_QTREE was changed to store the range table as an array of
** pointers to PST_RNGENTRY structure.
** 14-feb-92 (andre)
** we will no longer have to fill in privilege name for permits
** specifying one privilege - it will be handled in respective
** grammars.
** 15-jun-92 (barbara)
** For Sybil, change interface to pst_rgent(), Star returns from
** psy_dpermit before permits get stored.
** 07-jul-92 (andre)
** DB_PROTECTION tuple will contain an indicator of how the permit was
** created, i.e. whether it was created using SQL or QUEL and if the
** former, then whether it was created using GRANT statement. Having
** this information will facilitate merging similar and identical
** permit tuples.
** 14-jul-92 (andre)
** semantics of GRANT ALL [PRIVILEGES] is different from that of
** CREATE PERMIT ALL in that the former (as dictated by SQL92) means
** "grant all privileges which the current auth id posesses WGO"
** whereas the latter (as is presently interpreted) means "grant all
** privileges that can be defined on the object" which in case of
** tables and views means SELECT, INSERT, DELETE, UPDATE.
** psy_tbl_grant_check() (function responsible for determining whether
** a user may grant specified privilege on a specified table or view)
** will have to be notified whether we are processing GRANT ALL. Its
** behaviour will change as follows:
** - if processing GRANT ALL and psy_tbl_grant_check() determines
** that the user does not possess some (but not all) of the
** privileges passed to it by the caller it will not treat it as an
** error, but will instead inform the caller of privileges that the
** user does not posess,
** - if processing GRANT ALL and psy_tbl_grant_check() determines
** that the user does not possess any of the privileges passed to
** it by the caller it will treat it as an error
** - if processing a statement other than GRANT ALL and
** psy_tbl_grant_check() determines that the user does not possess
** some of the privileges passed to it by the caller it will treat
** it as an error
** 16-jul-92 (andre)
** if a permit being created depends on some privileges, build a
** structure describing these privileges and store its address in
** rdf_cb->rdr_indep.
** 18-jul-92 (andre)
** we will no longer be telling QEF to turn off DMT_ALL_PROT or
** DMT_RETRIEVE_PRO when a user creates ALL/RETRIEVE TO ALL permit.
** QEF will figure out on its own whether PUBLIC now has RETRIEVE or
** ALL on a table/view
** 20-jul-92 (andre)
** if user specified a list of columns to which privilege(s) should
** not apply, set dbp_domset correctly
** 03-aug-92 (barbara)
** Invalidate base table infoblk from RDF cache for CREATE PERMIT
** and CREATE SEC_ALARM.
** 16-sep-92 (andre)
** privilege maps are build using bitwise ops, so care should be
** exercised when accessing it using BT*() functions
** 17-jun-93 (andre)
** changed interface of psy_secaudit() to accept PSS_SESBLK
** 5-jul-93 (robf)
** changed interface of psy_secaudit() to accept security label
** 7-jan-94 (swm)
** Bug #58635
** Added PTR cast for qsf_owner which has changed type to PTR.
** 06-mar-96 (nanpr01)
** Move the QSF request block initialization up. because if
** pst_rgnent returns a failure status code, subsequent QSF
** calls get bad control block error.
*/
DB_STATUS
psy_dpermit(
PSY_CB *psy_cb,
PSS_SESBLK *sess_cb)
{
RDF_CB rdf_cb;
register RDR_RB *rdf_rb = &rdf_cb.rdf_rb;
QSF_RCB qsf_rb;
DB_STATUS status;
DB_STATUS stat;
DB_PROTECTION ptuple;
register DB_PROTECTION *protup = &ptuple;
i4 *domset = ptuple.dbp_domset;
register i4 i, j;
i4 err_code;
PSS_RNGTAB *rngvar;
PSS_USRRANGE *rngtab;
PST_PROCEDURE *pnode;
PST_QTREE *qtree;
DB_ERROR *err_blk = &psy_cb->psy_error;
i4 textlen;
i4 tree_lock = 0;
i4 text_lock = 0;
DB_TAB_ID tabids[PST_NUMVARS];
PSQ_INDEP_OBJECTS indep_objs;
PSQ_OBJPRIV obj_priv; /* space for independent DELETE */
PSQ_COLPRIV col_privs[2]; /*
** space for independent INSERT and
** UPDATE
*/
PST_VRMAP varmap;
PSY_TBL *psy_tbl;
DB_TIME_ID timeid;
DB_NAME *objname;
/*
** For CREATE/DEFINE PERMIT execute code below.
*/
/* initialize the QSF control block */
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_PSF_ID;
qsf_rb.qsf_sid = sess_cb->pss_sessid;
rngtab = &sess_cb->pss_auxrng;
/* table info is stored in the only entry in the table queue */
psy_tbl = (PSY_TBL *) psy_cb->psy_tblq.q_next;
status = pst_rgent(sess_cb, rngtab, -1, "", PST_SHWID,
(DB_TAB_NAME *) NULL, (DB_TAB_OWN *) NULL,
&psy_tbl->psy_tabid, TRUE, &rngvar, (i4) 0, err_blk);
if (DB_FAILURE_MACRO(status))
goto exit;
/* In STAR, we do not actually store permits */
if (sess_cb->pss_distrib & DB_3_DDB_SESS)
{
qsf_rb.qsf_lk_state = QSO_EXLOCK;
goto exit;
}
/* Fill in the RDF request block */
pst_rdfcb_init(&rdf_cb, sess_cb);
/* The table which is receiving the permit */
STRUCT_ASSIGN_MACRO(psy_tbl->psy_tabid, rdf_rb->rdr_tabid);
/* Tell RDF we're doing a permit definition */
rdf_rb->rdr_update_op = RDR_APPEND;
rdf_rb->rdr_types_mask = RDR_PROTECT;
rdf_rb->rdr_qrytuple = (PTR) protup;
/* initialize independent object structure */
indep_objs.psq_objs = (PSQ_OBJ *) NULL;
indep_objs.psq_objprivs = (PSQ_OBJPRIV *) NULL;
indep_objs.psq_colprivs = (PSQ_COLPRIV *) NULL;
indep_objs.psq_grantee = &sess_cb->pss_user;
rdf_rb->rdr_indep = (PTR) &indep_objs;
/*
** populate the IIPROTECT tuple
*/
/* Zero out the template */
(VOID)MEfill(sizeof(ptuple), (u_char) 0, (PTR) protup);
/* store grantee type */
protup->dbp_gtype = psy_cb->psy_gtype;
/* Init reserved block */
(VOID)MEfill(sizeof(protup->dbp_reserve),
(u_char) ' ', (PTR) protup->dbp_reserve);
/* Init obj name */
STRUCT_ASSIGN_MACRO(psy_tbl->psy_tabnm, protup->dbp_obname);
/*@FIX_ME@ Where does this come from? */
protup->dbp_obstat = ' ';
/* store the object type indicator */
if (psy_tbl->psy_mask & PSY_OBJ_IS_TABLE)
{
protup->dbp_obtype = DBOB_TABLE;
}
else if (psy_tbl->psy_mask & PSY_OBJ_IS_VIEW)
{
protup->dbp_obtype = DBOB_VIEW;
}
else
{
protup->dbp_obtype = DBOB_INDEX;
}
STRUCT_ASSIGN_MACRO(psy_tbl->psy_owner, protup->dbp_obown);
STRUCT_ASSIGN_MACRO(sess_cb->pss_user, protup->dbp_grantor);
TMnow((SYSTIME *)&timeid);
protup->dbp_timestamp.db_tim_high_time = timeid.db_tim_high_time;
protup->dbp_timestamp.db_tim_low_time = timeid.db_tim_low_time;
/* The table on which we're giving permission */
STRUCT_ASSIGN_MACRO(psy_tbl->psy_tabid, protup->dbp_tabid);
/* Beginning and ending times of day */
protup->dbp_pdbgn = psy_cb->psy_timbgn;
protup->dbp_pdend = psy_cb->psy_timend;
/* Beginning and ending days of week */
protup->dbp_pwbgn = psy_cb->psy_daybgn;
protup->dbp_pwend = psy_cb->psy_dayend;
if (psy_cb->psy_numcols != 0 && ~psy_cb->psy_flags & PSY_EXCLUDE_COLUMNS)
{
/* user specified a list of columns to which privilege(s) will apply */
/* Bit map of permitted columns */
psy_fill_attmap(domset, ((i4) 0));
for (i = 0; i < psy_cb->psy_numcols; i++)
{
BTset((i4)psy_cb->psy_cols[i].db_att_id, (char *) domset);
}
}
else
{
/*
** user specified table-wide privilege(s) or a list of columns L s.t.
** privilege(s) will apply to the entire table except for columns in L
*/
psy_fill_attmap(domset, ~((i4) 0));
if (psy_cb->psy_flags & PSY_EXCLUDE_COLUMNS)
{
/*
** exclude specified columns from the list of columns to which
** privilege(s) will apply
*/
for (i = 0; i < psy_cb->psy_numcols; i++)
{
BTclear((i4) psy_cb->psy_cols[i].db_att_id, (char *) domset);
}
}
}
if (rngvar->pss_tabdesc->tbl_status_mask & DMT_VIEW)
{
/*
** if view is owned by the current user, psy_tbl_grant_check() will
** determine if the permit can, indeed, be created; as long as we are
** preserving the kludge that allows users with CATUPD create permits on
** catalogs and DBAs to create permits on extended catalogs, we shall
** not call psy_tbl_grant_check() on view not owned by the current user,
** since it is likely to result in psy_tbl_grant_check() complaining
** about inadequate permissions
*/
if (!MEcmp((PTR) &rngvar->pss_ownname, (PTR) &sess_cb->pss_user,
sizeof(sess_cb->pss_user)))
{
i4 tbl_wide_privs;
PSY_COL_PRIVS col_specific_privs, *csp,
indep_col_specific_privs;
DB_TAB_ID indep_id;
i4 indep_tbl_wide_privs;
bool insuf_privs, quel_view;
i4 val1, val2;
/*
** build maps of table-wide and column-specific privileges for
** psy_tbl_grant_check()
** if a column list was specified with CREATE PERMIT and
** privileges specified in the statement include a set of
** privileges S s.t. for all P in S, P can only be specified as
** table-wide with GRANT statement (currently this includes
** SELECT, INSERT, DELETE), we will make
** psy_tbl_grant_check() think that privileges in S are
** table-wide.
** This will work correctly since if the view was defined over
** some objects owned by other user(s), for every P in S we
** would need table-wide privilege WGO on the underlying object.
**
** For the purposes of providing more descriptive output for
** trace point ps131, if column-list was specified, we will pass
** the map of attributes even if column-specific UPDATE was not
** specified
*/
if (psy_cb->psy_numcols != 0 &&
(psy_cb->psy_opmap & DB_REPLACE ||
ult_check_macro(&sess_cb->pss_trace, 3, &val1, &val2)
)
)
{
i4 *ip;
csp = &col_specific_privs;
/*
** column-specific UPDATE privilege will not be translated into
** a table-wide privilege since GRANT allows for specification
** of column-specific UPDATE privilege
*/
csp->psy_col_privs = psy_cb->psy_opmap & DB_REPLACE;
tbl_wide_privs = psy_cb->psy_opmap & ~DB_REPLACE;
/*
** if creating a permit on a set of columns and UPDATE is not
** one of the privileges named in the statement, store the
** attribute map in the first element of the attribute map list
*/
ip = (csp->psy_col_privs)
? csp->psy_attmap[PSY_UPDATE_ATTRMAP].map
: csp->psy_attmap->map;
/* copy the attribute map */
for (i = 0; i < DB_COL_WORDS; i++, ip++)
{
*ip = domset[i];
}
}
else
{
tbl_wide_privs = psy_cb->psy_opmap;
csp = (PSY_COL_PRIVS *) NULL;
}
status = psy_tbl_grant_check(sess_cb, (i4) PSQ_PROT,
&rngvar->pss_tabid, &tbl_wide_privs, csp, &indep_id,
&indep_tbl_wide_privs, &indep_col_specific_privs,
psy_cb->psy_flags, &insuf_privs, &quel_view,
&psy_cb->psy_error);
if (DB_FAILURE_MACRO(status))
{
goto exit;
}
if (insuf_privs)
{
/* must audit failure to create a permit */
if ( Psf_srvblk->psf_capabilities & PSF_C_C2SECURE )
{
DB_ERROR e_error;
/* Must audit CREATE PERMIT failure. */
status = psy_secaudit(FALSE, sess_cb,
(char *)&rngvar->pss_tabdesc->tbl_name,
&rngvar->pss_tabdesc->tbl_owner,
sizeof(DB_TAB_NAME), SXF_E_TABLE,
I_SX2016_PROT_TAB_CREATE, SXF_A_FAIL | SXF_A_CREATE,
&e_error);
status = (status > E_DB_ERROR) ? status : E_DB_ERROR;
}
goto exit;
}
else if (quel_view)
{
goto exit;
}
/*
** If user is trying to grant one or more of
** INSERT/DELETE/UPDATE on his/her view whose underlying table
** or view is owned by another user, psy_tbl_grant_check() will
** return id of the underlying object along with map of
** privileges. We will convert maps of independent privileges
** into elements of independent privilege list and pass them
** along to QEF
*/
if ( indep_id.db_tab_base != (i4) 0
&& ( indep_id.db_tab_base != rngvar->pss_tabid.db_tab_base
|| indep_id.db_tab_index !=
rngvar->pss_tabid.db_tab_index
)
)
{
if (indep_tbl_wide_privs & DB_DELETE)
{
/*
** the only expected independent table-wide privilege
** is DELETE
*/
obj_priv.psq_next = (PSQ_OBJPRIV *) NULL;
obj_priv.psq_objtype = PSQ_OBJTYPE_IS_TABLE;
obj_priv.psq_privmap = (i4) DB_DELETE;
obj_priv.psq_objid.db_tab_base = indep_id.db_tab_base;
obj_priv.psq_objid.db_tab_index = indep_id.db_tab_index;
indep_objs.psq_objprivs = &obj_priv;
}
if (indep_col_specific_privs.psy_col_privs)
{
i4 i, j;
PSQ_COLPRIV *csp;
i4 *att_map, *p;
i4 priv_map = 0;
/*
** privilege map is built using bitwise operators, but
** here using BTnext() makes code much more palatable,
** so convert a privilege map
*/
if (indep_col_specific_privs.psy_col_privs & DB_APPEND)
BTset(DB_APPP, (char *) &priv_map);
if (indep_col_specific_privs.psy_col_privs & DB_REPLACE)
BTset(DB_REPP, (char *) &priv_map);
for (i = -1, csp = col_privs;
(i = BTnext(i, (char *) &priv_map, BITS_IN(priv_map)))
!= -1;
csp++
)
{
csp->psq_next = indep_objs.psq_colprivs;
indep_objs.psq_colprivs = csp;
csp->psq_objtype = PSQ_OBJTYPE_IS_TABLE;
csp->psq_tabid.db_tab_base = indep_id.db_tab_base;
csp->psq_tabid.db_tab_index = indep_id.db_tab_index;
switch (i)
{
case DB_APPP: /* INSERT privilege */
{
csp->psq_privmap = (i4) DB_APPEND;
att_map = indep_col_specific_privs.
psy_attmap[PSY_INSERT_ATTRMAP].map;
break;
}
case DB_REPP:
{
csp->psq_privmap = (i4) DB_REPLACE;
att_map = indep_col_specific_privs.
psy_attmap[PSY_UPDATE_ATTRMAP].map;
break;
}
}
for (p = csp->psq_attrmap, j = 0;
j < DB_COL_WORDS;
j++)
{
*p++ = *att_map++;
}
}
}
}
}
else
{
/*
** either this is a catalog and the user has CATUPD or
** this is an extended catalog and the user is the DBA;
** since we may be allowing a user to create a permit by
** circumventing the permit system, we only need to ascertain that
** this is an SQL view
*/
i4 issql = 0;
status = psy_sqlview(rngvar, sess_cb, err_blk, &issql);
if (status)
{
goto exit;
}
if (!issql)
{
/* can only have permits on SQL views */
psf_error(3598L, 0L, PSF_USERERR, &err_code, err_blk, 1,
psf_trmwhite(sizeof(rngvar->pss_tabname),
(char *) &rngvar->pss_tabname),
&rngvar->pss_tabname);
status = E_DB_ERROR;
goto exit;
}
}
}
/* Name of user getting permission */
STRUCT_ASSIGN_MACRO(psy_cb->psy_user, protup->dbp_owner);
/* Terminal at which permission given */
STRUCT_ASSIGN_MACRO(psy_cb->psy_terminal, protup->dbp_term);
/* Give RDF pointer to query tree, if any */
if (!psy_cb->psy_istree)
{
rdf_rb->rdr_qry_root_node = (PTR) NULL;
}
else
{
PST_VRMAP varset;
i4 j;
STRUCT_ASSIGN_MACRO(psy_cb->psy_intree, qsf_rb.qsf_obj_id);
qsf_rb.qsf_lk_state = QSO_EXLOCK;
status = qsf_call(QSO_LOCK, &qsf_rb);
if (DB_FAILURE_MACRO(status))
{
(VOID) psf_error(E_PS0D19_QSF_INFO, qsf_rb.qsf_error.err_code,
PSF_INTERR, &err_code, err_blk, 0);
goto exit;
}
tree_lock = qsf_rb.qsf_lk_id;
pnode = (PST_PROCEDURE *) qsf_rb.qsf_root;
qtree = (PST_QTREE *) pnode->pst_stmts->pst_specific.pst_tree;
rdf_rb->rdr_qry_root_node = (PTR) pnode;
/* check for no views in the qualification.
*/
(VOID)psy_varset(qtree->pst_qtree, &varset);
j = BTnext(-1, (char *) &varset, BITS_IN(varset));
for ( ; j >= 0; j = BTnext(j, (char *) &varset, BITS_IN(varset)))
{
status = pst_rgent(sess_cb, rngtab, -1, "", PST_SHWID,
(DB_TAB_NAME *) NULL, (DB_TAB_OWN *) NULL,
&qtree->pst_rangetab[j]->pst_rngvar, TRUE,
&rngvar, (i4) 0, err_blk);
if (status)
goto exit;
if (rngvar->pss_tabdesc->tbl_status_mask & DMT_VIEW)
{
psf_error(3597L, 0L, PSF_USERERR, &err_code, err_blk, 1,
psf_trmwhite(sizeof(rngvar->pss_tabname),
(char *) &rngvar->pss_tabname),
&rngvar->pss_tabname);
status = E_DB_ERROR;
goto exit;
}
}
}
/* Give RDF a pointer to the query text to be stored in iiqrytext */
STRUCT_ASSIGN_MACRO(psy_cb->psy_qrytext, qsf_rb.qsf_obj_id);
qsf_rb.qsf_lk_state = QSO_EXLOCK;
status = qsf_call(QSO_LOCK, &qsf_rb);
if (DB_FAILURE_MACRO(status))
{
(VOID) psf_error(E_PS0D19_QSF_INFO, qsf_rb.qsf_error.err_code,
PSF_INTERR, &err_code, err_blk, 0);
goto exit;
}
text_lock = qsf_rb.qsf_lk_id;
MEcopy((char *) qsf_rb.qsf_root, sizeof(i4), (char *) &textlen);
rdf_rb->rdr_l_querytext = textlen;
rdf_rb->rdr_querytext = ((char *) qsf_rb.qsf_root) + sizeof(i4);
rdf_rb->rdr_status = (sess_cb->pss_lang == DB_SQL) ? DB_SQL : 0;
/* determine if the permit specifies exactly one privilege */
if (BTcount((char *) &psy_cb->psy_opmap, BITS_IN(psy_cb->psy_opmap)) > 1)
{
/*
** if permit specified more than one privilege, notify QEF that it will
** have to split the permit into multiple IIPROTECT tuples
*/
rdf_rb->rdr_instr |= RDF_SPLIT_PERM;
}
else if (psy_cb->psy_opmap & DB_RETRIEVE)
{
/*
** if qeu_cprot() will not be splitting the permit into multiple tuples
** and RETRIEVE is the privilege mentioned in it, set the two bits
** associated with DB_RETRIEVE
*/
psy_cb->psy_opmap |= DB_TEST | DB_AGGREGATE;
psy_cb->psy_opctl |= DB_TEST | DB_AGGREGATE;
}
/* Null out the DMU control block pointer, just in case */
rdf_rb->rdr_dmu_cb = (PTR) NULL;
/* produce list of dependent tables */
rdf_rb->rdr_cnt_base_id = 0;
if (psy_cb->psy_istree && qtree->pst_qtree)
{
j = 0;
(VOID)psy_varset(qtree->pst_qtree, &varmap);
for (i = -1; (i = BTnext(i, (char*) &varmap, PST_NUMVARS)) > -1;)
{
/* if this is the table that is getting the permit, ignore */
if (qtree->pst_rangetab[i]->pst_rngvar.db_tab_base !=
psy_tbl->psy_tabid.db_tab_base
||
qtree->pst_rangetab[i]->pst_rngvar.db_tab_index !=
psy_tbl->psy_tabid.db_tab_index
)
{
rdf_rb->rdr_cnt_base_id++;
STRUCT_ASSIGN_MACRO(qtree->pst_rangetab[i]->pst_rngvar,
tabids[j++]);
}
}
rdf_rb->rdr_base_id = tabids;
}
protup->dbp_popctl = psy_cb->psy_opctl;
protup->dbp_popset = psy_cb->psy_opmap;
/*
** store an indication of whether this permit is being created using SQL or
** QUEL
*/
protup->dbp_flags = (sess_cb->pss_lang == DB_SQL) ? DBP_SQL_PERM : (i2) 0;
protup->dbp_flags |= DBP_65_PLUS_PERM;
/* Now let RDF do all the work of the permit definition */
status = rdf_call(RDF_UPDATE, (PTR) &rdf_cb);
if (DB_FAILURE_MACRO(status))
{
if (rdf_cb.rdf_error.err_code == E_RD0002_UNKNOWN_TBL)
{
(VOID) psf_error(E_PS0903_TAB_NOTFOUND, 0L, PSF_USERERR,
&err_code, err_blk, 1,
psf_trmwhite(sizeof(psy_tbl->psy_tabnm),
(char *) &psy_tbl->psy_tabnm),
&psy_tbl->psy_tabnm);
}
else
{
(VOID) psf_rdf_error(RDF_UPDATE, &rdf_cb.rdf_error,
&psy_cb->psy_error);
}
goto exit;
}
/*
** Invalidate base object's infoblk from RDF cache.
*/
pst_rdfcb_init(&rdf_cb, sess_cb);
STRUCT_ASSIGN_MACRO(psy_cb->psy_tables[0], rdf_rb->rdr_tabid);
status = rdf_call(RDF_INVALIDATE, (PTR) &rdf_cb);
if (DB_FAILURE_MACRO(status))
{
(VOID) psf_rdf_error(RDF_INVALIDATE, &rdf_cb.rdf_error,
&psy_cb->psy_error);
}
exit:
qsf_rb.qsf_lk_state = QSO_EXLOCK;
if (psy_cb->psy_istree)
{
/* Destroy query tree */
STRUCT_ASSIGN_MACRO(psy_cb->psy_intree, qsf_rb.qsf_obj_id);
if ((qsf_rb.qsf_lk_id = tree_lock) == 0)
{
stat = qsf_call(QSO_LOCK, &qsf_rb);
if (DB_FAILURE_MACRO(stat))
{
(VOID) psf_error(E_PS0D18_QSF_LOCK,
qsf_rb.qsf_error.err_code, PSF_INTERR,
&err_code, &psy_cb->psy_error, 0);
if (!status || stat == E_DB_FATAL)
status = stat;
}
tree_lock = qsf_rb.qsf_lk_id;
}
stat = qsf_call(QSO_DESTROY, &qsf_rb);
if (DB_FAILURE_MACRO(stat))
{
(VOID) psf_error(E_PS0D1A_QSF_DESTROY,
qsf_rb.qsf_error.err_code, PSF_INTERR,
&err_code, &psy_cb->psy_error, 0);
if (!status || stat == E_DB_FATAL)
status = stat;
}
tree_lock = 0;
}
/* Destroy query text */
STRUCT_ASSIGN_MACRO(psy_cb->psy_qrytext, qsf_rb.qsf_obj_id);
if ((qsf_rb.qsf_lk_id = text_lock) == 0)
{
stat = qsf_call(QSO_LOCK, &qsf_rb);
if (DB_FAILURE_MACRO(stat))
{
(VOID) psf_error(E_PS0D18_QSF_LOCK, qsf_rb.qsf_error.err_code,
PSF_INTERR, &err_code, &psy_cb->psy_error, 0);
if (!status || stat == E_DB_FATAL)
status = stat;
}
text_lock = qsf_rb.qsf_lk_id;
}
stat = qsf_call(QSO_DESTROY, &qsf_rb);
if (DB_FAILURE_MACRO(stat))
{
(VOID) psf_error(E_PS0D1A_QSF_DESTROY, qsf_rb.qsf_error.err_code,
PSF_INTERR, &err_code, &psy_cb->psy_error, 0);
if (!status || stat == E_DB_FATAL)
status = stat;
}
return (status);
}
/*{
** Name: psy_subsvars - Scan query tree and replace VAR nodes
**
** Description:
** Scans a tree and finds all VAR nodes for this variable.
** These nodes are looked up in the translation tree and
** replaced by the value found there. If this is for a
** view, the corresponding node must exist in the translation
** tree. If not for a view, a 'zero' node (of a type appropriate based
** on the context) is created and inserted, or, if for a "replace
** cursor" command, a CURVAL node is substituted for the VAR
** node.
**
** This routine is one half of the guts of the whole view
** algorithm.
**
** VAR nodes are detached and replaced with the replacement
** as defined by the view. Note that there can never be any
** problems here with update anomalies, since VAR nodes are
** only used in retrieve contexts.
**
** It does some extra processing with RESDOM nodes with
** resno = 0. These nodes specify a 'tid' domain, and are
** included by the parser on REPLACE and DELETE commands
** Subsvars will allow this construct iff the right hand pointer is a
** VAR node with attno = 0. In pre-Jupiter versions, this used
** to update the variable number in these tid RESDOMs; in Jupiter,
** however, it was changed to keep the same result variable number
** throughout the qrymod process, so this should be unnecessary.
** This is because the resvar is the variable number of the one and
** only underlying base relation of the view on an update
** (which is presumably the only case where this can come
** up). Psy_vrscan has already insured that there can only be
** a single base relation in this case.
**
** This whole messy thing is only done with view substitutions.
** NOTE: THIS IS NOT TRUE! IT IS ALSO DONE FOR INTEGRITY SUBSTITUTIONS!
** I DON'T KNOW WHY THIS COMMENT IS HERE.
**
** In order to fix the handling of aggregates over views, subsvars
** calls psy_apql at the appropriate place to append a
** view qualification (if any). It is done here to handle nested
** aggregates correctly since after psy_subsvars we no longer know
** which nested aggregates actually contained the view variable.
** The view qual will be appended if and only if the view var
** appears explicitly within the immediate scope of a root node
** (NOT in a nested aggregate.)
**
** If at any scope we encounter a var node, we add the qualification
** to that scope. Once a var node has been found in a scope (and
** the qualifaction added), for example, a nested aggregate, the
** qualification is not added to an outer scope unless a var node
** in the view or integ has been found in that outer scope.
**
**
** Inputs:
** proot Pointer to pointer to root of tree
** to be updated
** rngvar view variable range table entry
** transtree Pointer to the target list of the
** translation tree
** vmode PSQ_VIEW if called from view processor,
** PSQ_APPEND is called from the integrity
** processor with an APPEND command, else
** something else. Mostly, changes
** handling of tid nodes, and forces an
** error on a view if the VAR node in the
** scanned tree does not exist in the
** vtree.
** vqual View qualification to be appended,
** if any.
** resvar Range table entry for result variable
** in query being modified.
** from_list from_list from view getting added.
** qmode Query mode of user query.
** cursid Cursor id of current cursor, if any
** result Pointer to indicator for result.
** dup_rb Ptr to dup. request block
** pss_op_mask -- 0
** pss_num_joins -- PST_NOJOIN
** pss_tree_info -- NULL
** pss_mstream -- ptr to memory stream to be used
** pss_err_blk -- ptr to error block
**
** Outputs:
** proot User query tree can be updated
** result Filled in with TRUE if view variable
** was found, FALSE if not. Valid only
** if E_DB_OK returned.
** dup_rb
** pss_err_blk Filled in if an error happens.
** Returns:
** E_DB_OK Success
** E_DB_ERROR Failure
** Exceptions:
** none
**
** Side Effects:
** Can allocate memory
**
** History:
** 19-jun-86 (jeff)
** written
** 1-oct-86 (daved)
** set return to TRUE if a VAR node is found.
** 23-dec-86 (daved)
** copy qualification before appending it. this avoids graphs in
** the tree as well as, and more importantly, the re-use of the
** memory used by the qualification before its time. That is,
** if vqual is in temporary memory and gets deleted but the
** proot tree thinks the memory is still around, bad things happen.
** 12-aug-87 (stec)
** Removed test for special 'tid' attribute case, which, according
** to Jeff is no longer needed.
** Check for special 'tid' resdom now includes open cursor stmt.
** 15-oct-87 (stec)
** Added the removed test for special 'tid' attribute case;
** it's necessary for checking cases like "retrieve (viewname.tid)".
** 03-dec-87 (stec)
** Change psy_apql interface.
** 31-dec-87 (stec)
** Cleanup.
** 08-feb-88 (stec)
** Modify psy_subsvars to generate CURVAL nodes for replace cursor statement.
** 04-nov-88 (stec)
** Fix a view substitution bug. When visiting an AGHEAD node it may happen
** that count(*), or count(const) were defined, in which case there are
** no VAR nodes and the applicability of the view has to be determined from
** the relation bitmap in the node. This anomaly exists only in SQL.
** 14-dec-88 (stec)
** Fix correlated subqueries bug.
** 05-apr-89 (andre)
** simplify the test for when reference to the view in pst_tvrm is to
** be replaced with the tables used to define the view. We no longer
** care if there were any variables found below the root node, instead,
** we do it for every root node which has a bit corresponding to the
** view set in pst_tvrm.
** As a part of the fix, qualification of the view will be appended to
** the tree whenever the view is found in the pst_tvrm of the root
** node.
** Besides allowing us to get rid of calling recursive psy_fixmap() in
** psy_view, but it also fixes bugs such as:
** "select const from view" returning more rows than there are in the
** view.
** 04-may-89 (andre)
** for the time being, set pst_maks1 in all ROOT-type nodes to 0.
** 01-jun-89 (andre)
** The preceding fix was not perfect.
** "create view v as select * from t where <qual>;
** select <aggregate> from v\g"
** would result in as many rows containing result of applying
** <aggregate> as there are rows in v. This happens only in SQL. The
** problem is that <qual> gets appended to both AGGHEAD node and the
** ROOT node. The solution is as follows:
** For every node N s.t. N is of type ROOT or SUBSELECT, remember
** if <qual> has been applied to an AGGHEAD node in the left
** subtree of N (in SQL you can not have AGGHEADs in the
** "where-clause"). If <qual> has been applied to AGGHEAD(s) in
** the left subtree of N, do not append it to the right subtree of
** N.
** 22-jun-89 (andre)
** And yet another fix for the previous bug fix. I have incorrectly
** assumed that there may be no AGGHEADs in the right subtrre of
** ROOT/SUBSEL (select ... having agg(col)). Before setting *mask to
** indicate that an AGGHEAD has been seen, make sure that we are in the
** left subtree of the immediate ROOT/SUBSEL parent
** (mask != (i4 *) NULL). If mask is NULL, we must be in the right
** subtree, and the fact that we saw an AGGHEAD is of no importance
** (or shall I add "or so I believe"?)
** 13-sep-89 (andre)
** receive ptr to PSS_DUPRB which will point at memopry stream and
** error block + it will be used when calling pst_treedup(). The
** fields in dup_rb must be set as follows:
** pss_op_mask -- 0
** pss_num_joins -- PST_NOJOIN
** pss_tree_info -- NULL
** pss_mstream -- ptr to memory stream to be used
** pss_err_blk -- ptr to error block
** 14-sep-92 (andre)
** do not zero out pst_mask1 in PST_ROOT and PST_SUBSEL node
** (fix for bug 45238)
** 11-feb-93 (andre)
** if a query tree involved a reference to a TID attribute of a view V,
** replace it with a reference to TID attribute of V's underlying table
** or view; this is accomplished by replacing variable number found in
** the PST_VAR node with the variable number of the view's underlying
** table/view (which can be found by looking for the first set bit in
** from_list)
** 27-nov-02 (inkdo01)
** Range table expansion (i4 changed to PSAT_J_MASK).
** 13-Jun-2006 (kschendel)
** Barf if we translate a var node to a seqop default in an INSERT.
** This only happens if we're translating an integrity where-clause
** tree, and a var in that where-clause isn't mentioned in the
** values list, so we stick the default in instead. Seqops aren't
** allowed in where clauses. (It would imply that the insert
** integrity-permission depends on the sequence value, which is
** silly at best.)
** 15-May-2007 (kiria01) b111992
** Flatten out much of the recursion of this function to reduce
** runtime stack usage - especially bad with views containing
** massive IN clauses (>5K elements).
** 28-nov-2007 (dougi)
** Add PSQ_REPDYN to PSQ_DEFCURS test for cached dynamic qs.
** 05-Nov-2009 (kiria01) b122841
** Use psl_mk_const_similar to cast default values directly.
** 12-Nov-2009 (kiria01) b122841
** Corrected psl_mk_const_similar parameters with explicit
** mstream.
** 5-Feb-2010 (hanal04) Bug 123209
** psy_integ() calls psy_subsvars() to subsitute VARs in the
** integrity tree with the corresponding nodes from the
** user query. When a VAR is replaced with a CONST cast the
** CONST to the VAR's datatype. This stops the substitution from
** breaking ADE_COMPAREN & ADE_NCOMPAREN processing if the
** VAR was part of an IN LIST.
** 18-May-2010 (kiria01) b123442
** Force psl_mk_const_similar to generate coercion to cleanly
** enable correct datatype to be represented when substituting
** default values.
*/
DB_STATUS
psy_subsvars(
PSS_SESBLK *cb,
PST_QNODE **proot,
PSS_RNGTAB *rngvar,
PST_QNODE *transtree,
i4 vmode,
PST_QNODE *vqual,
PSS_RNGTAB *resvar,
PST_J_MASK *from_list,
i4 qmode,
DB_CURSOR_ID *cursid,
i4 *mask,
PSS_DUPRB *dup_rb)
{
PSY_STK stk = {0, 0, {0, }};/* Backtrack stack */
PST_QNODE *t; /* Temporary for *proot */
i4 vn = rngvar
? rngvar->pss_rgno : -1; /* can be NULL on replace cursor statements */
i4 err_code;
DB_STATUS status = E_DB_OK;
while(proot && (t = *proot))
{
/* These 3 mask variables are only used for ROOT, SUBSEL and AGHEAD */
i4 newmask; /* For receiving result from recursive call */
i4 *l_mask; /* For propagating state to recursive caller */
i4 *r_mask; /* .. */
/*
** The recursive nature of this function has been restructured to
** allow for most of the processing to be achieved in an iterative
** manner. Unlike with the other functions in this module, the
** flattening could not be complete due to the 'mask' output parameter
** which requires local storage for certain node types: ROOT, SUBSEL
** and AGHEAD. If we have one of these node types we recurse 1 level
** to process the left and right sub-trees with the correct scoping of
** the 'mask' variable.
*/
switch (t->pst_sym.pst_type)
{
case PST_ROOT:
/* Handle any unions */
if (t->pst_sym.pst_value.pst_s_root.pst_union.pst_next)
{
/*
** Defer the tree representing the next subselect in the UNION
** status = psy_subsvars(cb,
** &t->pst_sym.pst_value.pst_s_root.pst_union.pst_next, rngvar, transtree,
** vmode, vqual, resvar, from_list, qmode, cursid, (i4 *) NULL,
** dup_rb);
*/
psy_push(&stk, (PTR)&t->pst_sym.pst_value.pst_s_root.pst_union.pst_next,
&status);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
}
/*FALLTHROUGH*/
case PST_SUBSEL:
/*
** The following applies when language is SQL:
** if this is a ROOT or a SUBSELECT node, we want to know if the left
** subtree contains AGGHEAD nodes to which view qualification have been
** applied; we are not concerned with AGGHEAD nodes in the
** qualification (there shouldn't be any, anyway) or in other members
** of the union.
*/
if (cb->pss_lang == DB_SQL)
{
newmask = 0;
l_mask = &newmask;
/* we don't care about the right subtree */
r_mask = (i4 *) NULL;
}
/*FALLTHROUGH*/
case PST_AGHEAD:
/*
** The following applies when language is SQL:
** If this is an AGGHEAD node, set a bit in 'mask' to remember that
** we saw it.
*/
if (t->pst_sym.pst_type == PST_AGHEAD)
{
if (cb->pss_lang == DB_SQL)
{
if (l_mask = r_mask = mask)
/*
** If we are in the right subtree of the immediate ROOT/SUBSELECT
** parent, mask will be NULL, since we are not concerned with
** AGHEADs in the right subtrees.
*/
*mask |= PSS_1SAW_AGG;
}
/*
** pst_mask1 in PST_AGHEAD node is neither used nor set; I think it
** would be a good idea to set it, but at this point there is not a heck
** of a lot that we can do. Here we will zero out PST_AGHEAD.pst_mask1
** purely for esthetic reasons.
*/
t->pst_sym.pst_value.pst_s_root.pst_mask1 = 0;
}
/*
** Recurse 1 level to process the left & right subtrees completly
** so that we can complete the processing of this node
*/
status = psy_subsvars(cb, &t->pst_left, rngvar, transtree, vmode,
vqual, resvar, from_list, qmode, cursid, l_mask, dup_rb);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* Process the right branch */
status = psy_subsvars(cb, &t->pst_right, rngvar, transtree, vmode,
vqual, resvar, from_list, qmode, cursid, r_mask, dup_rb);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* Add `from' list to bitmap, remove entry for replaced var */
if (BTtest(vn, (char*)&t->pst_sym.pst_value.pst_s_root.pst_tvrm))
{
BTclear(vn, (char*)&t->pst_sym.pst_value.pst_s_root.pst_tvrm);
BTor(PST_NUMVARS, (char *)from_list,
(char *)&t->pst_sym.pst_value.pst_s_root.pst_tvrm);
t->pst_sym.pst_value.pst_s_root.pst_tvrc =
BTcount((char*)&t->pst_sym.pst_value.pst_s_root.pst_tvrm,
BITS_IN(t->pst_sym.pst_value.pst_s_root.pst_tvrm));
/*
** We will append qualification (if there is one) if the
** following holds:
** 1) This is not an SQL (must be QUEL) query OR
** 2) if node is ROOT or SUBSEL (i.e. not an AGHEAD) then there
** were no AGHEADs found in its left subtree
**
** Let QUAL <==> there is a qualification,
** SQL <==> language is SQL
** ROOT <==> node type is ROOT
** SUBSEL <==> node type is SUBSEL
** AGG <==> node type is AGHEAD
** SAW_AGG <==> mask & PSS_1SAW_AGG. Then
**
** (Do not apply qualification) <==>
** !QUAL + SQL * (ROOT + SUBSEL) * SAW_AGG -->
** (Apply qualification) <==>
** !(!QUAL + SQL * (ROOT + SUBSEL) * SAW_AGG) <==>
** QUAL * !(SQL * (ROOT + SUBSEL) * SAW_AGG) <==>
** QUAL * (!SQL + !((ROOT + SUBSEL) * SAW_AGG)) <==>
** QUAL * (!SQL + !(ROOT + SUBSEL) + !SAW_AGG) <==>
** QUAL * (!SQL + AGG + !SAW_AGG)
*/
if (vqual &&
(cb->pss_lang != DB_SQL ||
t->pst_sym.pst_type == PST_AGHEAD ||
(*l_mask & PSS_1SAW_AGG) == 0))
{
PST_QNODE *vqual_copy;
dup_rb->pss_tree = vqual;
dup_rb->pss_dup = &vqual_copy;
status = pst_treedup(cb, dup_rb);
dup_rb->pss_tree = (PST_QNODE *)NULL;
dup_rb->pss_dup = (PST_QNODE **)NULL;
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* append view qualification */
status = psy_apql(cb, dup_rb->pss_mstream, vqual_copy, t,
dup_rb->pss_err_blk);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
}
}
/* left & right have been processed */
break;
case PST_VAR:
/*
** This is a terminal node - the expectation is that left & right are 0
*/
/*
** Check for a VAR node but of a different variable than the one
** we are substituting for. REPLACE CURSOR (quel version) is an
** exception because the substitution variable (resvar) is not
** defined, in that case we do not want to execute the code
** below, but want to continue the translation process.
*/
if (vn != -1 && t->pst_sym.pst_value.pst_s_var.pst_vno != vn)
break;
/*
** if this is a reference to a TID attribute of a view (which is not
** a "real" attribute), it needs to be translated into a reference
** to the TID attribute of the view's underlying table or view
*/
if (t->pst_sym.pst_value.pst_s_var.pst_atno.db_att_id == 0 &&
vmode == PSQ_VIEW)
{
t->pst_sym.pst_value.pst_s_var.pst_vno =
BTnext(-1, (char *) from_list, sizeof(*from_list));
}
else
{
PST_QNODE *v;
/* find var in vtree */
status = psy_vfind((u_i2)t->pst_sym.pst_value.pst_s_var.pst_atno.db_att_id,
transtree, &v, dup_rb->pss_err_blk);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
if (v == (PST_QNODE *)NULL)
{
/* attribute not defined in view */
if (vmode == PSQ_VIEW)
{
psf_error(E_PS0D03_ATT_NOT_FOUND, 0L, PSF_INTERR, &err_code,
dup_rb->pss_err_blk, 0);
status = E_DB_SEVERE;
proot = NULL; /* Exiting to return error */
break;
}
/* append defaults for integrity. Integrity might exist on a value
** we are appending by default. I.e., the attribute was not mentioned
** in the target list. We replace the var node in the integrity with
** a default value so that the integrity will read 'default value' ?
** value.
*/
else if (vmode == PSQ_APPEND)
{
status = psl_make_default_node(cb, dup_rb->pss_mstream, resvar,
t->pst_sym.pst_value
.pst_s_var.pst_atno.db_att_id,
&v, dup_rb->pss_err_blk);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* Try to cast to column type */
status = psl_mk_const_similar(cb, dup_rb->pss_mstream,
&t->pst_sym.pst_dataval,
&v, dup_rb->pss_err_blk, NULL);
if (DB_FAILURE_MACRO(status))
return(status);
/* If we ended up with a sequence default, fail. This is an
** unreasonable situation, integrity where tests should not apply
** to sequence defaults.
*/
if (v->pst_sym.pst_type == PST_SEQOP)
{
psf_error(6319, 0, PSF_USERERR, &err_code,
dup_rb->pss_err_blk, 0);
status = E_DB_ERROR;
proot = NULL; /* Exiting to return error */
break;
}
}
/* we would like to delete the qualification for this node since the
** value is not changing and thus we don't need to worry about integrity
** constaints on it. However, we don't do that. Instead we have the
** integrity refer to the value in the current row that reflects the
** value for the attribute. In the replace statement (not replace
** cursor) we just perform the retrieve, the qualification is unneeded
** but doesn't hurt anything. We want to avoid causing a retrieve for
** each update cursor; therefore, we change the varnode to refer to the
** current value (ie the retrieve has already been done).
*/
else if (vmode == PSQ_REPCURS)
{
PST_CRVAL_NODE curval;
/* Create a CURVAL node for the corresponding column */
curval.pst_curcol.db_att_id =
t->pst_sym.pst_value.pst_s_var.pst_atno.db_att_id;
STRUCT_ASSIGN_MACRO(*cursid, curval.pst_cursor);
status = pst_node(cb, dup_rb->pss_mstream, (PST_QNODE *)NULL,
(PST_QNODE *)NULL, PST_CURVAL, (PTR)&curval, sizeof(curval),
t->pst_sym.pst_dataval.db_datatype,
t->pst_sym.pst_dataval.db_prec,
t->pst_sym.pst_dataval.db_length,
(DB_ANYTYPE *)t->pst_sym.pst_dataval.db_data, &v,
dup_rb->pss_err_blk, (i4) 0);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
}
}
else
{
dup_rb->pss_tree = v;
dup_rb->pss_dup = &v;
status = pst_treedup(cb, dup_rb);
dup_rb->pss_tree = (PST_QNODE *)NULL;
dup_rb->pss_dup = (PST_QNODE **)NULL;
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* When called from psy_integ() v will be found but
** may still need constants to be cast.
*/
if ((v != (PST_QNODE *)NULL) &&
(v->pst_sym.pst_type == PST_CONST))
{
bool handled;
/* Try to cast to column type */
status = psl_mk_const_similar(cb, dup_rb->pss_mstream,
&t->pst_sym.pst_dataval,
&v, dup_rb->pss_err_blk,
&handled);
if (DB_FAILURE_MACRO(status))
return(status);
}
}
/* replace VAR node */
if (v != (PST_QNODE *)NULL)
{
*proot = v;
}
}
/* left and right should have been null as we are on a terminal */
break;
case PST_RESDOM:
/* Process `TID' resdom used by DELETE, REPLACE and OPEN CURSOR */
if (t->pst_sym.pst_value.pst_s_rsdm.pst_rsno == 0 &&
(qmode == PSQ_DELETE || qmode == PSQ_REPLACE ||
qmode == PSQ_DEFCURS || qmode == PSQ_REPDYN))
{
/*
** If resvar not specified, or if not resvar, ignore leaf.
*/
if (resvar && vn == resvar->pss_rgno)
{
/* t->right better be VAR node, attno 0 */
t = t->pst_right;
if (t->pst_sym.pst_type != PST_VAR ||
t->pst_sym.pst_value.pst_s_var.pst_atno.db_att_id != 0 ||
t->pst_sym.pst_value.pst_s_var.pst_vno != vn)
{
(VOID) psf_error(E_PS0D02_BAD_TID_NODE, 0L, PSF_INTERR, &err_code,
dup_rb->pss_err_blk, 0);
status = E_DB_SEVERE;
proot = NULL; /* Exiting to return error */
break;
}
}
else if (t->pst_right)
/* Process the right branch */
psy_push(&stk, (PTR)&t->pst_right, &status);
}
else if (t->pst_right)
/* Process the right branch */
psy_push(&stk, (PTR)&t->pst_right, &status);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
/* Process left branch */
if (t->pst_left)
psy_push(&stk, (PTR)&t->pst_left, &status);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
break;
default:
/*
** Just ensure that we traverse the tree
*/
if (t->pst_right)
psy_push(&stk, (PTR)&t->pst_right, &status);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
if (t->pst_left)
psy_push(&stk, (PTR)&t->pst_left, &status);
if (DB_FAILURE_MACRO(status))
{
proot = NULL; /* Exiting to return error */
break;
}
break;
}
if (!proot) /* We're breaking out early to exit */
break;
/*
** Get next deferred node
*/
proot = (PST_QNODE**)psy_pop(&stk);
}
/* Release any outstanding entries */
psy_pop_all(&stk);
return status;
}
DB_STATUS
pst_ruledup(
PSS_SESBLK *sess_cb,
PSF_MSTREAM *mstream,
i4 filter,
char *col_mask,
PST_STATEMENT *stmt_tree,
PST_STATEMENT **stmt_dup,
DB_ERROR *err_blk)
{
PST_STATEMENT *curs; /* Current stmt to walk through list */
PST_STATEMENT *ifs; /* IF statement */
PST_STATEMENT *cps; /* CP statement */
PST_STATEMENT *prev_if; /* Previous IF and CP statements to */
PST_STATEMENT *prev_cp; /* patch dangling pointers */
PST_STATEMENT *cur_rule; /* PTR to CP node or IF-CP node pair */
PST_STATEMENT *result; /* Return value - start of list */
PSC_RULE_TYPE *rtype; /* Filter rule type */
DB_COLUMN_BITMAP tst_mask; /* test mask for update columns */
DB_STATUS status;
PSS_DUPRB dup_rb;
i4 err_code;
*stmt_dup = result = NULL;
if ((curs = stmt_tree) == NULL) /* Nothing doing */
return (E_DB_OK);
prev_if = NULL;
prev_cp = NULL;
/* initialize fields in dup_rb */
dup_rb.pss_op_mask = 0;
dup_rb.pss_num_joins = PST_NOJOIN;
dup_rb.pss_tree_info = (i4 *) NULL;
dup_rb.pss_mstream = mstream;
dup_rb.pss_err_blk = err_blk;
while (curs != NULL)
{
/*
** Filter out current rule if not applicable. Check statement type of
** caller and rule, and column mask.
*/
if (filter != 0)
{
if ((rtype = (PSC_RULE_TYPE *)curs->pst_opf) == NULL)
{
psf_error(E_PS0C06_BAD_STMT, 0L, PSF_INTERR,
&err_code, err_blk, 1,
sizeof("PSC_RULE_TYPE.pst_opf")-1,
"PSC_RULE_TYPE.pst_opf");
return (E_DB_ERROR);
}
/* copy the bitmap of the rule to an overwriteable test mask,
** and test that against the bitmap of columns being updated
*/
MEcopy((PTR) &rtype->psr_columns,
sizeof(DB_COLUMN_BITMAP), (PTR) &tst_mask);
BTand((i4) DB_COL_BITS,
(char *) col_mask, (char *) tst_mask.db_domset);
/* Check statement type of caller and rule,
** and check result of column bitmap test.
*/
if ( ((rtype->psr_statement & filter) == 0)
|| (BTcount((char *) tst_mask.db_domset, DB_COL_BITS) == 0)
)
{
curs = curs->pst_next; /* Skip this one */
continue;
}
}
ifs = cps = NULL; /* Current ones start out nulled */
/* If found IF, allocate node, patch pointers & continue with CP node */
if (curs->pst_type == PST_IF_TYPE)
{
status = psf_malloc(sess_cb, mstream, sizeof(*ifs), (PTR*)&ifs, err_blk);
if (status != E_DB_OK)
return (status);
STRUCT_ASSIGN_MACRO(*curs, *ifs);
if (filter != 0) /* Detach for safety when filtering */
ifs->pst_opf = NULL;
/* Patch/copy IF condition pointer and confirm it exists*/
dup_rb.pss_tree = curs->pst_specific.pst_if.pst_condition;
dup_rb.pss_dup = &ifs->pst_specific.pst_if.pst_condition;
status = pst_treedup(sess_cb, &dup_rb);
if (status != E_DB_OK)
return (status);
if (ifs->pst_specific.pst_if.pst_condition == NULL)
{
psf_error(E_PS0C06_BAD_STMT, 0L, PSF_INTERR,
&err_code, err_blk, 1,
sizeof("PST_IF.pst_condition") - 1,
"PST_IF.pst_condition");
return (E_DB_ERROR);
}
/* True and False links done later */
curs = ifs->pst_link; /* Better be a CP statement node */
} /* If found an IF node */
if (curs->pst_type != PST_CP_TYPE)
{
psf_error(E_PS0C06_BAD_STMT, 0L, PSF_INTERR,
&err_code, err_blk, 1,
sizeof("PST_CP") - 1, "PST_CP");
return (E_DB_ERROR);
}
/* Allocate and initialize CP node */
status = psf_malloc(sess_cb, mstream, sizeof(*cps), (PTR *)&cps, err_blk);
if (status != E_DB_OK)
return (status);
STRUCT_ASSIGN_MACRO(*curs, *cps);
if (filter != 0) /* Detach for safety when filtering */
cps->pst_opf = NULL;
/* If there are any arguments patch/copy arguments list pointer */
if (curs->pst_specific.pst_callproc.pst_arglist != NULL)
{
dup_rb.pss_tree = curs->pst_specific.pst_callproc.pst_arglist;
dup_rb.pss_dup = &cps->pst_specific.pst_callproc.pst_arglist;
status = pst_treedup(sess_cb, &dup_rb);
if (status != E_DB_OK)
return (status);
}
/* Adjust pointers of [IF node and] CP node */
if (ifs != NULL)
{
cur_rule = ifs; /* Rule pair is IF->CP */
ifs->pst_link = cps;
ifs->pst_specific.pst_if.pst_true = cps;
}
else
{
cur_rule = cps; /* Rule is just CP */
}
if (result == NULL) /* 1st rule - no patch needed */
{
result = cur_rule;
}
else /* Patch dangling pointers of previous [IF node &] CP node */
{
if (prev_if != NULL)
{
prev_if->pst_next = cur_rule;
prev_if->pst_specific.pst_if.pst_false = cur_rule;
}
prev_cp->pst_next = cur_rule;
prev_cp->pst_link = cur_rule;
}
/* Move on to next statement */
prev_if = ifs;
prev_cp = cps;
curs = curs->pst_next;
} /* While there are more statements */
/* Clear dangling pointers of last [IF node and] CP node */
if (prev_if != NULL)
{
prev_if->pst_next = NULL;
prev_if->pst_specific.pst_if.pst_false = NULL;
}
if (prev_cp != NULL) /* Could be null if all were filtered out */
{
prev_cp->pst_next = NULL;
prev_cp->pst_link = NULL;
}
*stmt_dup = result;
return (E_DB_OK);
} /* pst_ruledup */
/*{
** Name: opn_jmaps - set various join operator tree maps
**
** Description:
{@comment_line@}...
**
** Inputs:
** subquery ptr to subquery being analyzed
** nodep ptr to current operator node which
** will have maps initialized
** ojmap NULL if no outer joins exist
** - map of outer joins which are
** evaluated in parent nodes.
**
** Outputs:
** nodep->opn_eqm set of equivalence class available
** from subtree
** nodep->opn_rlmap bitmap of relations in the subtree
** nodep->opn_rlasg order in which the relations in
** opn_rlmap are assigned to the leaves
** Returns:
** TRUE if there is a valid placement of subselect nodes with
** all required equivalence classes available for execution of the
** boolean factor used for the subselect
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 11-jun-86 (seputis)
** initial creation from setjmaps
** 29-mar-90 (seputis)
** fix byte alignment problems
** 2-apr-91 (seputis)
** only partially copied relation assignment causing run_all diffs
** fix for b35461, this would cause the OPF cache of query plans
** to not be effectively used, and could cause performance problems
** on non-VMS systems. This fix should be used whenever a poor
** query plan bug is reported which cannot be reproduced on VMS.
** 15-feb-94 (ed)
** - bug 59598 - correct mechanism in which boolean factors are
** evaluated at several join nodes
** 11-apr-94 (ed)
** - bug 59937 - E_OP0489 consistency check due to inner join ojid
** not being visible in boolean factor placement maps
** 31-jul-97 (inkdo01)
** Fix to force SVAR func atts ref'ed in ON clauses to materialize
** just before needed (to incorporate proper null semantics).
** 9-jul-99 (hayke02 for inkdo01)
** Set opn_eqm bits in lower level nodes (e.g. leaf nodes) when
** func attrs are found in higher level OJ nodes. This change
** fixes bug 92749.
** 20-Mar-02 (wanfr01)
** Bug 106678, INGSRV 1633
** Confirm function attribute as an ojid before associating it
** with an outer join node.
** 16-sep-03 (hayke02)
** Check for OPN_OJINNERIDX in nodep->opn_jmask to indicate that
** placement of a coverqual inner index outer join needs to be
** checked.
** 28-apr-04 (hayke02)
** Modify previous change so that we return FALSE and reject the QEP
** if the index outer join node (node->LEFT) has a non-zero opn_nchild
** for node->LEFT->RIGHT. This will allow only QEPs where the OJ
** inner is the index only and not the index joined to another
** relation. This change fixes problem INGSRV 2808, bug 112211.
** 05-Oct-2004 (huazh01)
** Remove the above fix. The fix for 111627 handles b106678
** as well. This fixes b113160, INGSRV2984.
** 14-mar-05 (hayke02)
** Modify the fix for problem INGSRV 2808, bug 112211 so that we now
** check for more than 1 var in the opl_ivmap. This now allows the
** correct rejection of plans that have had their opn_child's set up
** with left joins 'reversed' into right joins. This change fixes
** problems INGSRV 3049 and 3094, bugs 113457 and 113990.
** 23-sep-05 (hayke02)
** Check for a WHERE clause (OPL_NOOOUTER opz_ojid) OJSVAR func att,
** and make sure that all OJs that this func att is inner to are
** executed before the join involving this func att. This change fixes
** bug 114912.
** 30-jan-07 (hayke02)
** Disable the fix for bug 114912 for cart prod (OPL_BOJCARTPROD) OJs.
** This change fixes bug 117513.
** 27-Oct-2009 (kiria01) SIR 121883
** Scalar sub-selects - protect subp->opv_eqcrequired from bad de-ref.
[@history_line@]...
*/
bool
opn_jmaps(
OPS_SUBQUERY *subquery,
OPN_JTREE *nodep,
OPL_BMOJ *ojmap)
{
OPL_OUTER *outerp;
if (nodep->opn_nleaves == 1)
{ /* leaf node */
OPV_IVARS varno; /* joinop range variable number
** of leaf */
varno = nodep->opn_prb[0]; /* by definition of leaf - only
** one variable in partition */
nodep->opn_rlasg[0] = varno; /* trivial ordering for leaf */
MEfill( sizeof(nodep->opn_rlmap), (u_char)0, (PTR)&nodep->opn_rlmap );
if (subquery->ops_oj.opl_lv > 0)
{
MEfill( sizeof(nodep->opn_ojinnermap),
(u_char)0, (PTR)&nodep->opn_ojinnermap);
MEfill( sizeof(nodep->opn_ojevalmap),
(u_char)0, (PTR)&nodep->opn_ojevalmap);
opl_sjij(subquery, varno, &nodep->opn_ojinnermap, ojmap);
}
BTset((i4)varno, (char *)&nodep->opn_rlmap); /* only one bit set for leaf*/
MEcopy ((PTR)&subquery->ops_vars.opv_base->opv_rt[varno]->opv_maps.opo_eqcmap,
sizeof(nodep->opn_eqm), (PTR)&nodep->opn_eqm ); /* copy map of
** equivalence classes
** associated with varno of this
** leaf */
return(TRUE);
}
else
{ /* non-leaf node */
OPN_JTREE *leftchildp; /* ptr to left child node */
OPN_JTREE *rightchildp; /* ptr to right child node */
leftchildp = nodep->opn_child[OPN_LEFT];
rightchildp = nodep->opn_child[OPN_RIGHT];
if (ojmap)
{
MEfill(sizeof(nodep->opn_ojevalmap), (u_char)0,
(PTR)&nodep->opn_ojevalmap);
if( (nodep->opn_ojid >= 0)
&&
!BTtest((i4)nodep->opn_ojid, (char *)ojmap))
{ /* setup the outer join map which contains all outer joins
** which are completely evaluated within this subtree */
BTset((i4)nodep->opn_ojid, (char *)&nodep->opn_ojevalmap);
BTset((i4)nodep->opn_ojid, (char *)ojmap);
}
}
if (!opn_jmaps (subquery, leftchildp, ojmap)) /* get info on left child */
return(FALSE);
if (!opn_jmaps (subquery, rightchildp, ojmap)) /* get info on right child */
return(FALSE);
MEcopy ((PTR)&leftchildp->opn_rlmap,
sizeof(nodep->opn_rlmap),
(PTR)&nodep->opn_rlmap ); /* get var bitmap from left
** child */
BTor( (i4)BITS_IN(nodep->opn_rlmap),
(char *)&rightchildp->opn_rlmap,
(char *)&nodep->opn_rlmap ); /* "OR" rightchildp->opn_rlmap
** into nodep->opn_rlmap */
if (ojmap)
{ /* setup ojinnermap which contains all outer joins which are
** partially or totally evaluated within this subtree, but
** not at this node unless it is in the subtree */
MEcopy((PTR)&leftchildp->opn_ojinnermap,
sizeof(leftchildp->opn_ojinnermap),
(PTR)&nodep->opn_ojinnermap);
BTor((i4)BITS_IN(rightchildp->opn_ojinnermap),
(char *)&rightchildp->opn_ojinnermap,
(char *)&nodep->opn_ojinnermap);
if (leftchildp->opn_ojid >= 0)
BTset((i4)leftchildp->opn_ojid, (char *)&nodep->opn_ojinnermap);
if (rightchildp->opn_ojid >= 0)
BTset((i4)rightchildp->opn_ojid, (char *)&nodep->opn_ojinnermap);
if (subquery->ops_mask & OPS_IJCHECK)
opl_ijcheck(subquery, &leftchildp->opn_ojinnermap,
&rightchildp->opn_ojinnermap, &nodep->opn_ojinnermap,
&leftchildp->opn_ojevalmap, &rightchildp->opn_ojevalmap,
&nodep->opn_rlmap);
/* map of outerjoins which are entirely evaluated within
** this subtree */
BTor((i4)BITS_IN(leftchildp->opn_ojevalmap),
(char *)&leftchildp->opn_ojevalmap,
(char *)&nodep->opn_ojevalmap);
BTor((i4)BITS_IN(rightchildp->opn_ojevalmap),
(char *)&rightchildp->opn_ojevalmap,
(char *)&nodep->opn_ojevalmap);
if ((nodep->opn_jmask & OPN_OJINNERIDX) &&
((nodep->opn_ojid != nodep->opn_child[OPN_LEFT]->opn_ojid) ||
((nodep->opn_ojid == nodep->opn_child[OPN_LEFT]->opn_ojid) &&
(nodep->opn_ojid >= 0) &&
(BTcount((char *)subquery->ops_oj.opl_base->opl_ojt
[nodep->opn_ojid]->opl_ivmap, subquery->ops_vars.opv_rv) > 1))))
return(FALSE);
}
MEcopy ((PTR)leftchildp->opn_rlasg,
leftchildp->opn_nleaves * sizeof(nodep->opn_rlasg[0]),
(PTR)nodep->opn_rlasg); /* get relations from left
** child */
MEcopy ((PTR)rightchildp->opn_rlasg,
rightchildp->opn_nleaves * sizeof(nodep->opn_rlasg[0]),
(PTR)(nodep->opn_rlasg + leftchildp->opn_nleaves)); /* get
** relations from right child
** and place them beside the
** ones from the left child */
MEcopy ((PTR)&leftchildp->opn_eqm,
sizeof(nodep->opn_eqm),
(PTR)&nodep->opn_eqm ); /* copy equivalence class map
** from left child to this node
*/
BTor( (i4)BITS_IN(nodep->opn_eqm),
(char *)&rightchildp->opn_eqm,
(char *)&nodep->opn_eqm ); /* "OR" right child equivalence
** map into this to produce
** map for this node */
if (subquery->ops_joinop.opj_virtual)
{ /* there is a subselect in this query so check for availability
** of equivalence classes used for evaluation of boolean factors
** containing the subselect
*/
OPV_SUBSELECT *subp; /* ptr to subselect descriptor
** for range variable */
if ( (rightchildp->opn_nleaves == 1)
&&
(
subp = subquery->ops_vars.opv_base->
opv_rt[rightchildp->opn_prb[0]]->opv_subselect
)
)
{ /* right child is a subselect so test for correct leaf
** placement */
if (!subp->opv_eqcrequired ||
!BTsubset( (char *)subp->opv_eqcrequired,
(char *)&nodep->opn_eqm,
(i4)BITS_IN(OPE_BMEQCLS)
)
)
return (FALSE); /* cannot evaluate all boolean
** factors with SEJOIN nodes
** in this configuration */
else
{ /* check if all corelated variables are available in the
** outer - FIXME create another pointer field which
** contains this information so this loop is avoided */
for (;subp; subp = subp->opv_nsubselect)
{
if (!BTsubset( (char *)&subp->opv_eqcmp,
(char *)&leftchildp->opn_eqm,
(i4)BITS_IN(OPE_BMEQCLS)
)
)
return (FALSE); /* not all correlated
** equivalence classes
** are available from the outer
** so return */
}
}
}
if ( (leftchildp->opn_nleaves == 1)
&&
(subp = subquery->ops_vars.opv_base->
opv_rt[leftchildp->opn_prb[0]]->opv_subselect)
)
{
if (!subp->opv_eqcrequired ||
!BTsubset( (char *)subp->opv_eqcrequired,
(char *)&nodep->opn_eqm,
(i4)BITS_IN(OPE_BMEQCLS)
)
)
return (FALSE); /* cannot evaluate all boolean
** factors with SEJOIN nodes
** in this configuration */
else
{ /* check if all corelated variables are available in the
** outer - FIXME create another pointer field which
** contains this information so this loop is avoided */
for (;subp; subp = subp->opv_nsubselect)
{
if (!BTsubset( (char *)&subp->opv_eqcmp,
(char *)&rightchildp->opn_eqm,
(i4)BITS_IN(OPE_BMEQCLS)
)
)
return (FALSE); /* not all correlated
** equivalence classes
** are available from the outer
** so return */
}
}
}
}
if ((subquery->ops_oj.opl_lv > 0)
&&
(nodep->opn_ojid != OPL_NOOUTER))
{
OPV_IVARS maxvar;
/* this is an outer join function attribute which should
** only appear at the point that the outer join is
** actually performed */
maxvar = subquery->ops_vars.opv_rv;
outerp = subquery->ops_oj.opl_base->opl_ojt[nodep->opn_ojid];
if ((outerp->opl_type == OPL_LEFTJOIN)
||
(outerp->opl_type == OPL_FULLJOIN))
{
OPV_BMVARS tempvmap;
OPV_IVARS innervar;
MEcopy((PTR)outerp->opl_maxojmap, sizeof(tempvmap),
(PTR)&tempvmap);
BTand((i4)BITS_IN(tempvmap), (char *)&nodep->opn_rlmap,
(char *)&tempvmap);
for (innervar = -1; (innervar = BTnext((i4)innervar,
(char *)&tempvmap, (i4)maxvar))>=0;)
{
OPE_IEQCLS ojeqcls;
ojeqcls = subquery->ops_vars.opv_base->opv_rt
[innervar]->opv_ojeqc;
if (ojeqcls != OPE_NOEQCLS)
BTset((i4)ojeqcls, (char *)&nodep->opn_eqm);
}
}
}
{ /* determine multi-variable functions that can first be calculated
** at this node
*/
OPZ_IFATTS fattr; /* current function attribute
** being analyzed */
OPZ_IFATTS maxfattr; /* maximum number of function
** attributes defined */
OPZ_FT *fbase; /* ptr to base of array of ptrs
** to function attribute
** elements */
OPZ_AT *abase; /* ptr to base of array of ptrs
** to joinop attribute elements
*/
maxfattr = subquery->ops_funcs.opz_fv; /* number of function
** attributes defined */
fbase = subquery->ops_funcs.opz_fbase; /* ptr to base of array
** of function attributes */
abase = subquery->ops_attrs.opz_base; /* ptr to base of array
** of ptrs to joinop attribute
** elements */
for (fattr = 0; fattr < maxfattr ; fattr++)
{
OPZ_FATTS *fattrp; /* ptr to current function
** attribute being analyzed */
OPE_IEQCLS eqcls; /* equivalence class of the
** multi-variable function
** attribute */
fattrp = fbase->opz_fatts[fattr];
eqcls = abase->opz_attnums[fattrp->opz_attno]->opz_equcls; /*
** equivalence class associated
** with the multi-variable
** function attribute */
/* check for WHERE clause (OPL_NOOUTER opz_ojid) OJSVAR func att
** and then make sure that all OJs that this func att is inner
** to are executed before the join involving this func att
*/
if (fattrp->opz_type == OPZ_SVAR
&&
(fattrp->opz_mask & OPZ_OJSVAR)
&&
nodep->opn_ojid != OPL_NOOUTER
&&
fattrp->opz_ojid == OPL_NOOUTER
&&
(fattrp->opz_ijmap
&&
BTtest((i4)nodep->opn_ojid, (char *)fattrp->opz_ijmap)
&&
!(outerp->opl_mask & OPL_BOJCARTPROD)))
{
OPZ_IATTS attno;
bool allinrlmap = TRUE;
OPE_EQCLIST *eqclsp;
eqclsp = subquery->ops_eclass.ope_base->ope_eqclist[eqcls];
for (attno = -1; (attno = BTnext((i4)attno,
(PTR)&eqclsp->ope_attrmap,
(i4)subquery->ops_attrs.opz_av)) != -1; )
{
if (!BTtest((i4)abase->opz_attnums[attno]->opz_varnm,
(char *)&nodep->opn_rlmap))
{
allinrlmap = FALSE;
break;
}
}
if (allinrlmap)
return(FALSE);
}
if ((fattrp->opz_type != OPZ_MVAR)
&& !(fattrp->opz_type == OPZ_SVAR &&
fattrp->opz_mask & OPZ_OJSVAR &&
fattrp->opz_ojid == nodep->opn_ojid)
||
(fattrp->opz_mask & OPZ_OJFA))
continue; /* only multi-variable
** functions are assigned here
** (and SVARs in ON clauses
** of OJs eval'd at this node)
** since others where assigned
** earlier, ... also outer join
** special eqc were assigned
** prior to this loop */
if (fattrp->opz_type == OPZ_SVAR)
{
/* Must be ON clause ref'ed SVAR. Set bit in whichever
** child node covers the SVAR eqcmap. */
if (BTsubset((char *)&fattrp->opz_eqcm,
(char *)&nodep->opn_child[1]->opn_eqm,
(i4)BITS_IN(nodep->opn_eqm)))
BTset((i4)eqcls, (char *)&nodep->opn_child[1]->opn_eqm);
else if (BTsubset((char *)&fattrp->opz_eqcm,
(char *)&nodep->opn_child[0]->opn_eqm,
(i4)BITS_IN(nodep->opn_eqm)))
BTset((i4)eqcls, (char *)&nodep->opn_child[0]->opn_eqm);
/* set fattr eqcls bit in
** proper child opn_eqm */
continue;
}
if (BTtest( (i4)eqcls, (char *)&nodep->opn_eqm))
continue; /* if function attribute has
** been added then
** continue */
if (BTsubset((char *)&fattrp->opz_eqcm,
(char *)&nodep->opn_eqm,
(i4)BITS_IN(nodep->opn_eqm))
)
BTset((i4)eqcls, (char *)&nodep->opn_eqm); /* set bit if all
** the required equivalence
** classes are available
** for the function attribute
*/
}
}
}
return(TRUE);
}
/*{
** Name: opa_obylist - replace variables in outer by inner
**
** Description:
** This procedure will attempt to replace the variables in the outer
** aggregate by using bylist attributes of the inner aggregate.
**
** Inputs:
** global global state variable
** inner inner function aggregate subquery
** whose bylist will be used to attempt
** to replace the outer aggregate variables
** outer outer aggregate subquery whose variables
** will possibly be replaced by the inner
**
** Outputs:
** Returns:
** VOID
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 15-apr-86 (seputis)
** initial creation
** 16-may-96 (inkdo01)
** Change 409554 has been backed out to fix bug 74793. It claimed to
** eliminate obsolete code (because of change 409457), but the code
** appears to have still been necessary for queries involving outer
** joins of aggregate views.
** 3-dec-02 (inkdo01)
** Changes for range table expansion.
** 23-nov-05 (inkdo01)
** Fix a bug in one of the more complex expressions that derived from
** the range table expansion.
[@history_line@]...
*/
static VOID
opa_obylist(
OPS_STATE *global,
OPS_SUBQUERY *inner,
OPS_SUBQUERY *outer)
{
OPV_GBMVARS outermap; /* var map of outer aggregate */
opv_smap(outer); /* get variable map of outer aggregate */
MEcopy((char *)&outer->ops_root->pst_sym.pst_value.pst_s_root.pst_lvrm,
sizeof(outermap), (char *)&outermap);
BTor(OPV_MAXVAR, (char *)&outer->ops_root->pst_sym.pst_value.pst_s_root.pst_rvrm,
(char *)&outermap);
opv_smap(inner); /* get variable map of inner aggregate */
BTand(OPV_MAXVAR, (char *)&inner->ops_agg.opa_blmap, (char *)&outermap);
if (BTcount((char *)&outermap, OPV_MAXVAR) == 0)
/* if the outer aggregate and the inner aggregate do not have any
** variables in common then there can be no replacement so return.
*/
return;
BTor(OPV_MAXVAR, (char *)&inner->ops_root->pst_sym.pst_value.pst_s_root.pst_tvrm,
(char *)&outer->ops_aggmap);
BTor(OPV_MAXVAR, (char *)&inner->ops_root->pst_sym.pst_value.pst_s_root.pst_lvrm,
(char *)&outer->ops_aggmap);
BTor(OPV_MAXVAR, (char *)&inner->ops_root->pst_sym.pst_value.pst_s_root.pst_rvrm,
(char *)&outer->ops_aggmap);
/* this set of variables could be substituted
** in the outer, so they are not to be
** assumed to be in the from list for
** a cartesean product as in the query
** "select r.a from r,s" */
{
OPV_GBMVARS usedmap; /* var map of variables which were
** replaced by substituting the
** bylist attributes of the inner
*/
OPV_GBMVARS newmap; /* var map of the outer aggregate
** after the inner aggregate bylist
** used to substitute expressions
** in the outer
*/
OPV_GBMVARS tempmap;
MEfill(sizeof(usedmap), 0, (char *)&usedmap);
/* initialize var map */
opa_checkopt(global, inner->ops_agg.opa_byhead->pst_left, outer->ops_root,
&usedmap, &newmap); /* this routine will return information
** on what the query tree would
** look like if the inner aggregate
** was substituted (without actually
** doing the substitution)
*/
MEcopy((char *)&newmap, sizeof(newmap), (char *)&tempmap);
BTand(OPV_MAXVAR, (char *)&usedmap, (char *)&tempmap);
/* This replaces the old (32 bit varmap) test of "usedmap &&
** !(newmap & usedmap)". */
if (BTcount((char *)&usedmap, OPV_MAXVAR) != 0 &&
/* non-zero implies some optimizations
** were found */
BTcount((char *)&tempmap, OPV_MAXVAR) == 0)
/* the substitution would eliminate
** those variables entirely */
{
/* COMMIT THE CHANGES
** the usedmap is non-zero so some variable subtitutions were
** found. Moreover, the substitutions would entirely eliminate
** the variables since newmap is non-zero
**
** First making a copy of the bylist for the outer aggregate
** if it exists (and if it is not the main query). This
** is done to avoid the problem of optimizing away the links
** made by the outer aggregate. For example, in the query
** RETRIEVE SUPPLIERS WHO SUPPLY ALL PARTS
** ret( s.sname, s.s) where any(p.p by s.s where any(sp.tid
** by p.p,s.s where p.p=sp.p and s.s=sp.s)=0)=0
** In this query the outer aggregate references only attributes
** in the BY list of the inner aggregate, and won't have the
** aggregate result linked to the main query ... if we did
** not make a copy of the bylist ... remember that the outer
** aggregate was linked to the main query by using the by list
** subtrees directly!
** FIXME - OPA_LINK will copy the bylists anyways so this copy
** is not needed
*/
OPV_IGVARS innervarno; /* var number of inner
** aggregate which will be
** referenced for substitution */
if (outer->ops_sqtype == OPS_MAIN)
global->ops_gmask |= OPS_TCHECK;
else if (outer->ops_agg.opa_byhead) /* outer aggregate has a by list */
{
PST_QNODE *bylist; /* used to traverse the bylist */
/* traverse the bylist and copy the subtrees */
for ( bylist = outer->ops_agg.opa_byhead->pst_left;
bylist && bylist->pst_sym.pst_type != PST_TREE;
bylist = bylist->pst_left)
opv_copytree( global, &bylist->pst_right );
}
/* Traverse the tree and actually perform the substitutions instead
** of only checking for them
*/
innervarno = (*inner->ops_agg.opa_graft)->pst_sym.pst_value.
pst_s_var.pst_vno;
if (outer->ops_global->ops_qheader->pst_numjoins > 0)
{ /* make sure that all the outer joins semantics are
** the same for all the relations referenced, or else
** semantics are lost, i.e. cannot substitute if variables
** have different maps */
PST_J_MASK pinner;
PST_J_MASK pouter;
bool first_time;
OPV_IGVARS gvar;
PST_J_MASK *ijmaskp;
PST_J_MASK *ojmaskp;
OPL_PARSER *pinnerp;
OPL_PARSER *pouterp;
first_time = TRUE;
pinnerp = outer->ops_oj.opl_pinner;
pouterp = outer->ops_oj.opl_pouter;
for (gvar = -1; (gvar = BTnext((i4)gvar, (char *)&usedmap,
(i4)BITS_IN(usedmap)))>=0;)
{
if (first_time)
{
MEcopy((PTR)&pinnerp->opl_parser[gvar],
sizeof(pinner), (PTR)&pinner);
MEcopy((PTR)&pouterp->opl_parser[gvar],
sizeof(pouter), (PTR)&pouter);
}
else
{
if (MEcmp((PTR)&pinnerp->opl_parser[gvar],
(PTR)&pinner, sizeof(pinner))
||
MEcmp((PTR)&pouterp->opl_parser[gvar],
(PTR)&pouter, sizeof(pouter))
)
return; /* outer joins semantics of
** variables to be substituted are
** different, FIXME, try to substitute
** one variable instead of 2 */
}
}
/* copy the outer join semantics to the substituted variable */
ijmaskp = &pinnerp->opl_parser[innervarno];
ojmaskp = &pouterp->opl_parser[innervarno];
if ((BTnext((i4)-1, (char *)ijmaskp, (i4)BITS_IN(*ijmaskp)) >= 0)
||
(BTnext((i4)-1, (char *)ojmaskp, (i4)BITS_IN(*ojmaskp)) >= 0)
)
opx_error(E_OP0288_OJAGG); /* should not already have an
** outer join defined on this aggregate
** in this query */
MEcopy((PTR)&pinner, sizeof(*ijmaskp), (PTR)ijmaskp);
MEcopy((PTR)&pouter, sizeof(*ojmaskp), (PTR)ojmaskp);
}
outer->ops_vmflag = FALSE; /* bitmaps need to be updated if a
** substitution on the outer is made */
opa_commit(global, inner->ops_agg.opa_byhead->pst_left,
&outer->ops_root, innervarno); /* this routine will traverse
** the tree in the same way as
** opa_checkopt except that
** substitutions will actually be made
*/
global->ops_gmask &= (~OPS_TCHECK);
}
}
}
/*{
** Name: opa_checkopt - check for possibility of optimization
**
** Description:
** This routine will create variable map of what the outer aggregate
** would appear like if all possible substitutions of the inner aggregate
** bylist attributes were made. The map of the all the inner aggregate
** bylist elements used in the substitution is also created. Thus, if
** no substitutions are made then this map would be empty.
**
** Inputs:
** global global state variable
** root root of query tree which will
** be analyzed for possible substitutions
** - this root is a subtree of the outer
** aggregate.
** bylist base of bylist which will be
** used for substitutions
**
** Outputs:
** usedmap ptr to map of all variables found
** in the "hit list" i.e. map of variables
** which will be replaced if the
** substitution were actually made
** newmap ptr to varmap of root, filled in if
** the substitutions were actually made
** Returns:
** varmap of root if the substitutions were actually made
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 15-apr-86 (seputis)
** initial creation
** 4-dec-02 (inkdo01)
** Return variable changed to a call-by-ref parm to support
** range table expansion.
[@history_line@]...
*/
static VOID
opa_checkopt(
OPS_STATE *global,
PST_QNODE *bylist,
PST_QNODE *root,
OPV_GBMVARS *usedmap,
OPV_GBMVARS *newmap)
{
PST_QNODE *node; /* ptr to current by list element being
** substituted
*/
MEfill(sizeof(*newmap), 0, (char *)newmap); /* init the bit map */
if ( root )
{
for(node = bylist; /* get first element of by list */
node && node->pst_sym.pst_type != PST_TREE; /* at the end of
** the bylist ? */
node = node->pst_left) /* get next bydom attribute */
{
if ( opv_ctrees( global, root, node->pst_right ) )
{
opv_mapvar( root, usedmap); /* update map of global range
** variables used in subtree */
return; /* substitution is made so no vars will
** be contributed to the map of the tree
** after substitution i.e. return 0
*/
}
}
/* try the subtrees if none of the bylist elements matched */
{
OPV_GBMVARS tempmap; /* used to create bit map for var node*/
if (root->pst_sym.pst_type == PST_VAR)
{
OPV_GRV *gvarp; /* global range var associated
** with this node */
BTset( (i4)root->pst_sym.pst_value.pst_s_var.pst_vno,
(char *)newmap);
gvarp = global->ops_rangetab.opv_base->
opv_grv[root->pst_sym.pst_value.pst_s_var.pst_vno];
if (gvarp->opv_gsubselect
&&
gvarp->opv_gsubselect->opv_subquery)
{
MEcopy((char *)&gvarp->opv_gsubselect->opv_subquery->
ops_correlated, sizeof(tempmap), (char *)&tempmap);
BTor(OPV_MAXVAR, (char *)&gvarp->opv_gsubselect->opv_subquery->
ops_fcorelated, (char *)&tempmap);
if (BTcount((char *)&tempmap, OPV_MAXVAR))
{ /* if a correlated subquery is referenced then the
** correlated variables cannot be substituted
** - FIXME need to find all correlated vars, and see if
** enough attributes exist to supply correlated values
** this can be done by running opa_subselect in OPAFINAL.C
** prior to this optimization
** ... also need to make sure the correlated subquery
** is not used in another context as determined by
** opa_compat
** - for now do not substitute correlated variables
*/
BTor( (i4)BITS_IN(OPV_GBMVARS), (char *)
&gvarp->opv_gsubselect->opv_subquery->ops_correlated,
(char *)newmap);
BTor( (i4)BITS_IN(OPV_GBMVARS), (char *)
&gvarp->opv_gsubselect->opv_subquery->ops_fcorelated,
(char *)newmap);
}
}
return; /* return map with bit set for this var
** since a substition will not be made, so
** the var will appear in the optimized tree
** if it is created */
}
else
{
opa_checkopt( global, bylist, root->pst_left, usedmap, newmap);
MEcopy((char *)newmap, sizeof(tempmap), (char *)&tempmap);
BTand(OPV_MAXVAR, (char *)usedmap, (char *)&tempmap);
if (BTcount((char *)&tempmap, OPV_MAXVAR))
/* if the maps have an intersection then abort the search
** since there will not be a commit made
*/
return;
/* traverse the right side of the tree */
opa_checkopt( global, bylist, root->pst_right,usedmap, &tempmap);
BTor(OPV_MAXVAR, (char *)&tempmap, (char *)newmap);
return;
}
}
}
MEfill(sizeof(*newmap), 0, (char *)newmap); /* return empty map */
return;
}
/*{
** Name: OPC_EXCH_BUILD - Build a QEN_EXCH node.
**
** Description:
{@comment_line@}...
**
** Inputs:
[@PARAM_DESCR@]...
**
** Outputs:
[@PARAM_DESCR@]...
** Returns:
** {@return_description@}
** Exceptions:
** [@description_or_none@]
**
** Side Effects:
** [@description_or_none@]
**
** History:
** 13-nov-03 (inkdo01)
** Written for parallel query processing (cloned from opcsorts.c).
** 1-mar-04 (inkdo01)
** Allocate and format bit map to identify DSH-based structures
** to allocate with child DSHs.
** 21-july-04 (inkdo01)
** Change to use index arrays, rather than bit map.
** 6-aug-04 (inkdo01)
** Change setting of || union to opo_punion.
** 31-dec-04 (inkdo01)
** Added parm to opc_materialize to assure there's always exch_mat
** code (fixes 113694).
** 27-Aug-2007 (kschendel) SIR 122512
** Count subplan headers, info used by hashop reservation.
** 14-May-2010 (kschendel) b123565
** Node nthreads now defaults to zero, push counts even for 1:1
** exchange so that QEF knows whether a given node is under an
** exchange or not.
** 19-May-2010 (kschendel) b123759
** Include (new style) partition qualification data in exch counts.
** DSH rows can pop up multiple times, especially in pquals, use
** a bitmap to avoid listing a row more than once (would leak
** memory in QEF, at least for 1:N exchanges).
*/
VOID
opc_exch_build(
OPS_STATE *global,
OPC_NODE *cnode)
{
OPS_SUBQUERY *subqry = global->ops_cstate.opc_subqry;
OPO_CO *co = cnode->opc_cco;
OPC_EQ *ceq = cnode->opc_ceq;
QEN_NODE *qn = cnode->opc_qennode;
QEN_EXCH *ex = &cnode->opc_qennode->node_qen.qen_exch;
QEN_QP *qpp;
QEF_QP_CB *qp = global->ops_cstate.opc_qp;
OPC_NODE outer_cnode;
QEF_AHD *union_action = NULL;
PTR rowmap; /* DSH row tracker */
i4 arr1size, arr2size, i, j, ucount;
i4 arrcnts[IX_MAX];
i4 mapbits, mapbytes;
bool weset_exchn = FALSE;
/* compile the outer tree */
STRUCT_ASSIGN_MACRO(*cnode, outer_cnode);
if (!(global->ops_cstate.opc_flags & OPC_EXCH_N) &&
co->opo_ccount > 1)
{
weset_exchn = TRUE;
global->ops_cstate.opc_flags |= OPC_EXCH_N;
}
qp->qp_status |= QEQP_PARALLEL_PLAN;
outer_cnode.opc_cco = co->opo_outer;
outer_cnode.opc_invent_sort = FALSE;
opc_qentree_build(global, &outer_cnode);
ex->exch_out = outer_cnode.opc_qennode;
ex->exch_ccount = co->opo_ccount;
ex->exch_flag = 0;
cnode->opc_below_rows += outer_cnode.opc_below_rows;
if (global->ops_cstate.opc_flags & OPC_EXCH_N)
ex->exch_flag |= EXCH_NCHILD;
if (weset_exchn)
global->ops_cstate.opc_flags &= ~OPC_EXCH_N;
if (co->opo_punion)
{
ex->exch_flag |= EXCH_UNION;
ex->exch_out->node_qen.qen_qp.qp_flag |= QP_PARALLEL_UNION;
ucount = ex->exch_ccount;
}
else ucount = 1;
/* Count up subplan headers below here, normally 1, but N if this is
** a parallel union. This is purely to help out join reservation,
** so don't bother if child is just an orig.
*/
if (ex->exch_out->qen_type != QE_ORIG)
qp->qp_pqhead_cnt += ucount;
/* Post exch thread-counts to the sub-plan underneath this exch.
** (even if it's a 1:1 exch). This tells everyone that the sub-plan
** will be executed in a child thread. In addition, for the 1:n
** case, the ORIG and partition-compatible joins need to know N.
*/
opc_pushcount(ex->exch_out, ex->exch_ccount);
/* materialize the inner tuple */
opc_materialize(global, cnode, &ex->exch_mat,
&co->opo_maps->opo_eqcmap, ceq,
&qn->qen_row, &qn->qen_rsz, (i4)FALSE, (bool)TRUE, (bool)TRUE);
/* only drop dups if explicitly told to do so. This also disables the
** "only sort on key columns" change (because of odd cases where it seems
** to rely on the additional sort keys in its dups dropping strategies),
** so it's to our advantage to limit the dups dropping cases. */
if ((subqry->ops_duplicates == OPS_DKEEP || subqry->ops_duplicates ==
OPS_DUNDEFINED) && co->opo_odups == OPO_DDEFAULT
)
{
ex->exch_dups = 0;
}
else if (co->opo_odups == OPO_DREMOVE ||
subqry->ops_duplicates == OPS_DREMOVE
)
{
ex->exch_dups = DMR_NODUPLICATES;
}
else
{
/* error */
}
/* CB number for exchange context CB */
opc_ptcb(global, &ex->exch_exchcb, sizeof(EXCH_CB));
/* Fill in the attributes to place in the exchange buffer. */
opc_eexatts(global, &co->opo_maps->opo_eqcmap, ceq,
&ex->exch_atts, &ex->exch_acount);
/* Fill in the atts to merge on. */
ex->exch_macount = 0;
ex->exch_matts = (DMT_KEY_ENTRY **) NULL;
/* To avoid double-counting a row, which is especially easy if PQUAL's
** are around, use a bitmap to track rows. There usually aren't a
** huge number of rows, even in complex query plans.
** Double-counting a row is nonfatal, but it leaks memory for unused
** row buffers in QEF for 1:N plans.
*/
mapbits = global->ops_cstate.opc_qp->qp_row_cnt;
mapbytes = (mapbits + 7) / 8;
rowmap = opu_Gsmemory_get(global, mapbytes);
/* Build buffer/structure index arrays for each child (if || union,
** one set of arrays per child, else just one set of arrays). */
for (i = 0; i < ucount; i++)
{
/* Allocate arrays to identify buffers and structures to attach
** to child DSHs resulting from this EXCH node. First build vector
** of subarray counts for each class of buffers/structs. */
for (j = 0; j < IX_MAX; j++)
arrcnts[j] = 0; /* init count array */
MEfill(mapbytes, 0, rowmap); /* and row tracker */
/* Set subarray counts. */
opc_exnheadcnt(global, qn, arrcnts, rowmap); /* count for EXCH node hdr */
arrcnts[IX_CX]++; /* + 1 for the exch_mat CX */
BTset(OPC_CTEMP, rowmap); /* + the temp row under exch */
if (ex->exch_flag & EXCH_UNION)
opc_exunion_arrcnt(global, qn, &union_action, arrcnts, rowmap);
/* counts for curr union select */
else
opc_exnodearrcnt(global, qn->node_qen.qen_exch.exch_out, arrcnts, rowmap);
/* counts everything under exch */
/* Determine total size of i2 and i4 arrays and alloc memory. */
arrcnts[IX_ROW] = BTcount(rowmap, mapbits);
for (j = 0, arr1size = 0; j < IX_CX; j++)
arr1size += arrcnts[j];
for (j = IX_CX, arr2size = 0; j < IX_MAX; j++)
arr2size += arrcnts[j];
ex->exch_ixes[i].exch_array1 = (i2 *)opu_qsfmem(global, arr1size *
sizeof(i2));
ex->exch_ixes[i].exch_array2 = (i4 *)opu_qsfmem(global, arr2size *
sizeof(i4));
/* Set counts into EXCH. */
ex->exch_ixes[i].exch_row_cnt = arrcnts[IX_ROW];
ex->exch_ixes[i].exch_hsh_cnt = arrcnts[IX_HSH];
ex->exch_ixes[i].exch_hsha_cnt = arrcnts[IX_HSHA];
ex->exch_ixes[i].exch_stat_cnt = arrcnts[IX_STAT];
ex->exch_ixes[i].exch_ttab_cnt = arrcnts[IX_TTAB];
ex->exch_ixes[i].exch_hld_cnt = arrcnts[IX_HLD];
ex->exch_ixes[i].exch_shd_cnt = arrcnts[IX_SHD];
ex->exch_ixes[i].exch_pqual_cnt = arrcnts[IX_PQUAL];
ex->exch_ixes[i].exch_cx_cnt = arrcnts[IX_CX];
ex->exch_ixes[i].exch_dmr_cnt = arrcnts[IX_DMR];
ex->exch_ixes[i].exch_dmt_cnt = arrcnts[IX_DMT];
ex->exch_ixes[i].exch_dmh_cnt = arrcnts[IX_DMH];
/* Determine start of each subarray. */
for (j = IX_MAX; j > IX_CX; j--)
{
arr2size -= arrcnts[j-1];
arrcnts[j-1] = arr2size;
}
for (j = IX_CX; j > 0; j--)
{
arr1size -= arrcnts[j-1];
arrcnts[j-1] = arr1size;
}
/* Load subarrays - note EXCH nodes stop array loading, so this
** EXCH node is loaded here, not in opc_ex...arrset(). Likewise,
** the QP node on top of a || union is loaded here. The subtrees
** below the EXCH and QP nodes are handled by the opc_ex...arrset()
** functions. The row indexes are listed via the row bitmap.
*/
j = BTnext(-1, rowmap, mapbits);
while (j != -1)
{
ex->exch_ixes[i].exch_array1[arrcnts[IX_ROW]++] = j;
j = BTnext(j, rowmap, mapbits);
}
opc_exnheadset(global, qn, ex->exch_ixes[i].exch_array1,
ex->exch_ixes[i].exch_array2, arrcnts);
/* for EXCH node header */
ex->exch_ixes[i].exch_array2[arrcnts[IX_CX]++] = ex->exch_mat->
qen_pos; /* exch_mat CX */
if (ex->exch_flag & EXCH_UNION)
{
qpp = &ex->exch_out->node_qen.qen_qp;
opc_exnheadset(global, ex->exch_out, ex->exch_ixes[i].exch_array1,
ex->exch_ixes[i].exch_array2, arrcnts);
/* for QP node header */
if (qpp->qp_qual != (QEN_ADF *) NULL)
ex->exch_ixes[i].exch_array2[arrcnts[IX_CX]++] =
qpp->qp_qual->qen_pos;
opc_exactarrset(global, union_action,
ex->exch_ixes[i].exch_array1,
ex->exch_ixes[i].exch_array2, arrcnts);
}
else opc_exnodearrset(global, qn->node_qen.qen_exch.exch_out,
ex->exch_ixes[i].exch_array1,
ex->exch_ixes[i].exch_array2, arrcnts);
}
}
