/*{
** 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: opj_union - optimize unions
**
** Description:
** The routine determines which qualifications of a parent query
** can be copied to the union, so that the union can be more restrictive
** or partitions of the union can be eliminated entirely in some cases.
**
** Inputs:
** subquery ptr to subquery be analyzed
**
** Outputs:
** Returns:
** VOID
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 21-jun-89 (seputis)
** initial creation
** 01-Oct-2001 (hanal04) Bug 105464 INGSRV 1517
** After calling opv_copytree() mark the target subquery
** as non-CNF if the source suquery was non-CNF.
** 11-may-05 (inkdo01)
** Don't copy ON clause BFs to union subqueries - fixes 114493.
** 20-apr-07 (hayke02)
** Limit the fix for bug 114493 (test for a OPL_NOOUTER pst_joinid)
** to those subqueries containing outer joins, otherwise pst_joinid
** will be PST_NOJOIN (0). This change fixes bug 118088.
** 27-mar-2009 (huazh01)
** don't copy OPZ_FANUM, OPZ_SNUM, OPZ_CORRELATED attribute into
** 'unionbm'. Doing so will cause opj_utree() to convert the
** union_subquery->ops_sunion.opu_qual qualification into a
** PST_QNODE node containing negative attribute id, and causes
** E_OP0384 error. (bug 121602)
[@history_template@]...
*/
VOID
opj_union(
OPS_SUBQUERY *subquery)
{
OPV_IVARS lvar;
for (lvar = subquery->ops_vars.opv_prv; --lvar>=0;)
{ /* look at the union views referenced in this subquery */
OPV_VARS *unionp;
unionp = subquery->ops_vars.opv_base->opv_rt[lvar];
if (unionp->opv_grv
&&
(unionp->opv_grv->opv_created == OPS_VIEW)
&&
unionp->opv_grv->opv_gquery
&&
unionp->opv_grv->opv_gquery->ops_union
)
{ /* a union view has been found, so search the list of boolean
** factors to determine which terms can be placed into the qualifications
** of the union */
OPE_BMEQCLS unionbm; /* bitmap of the equivalence classes which
** are available in the union view */
OPS_SUBQUERY *union_subquery;
OPB_BMBF bfbm;
OPB_IBF maxbf; /* current boolean factor number */
maxbf = BITS_IN(bfbm);
union_subquery = unionp->opv_grv->opv_gquery;
if (union_subquery->ops_sunion.opu_mask & OPU_QUAL)
{
if (union_subquery->ops_sunion.opu_qual == (PST_QNODE *)NULL)
continue; /* since entire union is required by
** another subquery, no need to proceed */
MEfill(sizeof(bfbm), (u_char)0, (PTR)&bfbm);
BTnot((i4)BITS_IN(bfbm), (char *)&bfbm); /* bits will get
** reset as identical qualifications are
** found */
}
MEfill(sizeof(unionbm), (u_char)0, (PTR)&unionbm);
{ /* search thru list of attributes and mark
** appropriate equivalence classes*/
/* opv_eqcmp not initialized yet */
OPZ_IATTS attr;
OPZ_AT *abase;
abase = subquery->ops_attrs.opz_base; /* ptr to base of array of ptrs
** to joinop attributes */
for (attr = subquery->ops_attrs.opz_av; --attr>=0;)
{ /* opv_eqcmp not initialized yet */
OPZ_ATTS *attrp;
attrp = abase->opz_attnums[attr];
if ((attrp->opz_varnm == lvar)
&&
(attrp->opz_equcls >= 0)
&&
attrp->opz_attnm.db_att_id >= 0
)
BTset ((i4)attrp->opz_equcls, (char *)&unionbm);
}
}
{ /* search list of conjuncts, boolean factor structure has
** not been created at this point */
OPB_IBF total_bfs; /* number of qualifications placed into
** union view list */
PST_QNODE *qual;
total_bfs = 0;
for (qual = subquery->ops_root->pst_right;
qual->pst_sym.pst_type != PST_QLEND;
qual = qual->pst_right)
{
OPE_BMEQCLS qual_eqcmp;
MEfill(sizeof(qual_eqcmp), (u_char)0, (PTR)&qual_eqcmp);
ope_aseqcls(subquery, &qual_eqcmp, qual->pst_left);
/* assign
** equivalence classes for vars in
** the qualification which have not
** been assigned yet
*/
if (BTsubset((char *)&qual_eqcmp, (char *)&unionbm, (i4)BITS_IN(unionbm))
&&
!(subquery->ops_oj.opl_base &&
(qual->pst_left->pst_sym.pst_value.pst_s_op.pst_joinid
!= OPL_NOOUTER)))
{ /* this boolean factor contains equivalence classes which
** are all in the union view, so it can be evaluated inside
** the union view */
if (union_subquery->ops_sunion.opu_mask & OPU_QUAL)
{ /* qualification must already be in the list
** so compare to existing list of entries */
PST_QNODE *old_qual;
OPB_IBF bfcount;
bfcount = 0;
for (old_qual = union_subquery->ops_sunion.opu_qual;
old_qual; old_qual = old_qual->pst_right)
{
if (BTtest((i4)bfcount, (char *)&bfbm) /* if this
** boolean factor has not been
** matched */
&&
opj_ctree(subquery, qual->pst_left, lvar,
union_subquery, old_qual->pst_left) /*
** and if the qualification
** matches the current one */
)
{ /* found a match so mark the boolean
** factor as being in common */
BTclear((i4)bfcount, (char *)&bfbm);
break;
}
bfcount++;
}
}
else
{ /* if this is the first time then just copy the
** qualification and place into the list */
PST_QNODE *and_node;
total_bfs++;
if (total_bfs >= BITS_IN(unionbm))
break; /* cannot add anymore qualifications
** since the max boolean factor
** count has been reached */
and_node = opv_opnode(subquery->ops_global, PST_AND, (ADI_OP_ID)0,
(OPL_IOUTER)OPL_NOOUTER);
and_node->pst_left = qual->pst_left;
opv_copytree(subquery->ops_global, &and_node->pst_left);
and_node->pst_right = union_subquery->ops_sunion.opu_qual;
union_subquery->ops_sunion.opu_qual = and_node;
if(subquery->ops_mask & OPS_NONCNF)
{
union_subquery->ops_mask |= OPS_NONCNF;
}
}
}
}
}
if (union_subquery->ops_sunion.opu_mask & OPU_QUAL)
{ /* previous qualification exists so need to get common qualifications,
** by using boolean factor bitmap of those qualifications which are
** to be eliminated */
OPB_IBF bfno;
PST_QNODE **qualpp;
OPB_IBF current;
current = 0;
qualpp = &union_subquery->ops_sunion.opu_qual;
for (bfno = -1; (bfno = BTnext((i4)bfno, (char *)&bfbm, (i4)maxbf)) >= 0;)
{
while ((current < bfno) && *qualpp)
{ /* find next qualification to eliminate */
current++;
qualpp = &(*qualpp)->pst_right;
}
if (*qualpp)
*qualpp = (*qualpp)->pst_right; /* remove this qual since
** no match was found for this subquery */
else
break; /* end of qual list reached */
}
}
else
{ /* this is the first qualification in the list, so it can be applied */
union_subquery->ops_sunion.opu_mask |= OPU_QUAL;
if (union_subquery->ops_sunion.opu_qual)
opj_utree(subquery, union_subquery->ops_sunion.opu_qual, lvar); /*
** convert the
** qualification to reference var nodes
** of the union view, so that comparisons
** can be made later */
}
}
}
}
/*{
** 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;
}
/*{
** Name: opn_gnperm - get next valid permutation of relations
**
** Description:
** A valid permutation of relations is a group of relations
** that provide the necessary data (eqc classes) to process
** the query. The equivalence classes provided by the base
** relations must be provided by this resulting permutiation
** either through the use of the base relations themselves
** or through their own secondary indexes.
**
** Relations move back and forth between the 2 partitions.
** There must be exactly 2 partitions where partsz[0] is the number of
** relations to be considered for enumeration and partsz[1] contain the
** remainder. Each call will produce
** a "new" set (where order does not matter) of relations
** in the first partition which satisfy the constraints mentioned
** earlier.
**
** FIXME - can make this routine go much faster by calculating which
** relations can be replaced by indexes and iterating through all
** combinations of those only i.e. there will be 3 partitions, 1)the
** primaries, 2)the set of indexes which cannot ever be
** used to replace the base
** relation, and 3)the set of indexes which can. Iterate through
** all combinations of (1&3), for each subset of 2
**
** Also, can decide that if an index was included to replace the
** base relation, then any indexes on that relation would not be
** useful if the relation was not included, and eliminate that case here
** since a scan is required anyways. An improvement would be to detect
** that a keyed lookup would be useful on these indexes
**
** Inputs:
** subquery ptr to current subquery being analyzed
** permutation current permutation of relations
** numleaves number of relations in permutation
** partsz array of partition sizes where partsz[0]
** is the size of the first partition
** "partsz[0]+partsz[1] == numleaves"
** pr_n_included map of base relations not included in
** valid partition
** firstcomb TRUE - combination was set by opn_process
** so we're just checking heuristics
**
** Outputs:
** Returns:
** TRUE if another permutation exists
** Exceptions:
** none
**
** Side Effects:
** none
**
** History:
** 11-jun-86 (seputis)
** initial creation
** 29-mar-89 (seputis)
** gateway additions
** 29-mar-90 (seputis)
** fix byte alignment problems
** 1-apr-94 (ed)
** b60125 - cart prod variable incorrectly eliminated
** 27-aug-02 (inkdo01)
** Apply heuristics to initial combination generated by opn_process
** so some index heuristics aren't applied to all permutations of a
** bad combination in opn_jintersect.
** 21-mar-06 (dougi)
** Verify that current combination satisfies index hints (if any).
[@history_line@]...
*/
bool
opn_gnperm(
OPS_SUBQUERY *subquery,
OPN_STLEAVES permutation,
OPN_LEAVES numleaves,
OPN_PARTSZ partsz,
OPV_BMVARS *pr_n_included,
bool firstcomb)
{
OPN_CHILD numpartitions; /* number of partitions */
OPV_IVARS maxprimary; /* number of primary joinop
** range variables in the
** query */
OPV_RT *vbase; /* ptr to base of array of
** ptrs to joinop range
** variables */
OPN_LEAVES firstpartsz; /* number of elements in the
** first partition */
OPE_IEQCLS maxeqcls; /* number of equivalence classes
** defined */
bool indexes_gateway; /* TRUE if subquery contains secondaries
** on restricted gateway tables */
maxeqcls = subquery->ops_eclass.ope_ev; /* get number of equivalence
** classes in subquery */
maxprimary = subquery->ops_vars.opv_prv; /* number of primary relations
** defined */
numpartitions = 2; /* number of partitions of the
** set of relations is always 2
** - first partition contains
** the set of relations which
** will be considered for
** the next enumeration
** - second partition contains
** relations which are not being
** considered for this
** enumeration */
vbase = subquery->ops_vars.opv_base; /* ptr to base of array of ptrs
** to joinop range variables */
firstpartsz = partsz[0]; /* number of elements in first
** partition */
indexes_gateway = (subquery->ops_gateway.opg_smask
& OPG_INDEX) != 0; /* gateway mask indicates whether
** indexes need to be checked */
/* Return when a valid partition has been found */
for (;;)
{
if (!firstcomb && numleaves == firstpartsz)
return(FALSE); /* no combinations and it failed
** heuristics */
/* Get next partition */
if (!firstcomb && !opn_partition(subquery, permutation, numleaves,
partsz, numpartitions, FALSE))
return(FALSE); /* no more partitions */
firstcomb = FALSE; /* reset for loop */
MEfill(sizeof(*pr_n_included), (u_char)0, (PTR)pr_n_included);
BTnot((i4)maxprimary, (char *)pr_n_included); /* all base relations are
** not included */
{ /* For each element in the partition, find out if it is a
** base relation */
OPV_IVARS partvarno; /* joinop range variable in the
** first partition */
OPV_BMVARS replaced; /* bitmap of vars that should
** be replaced */
OPV_BMVARS table_gateway; /* for gateways, there are tables
** which cannot accessed by TID joins
** but secondaries can be used to
** replace the base relation
** entirely */
bool skip_gateway; /* set TRUE if this particular set of
** relations references both a base table
** and a secondary index , which is
** not supported for gateway tables */
if (indexes_gateway)
MEfill(sizeof(table_gateway), (u_char)0, (PTR)&table_gateway);
skip_gateway = FALSE;
MEfill(sizeof(replaced), (u_char)0, (PTR)&replaced);
for (partvarno = 0; partvarno < firstpartsz; partvarno++)
{
OPV_IVARS vno; /* variable being analzyed */
OPV_VARS *ivarp; /* ptr to index range variable*/
vno = permutation[partvarno];
ivarp = vbase->opv_rt[vno];
/* if its included, don't worry about it */
if (vno < maxprimary)
BTclear((i4) vno, (char *)pr_n_included);
else
{
if ( ivarp->opv_index.opv_eqclass == OPE_NOEQCLS ||
ivarp->opv_mask & OPV_CINDEX )
/* set bitmap if index was added only to replace
** base relation */
BTset ( (i4) ivarp->opv_index.opv_poffset,
(char *) &replaced );
}
if (indexes_gateway
&&
ivarp->opv_grv->opv_relation /* if this is an RDF relation */
&&
(ivarp->opv_grv->opv_relation->rdr_rel->tbl_status_mask & DMT_GATEWAY) /* is this
** a gateway table */
&&
(subquery->ops_global->ops_cb->ops_server->opg_smask & OPF_INDEXSUB)
/* and the gateway relation has index
** constraints on it */
&&
(vno != ivarp->opv_index.opv_poffset) /* do not consider the primary
** relation for this test */
)
{ /* check constraint on secondary index access for gateway */
if (BTtest((i4)ivarp->opv_index.opv_poffset, (char *)&table_gateway))
{
skip_gateway = TRUE; /* this base relation was referenced
** previously by this set, so this set
** of relations needs to be skipped */
break;
}
BTset((i4)ivarp->opv_index.opv_poffset, (char *)&table_gateway); /*
** if only one index for this table in this
** partition then it is legal, so mark
** base table bit so that 2+ index search
** space is eliminated */
}
}
if ((!BTsubset((char *)&replaced, (char *)pr_n_included, (i4)maxprimary))
||
skip_gateway)
continue; /* this is a useless partition
** since an index and the
** respective base relation it
** was intended to replace are
** both included
** OR a restricted gateway table
** was accessed */
if ((subquery->ops_mask2 & OPS_IXHINTS) &&
!opn_index_hint(subquery, permutation, partsz[0]))
continue; /* if there are index hints in
** this subquery and the
** current combination doesn't
** satisfy them, get the next */
}
{
OPV_IVARS varno; /* varno of primary which was
** not included */
bool noprimary; /* TRUE if no primaries were
** replaced */
noprimary = TRUE;
for (varno = -1;
(varno = BTnext((i4)varno,
(char *)pr_n_included,
(i4)maxprimary))
>= 0;)
{ /* initialize temp equivalence class map associated with
** primary relations - the map will be used to gather
** all equivalence classes which the indexes provide */
noprimary = FALSE;
MEfill( sizeof(vbase->opv_rt[varno]->opv_primary.opv_teqcmp),
(u_char)0,
(PTR)&vbase->opv_rt[varno]->opv_primary.opv_teqcmp);/*
** init temporary work
** area of joinop range
** variable element */
}
if (noprimary)
return(TRUE); /* no need to check indexes
** since no primaries were
** replaced */
}
{
/* For each index being included in the partition, add the available
** equivalence classes to the primary's map
*/
OPV_IVARS indexvarno; /* joinop range var number of
** index being analyzed */
for (indexvarno = 0; indexvarno < firstpartsz; indexvarno++)
{
OPV_VARS *indexp; /* ptr to joinop range var
** element of current index
** being analyzed */
if(permutation[indexvarno] < maxprimary)
continue; /* not an index so continue*/
indexp = vbase->opv_rt[permutation[indexvarno]]; /* get ptr
** to index element */
BTor( (i4)maxeqcls,
(char *)&indexp->opv_maps.opo_eqcmap,
(char *)&vbase->opv_rt[indexp->opv_index.opv_poffset]->
opv_primary.opv_teqcmp); /* accumulate all
** all equivalence classes
** available from indexes in
** the temp associated with
** the primary */
}
}
{
/* check if each primary which is replaced has all the necessary
** equivalence classes available from the indexes */
OPV_IVARS primvarno; /* joinop range variable
** number of primary which
** is not included */
for (primvarno = -1;
(primvarno = BTnext((i4)primvarno,
(char *)pr_n_included,
(i4) maxprimary))
>= 0;)
{
OPV_VARS *primvarp; /* ptr to primary joinop range
** var element to be
** replaced */
primvarp = vbase->opv_rt[primvarno]; /* get ptr to primary to
** be replaced */
if (!BTsubset( (char *)&primvarp->opv_maps.opo_eqcmap,
(char *)&primvarp->opv_primary.opv_teqcmp,
(i4)maxeqcls)
||
(primvarp->opv_mask & OPV_NOATTRIBUTES)) /* check if this
** is a no attribute cart prod
** in which case the base relation
** is not removed */
break; /* if there are equivalence
** classes in the primary which
** are not in the set provided
** by the indexes then exit
** with primvarno >= 0 */
}
if (primvarno < 0)
return (TRUE); /* all the primaries have been
** successfully replaced */
}
}
}
