Pseudo-code for Getting the Table Expression
dam_getTableSearchExp from the EXECUTE function of the IP.
{
int iTableNum;
DAM_HLOGEXP hSearchExp, hJoinExp;
int iJoinType;
int bPartialExp;
/* get the search expression and Join expression handles */
iTableNum = 0;
dam_getTableSearchExp(hstmt, &iTableNum, &hSearchExp, &iJoinType, &hJoinExp, &bPartialExp);
/* get filter conditions */
ip_print_logexp(hSearchExp);
/* check the Join type */
if (hJoinExp) {
if (iJoinType == SQL_JOIN_LEFT_OUTER) printf(" OUTER JOIN ");
if (iJoinType == SQL_JOIN_LEFT_INNER || iJoinType == SQL_JOIN_OLD_STYLE)
printf("INNER JOIN ");
/* get Join conditions */
ip_print_logexp(hJoinExp);
}
int ip_print_logexp(DAM_HLOGEXP hSearchExp)
{
int iType; /* AND, OR, NOT or CONDITION */
DAM_HLOGEXP hLeft, hRight;
DAM_HCOND hCond;
/* get and print the logical expression */
damex_describeLogicExp(hSearchExp,
&iType, /* AND, OR, NOT or CONDITION */
&hLeft,
&hRight,&hCond);
switch (iType) {
case SQL_EXP_COND:
ip_print_cond(hCond);
break;
case SQL_EXP_AND:
/* left-expression AND right-expression */
ip_print_logexp(hLeft);
printf( " AND ");
ip_print_logexp(hRight);
break;
case SQL_EXP_OR:
/* left-expression OR right-expression */
ip_print_logexp(hLeft);
printf( " OR ");
ip_print_logexp(hRight);
break;
case SQL_EXP_NOT:
/* NOT left-expression */
printf( " NOT ");
ip_print_logexp(hLeft);
break;
}
return DAM_SUCCESS;
}
int ip_print_cond(DAM_HCOND hCond)
{
int iType;
DAM_HVALEXP hLeft, hRight, hExtra;
damex_describeCond(hCond,
&iType, /* >, <, =, BETWEEN etc.*/
&hLeft,
&hRight,
&hExtra); /* used for BETWEEN */
/* EXISTS and UNIQUE predicates */
if (iType & (SQL_OP_EXISTS | SQL_OP_UNIQUE)) {
if (iType & SQL_OP_NOT) printf( " NOT ");
if (iType & SQL_OP_EXISTS) printf( " EXISTS ");
if (iType & SQL_OP_UNIQUE) printf( " UNIQUE ");
ip_print_valexp(hLeft);
}
/* conditional predicates */
if (iType & ( SQL_OP_SMALLER | SQL_OP_GREATER | SQL_OP_EQUAL)) {
ip_print_valexp(hLeft);
if (iType & SQL_OP_NOT) {
if (iType & SQL_OP_EQUAL) printf( " <> ");
}
else {
printf( " ");
if (iType & SQL_OP_SMALLER) printf( "<");
if (iType & SQL_OP_GREATER) printf( ">");
if (iType & SQL_OP_EQUAL) printf( "=");
printf( " ");
}
if (iType & (SQL_OP_QUANTIFIER_ALL | SQL_OP_QUANTIFIER_SOME | SQL_OP_QUANTIFIER_ANY) {
if (iType & SQL_OP_QUANTIFIER_ALL) printf( " ALL ");
if (iType & SQL_OP_QUANTIFIER_SOME) printf( " SOME ");
if (iType & SQL_OP_QUANTIFIER_ANY) printf( " ANY ");
}
ip_print_valexp(hRight);
} /* conditional predicate */
/* like predicate */
if (iType & SQL_OP_LIKE) {
ip_print_valexp(hLeft);
if (iType & SQL_OP_NOT) printf( " NOT ");
printf( " LIKE ");
ip_print_valexp(hRight);
if (hExtra) {
printf( " ESCAPE ");
ip_print_valexp(hExtra);
}
} /* like predicate */
/* Is NULL predicate */
if (iType & SQL_OP_ISNULL) {
ip_print_valexp(hLeft);
if (iType & SQL_OP_NOT)
printf( " IS NOT NULL ");
else
printf( " IS NULL ");
}
/* IN predicate */
if (iType & SQL_OP_IN) {
ip_print_valexp(hLeft);
if (iType & SQL_OP_NOT) printf( " NOT ");
printf( " IN (");
ip_print_valexp(hRight);
pintf( " )");
}
/* BETWEEN predicate */
if (iType & SQL_OP_BETWEEN) {
/* check if the between is a form of ( >= and < ) OR (> and <)
OR (> and <=)
*/
if ((iType & SQL_OP_BETWEEN_OPEN_LEFT) ||
(iType & SQL_OP_BETWEEN_OPEN_RIGHT)) {
/* format it as two conditions */
ip_print_valexp(hLeft);
if (iType & SQL_OP_BETWEEN_OPEN_LEFT)
printf( " > ");
else
printf( " >= ");
ip_print_valexp(hRight);
printf( " AND ");
ip_print_valexp(hLeft);
if (iType & SQL_OP_BETWEEN_OPEN_RIGHT)
printf( " < ");
else
printf( " <= ");
ip_print_valexp(hExtra);
}
else {
/* standard BETWEEN pattern */
ip_print_valexp(hLeft);
if (iType & SQL_OP_NOT) printf( " NOT ");
printf( " BETWEEN ");
ip_print_valexp(hRight);
printf( " AND ");
ip_print_valexp(hExtra);
}
} /* BETWEEN */
return DAM_SUCCESS;
}
int ip_print_valexp(DAM_HVALEXP hValExp)
{
int iType; /* literal value, column, +, -, *, / etc */
int iFuncType;
DAM_HVALEXP hLeftValExp;
DAM_HVALEXP hRightValExp;
DAM_HVAL hVal;
DAM_HSCALAR_VALEXP hScalarValExp;
damex_describeValExp(hValExp, &iType, /* literal value, column, +, -, *, / etc */
&iFuncType,
&hLeftValExp,
&hRightValExp,
&hVal,
&hScalarValExp
);
/* function type (SQL_F_COUNT, SQL_F_MIN etc will not occur in search expressions */
switch (iType) {
case SQL_VAL_EXP_VAL:
ip_print_val(hVal);
break;
case SQL_VAL_EXP_ADD:
case SQL_VAL_EXP_SUBTRACT:
ip_print_valexp(hLeftValExp);
if (iType == SQL_VAL_EXP_AND) printf( "+");
if (iType == SQL_VAL_EXP_SUBTRACT) printf( "-");
if (iType == SQL_VAL_EXP_MULTIPLE) printf( "*");
if (iType == SQL_VAL_EXP_DIVIDE) printf( "/");
ip_print_valexp(hRightValExp);
break;
case SQL_VAL_EXP_SCALAR:
ip_print_scalar_valexp(hScalarValExp);
break;
}
return DAM_SUCCESS;
}
int ip_print_scalar_valexp(DAM_HSCALAR_VALEXP hScalarValExp)
{
char sName[DAM_MAX_ID_LEN+1];
char sQualifierName[DAM_MAX_ID_LEN+1];
DAM_HVALEXP_LIST hValExpList;
damex_describeScalarValExpEx2(hScalarValExp, sQualifierName, sName,
&hValExpList);
printf( "%s", sQualifierName, sName);
printf( "( ");
if (hValExpList) ip_print_valexp_list(hValExpList);
printf( ") ");
return DAM_SUCCESS;
}
int ip_print_valexp_list(DAM_HVALEXP_LIST hValExpList)
{
DAM_HVALEXP hValExp;
int iFirst = TRUE;
hValExp = damex_getFirstValExp(hValExpList);
while (hValExp) {
if (!iFirst)
printf( ", ");
else
iFirst = FALSE;
ip_print_valexp(hValExp);
hValExp = damex_getNextValExp(hValExpList);
}
printf( " ");
return DAM_SUCCESS;
}
int ip_print_val(DAM_HQUERY hquery, DAM_HVAL hVal)
{
int iType; /* literal value, column */
int iXoType; /* type of literal value – INTEGER, CHAR etc */
void *pData;
DAM_HCOL hCol;
DAM_HQUERY hSubQuery;
damex_describeVal(hVal, &iType,
&iXoType,
&pData,
&hCol,
&hSubQuery);
switch (iType) {
case SQL_VAL_DATA_CHAIN:
break;
case SQL_VAL_NULL:
printf( "NULL"); break;
case SQL_VAL_QUERY: /* query */
ip_print_query_values(hSubQuery);
break;
case SQL_VAL_COL: /* value is the column value */
ip_print_col(hCol); break;
case SQL_VAL_INTERVAL:
break;
case SQL_VAL_LITERAL: /* value is a Xo Type literal */
ip_print_data(iXoType, pData);
break;
default:
printf( "Invalid Value Type:%d", iType); break;
}
return DAM_SUCCESS;
}
int ip_print_query_values(DAM_HQUERY hQuery)
{
int iRetCode;
int iXoType;
void *pVal;
int iValLen;
int bFoundVal = FALSE;
iRetCode = dam_getQueryFirstResultValue(hQuery, &iXoType, &pVal, &iValLen);
while (iRetCode == DAM_SUCCESS) {
if (bFoundVal)
printf(", ");
if (iValLen == XO_NULL_DATA)
printf( "NULL");
else
ip_print_data(iXoType, pVal);
bFoundVal = TRUE;
iRetCode = dam_getQueryNextResultValue(hQuery, &iXoType, &pVal, &iValLen);
}
/* when results are empty, we will use NULL value */
if (!bFoundVal)
printf("NULL");
if (iRetCode != DAM_NO_DATA_FOUND) return iRetCode;
return DAM_SUCCESS;
}
int ip_print_data(int iXoType, void *pData)
{
xo_tm *pxoTime;
switch (iXoType) {
case XO_TYPE_CHAR: /* pVal is a char literal */
case XO_TYPE_VARCHAR:
case XO_TYPE_NUMERIC:
case XO_TYPE_DECIMAL:
printf( "'%s'", (char *)pData);
break;
case XO_TYPE_INTEGER: /* pVal is a integer literal */
printf( "%ld", *(long *)pData);
break;
case XO_TYPE_SMALLINT: /* pVal is small integer literal */
printf( "%d", (int)(*(short *)pData));
break;
case XO_TYPE_FLOAT: /* pVal is a double literal */
case XO_TYPE_DOUBLE:
printf( "%Lf", *(double *)pData);
break;
case XO_TYPE_REAL: /* pVal is a float literal */
printf( "%f", *(float *)pData);
break;
case XO_TYPE_DATE:
pxoTime = (xo_tm *)pData;
printf( "{d '%d-%02d-%02d'}", pxoTime->tm_year,
pxoTime->tm_mon+1, pxoTime->tm_mday);
break;
case XO_TYPE_TIME:
pxoTime = (xo_tm *)pData;
printf( "{t '%02d:%02d:%02d'}", pxoTime->tm_hour,
pxoTime->tm_min, pxoTime->tm_sec);
break;
case XO_TYPE_TIMESTAMP:
pxoTime = (xo_tm *)pData;
if (pxoTime->tm_frac > 0) {
int frac;
frac = (int) (pxoTime->tm_frac * 0.000001);
printf( "{ts '%d-%02d-%02d %02d:%02d:%02d.%03d'}",
pxoTime->tm_year, pxoTime->tm_mon+1, pxoTime->tm_mday,
pxoTime->tm_hour, pxoTime->tm_min, pxoTime->tm_sec, frac);
}
else
printf( "{ts '%d-%02d-%02d %02d:%02d:%02d'}",
pxoTime->tm_year, pxoTime->tm_mon+1, pxoTime->tm_mday,
pxoTime->tm_hour, pxoTime->tm_min, pxoTime->tm_sec);
break;
default:
printf( "Invalid Xo Value Type:%d", iXoType);
break;
}
return DAM_SUCCESS;
}
int ip_print_col(DAM_HCOL hCol)
{
int iTableNum, iColNum;
char sColName[DAM_MAX_ID_LEN+1];
DAM_HSTMT hstmt = pStmtDA->dam_hstmt; /* we need to pass this variable as argument */
damex_describeCol(hCol,
&iTableNum,
&iColNum,
sColName, NULL, NULL, NULL, NULL);
/* check for correlated column and join columns */
if (damex_isCorrelatedCol(hCol) ||
(pStmtDA->iCurTableNum != DAM_NOT_SET && iTableNum != pStmtDA->iCurTableNum)) {
int iValLen;
void *pVal;
dam_getJoinColValue(hstmt, hCol, XO_TYPE_CHAR, &pVal, &iValLen);
if (iValLen == XO_NULL_DATA)
printf( " NULL ");
else
printf( " '%s' ", (char *)pVal);
}
else {
printf( "T%d.%s", iTableNum, sColName);
}
return DAM_SUCCESS;
}
