You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
1838 lines
62 KiB
1838 lines
62 KiB
//--------------------------------------------------------------------
|
|
// Microsoft OLE-DB Query
|
|
//
|
|
// Copyright 1997 Microsoft Corporation. All Rights Reserved.
|
|
//
|
|
// @doc
|
|
//
|
|
// @module treeutil.cpp |
|
|
//
|
|
// Contains tree manipulation utility functions for both OLE-DB and QTE trees.
|
|
//
|
|
// @devnote None
|
|
//
|
|
// @rev 0 | 12-Feb-97 | v-charca | Created
|
|
//
|
|
#pragma hdrstop
|
|
#include "msidxtr.h"
|
|
|
|
|
|
#define INDENTLINE setfill('\t') << setw(indentLevel) << ""
|
|
#define VAL_AND_CCH_MINUS_NULL(p1) (p1), ((sizeof(p1) / sizeof(*(p1))) - 1)
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Converts a wide character string string into a LARGEINTEGER
|
|
// @rdesc Pointer to new UNICODE string
|
|
|
|
HRESULT PropVariantChangeTypeI64(
|
|
PROPVARIANT* pvarValue )
|
|
{
|
|
LPWSTR pwszVal = pvarValue->bstrVal;
|
|
ULONGLONG uhVal = 0;
|
|
UINT iBase = 10;
|
|
BOOL fNegative = FALSE;
|
|
UINT uiDigitVal = 0;
|
|
if (L'-' == *pwszVal)
|
|
{
|
|
fNegative = TRUE; // remember we need to negate later
|
|
pwszVal++;
|
|
}
|
|
else if (L'+' == *pwszVal)
|
|
pwszVal++; // a plus sign is simply noise
|
|
|
|
if ((L'0' == pwszVal[0]) && (L'x' == pwszVal[1] || L'X' == pwszVal[1]))
|
|
{
|
|
iBase = 16;
|
|
pwszVal += 2;
|
|
}
|
|
ULONGLONG uhMaxPartial = _UI64_MAX / iBase;
|
|
|
|
while (*pwszVal)
|
|
{
|
|
if (iswdigit(*pwszVal))
|
|
uiDigitVal = *pwszVal - L'0';
|
|
else /* a-fA-F */
|
|
uiDigitVal = towupper(*pwszVal) - L'A' + 10;
|
|
|
|
if (uhVal < uhMaxPartial ||
|
|
(uhVal == uhMaxPartial && (ULONGLONG)uiDigitVal <= _UI64_MAX % iBase))
|
|
uhVal = uhVal * iBase + uiDigitVal;
|
|
else // adding this digit would cause an overflow to occur
|
|
return DISP_E_OVERFLOW;
|
|
|
|
pwszVal++;
|
|
}
|
|
|
|
|
|
if (fNegative)
|
|
{
|
|
if (uhVal > -_I64_MIN)
|
|
return DISP_E_OVERFLOW;
|
|
else
|
|
{
|
|
SysFreeString(pvarValue->bstrVal);
|
|
pvarValue->vt = VT_I8;
|
|
pvarValue->hVal.QuadPart = -(LONGLONG)uhVal;
|
|
}
|
|
}
|
|
else
|
|
{
|
|
SysFreeString(pvarValue->bstrVal);
|
|
pvarValue->vt = VT_UI8;
|
|
pvarValue->uhVal.QuadPart = uhVal;
|
|
}
|
|
|
|
return S_OK;
|
|
}
|
|
|
|
|
|
#ifdef DEBUG
|
|
//--------------------------------------------------------------------
|
|
// @func ostream& | operator shift-left |
|
|
// Dumps the given LPOLESTR string into the given ostream.
|
|
// @rdesc ostream
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
LPWSTR pwszName //@parm IN | LPWSTR string to dump.
|
|
)
|
|
{
|
|
UINT cLen = wcslen(pwszName);
|
|
for (UINT i=0; i<cLen; i++)
|
|
osOut << char(pwszName[i]);
|
|
return osOut;
|
|
}
|
|
#endif
|
|
|
|
//--------------------------------------------------------------------
|
|
//@func Allocates and initializes an OLE-DB DBCOMMANDTREE
|
|
// of the given kind and op.
|
|
//
|
|
//@rdesc DBCommandTree node of the correct kind and
|
|
// with any additional memory for the value field allocated.
|
|
// All other fields are NULL or default values.
|
|
//
|
|
DBCOMMANDTREE * PctAllocNode(
|
|
DBVALUEKIND wKind, //@parm IN | kind of tree to create
|
|
DBCOMMANDOP op ) //@parm IN
|
|
{
|
|
DBCOMMANDTREE* pTableNode = NULL;
|
|
|
|
pTableNode = (DBCOMMANDTREE*) CoTaskMemAlloc(sizeof(DBCOMMANDTREE));
|
|
if (NULL == pTableNode)
|
|
return NULL;
|
|
|
|
// Set default values
|
|
pTableNode->op = op;
|
|
pTableNode->wKind = (WORD)wKind;
|
|
pTableNode->pctFirstChild = NULL;
|
|
pTableNode->pctNextSibling = NULL;
|
|
pTableNode->value.pvValue = NULL;
|
|
pTableNode->hrError = S_OK;
|
|
|
|
switch (wKind)
|
|
{
|
|
case DBVALUEKIND_BYGUID:
|
|
pTableNode->value.pdbbygdValue = (DBBYGUID*) CoTaskMemAlloc(sizeof DBBYGUID);
|
|
if (NULL == pTableNode->value.pdbbygdValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_COLDESC:
|
|
pTableNode->value.pcoldescValue = (DBCOLUMNDESC*) CoTaskMemAlloc(sizeof DBCOLUMNDESC);
|
|
if (NULL == pTableNode->value.pcoldescValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_ID:
|
|
pTableNode->value.pdbidValue = (DBID*) CoTaskMemAlloc(sizeof DBID);
|
|
if (NULL == pTableNode->value.pdbidValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENT:
|
|
pTableNode->value.pdbcntntValue = (DBCONTENT*) CoTaskMemAlloc(sizeof DBCONTENT);
|
|
if (NULL == pTableNode->value.pdbcntntValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTSCOPE:
|
|
pTableNode->value.pdbcntntscpValue = (DBCONTENTSCOPE*) CoTaskMemAlloc(sizeof DBCONTENTSCOPE);
|
|
if ( NULL == pTableNode->value.pdbcntntscpValue )
|
|
{
|
|
CoTaskMemFree( pTableNode );
|
|
pTableNode = NULL;
|
|
}
|
|
else
|
|
RtlZeroMemory( pTableNode->value.pdbcntntscpValue, sizeof(DBCONTENTSCOPE) );
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTTABLE:
|
|
pTableNode->value.pdbcntnttblValue = (DBCONTENTTABLE*) CoTaskMemAlloc(sizeof DBCONTENTTABLE);
|
|
if ( NULL == pTableNode->value.pdbcntnttblValue )
|
|
{
|
|
CoTaskMemFree( pTableNode );
|
|
pTableNode = NULL;
|
|
}
|
|
else
|
|
RtlZeroMemory( pTableNode->value.pdbcntnttblValue, sizeof(DBCONTENTTABLE) );
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTVECTOR:
|
|
pTableNode->value.pdbcntntvcValue = (DBCONTENTVECTOR*) CoTaskMemAlloc(sizeof DBCONTENTVECTOR);
|
|
if (NULL == pTableNode->value.pdbcntntvcValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_GROUPINFO:
|
|
pTableNode->value.pdbgrpinfValue = (DBGROUPINFO*) CoTaskMemAlloc(sizeof DBGROUPINFO);
|
|
if (NULL == pTableNode->value.pdbgrpinfValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
// case DBVALUEKIND_PARAMETER:
|
|
// case DBVALUEKIND_PROPERTY:
|
|
|
|
case DBVALUEKIND_SETFUNC:
|
|
pTableNode->value.pdbstfncValue = (DBSETFUNC*) CoTaskMemAlloc(sizeof DBSETFUNC);
|
|
if (NULL == pTableNode->value.pdbstfncValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_SORTINFO:
|
|
pTableNode->value.pdbsrtinfValue = (DBSORTINFO*) CoTaskMemAlloc(sizeof DBSORTINFO);
|
|
if (NULL == pTableNode->value.pdbsrtinfValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_TEXT:
|
|
pTableNode->value.pdbtxtValue = (DBTEXT*) CoTaskMemAlloc(sizeof DBTEXT);
|
|
if (NULL == pTableNode->value.pdbtxtValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_COMMAND:
|
|
case DBVALUEKIND_MONIKER:
|
|
case DBVALUEKIND_ROWSET:
|
|
break;
|
|
|
|
case DBVALUEKIND_LIKE:
|
|
pTableNode->value.pdblikeValue = (DBLIKE*) CoTaskMemAlloc(sizeof DBLIKE);
|
|
if (NULL == pTableNode->value.pdblikeValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTPROXIMITY:
|
|
pTableNode->value.pdbcntntproxValue = (DBCONTENTPROXIMITY*) CoTaskMemAlloc(sizeof DBCONTENTPROXIMITY);
|
|
if (NULL == pTableNode->value.pdbcntntproxValue)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_IDISPATCH:
|
|
case DBVALUEKIND_IUNKNOWN:
|
|
case DBVALUEKIND_EMPTY:
|
|
case DBVALUEKIND_NULL:
|
|
case DBVALUEKIND_I2:
|
|
case DBVALUEKIND_I4:
|
|
case DBVALUEKIND_R4:
|
|
case DBVALUEKIND_R8:
|
|
case DBVALUEKIND_CY:
|
|
case DBVALUEKIND_DATE:
|
|
case DBVALUEKIND_BSTR:
|
|
case DBVALUEKIND_ERROR:
|
|
case DBVALUEKIND_BOOL:
|
|
break;
|
|
|
|
case DBVALUEKIND_VARIANT:
|
|
// NOTE: This is really a PROPVARIANT node, but there is no DBVALUEKIND for PROPVARIANT.
|
|
pTableNode->value.pvValue = (PROPVARIANT*) CoTaskMemAlloc(sizeof PROPVARIANT);
|
|
if (NULL == pTableNode->value.pvValue )
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
else
|
|
PropVariantInit((PROPVARIANT*)(pTableNode->value.pvValue));
|
|
break;
|
|
|
|
case DBVALUEKIND_VECTOR:
|
|
case DBVALUEKIND_ARRAY:
|
|
case DBVALUEKIND_BYREF:
|
|
case DBVALUEKIND_I1:
|
|
case DBVALUEKIND_UI1:
|
|
case DBVALUEKIND_UI2:
|
|
case DBVALUEKIND_UI4:
|
|
case DBVALUEKIND_I8:
|
|
case DBVALUEKIND_UI8:
|
|
break;
|
|
|
|
case DBVALUEKIND_GUID:
|
|
pTableNode->value.pGuid = (GUID*) CoTaskMemAlloc(sizeof GUID);
|
|
if (NULL == pTableNode->value.pGuid)
|
|
{
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_BYTES:
|
|
case DBVALUEKIND_STR:
|
|
case DBVALUEKIND_WSTR:
|
|
case DBVALUEKIND_NUMERIC:
|
|
// case DBVALUEKIND_DBDATE:
|
|
// case DBVALUEKIND_DBTIME:
|
|
// case DBVALUEKIND_DBTIMESTAMP:
|
|
break;
|
|
|
|
default:
|
|
assert(!"PctAllocNode: illegal wKind");
|
|
CoTaskMemFree(pTableNode);
|
|
pTableNode = NULL;
|
|
break;
|
|
}
|
|
|
|
return pTableNode;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Reverses a linked list of DBCOMMANDTREE siblings. This is necessary
|
|
// for left recursive rule in the YACC grammar.
|
|
//
|
|
// @rdesc DBCOMMANDTREE *
|
|
//
|
|
DBCOMMANDTREE * PctReverse(
|
|
DBCOMMANDTREE * pct ) // @parm IN | original list to be reversed
|
|
{
|
|
DBCOMMANDTREE *pctPrev = NULL;
|
|
DBCOMMANDTREE *pctNext = pct;
|
|
|
|
/** NULL or 1 item list is itself **/
|
|
if(pct == NULL || pct->pctNextSibling == NULL)
|
|
return pct;
|
|
|
|
Assert(pct != NULL);
|
|
|
|
while(pct != NULL)
|
|
{
|
|
pctNext = pctNext->pctNextSibling;
|
|
pct->pctNextSibling = pctPrev;
|
|
pctPrev = pct;
|
|
pct = pctNext;
|
|
}
|
|
|
|
return pctPrev;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Creates a DBCOMMANDTREE and tags it by the given op and sets its
|
|
// arguments. Note that this routine is takes variable params to DBCOMMANDTREE's. This
|
|
// allows the YACC grammer file to use a central entry point to create a
|
|
// parse tree complete with all its children args.
|
|
//
|
|
// @side This routine will traverse arg inputs before appending trailing args. This
|
|
// gives the effect of appending lists to lists.
|
|
//
|
|
// @rdesc DBCOMMANDTREE *
|
|
//
|
|
// @devnote
|
|
// Last argument must be NULL: As end of var args is detected with NULL.
|
|
//
|
|
DBCOMMANDTREE *PctCreateNode(
|
|
DBCOMMANDOP op, // @parm IN | op tag for new node
|
|
DBVALUEKIND wKind, //@parm IN | kind to node to allocate
|
|
DBCOMMANDTREE * pctArg, // @parm IN | var arg children
|
|
... )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBCOMMANDTREE * pctRoot = NULL;
|
|
DBCOMMANDTREE * pctCurArg = NULL;
|
|
USHORT cNode = 0;
|
|
va_list pArg;
|
|
|
|
if (pctArg != NULL)
|
|
{
|
|
va_start(pArg, pctArg); // start var arg list
|
|
|
|
/** create arg list by chaining all input node togther **/
|
|
pctCurArg = pctArg;
|
|
while(TRUE)
|
|
{
|
|
|
|
/** walk to the end of the current list **/
|
|
while (pctCurArg->pctNextSibling != NULL)
|
|
{
|
|
pctCurArg = pctCurArg->pctNextSibling;
|
|
cNode++;
|
|
}
|
|
|
|
/** place the next arg onto the tail of the list (this might also be a list) **/
|
|
pctCurArg->pctNextSibling = va_arg(pArg, DBCOMMANDTREE *); // get next var arg
|
|
|
|
/** no more args to append to list**/
|
|
if (pctCurArg->pctNextSibling == NULL)
|
|
break;
|
|
}
|
|
|
|
va_end(pArg); // destruct var arg list
|
|
}
|
|
|
|
/** create the node and add specifc type info **/
|
|
if((pctRoot = PctAllocNode(wKind)) == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto CreateErr;
|
|
}
|
|
|
|
|
|
/** tag node type and set child arg list **/
|
|
pctRoot->op = op;
|
|
pctRoot->pctFirstChild = pctArg;
|
|
|
|
Assert(NULL != pctRoot);
|
|
|
|
/** Success **/
|
|
return pctRoot;
|
|
|
|
CreateErr:
|
|
return NULL;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func Creates a DBCOMMANDTREE and tags it by the given op and sets its
|
|
// arguments. Note that this routine is takes variable params to DBCOMMANDTREE's. This
|
|
// allows the YACC grammer file to use a central entry point to create a
|
|
// parse tree complete with all its children args.
|
|
//
|
|
// @side This routine will traverse arg inputs before appending trailing args. This
|
|
// gives the effect of appending lists to lists.
|
|
//
|
|
// @rdesc DBCOMMANDTREE *
|
|
//
|
|
// @devnote
|
|
// Last argument must be NULL: As end of var args is detected with NULL.
|
|
//
|
|
DBCOMMANDTREE *PctCreateNode(
|
|
DBCOMMANDOP op, // @parm IN | op tag for new node
|
|
DBCOMMANDTREE * pctArg, // @parm IN | var arg children
|
|
... )
|
|
{
|
|
HRESULT hr = S_OK;
|
|
DBCOMMANDTREE * pctRoot = NULL;
|
|
DBCOMMANDTREE * pctCurArg = NULL;
|
|
USHORT cNode = 0;
|
|
va_list pArg;
|
|
|
|
if (pctArg != NULL)
|
|
{
|
|
va_start(pArg, pctArg); // start var arg list
|
|
|
|
/** create arg list by chaining all input node togther **/
|
|
pctCurArg = pctArg;
|
|
while(TRUE)
|
|
{
|
|
|
|
/** walk to the end of the current list **/
|
|
while (pctCurArg->pctNextSibling != NULL)
|
|
{
|
|
pctCurArg = pctCurArg->pctNextSibling;
|
|
cNode++;
|
|
}
|
|
|
|
/** place the next arg onto the tail of the list (this might also be a list) **/
|
|
pctCurArg->pctNextSibling = va_arg(pArg, DBCOMMANDTREE *); // get next var arg
|
|
|
|
/** no more args to append to list**/
|
|
if (pctCurArg->pctNextSibling == NULL)
|
|
break;
|
|
}
|
|
|
|
va_end(pArg); // destruct var arg list
|
|
}
|
|
|
|
/** create the node and add specifc type info **/
|
|
if((pctRoot = PctAllocNode(DBVALUEKIND_EMPTY)) == NULL)
|
|
{
|
|
hr = E_OUTOFMEMORY;
|
|
goto CreateErr;
|
|
}
|
|
|
|
|
|
/** tag node type and set child arg list **/
|
|
pctRoot->op = op;
|
|
pctRoot->pctFirstChild = pctArg;
|
|
|
|
Assert(NULL != pctRoot);
|
|
|
|
/** Success **/
|
|
return pctRoot;
|
|
|
|
CreateErr:
|
|
return NULL;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
//@func Determines the number of siblings of a given node.
|
|
//
|
|
UINT GetNumberOfSiblings(
|
|
DBCOMMANDTREE *pct ) //@parm IN | starting node
|
|
{
|
|
UINT cSiblings =0;
|
|
while (pct)
|
|
{
|
|
cSiblings++;
|
|
pct=pct->pctNextSibling;
|
|
}
|
|
return cSiblings;
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
//@func Recursively deletes a command tree using CoTaskMemFree
|
|
//
|
|
void DeleteDBQT(
|
|
DBCOMMANDTREE* pTableNode ) //@parm IN | Tree to delete
|
|
{
|
|
if ( 0 == pTableNode )
|
|
return;
|
|
|
|
//delete children and siblings
|
|
if (pTableNode->pctFirstChild)
|
|
DeleteDBQT(pTableNode->pctFirstChild);
|
|
if (pTableNode->pctNextSibling)
|
|
DeleteDBQT(pTableNode->pctNextSibling);
|
|
|
|
//delete member pointers
|
|
switch (pTableNode->wKind)
|
|
{
|
|
case DBVALUEKIND_BYGUID:
|
|
CoTaskMemFree(pTableNode->value.pdbbygdValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_COLDESC:
|
|
CoTaskMemFree(pTableNode->value.pcoldescValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_ID:
|
|
switch (pTableNode->value.pdbidValue->eKind)
|
|
{
|
|
case DBKIND_NAME:
|
|
case DBKIND_GUID_NAME:
|
|
CoTaskMemFree(pTableNode->value.pdbidValue->uName.pwszName);
|
|
break;
|
|
|
|
case DBKIND_PGUID_PROPID:
|
|
CoTaskMemFree(pTableNode->value.pdbidValue->uGuid.pguid);
|
|
break;
|
|
|
|
case DBKIND_PGUID_NAME:
|
|
CoTaskMemFree(pTableNode->value.pdbidValue->uName.pwszName);
|
|
CoTaskMemFree(pTableNode->value.pdbidValue->uGuid.pguid);
|
|
break;
|
|
|
|
case DBKIND_GUID:
|
|
case DBKIND_GUID_PROPID:
|
|
break; // nothing to get rid of
|
|
|
|
default: // It shouldn't be anything else
|
|
Assert(0);
|
|
}
|
|
CoTaskMemFree(pTableNode->value.pdbidValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENT:
|
|
CoTaskMemFree(pTableNode->value.pdbcntntValue->pwszPhrase);
|
|
CoTaskMemFree(pTableNode->value.pdbcntntValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTSCOPE:
|
|
CoTaskMemFree(pTableNode->value.pdbcntntscpValue->pwszElementValue);
|
|
CoTaskMemFree(pTableNode->value.pdbcntntscpValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTTABLE:
|
|
CoTaskMemFree(pTableNode->value.pdbcntnttblValue->pwszMachine);
|
|
CoTaskMemFree(pTableNode->value.pdbcntnttblValue->pwszCatalog);
|
|
CoTaskMemFree(pTableNode->value.pdbcntnttblValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTVECTOR:
|
|
CoTaskMemFree(pTableNode->value.pdbcntntvcValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_LIKE:
|
|
CoTaskMemFree(pTableNode->value.pdblikeValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTPROXIMITY:
|
|
CoTaskMemFree(pTableNode->value.pdbcntntproxValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_GROUPINFO:
|
|
CoTaskMemFree(pTableNode->value.pdbgrpinfValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_SETFUNC:
|
|
CoTaskMemFree(pTableNode->value.pdbstfncValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_SORTINFO:
|
|
CoTaskMemFree(pTableNode->value.pdbsrtinfValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_TEXT:
|
|
Assert(NULL != pTableNode->value.pdbtxtValue);
|
|
Assert(NULL != pTableNode->value.pdbtxtValue->pwszText);
|
|
CoTaskMemFree(pTableNode->value.pdbtxtValue->pwszText);
|
|
CoTaskMemFree(pTableNode->value.pdbtxtValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_COMMAND:
|
|
case DBVALUEKIND_MONIKER:
|
|
case DBVALUEKIND_ROWSET:
|
|
case DBVALUEKIND_IDISPATCH:
|
|
case DBVALUEKIND_IUNKNOWN:
|
|
case DBVALUEKIND_EMPTY:
|
|
case DBVALUEKIND_NULL:
|
|
case DBVALUEKIND_I2:
|
|
case DBVALUEKIND_I4:
|
|
case DBVALUEKIND_R4:
|
|
case DBVALUEKIND_R8:
|
|
case DBVALUEKIND_CY:
|
|
case DBVALUEKIND_DATE:
|
|
break;
|
|
|
|
case DBVALUEKIND_BSTR:
|
|
CoTaskMemFree(pTableNode->value.pbstrValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_ERROR:
|
|
case DBVALUEKIND_BOOL:
|
|
break;
|
|
|
|
case DBVALUEKIND_VARIANT:
|
|
{
|
|
HRESULT hr = PropVariantClear((PROPVARIANT*)pTableNode->value.pvValue);
|
|
if (FAILED(hr))
|
|
Assert(0); // UNDONE: meaningful error message
|
|
CoTaskMemFree(pTableNode->value.pvValue);
|
|
}
|
|
break;
|
|
|
|
case DBVALUEKIND_VECTOR:
|
|
case DBVALUEKIND_ARRAY:
|
|
case DBVALUEKIND_BYREF:
|
|
assert(!"DeleteDBQT Vector,array,byref not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_I1:
|
|
case DBVALUEKIND_UI1:
|
|
case DBVALUEKIND_UI2:
|
|
case DBVALUEKIND_UI4:
|
|
case DBVALUEKIND_I8:
|
|
case DBVALUEKIND_UI8:
|
|
break;
|
|
|
|
case DBVALUEKIND_GUID:
|
|
CoTaskMemFree(pTableNode->value.pGuid);
|
|
break;
|
|
|
|
case DBVALUEKIND_BYTES:
|
|
assert(!"DeleteDBQT BYTES not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_WSTR:
|
|
CoTaskMemFree(pTableNode->value.pwszValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_NUMERIC:
|
|
CoTaskMemFree(pTableNode->value.pdbnValue);
|
|
break;
|
|
|
|
default :
|
|
Assert(FALSE);
|
|
break;
|
|
}
|
|
CoTaskMemFree(pTableNode);
|
|
}
|
|
|
|
//--------------------------------------------------------------------
|
|
//@func Copies the OLE-DB tree (pTableNodeSrc) into a new tree
|
|
//@rdesc Return pointer to new tree in ppTableNodeDest
|
|
//
|
|
HRESULT HrQeTreeCopy(
|
|
DBCOMMANDTREE **ppTableNodeDest, // @parm OUT | destination for copy
|
|
const DBCOMMANDTREE *pTableNodeSrc ) // @parm IN | src OLE-DB tree
|
|
{
|
|
HRESULT hr = S_OK;
|
|
|
|
*ppTableNodeDest = NULL;
|
|
if (pTableNodeSrc == NULL)
|
|
return hr;
|
|
|
|
// Allocates the correct
|
|
DBCOMMANDTREE * pTableNode = PctAllocNode(pTableNodeSrc->wKind);
|
|
if (NULL == pTableNode)
|
|
return E_OUTOFMEMORY;
|
|
|
|
pTableNode->op = pTableNodeSrc->op;
|
|
pTableNode->hrError = pTableNodeSrc->hrError;
|
|
|
|
|
|
//Now for byref data, make a copy of the data
|
|
switch(pTableNode->wKind)
|
|
{
|
|
case DBVALUEKIND_ID:
|
|
RtlCopyMemory(pTableNode->value.pdbidValue,pTableNodeSrc->value.pdbidValue,sizeof(DBID));
|
|
switch (pTableNodeSrc->value.pdbidValue->eKind)
|
|
{
|
|
case DBKIND_NAME:
|
|
case DBKIND_GUID_NAME:
|
|
// need to create a new string
|
|
pTableNode->value.pdbidValue->uName.pwszName =
|
|
CoTaskStrDup(pTableNodeSrc->value.pdbidValue->uName.pwszName);
|
|
break;
|
|
case DBKIND_GUID:
|
|
case DBKIND_GUID_PROPID:
|
|
// nothing new to copy
|
|
break;
|
|
case DBKIND_PGUID_NAME:
|
|
// need to create a new string
|
|
pTableNode->value.pdbidValue->uName.pwszName =
|
|
CoTaskStrDup(pTableNodeSrc->value.pdbidValue->uName.pwszName);
|
|
// need to allocate and copy guid
|
|
pTableNode->value.pdbidValue->uGuid.pguid =
|
|
(GUID*)CoTaskMemAlloc(sizeof(GUID));
|
|
*pTableNode->value.pdbidValue->uGuid.pguid =
|
|
*pTableNodeSrc->value.pdbidValue->uGuid.pguid;
|
|
break;
|
|
case DBKIND_PGUID_PROPID:
|
|
// need to allocate and copy guid
|
|
pTableNode->value.pdbidValue->uGuid.pguid =
|
|
(GUID*)CoTaskMemAlloc(sizeof(GUID));
|
|
*pTableNode->value.pdbidValue->uGuid.pguid =
|
|
*pTableNodeSrc->value.pdbidValue->uGuid.pguid;
|
|
break;
|
|
default:
|
|
Assert(0);
|
|
}
|
|
break;
|
|
case DBVALUEKIND_BYGUID:
|
|
RtlCopyMemory(pTableNode->value.pdbbygdValue,pTableNodeSrc->value.pdbbygdValue,sizeof(DBBYGUID));
|
|
break;
|
|
case DBVALUEKIND_COLDESC:
|
|
if (NULL == pTableNodeSrc->value.pcoldescValue)
|
|
pTableNode->value.pcoldescValue = NULL;
|
|
else
|
|
{
|
|
RtlCopyMemory(pTableNode->value.pcoldescValue, pTableNodeSrc->value.pcoldescValue, sizeof(DBCOLUMNDESC));
|
|
|
|
if (NULL != pTableNodeSrc->value.pcoldescValue->dbcid.uName.pwszName)
|
|
pTableNode->value.pcoldescValue->dbcid.uName.pwszName = CoTaskStrDup(pTableNodeSrc->value.pcoldescValue->dbcid.uName.pwszName);
|
|
else
|
|
pTableNode->value.pcoldescValue->dbcid.uName.pwszName = NULL;
|
|
}
|
|
break;
|
|
case DBVALUEKIND_CONTENT:
|
|
RtlCopyMemory(pTableNode->value.pdbcntntValue, pTableNodeSrc->value.pdbcntntValue, sizeof(DBCONTENT));
|
|
// UNDONE: allocate and stuff ->pwszPhrase
|
|
break;
|
|
case DBVALUEKIND_CONTENTSCOPE:
|
|
(pTableNode->value.pdbcntntscpValue)->pwszElementValue = CoTaskStrDup( (pTableNodeSrc->value.pdbcntntscpValue)->pwszElementValue );
|
|
(pTableNode->value.pdbcntntscpValue)->dwFlags = (pTableNodeSrc->value.pdbcntntscpValue)->dwFlags;
|
|
// RtlCopyMemory(pTableNode->value.pdbcntntscpValue, pTableNodeSrc->value.pdbcntntscpValue, sizeof(DBCONTENTSCOPE));
|
|
break;
|
|
case DBVALUEKIND_CONTENTTABLE:
|
|
(pTableNode->value.pdbcntnttblValue)->pwszMachine = CoTaskStrDup( (pTableNodeSrc->value.pdbcntnttblValue)->pwszMachine );
|
|
(pTableNode->value.pdbcntnttblValue)->pwszCatalog = CoTaskStrDup( (pTableNodeSrc->value.pdbcntnttblValue)->pwszCatalog );
|
|
// RtlCopyMemory(pTableNode->value.pdbcntnttblValue, pTableNodeSrc->value.pdbcntnttblValue, sizeof(DBCONTENTTABLE));
|
|
break;
|
|
case DBVALUEKIND_LIKE:
|
|
RtlCopyMemory(pTableNode->value.pdblikeValue,pTableNodeSrc->value.pdblikeValue,sizeof(DBLIKE));
|
|
break;
|
|
case DBVALUEKIND_CONTENTPROXIMITY:
|
|
RtlCopyMemory(pTableNode->value.pdbcntntproxValue, pTableNodeSrc->value.pdbcntntproxValue, sizeof(DBCONTENTPROXIMITY));
|
|
// UNDONE: allocate and stuff ->pwszPhrase
|
|
break;
|
|
case DBVALUEKIND_CONTENTVECTOR:
|
|
//UNDONE: CoTaskMemFree(pTableNode->value.pdbcntntvcValue->rgulWeights);
|
|
RtlCopyMemory(pTableNode->value.pdbcntntvcValue, pTableNodeSrc->value.pdbcntntvcValue, sizeof(DBCONTENTVECTOR));
|
|
break;
|
|
case DBVALUEKIND_GROUPINFO:
|
|
RtlCopyMemory(pTableNode->value.pdbgrpinfValue,pTableNodeSrc->value.pdbgrpinfValue,sizeof(DBGROUPINFO));
|
|
break;
|
|
case DBVALUEKIND_SETFUNC:
|
|
RtlCopyMemory(pTableNode->value.pdbstfncValue,pTableNodeSrc->value.pdbstfncValue,sizeof(DBSETFUNC));
|
|
break;
|
|
case DBVALUEKIND_SORTINFO:
|
|
RtlCopyMemory(pTableNode->value.pdbsrtinfValue,pTableNodeSrc->value.pdbsrtinfValue,sizeof(DBSORTINFO));
|
|
break;
|
|
case DBVALUEKIND_TEXT:
|
|
pTableNode->value.pdbtxtValue->guidDialect = pTableNodeSrc->value.pdbtxtValue->guidDialect;
|
|
pTableNode->value.pdbtxtValue->pwszText = CoTaskStrDup(pTableNodeSrc->value.pdbtxtValue->pwszText);
|
|
pTableNode->value.pdbtxtValue->ulErrorLocator = pTableNodeSrc->value.pdbtxtValue->ulErrorLocator;
|
|
pTableNode->value.pdbtxtValue->ulTokenLength = pTableNodeSrc->value.pdbtxtValue->ulTokenLength;
|
|
break;
|
|
|
|
case DBVALUEKIND_BSTR:
|
|
assert(!"HrQeTreeCopy:BSTR not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_VARIANT:
|
|
PropVariantCopy((PROPVARIANT*)pTableNode->value.pvValue,
|
|
(PROPVARIANT*)pTableNodeSrc->value.pvValue);
|
|
break;
|
|
|
|
case DBVALUEKIND_VECTOR:
|
|
case DBVALUEKIND_ARRAY:
|
|
case DBVALUEKIND_BYREF:
|
|
assert(!"HrQeTreeCopy:Vector,Array,Byref not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_GUID:
|
|
*(pTableNode->value.pGuid) = *(pTableNodeSrc->value.pGuid);
|
|
break;
|
|
|
|
case DBVALUEKIND_BYTES:
|
|
assert(!"HrQeTreeCopy:bytes not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_WSTR:
|
|
pTableNode->value.pwszValue = CoTaskStrDup(pTableNodeSrc->value.pwszValue);
|
|
break;
|
|
|
|
// Copied as part of first 8 bytes
|
|
case DBVALUEKIND_COMMAND:
|
|
case DBVALUEKIND_MONIKER:
|
|
case DBVALUEKIND_ROWSET:
|
|
case DBVALUEKIND_IDISPATCH:
|
|
case DBVALUEKIND_IUNKNOWN:
|
|
//NYI : rossbu (6/29/95) -- AddRef interfaces on copy
|
|
case DBVALUEKIND_EMPTY:
|
|
case DBVALUEKIND_NULL:
|
|
case DBVALUEKIND_I2:
|
|
case DBVALUEKIND_I4:
|
|
case DBVALUEKIND_R4:
|
|
case DBVALUEKIND_R8:
|
|
case DBVALUEKIND_CY:
|
|
case DBVALUEKIND_DATE:
|
|
|
|
// Copied as part of first 8 bytes
|
|
case DBVALUEKIND_ERROR:
|
|
case DBVALUEKIND_BOOL:
|
|
|
|
// Copied as part of first 8 bytes
|
|
case DBVALUEKIND_I1:
|
|
case DBVALUEKIND_UI1:
|
|
case DBVALUEKIND_UI2:
|
|
case DBVALUEKIND_UI4:
|
|
case DBVALUEKIND_I8:
|
|
case DBVALUEKIND_UI8:
|
|
//Copy the data values
|
|
RtlCopyMemory(&(pTableNode->value), &(pTableNodeSrc->value),(sizeof pTableNode->value));
|
|
break;
|
|
|
|
default :
|
|
Assert(FALSE);
|
|
break;
|
|
}
|
|
|
|
hr = HrQeTreeCopy(&pTableNode->pctFirstChild, pTableNodeSrc->pctFirstChild);
|
|
if (FAILED(hr))
|
|
return ResultFromScode(hr);
|
|
|
|
hr = HrQeTreeCopy(&pTableNode->pctNextSibling, pTableNodeSrc->pctNextSibling);
|
|
if (FAILED(hr))
|
|
return ResultFromScode(hr);
|
|
|
|
*ppTableNodeDest = pTableNode;
|
|
return ResultFromScode(hr);
|
|
}
|
|
|
|
// ----------------------------------------------------------------------------
|
|
//
|
|
// Method: SetDepthAndInclusion
|
|
//
|
|
// Synopsis: Walks through the list of scopes and applies the scope
|
|
// information provided by pctInfo to each node.
|
|
//
|
|
// Arguments: [pctInfo] -- a node with deep/shallow, include/exclude info
|
|
// [pctScpList] -- a list of scope_list_element nodes
|
|
//
|
|
// History: 07-25-98 danleg Created
|
|
//
|
|
// ----------------------------------------------------------------------------
|
|
|
|
void SetDepthAndInclusion(
|
|
DBCOMMANDTREE * pctInfo,
|
|
DBCOMMANDTREE * pctScpList )
|
|
{
|
|
Assert( 0 != pctInfo && NULL != pctScpList );
|
|
|
|
DBCOMMANDTREE* pct = pctScpList;
|
|
while( NULL != pct )
|
|
{
|
|
pct->value.pdbcntntscpValue->dwFlags |=
|
|
(pctInfo->value.pdbcntntscpValue->dwFlags & (SCOPE_FLAG_MASK));
|
|
|
|
pct = pct->pctNextSibling;
|
|
}
|
|
}
|
|
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////// DEBUG OUTPUT////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
#ifdef DEBUG
|
|
|
|
|
|
|
|
/*
|
|
** DBOP to string map. Used to dump name rather than op # in OLE-DB tree nodes
|
|
** This map should be kept consistent with the OLE-DB op definitions since there
|
|
** is a one to one mapping.
|
|
*/
|
|
LPSTR mpoplpstr[] = {
|
|
"DBOP_scalar_constant",
|
|
"DBOP_DEFAULT",
|
|
"DBOP_NULL",
|
|
"DBOP_bookmark_name",
|
|
"DBOP_catalog_name",
|
|
"DBOP_column_name",
|
|
"DBOP_schema_name",
|
|
"DBOP_outall_name",
|
|
"DBOP_qualifier_name",
|
|
"DBOP_qualified_column_name",
|
|
"DBOP_table_name",
|
|
"DBOP_nested_table_name",
|
|
"DBOP_nested_column_name",
|
|
"DBOP_row",
|
|
"DBOP_table",
|
|
"DBOP_sort",
|
|
"DBOP_distinct",
|
|
"DBOP_distinct_order_preserving",
|
|
"DBOP_alias",
|
|
"DBOP_cross_join",
|
|
"DBOP_union_join",
|
|
"DBOP_inner_join",
|
|
"DBOP_left_semi_join",
|
|
"DBOP_right_semi_join",
|
|
"DBOP_left_anti_semi_join",
|
|
"DBOP_right_anti_semi_join",
|
|
"DBOP_left_outer_join",
|
|
"DBOP_right_outer_join",
|
|
"DBOP_full_outer_join",
|
|
"DBOP_natural_join",
|
|
"DBOP_natural_left_outer_join",
|
|
"DBOP_natural_right_outer_join",
|
|
"DBOP_natural_full_outer_join",
|
|
"DBOP_set_intersection",
|
|
"DBOP_set_union",
|
|
"DBOP_set_left_difference",
|
|
"DBOP_set_right_difference",
|
|
"DBOP_set_anti_difference",
|
|
"DBOP_bag_intersection",
|
|
"DBOP_bag_union",
|
|
"DBOP_bag_left_difference",
|
|
"DBOP_bag_right_difference",
|
|
"DBOP_bag_anti_difference",
|
|
"DBOP_division",
|
|
"DBOP_relative_sampling",
|
|
"DBOP_absolute_sampling",
|
|
"DBOP_transitive_closure",
|
|
"DBOP_recursive_union",
|
|
"DBOP_aggregate",
|
|
"DBOP_remote_table",
|
|
"DBOP_select",
|
|
"DBOP_order_preserving_select",
|
|
"DBOP_project",
|
|
"DBOP_project_order_preserving",
|
|
"DBOP_top",
|
|
"DBOP_top_percent",
|
|
"DBOP_top_plus_ties",
|
|
"DBOP_top_percent_plus_ties",
|
|
"DBOP_rank",
|
|
"DBOP_rank_ties_equally",
|
|
"DBOP_rank_ties_equally_and_skip",
|
|
"DBOP_navigate",
|
|
"DBOP_nesting",
|
|
"DBOP_unnesting",
|
|
"DBOP_nested_apply",
|
|
"DBOP_cross_tab",
|
|
"DBOP_is_NULL",
|
|
"DBOP_is_NOT_NULL",
|
|
"DBOP_equal",
|
|
"DBOP_not_equal",
|
|
"DBOP_less",
|
|
"DBOP_less_equal",
|
|
"DBOP_greater",
|
|
"DBOP_greater_equal",
|
|
"DBOP_equal_all",
|
|
"DBOP_not_equal_all",
|
|
"DBOP_less_all",
|
|
"DBOP_less_equal_all",
|
|
"DBOP_greater_all",
|
|
"DBOP_greater_equal_all",
|
|
"DBOP_equal_any",
|
|
"DBOP_not_equal_any",
|
|
"DBOP_less_any",
|
|
"DBOP_less_equal_any",
|
|
"DBOP_greater_any",
|
|
"DBOP_greater_equal_any",
|
|
"DBOP_anybits",
|
|
"DBOP_allbits",
|
|
"DBOP_anybits_any",
|
|
"DBOP_allbits_any",
|
|
"DBOP_anybits_all",
|
|
"DBOP_allbits_all",
|
|
"DBOP_between",
|
|
"DBOP_between_unordered",
|
|
"DBOP_match",
|
|
"DBOP_match_unique",
|
|
"DBOP_match_partial",
|
|
"DBOP_match_partial_unique",
|
|
"DBOP_match_full",
|
|
"DBOP_match_full_unique",
|
|
"DBOP_scalar_parameter",
|
|
"DBOP_scalar_function",
|
|
"DBOP_plus",
|
|
"DBOP_minus",
|
|
"DBOP_times",
|
|
"DBOP_over",
|
|
"DBOP_div",
|
|
"DBOP_modulo",
|
|
"DBOP_power",
|
|
"DBOP_like",
|
|
"DBOP_sounds_like",
|
|
"DBOP_like_any",
|
|
"DBOP_like_all",
|
|
"DBOP_is_INVALID",
|
|
"DBOP_is_TRUE",
|
|
"DBOP_is_FALSE",
|
|
"DBOP_and",
|
|
"DBOP_or",
|
|
"DBOP_xor",
|
|
"DBOP_equivalent",
|
|
"DBOP_not",
|
|
"DBOP_implies",
|
|
"DBOP_overlaps",
|
|
"DBOP_case_condition",
|
|
"DBOP_case_value",
|
|
"DBOP_nullif",
|
|
"DBOP_cast",
|
|
"DBOP_coalesce",
|
|
"DBOP_position",
|
|
"DBOP_extract",
|
|
"DBOP_char_length",
|
|
"DBOP_octet_length",
|
|
"DBOP_bit_length",
|
|
"DBOP_substring",
|
|
"DBOP_upper",
|
|
"DBOP_lower",
|
|
"DBOP_trim",
|
|
"DBOP_translate",
|
|
"DBOP_convert",
|
|
"DBOP_string_concat",
|
|
"DBOP_current_date",
|
|
"DBOP_current_time",
|
|
"DBOP_current_timestamp",
|
|
"DBOP_content_select",
|
|
"DBOP_content",
|
|
"DBOP_content_freetext",
|
|
"DBOP_content_proximity",
|
|
"DBOP_content_vector_or",
|
|
"DBOP_delete",
|
|
"DBOP_update",
|
|
"DBOP_insert",
|
|
"DBOP_min",
|
|
"DBOP_max",
|
|
"DBOP_count",
|
|
"DBOP_sum",
|
|
"DBOP_avg",
|
|
"DBOP_any_sample",
|
|
"DBOP_stddev",
|
|
"DBOP_stddev_pop",
|
|
"DBOP_var",
|
|
"DBOP_var_pop",
|
|
"DBOP_first",
|
|
"DBOP_last",
|
|
"DBOP_in",
|
|
"DBOP_exists",
|
|
"DBOP_unique",
|
|
"DBOP_subset",
|
|
"DBOP_proper_subset",
|
|
"DBOP_superset",
|
|
"DBOP_proper_superset",
|
|
"DBOP_disjoint",
|
|
"DBOP_pass_through",
|
|
"DBOP_defined_by_GUID",
|
|
"DBOP_text_command",
|
|
"DBOP_SQL_select",
|
|
"DBOP_prior_command_tree",
|
|
"DBOP_add_columns",
|
|
"DBOP_column_list_anchor",
|
|
"DBOP_column_list_element",
|
|
"DBOP_command_list_anchor",
|
|
"DBOP_command_list_element",
|
|
"DBOP_from_list_anchor",
|
|
"DBOP_from_list_element",
|
|
"DBOP_project_list_anchor",
|
|
"DBOP_project_list_element",
|
|
"DBOP_row_list_anchor",
|
|
"DBOP_row_list_element",
|
|
"DBOP_scalar_list_anchor",
|
|
"DBOP_scalar_list_element",
|
|
"DBOP_set_list_anchor",
|
|
"DBOP_set_list_element",
|
|
"DBOP_sort_list_anchor",
|
|
"DBOP_sort_list_element",
|
|
"DBOP_alter_character_set",
|
|
"DBOP_alter_collation",
|
|
"DBOP_alter_domain",
|
|
"DBOP_alter_index",
|
|
"DBOP_alter_procedure",
|
|
"DBOP_alter_schema",
|
|
"DBOP_alter_table",
|
|
"DBOP_alter_trigger",
|
|
"DBOP_alter_view",
|
|
"DBOP_coldef_list_anchor",
|
|
"DBOP_coldef_list_element",
|
|
"DBOP_create_assertion",
|
|
"DBOP_create_character_set",
|
|
"DBOP_create_collation",
|
|
"DBOP_create_domain",
|
|
"DBOP_create_index",
|
|
"DBOP_create_procedure",
|
|
"DBOP_create_schema",
|
|
"DBOP_create_synonym",
|
|
"DBOP_create_table",
|
|
"DBOP_create_temporary_tab",
|
|
"DBOP_create_translation",
|
|
"DBOP_create_trigger",
|
|
"DBOP_create_view",
|
|
"DBOP_drop_assertion",
|
|
"DBOP_drop_character_set",
|
|
"DBOP_drop_collation",
|
|
"DBOP_drop_domain",
|
|
"DBOP_drop_index",
|
|
"DBOP_drop_procedure",
|
|
"DBOP_drop_schema",
|
|
"DBOP_drop_synonym",
|
|
"DBOP_drop_table",
|
|
"DBOP_drop_translation",
|
|
"DBOP_drop_trigger",
|
|
"DBOP_drop_view",
|
|
"DBOP_foreign_key",
|
|
"DBOP_grant_privileges",
|
|
"DBOP_index_list_anchor",
|
|
"DBOP_index_list_element",
|
|
"DBOP_primary_key",
|
|
"DBOP_property_list_anchor",
|
|
"DBOP_property_list_element",
|
|
"DBOP_referenced_table",
|
|
"DBOP_rename_object",
|
|
"DBOP_revoke_privileges",
|
|
"DBOP_schema_authorization",
|
|
"DBOP_unique_key",
|
|
"DBOP_scope_list_anchor",
|
|
"DBOP_scope_list_element",
|
|
"DBOP_content_table",
|
|
NULL, // needed for DBOP_from_string (able to find the end of the list)
|
|
};
|
|
|
|
int indentLevel=0;
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func ostream& | operator shift-left |
|
|
// Dumps the given GUID node into the given ostream.
|
|
// @rdesc ostream
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
GUID guid //@parm IN | DBID node to dump.
|
|
)
|
|
{
|
|
osOut.setf(ios::hex,ios::basefield);
|
|
osOut << guid.Data1 << "-" << guid.Data2 << "-" << guid.Data3 << "-";
|
|
|
|
for (int i=0; i<8; i++)
|
|
osOut << (unsigned int)guid.Data4[i] << " ";
|
|
osOut.setf(ios::dec,ios::basefield);
|
|
return osOut;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func ostream& | operator shift-left |
|
|
// Dumps the given DBID node into the given ostream.
|
|
// @rdesc ostream
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
VARIANT __RPC_FAR *pvarValue //@parm IN | DBID node to dump.
|
|
)
|
|
{
|
|
switch (pvarValue->vt)
|
|
{
|
|
case VT_EMPTY:
|
|
osOut << "VT_EMPTY" << endl;
|
|
break;
|
|
|
|
case VT_NULL:
|
|
osOut << "VT_NULL" << endl;
|
|
break;
|
|
|
|
case VT_UI1:
|
|
osOut << "VT_UI1 = " << pvarValue->bVal << endl;
|
|
break;
|
|
|
|
case VT_I2:
|
|
osOut << "VT_I2 = " << pvarValue->iVal << endl;
|
|
break;
|
|
|
|
case VT_UI2:
|
|
osOut << "VT_UI2 = " << pvarValue->uiVal << endl;
|
|
break;
|
|
|
|
case VT_BOOL:
|
|
if (VARIANT_TRUE == pvarValue->boolVal)
|
|
osOut << "VT_BOOL = TRUE" << endl;
|
|
else
|
|
osOut << "VT_BOOL = FALSE" << endl;
|
|
break;
|
|
|
|
case VT_I4:
|
|
osOut << "VT_I4 = " << pvarValue->lVal << endl;
|
|
break;
|
|
|
|
case VT_UI4:
|
|
osOut << "VT_UI4 = " << pvarValue->ulVal << endl;
|
|
break;
|
|
|
|
case VT_I8:
|
|
{
|
|
WCHAR pwszI8[20];
|
|
swprintf(pwszI8, L"%I64d", ((PROPVARIANT*)pvarValue)->hVal);
|
|
osOut << "VT_I8 = " << pwszI8 << endl;
|
|
}
|
|
break;
|
|
|
|
case VT_UI8:
|
|
{
|
|
WCHAR pwszUI8[20];
|
|
swprintf(pwszUI8, L"%I64u (%I64x)",
|
|
((PROPVARIANT*)pvarValue)->uhVal,
|
|
((PROPVARIANT*)pvarValue)->uhVal);
|
|
osOut << "VT_UI8 = " << pwszUI8 << endl;
|
|
}
|
|
break;
|
|
|
|
case VT_R4:
|
|
osOut << "VT_R4 = " << pvarValue->fltVal << endl;
|
|
break;
|
|
|
|
case VT_R8:
|
|
osOut << "VT_R8 = " << pvarValue->dblVal << endl;
|
|
break;
|
|
|
|
case VT_CY:
|
|
{
|
|
WCHAR pwszI8[20];
|
|
swprintf(pwszI8, L"%I64d", ((PROPVARIANT*)pvarValue)->cyVal);
|
|
osOut << "VT_CY = " << pwszI8 << endl;
|
|
}
|
|
break;
|
|
|
|
case VT_DATE:
|
|
{
|
|
BSTR bstrVal = NULL;
|
|
HRESULT hr = VarBstrFromDate(pvarValue->date , LOCALE_SYSTEM_DEFAULT, 0, &bstrVal);
|
|
|
|
osOut << "VT_DATE = \"" << (LPWSTR)bstrVal << "\"" << endl;
|
|
SysFreeString(bstrVal);
|
|
}
|
|
break;
|
|
|
|
case VT_CLSID:
|
|
osOut << "VT_CLSID = " << ((PROPVARIANT*)pvarValue)->puuid << " "
|
|
<< *((PROPVARIANT*)pvarValue)->puuid << endl;
|
|
break;
|
|
|
|
case VT_BSTR:
|
|
osOut << "VT_BSTR = \"" << pvarValue->bstrVal << "\"" << endl;
|
|
break;
|
|
|
|
case VT_LPSTR:
|
|
osOut << "VT_LPSTR (tagDBVARIANT) = \"" << ((PROPVARIANT*)pvarValue)->pszVal << "\"" << endl;
|
|
break;
|
|
|
|
case VT_LPWSTR:
|
|
osOut << "VT_LPWSTR (tagDBVARIANT) = \"" << ((PROPVARIANT*)pvarValue)->pwszVal << "\"" << endl;
|
|
break;
|
|
|
|
case VT_FILETIME:
|
|
{
|
|
SYSTEMTIME systemTime;
|
|
FileTimeToSystemTime(&(((PROPVARIANT*)pvarValue)->filetime),&systemTime);
|
|
osOut << "VT_FILETIME (tagPROPVARIANT) = \"" << systemTime.wYear << "-" <<
|
|
systemTime.wMonth << "-" << systemTime.wDay << " " <<
|
|
systemTime.wHour << ":" << systemTime.wMinute << ":" <<
|
|
systemTime.wSecond << "." << systemTime.wMilliseconds << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_UI1|VT_VECTOR):
|
|
{
|
|
osOut << "VT_UI1|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->caub.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->caub.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->caub.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_I2|VT_VECTOR):
|
|
{
|
|
osOut << "VT_I2|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cai.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cai.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cai.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_UI2|VT_VECTOR):
|
|
{
|
|
osOut << "VT_UI2|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->caui.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->caui.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->caui.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_BOOL|VT_VECTOR):
|
|
{
|
|
osOut << "VT_BOOL|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cabool.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cabool.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cabool.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_I4|VT_VECTOR):
|
|
{
|
|
osOut << "VT_I4|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cal.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cal.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cal.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_UI4|VT_VECTOR):
|
|
{
|
|
osOut << "VT_UI4|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->caul.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->caul.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->caul.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_R4|VT_VECTOR):
|
|
{
|
|
osOut << "VT_R4|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->caflt.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->caflt.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->caflt.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_ERROR|VT_VECTOR):
|
|
{
|
|
osOut << "VT_ERROR|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cascode.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cascode.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cascode.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_I8|VT_VECTOR):
|
|
{
|
|
osOut << "VT_I8|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cah.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cah.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->cah.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_UI8|VT_VECTOR):
|
|
{
|
|
osOut << "VT_UI8|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cauh.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cauh.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->cauh.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_R8|VT_VECTOR):
|
|
{
|
|
osOut << "VT_R8|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cadbl.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cadbl.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cadbl.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_CY|VT_VECTOR):
|
|
{
|
|
osOut << "VT_CY|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cacy.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cacy.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->cacy.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_DATE|VT_VECTOR):
|
|
{
|
|
osOut << "VT_DATE|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cadate.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cadate.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cadate.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_FILETIME|VT_VECTOR):
|
|
{
|
|
osOut << "VT_FILETIME|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cafiletime.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cafiletime.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->cafiletime.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_CLSID|VT_VECTOR):
|
|
{
|
|
osOut << "VT_CLSID|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cauuid.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cauuid.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cauuid.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_CF|VT_VECTOR):
|
|
{
|
|
osOut << "VT_CF|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->caclipdata.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->caclipdata.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->caclipdata.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_BSTR|VT_VECTOR):
|
|
{
|
|
osOut << "VT_BSTR|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->cabstr.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->cabstr.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->cabstr.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_LPSTR|VT_VECTOR):
|
|
{
|
|
osOut << "VT_LPSTR|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->calpstr.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->calpstr.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->calpstr.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_LPWSTR|VT_VECTOR):
|
|
{
|
|
osOut << "VT_LPWSTR|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->calpwstr.cElems;
|
|
for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->calpwstr.cElems; i++)
|
|
osOut << " " << ((PROPVARIANT*)pvarValue)->calpwstr.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
case (VT_VARIANT|VT_VECTOR):
|
|
{
|
|
osOut << "VT_VARIANT|VT_VECTOR = " << ((PROPVARIANT*)pvarValue)->capropvar.cElems;
|
|
// for (ULONG i = 0; i<((PROPVARIANT*)pvarValue)->capropvar.cElems; i++)
|
|
// osOut << " " << ((PROPVARIANT*)pvarValue)->capropvar.pElems[i];
|
|
osOut << endl;
|
|
}
|
|
break;
|
|
|
|
default:
|
|
osOut << "type :" << pvarValue->vt << endl;
|
|
break;
|
|
}
|
|
return osOut;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func ostream& | operator shift-left |
|
|
// Dumps the given DBID node into the given ostream.
|
|
// @rdesc ostream
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
DBID __RPC_FAR *pdbid //@parm IN | DBID node to dump.
|
|
)
|
|
{
|
|
osOut << endl;
|
|
switch (pdbid->eKind)
|
|
{
|
|
case DBKIND_NAME:
|
|
osOut << INDENTLINE << "\t\tpwszName: " << pdbid->uName.pwszName << endl;
|
|
break;
|
|
case DBKIND_GUID:
|
|
osOut << INDENTLINE << "\t\tguid: "<< pdbid->uGuid.guid << endl;
|
|
break;
|
|
case DBKIND_GUID_NAME:
|
|
osOut << INDENTLINE << "\t\tguid: "<< pdbid->uGuid.guid << endl;
|
|
osOut << INDENTLINE << "\t\tpwszName: " << pdbid->uName.pwszName << endl;
|
|
break;
|
|
case DBKIND_GUID_PROPID:
|
|
osOut << INDENTLINE << "\t\tguid: "<< pdbid->uGuid.guid << endl;
|
|
osOut << INDENTLINE << "\t\tulPropid: " << pdbid->uName.ulPropid << endl;
|
|
break;
|
|
case DBKIND_PGUID_NAME:
|
|
osOut << INDENTLINE << "\t\tpguid: "<< (void*)pdbid->uGuid.pguid << " " << *pdbid->uGuid.pguid << endl;
|
|
osOut << INDENTLINE << "\t\tpwszName: " << pdbid->uName.pwszName << endl;
|
|
break;
|
|
case DBKIND_PGUID_PROPID:
|
|
osOut << INDENTLINE << "\t\tpguid: "<< (void*)pdbid->uGuid.pguid << " " << *pdbid->uGuid.pguid << endl;
|
|
osOut << INDENTLINE << "\t\tulPropid: " << pdbid->uName.ulPropid << endl;
|
|
break;
|
|
default:
|
|
Assert(0);
|
|
}
|
|
return osOut;
|
|
}
|
|
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
// @func ostream& | operator shift-left |
|
|
// Dumps the given DBCONTENTVECTOR node into the given ostream.
|
|
// @rdesc ostream
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
DBCONTENTVECTOR __RPC_FAR *pdbcntntvcValue //@parm IN | DBCONTENTVECTOR node to dump.
|
|
)
|
|
{
|
|
osOut << endl << INDENTLINE << "\t\tdwRankingMethod " << pdbcntntvcValue->dwRankingMethod;
|
|
switch(pdbcntntvcValue->dwRankingMethod)
|
|
{
|
|
case VECTOR_RANK_MIN:
|
|
osOut << " VECTOR_RANK_MIN" << endl;
|
|
break;
|
|
case VECTOR_RANK_MAX:
|
|
osOut << " VECTOR_RANK_MAX" << endl;
|
|
break;
|
|
case VECTOR_RANK_INNER:
|
|
osOut << " VECTOR_RANK_INNER" << endl;
|
|
break;
|
|
case VECTOR_RANK_DICE:
|
|
osOut << " VECTOR_RANK_DICE" << endl;
|
|
break;
|
|
case VECTOR_RANK_JACCARD:
|
|
osOut << " VECTOR_RANK_JACCARD" << endl;
|
|
break;
|
|
}
|
|
osOut << endl;
|
|
return osOut;
|
|
}
|
|
|
|
|
|
//--------------------------------------------------------------------
|
|
//@func:(DEBUG) ostream& | operator shift-left |
|
|
// Dumps the given DBCOMMANDTREE node into the given ostream.
|
|
//@rdesc ostream
|
|
//
|
|
ostream & operator <<
|
|
(
|
|
ostream &osOut, //@parm INOUT | ostream in which node is to be placed.
|
|
DBCOMMANDTREE &qt //@parm IN | OLE-DB node to dump.
|
|
)
|
|
{
|
|
DBCOMMANDTREE *pTableNodeT = NULL;
|
|
|
|
osOut << INDENTLINE << "Node" << &qt << endl;
|
|
osOut << INDENTLINE << "{" << endl;
|
|
osOut << INDENTLINE << "\tOP = " << mpoplpstr[qt.op] << " // Enum value: " << (USHORT) qt.op << endl;
|
|
// osOut << INDENTLINE << "\tError = " << qt.hrError << endl;
|
|
if (qt.pctFirstChild)
|
|
osOut << INDENTLINE << "\tpctFirstChild = " << qt.pctFirstChild << endl;
|
|
if (qt.pctNextSibling)
|
|
osOut << INDENTLINE << "\tpctNextSibling = " << qt.pctNextSibling << endl;
|
|
|
|
switch(qt.wKind)
|
|
{
|
|
case DBVALUEKIND_BYGUID:
|
|
osOut << INDENTLINE << "\twKind : BYGUID" << endl;
|
|
osOut << INDENTLINE << "\tcbInfo:" << qt.value.pdbbygdValue->cbInfo << endl;
|
|
osOut << INDENTLINE << "\tpbInfo:" << (VOID*)qt.value.pdbbygdValue->pbInfo << endl;
|
|
osOut << INDENTLINE << "\tguid:" << qt.value.pdbbygdValue->guid << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_ID:
|
|
osOut << INDENTLINE << "\twKind : ID " << qt.value.pdbidValue <<endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENT:
|
|
osOut << INDENTLINE << "\twKind : CONTENT " << qt.value.pdbcntntValue <<endl;
|
|
osOut << INDENTLINE << "\t\tpwszPhrase \"" << qt.value.pdbcntntValue->pwszPhrase << "\"" << endl;
|
|
osOut << INDENTLINE << "\t\tdwGenerateMethod " << qt.value.pdbcntntValue->dwGenerateMethod;
|
|
switch(qt.value.pdbcntntValue->dwGenerateMethod)
|
|
{
|
|
case GENERATE_METHOD_EXACT:
|
|
osOut << " GENERATE_METHOD_EXACT" << endl;
|
|
break;
|
|
case GENERATE_METHOD_PREFIX:
|
|
osOut << " GENERATE_METHOD_PREFIX" << endl;
|
|
break;
|
|
case GENERATE_METHOD_INFLECT:
|
|
osOut << " GENERATE_METHOD_INFLECT" << endl;
|
|
break;
|
|
}
|
|
osOut << INDENTLINE << "\t\tlWeight " << qt.value.pdbcntntValue->lWeight << endl;
|
|
osOut << INDENTLINE << "\t\tlcid " << qt.value.pdbcntntValue->lcid << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTSCOPE:
|
|
osOut << INDENTLINE << "\tdwFlags" << endl;
|
|
osOut << INDENTLINE << "\t\tInclude = " << (qt.value.pdbcntntscpValue->dwFlags & SCOPE_FLAG_INCLUDE) << endl;
|
|
osOut << INDENTLINE << "\t\tDeep = " << (qt.value.pdbcntntscpValue->dwFlags & SCOPE_FLAG_DEEP) << endl;
|
|
osOut << INDENTLINE << "\t\tType = " << (qt.value.pdbcntntscpValue->dwFlags & ~SCOPE_FLAG_MASK);
|
|
switch (qt.value.pdbcntntscpValue->dwFlags & ~(SCOPE_FLAG_MASK) )
|
|
{
|
|
case SCOPE_TYPE_WINPATH:
|
|
osOut << " SCOPE_TYPE_WINPATH" << endl;
|
|
break;
|
|
case SCOPE_TYPE_VPATH:
|
|
osOut << " SCOPE_TYPE_VPATH" << endl;
|
|
break;
|
|
default:
|
|
osOut << " Unknown type" << endl;
|
|
break;
|
|
}
|
|
osOut << INDENTLINE << "\tpwszElementValue = " << qt.value.pdbcntntscpValue->pwszElementValue << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTTABLE:
|
|
osOut << INDENTLINE << "\tpwszMachine = " << qt.value.pdbcntnttblValue->pwszMachine << endl;
|
|
osOut << INDENTLINE << "\tpwszCatalog = " << qt.value.pdbcntnttblValue->pwszCatalog << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_LIKE:
|
|
osOut << INDENTLINE << "\twKind : LIKE " << qt.value.pdblikeValue << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_CONTENTPROXIMITY:
|
|
osOut << INDENTLINE << "\twKind : CONTENTPROXIMITY " << qt.value.pdbcntntproxValue << endl;
|
|
osOut << INDENTLINE << "\t\tProximityUnit: " << qt.value.pdbcntntproxValue->dwProximityUnit << endl;
|
|
osOut << INDENTLINE << "\t\tProximityDistance: " << qt.value.pdbcntntproxValue->ulProximityDistance << endl;
|
|
osOut << INDENTLINE << "\t\tlWeight: " << qt.value.pdbcntntproxValue->lWeight << endl;
|
|
break;
|
|
case DBVALUEKIND_CONTENTVECTOR:
|
|
osOut << INDENTLINE << "\twKind : CONTENTVECTOR " << qt.value.pdbcntntvcValue <<endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_GROUPINFO:
|
|
osOut << INDENTLINE << "\twKind : GROUPINFO" << endl;
|
|
osOut << INDENTLINE << "\tlcid : " << (long)qt.value.pdbgrpinfValue->lcid << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_PROPERTY:
|
|
osOut << "\twKind : PROPERTY" << endl;
|
|
|
|
case DBVALUEKIND_SORTINFO:
|
|
osOut << INDENTLINE << "\twKind : sort info" << endl;
|
|
osOut << INDENTLINE << "\tlcid : " << (long)qt.value.pdbsrtinfValue->lcid << endl;
|
|
osOut << INDENTLINE << "\tsort direction : ";
|
|
if (TRUE == qt.value.pdbsrtinfValue->fDesc)
|
|
osOut << "Desc" << endl;
|
|
else
|
|
osOut << "Asc" << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_TEXT:
|
|
osOut << INDENTLINE << "//\twKind : TEXT" << endl;
|
|
osOut << INDENTLINE << "\t\t dialect guid: " << qt.value.pdbtxtValue->guidDialect << endl;
|
|
osOut << INDENTLINE << "\t\tpwszText : " << qt.value.pdbtxtValue->pwszText << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_COMMAND:
|
|
case DBVALUEKIND_MONIKER:
|
|
case DBVALUEKIND_ROWSET:
|
|
case DBVALUEKIND_IDISPATCH:
|
|
case DBVALUEKIND_IUNKNOWN:
|
|
assert(!"operator << for DBCOMMANDTREE: no COMMAND-UNKNOWN not implemented");
|
|
break;
|
|
|
|
case DBVALUEKIND_EMPTY:
|
|
osOut << INDENTLINE << "\twKind = empty" << endl;
|
|
break;
|
|
case DBVALUEKIND_NULL:
|
|
case DBVALUEKIND_I2:
|
|
osOut << INDENTLINE << "\twKind = I2" << endl;
|
|
osOut << INDENTLINE << "\t\t sValue = " << qt.value.sValue << endl;
|
|
break;
|
|
case DBVALUEKIND_I4:
|
|
osOut << INDENTLINE << "\twKind = I4" << endl;
|
|
osOut << INDENTLINE << "\t\t lValue = " << qt.value.lValue << endl;
|
|
break;
|
|
case DBVALUEKIND_R4:
|
|
osOut << INDENTLINE << "\twKind = R4" << endl;
|
|
osOut << INDENTLINE << "\t\t flValue = " << qt.value.flValue << endl;
|
|
break;
|
|
case DBVALUEKIND_R8:
|
|
osOut << INDENTLINE << "\twKind = R8" << endl;
|
|
osOut << INDENTLINE << "\t\t dblValue = " << qt.value.dblValue << endl;
|
|
break;
|
|
case DBVALUEKIND_CY:
|
|
osOut << INDENTLINE << "\twKind = CY" << endl;
|
|
assert(!"Printing Currency values not implemented");
|
|
// osOut << "\t\t cyValue = " << qt.value.cyValue << endl;
|
|
break;
|
|
case DBVALUEKIND_DATE:
|
|
osOut << INDENTLINE << "\twKind = DATE" << endl;
|
|
osOut << INDENTLINE << "\t\t dateValue = " << qt.value.dateValue << endl;
|
|
break;
|
|
case DBVALUEKIND_BSTR:
|
|
osOut << INDENTLINE << "\twKind = BSTR" << endl;
|
|
osOut << INDENTLINE << "\t\t pbstrValue = " << qt.value.pbstrValue << endl;
|
|
break;
|
|
case DBVALUEKIND_ERROR:
|
|
osOut << INDENTLINE << "\twKind = ERROR" << endl;
|
|
osOut << INDENTLINE << "\t\t scodeValue = " << qt.value.scodeValue << endl;
|
|
break;
|
|
case DBVALUEKIND_BOOL:
|
|
osOut << INDENTLINE << "\twKind = BOOL" << endl;
|
|
osOut << INDENTLINE << "\t\t fValue = " << qt.value.fValue << endl;
|
|
break;
|
|
case DBVALUEKIND_VARIANT:
|
|
osOut << INDENTLINE << "\twKind : VARIANT " << qt.value.pvarValue << endl;
|
|
break;
|
|
case DBVALUEKIND_VECTOR:
|
|
osOut << INDENTLINE << "\twKind = VECTOR" << endl;
|
|
osOut << INDENTLINE << "\t\t pdbvectorValue = " << qt.value.pdbvectorValue << endl;
|
|
break;
|
|
case DBVALUEKIND_ARRAY:
|
|
osOut << INDENTLINE << "\twKind = ARRAY" << endl;
|
|
osOut << "\t\t parrayValue = " << qt.value.parrayValue << endl;
|
|
break;
|
|
case DBVALUEKIND_BYREF:
|
|
osOut << INDENTLINE << "\twKind = BYREF" << endl;
|
|
osOut << INDENTLINE << "\t\t pvValue = " << qt.value.pvValue << endl;
|
|
break;
|
|
|
|
case DBVALUEKIND_I1:
|
|
osOut << INDENTLINE << "\twKind = I1" << endl;
|
|
osOut << INDENTLINE << "\t\t bValue = " << qt.value.schValue << endl;
|
|
break;
|
|
case DBVALUEKIND_UI1:
|
|
osOut << INDENTLINE << "\twKind = UI1" << endl;
|
|
osOut << INDENTLINE << "\t\t bValue = " << qt.value.uchValue << endl;
|
|
break;
|
|
case DBVALUEKIND_UI2:
|
|
osOut << INDENTLINE << "\twKind = UI2" << endl;
|
|
osOut << INDENTLINE << "\t\t sValue = " << qt.value.sValue << endl;
|
|
break;
|
|
case DBVALUEKIND_UI4:
|
|
osOut << INDENTLINE << "\twKind = UI4" << endl;
|
|
osOut << INDENTLINE << "\t\t ulValue = " << qt.value.ulValue << endl;
|
|
break;
|
|
case DBVALUEKIND_I8:
|
|
osOut << INDENTLINE << "\twKind = I8" << endl;
|
|
assert(!"llValue printing not supported");
|
|
break;
|
|
case DBVALUEKIND_UI8:
|
|
osOut << INDENTLINE << "\twKind = UI8" << endl;
|
|
assert(!"ullValue printing not supported");
|
|
break;
|
|
case DBVALUEKIND_GUID:
|
|
osOut << INDENTLINE << "\twKind = GUID" << endl;
|
|
osOut << INDENTLINE << "\t\t pGuid = " << qt.value.pGuid << endl;
|
|
break;
|
|
case DBVALUEKIND_BYTES:
|
|
osOut << INDENTLINE << "\twKind = BYTES" << endl;
|
|
osOut << INDENTLINE << "\t\t pbValue = " << qt.value.pbValue << endl;
|
|
break;
|
|
case DBVALUEKIND_WSTR:
|
|
osOut << INDENTLINE << "\twKind = WSTR" << endl;
|
|
osOut << INDENTLINE << "\t pwszValue = " << (void*) qt.value.pwszValue
|
|
<< " : " << qt.value.pwszValue << endl;
|
|
break;
|
|
case DBVALUEKIND_NUMERIC:
|
|
osOut << INDENTLINE << "\twKind = NUMERIC" << endl;
|
|
osOut << INDENTLINE << "\t\t pdbnValue = " << qt.value.pdbnValue << endl;
|
|
break;
|
|
default :
|
|
osOut << INDENTLINE << "\twKind = UNKNOWN " << (UINT) qt.wKind << endl;
|
|
assert(FALSE);
|
|
break;
|
|
}
|
|
|
|
// short cnt;
|
|
// for (cnt = 0, pTableNodeT = qt.pctFirstChild; pTableNodeT != NULL; pTableNodeT = pTableNodeT->pctNextSibling, cnt++)
|
|
// {
|
|
// osOut << INDENTLINE << "\tinput[" << cnt << "]: " << endl;
|
|
// osOut << INDENTLINE << "\t\tchild = " << "Node" << pTableNodeT << endl;
|
|
// }
|
|
|
|
osOut << INDENTLINE << "}" << endl << endl;
|
|
|
|
indentLevel++;
|
|
for (pTableNodeT = qt.pctFirstChild; pTableNodeT != NULL; pTableNodeT = pTableNodeT->pctNextSibling)
|
|
osOut << *pTableNodeT;
|
|
indentLevel--;
|
|
|
|
return osOut;
|
|
}
|
|
|
|
|
|
#endif //DEBUG
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|
|
//////////////////////////// DEBUG OUTPUT////////////////////////////////////////////////////////
|
|
/////////////////////////////////////////////////////////////////////////////////////////////////
|