windows-xp/Source/XPSP1/NT/ds/dns/server/wmi/ntrkcomm/sqleval.cpp

#include "sqleval.h"
#include <stdio.h>
#include <genlex.h>
#include <sqllex.h>
#include <sql_1.h>

// CSqlWmiEvalee
CSqlWmiEvalee::~CSqlWmiEvalee()
{
	if(m_pInstance)
		m_pInstance->Release();
}


CSqlWmiEvalee::CSqlWmiEvalee(
	IWbemClassObject* pInst)
	:m_pInstance(NULL)
{
	m_pInstance = pInst;
	if(m_pInstance)
		m_pInstance->AddRef();
	VariantInit(&m_v);
}

const VARIANT*
CSqlWmiEvalee::Get(
	WCHAR* wszName)
{
	VariantClear(&m_v);
	BSTR bstr = SysAllocString(wszName);
	if (bstr != NULL)
	{
		SCODE sc = m_pInstance->Get(
			bstr, 
			0, 
			&m_v,
			NULL,
			NULL);
		SysFreeString(bstr);
		if(sc != S_OK)
				throw sc;
	}
	
	return &m_v;
}
// CSqlEval

CSqlEval*
CSqlEval::CreateClass(
	SQL_LEVEL_1_RPN_EXPRESSION* pExpr,
	int* pNumberOfToken)
{
	if(pExpr== NULL || *pNumberOfToken<= 0)
		return NULL;
	SQL_LEVEL_1_TOKEN* pToken = pExpr->pArrayOfTokens+(*pNumberOfToken-1);
	
//	(*pNumberOfToken)--;
	switch(pToken->nTokenType)
	{
	case SQL_LEVEL_1_TOKEN::TOKEN_AND:
		return new CSqlEvalAnd(
			pExpr,
			pNumberOfToken);
	case SQL_LEVEL_1_TOKEN::TOKEN_OR:
		return new CSqlEvalOr(
			pExpr,
			pNumberOfToken);
	case SQL_LEVEL_1_TOKEN::OP_EXPRESSION:
		return new CSqlEvalExp(
			pExpr,
			pNumberOfToken);
	}
	return NULL;
}

BOOL
CSqlEval::Evaluate(
	CSqlEvalee* pInst)
{
	return TRUE;
}

// CSqlEvalAnd
CSqlEvalAnd::~CSqlEvalAnd()
{
	delete m_left;
	delete m_right;
}

CSqlEvalAnd::CSqlEvalAnd(
	SQL_LEVEL_1_RPN_EXPRESSION* pExpr,
	int* pTokens)
:m_left(NULL),m_right(NULL)
{
	(*pTokens)-- ;
	m_left = CSqlEval::CreateClass(
		pExpr,
		pTokens);
	m_right = CSqlEval::CreateClass(
		pExpr,
		pTokens);
	
}

BOOL
CSqlEvalAnd::Evaluate(
	CSqlEvalee* pInst)
{
	return m_left->Evaluate(pInst) && m_right->Evaluate(pInst);
}

void
CSqlEvalAnd::GenerateQueryEnum(CQueryEnumerator& qeInst)
{
	CQueryEnumerator qeNew = qeInst;
	m_left->GenerateQueryEnum(qeNew);

	m_right->GenerateQueryEnum(qeInst);
	qeInst.And(qeNew);

}


// CSqlEvalOR
CSqlEvalOr::~CSqlEvalOr()
{
	delete m_left;
	delete m_right;
}

CSqlEvalOr::CSqlEvalOr(
	SQL_LEVEL_1_RPN_EXPRESSION* pExpr,
	int* pTokens)
:m_left(NULL),m_right(NULL)
{
	(*pTokens)-- ;
	m_left = CSqlEval::CreateClass(
		pExpr,
		pTokens);
	m_right = CSqlEval::CreateClass(
		pExpr,
		pTokens);
	
}

BOOL
CSqlEvalOr::Evaluate(
	CSqlEvalee* pInst)
{
	return m_left->Evaluate(pInst) || m_right->Evaluate(pInst);
}

void
CSqlEvalOr::GenerateQueryEnum(CQueryEnumerator& qeInst)
{
	CQueryEnumerator qeNew = qeInst;
	m_left->GenerateQueryEnum(qeNew);

	m_right->GenerateQueryEnum(qeInst);
	qeInst.Or(qeNew);

}





// CSqlEvalExp
CSqlEvalExp::~CSqlEvalExp()
{
	SysFreeString(m_BstrName);
	VariantClear(&m_v);
}

CSqlEvalExp::CSqlEvalExp(
	SQL_LEVEL_1_RPN_EXPRESSION* pExpr,
	int* pTokens)
:m_BstrName(NULL) 
{
	VariantInit(&m_v);
	SQL_LEVEL_1_TOKEN* pToken = pExpr->pArrayOfTokens+(*pTokens-1);
	(*pTokens)--;
	m_BstrName = SysAllocString(pToken->pPropertyName);
	VariantCopy(&m_v, &(pToken->vConstValue));
	m_op = pToken->nOperator;
	switch(m_v.vt)
	{
	case VT_I2:
		m_dw =  m_v.iVal;
		m_DataType = IntergerType;
		break;
	case VT_I4:
		m_dw = m_v.lVal;
		m_DataType = IntergerType;
		break;
	case VT_BOOL:
		m_DataType = IntergerType;
		m_dw = m_v.boolVal;
		break;
	case VT_BSTR:
		m_DataType = StringType;
		m_bstr = m_v.bstrVal;
		break;
	default:
		throw WBEM_E_INVALID_PARAMETER;
	}
}

BOOL
CSqlEvalExp::Evaluate(
	CSqlEvalee* pInst)
{

	BOOL Result=FALSE;
	const VARIANT* pv = pInst->Get(m_BstrName);
	
	switch(m_DataType)
	{
	case IntergerType:
		DWORD dw;
		switch(pv->vt)
		{
		case VT_I2:
			dw =  pv->iVal;
			break;
		case VT_I4:
			dw = pv->lVal;
			break;
		case VT_BOOL:
			dw = pv->boolVal;
			break;
		}

		// compare
		switch(m_op)
		{
		case SQL_LEVEL_1_TOKEN::OP_EQUAL:
			Result = (dw == m_dw);
			break;
		case SQL_LEVEL_1_TOKEN::OP_NOT_EQUAL:
			Result = !(dw == m_dw);
			break;
		case SQL_LEVEL_1_TOKEN::OP_EQUALorGREATERTHAN:
			Result = (dw >= m_dw);
			break;
		case SQL_LEVEL_1_TOKEN::OP_EQUALorLESSTHAN:
			Result = (dw <= m_dw);
			break;
		case SQL_LEVEL_1_TOKEN::OP_LESSTHAN:
			Result = (dw < m_dw);
			break;
		case SQL_LEVEL_1_TOKEN::OP_GREATERTHAN:
			Result = (dw > m_dw);
			break;
		}
		break;
	case StringType:
		int rt = _wcsicmp(pv->bstrVal, m_bstr);
		switch(m_op)
		{
		case SQL_LEVEL_1_TOKEN::OP_EQUAL:
			Result = (rt == 0);
			break;
		case SQL_LEVEL_1_TOKEN::OP_NOT_EQUAL:
			Result = !(rt == 0);
			break;
		case SQL_LEVEL_1_TOKEN::OP_EQUALorGREATERTHAN:
			Result = (rt > 0 || rt == 0);
			break;
		case SQL_LEVEL_1_TOKEN::OP_EQUALorLESSTHAN:
			Result = (rt < 0 || rt == 0);
			break;
		case SQL_LEVEL_1_TOKEN::OP_LESSTHAN:
			Result = (rt < 0);
			break;
		case SQL_LEVEL_1_TOKEN::OP_GREATERTHAN:
			Result = (rt > 0 );
			break;
		}
		break;
	}

	return Result;
}

void
CSqlEvalExp::GenerateQueryEnum(CQueryEnumerator& qeInst)
{
	int nSize = qeInst.m_QueryFields.Size();
	const WCHAR** ppName = qeInst.m_QueryFields.Data();
	WCHAR** ppWstr = new WCHAR*[nSize];
    if ( ppWstr )
    {
	    for(int i=0;  i< nSize; i++)
	    {
		    if(_wcsicmp( m_BstrName, ppName[i]) == 0)
		    {
			    ppWstr[i] = m_v.bstrVal;
		    }
		    else
			    ppWstr[i] = NULL;
	    }
	    CQueryEnumerator::CStringArray strArray(
		    ppWstr,
		    nSize);
	    delete [] ppWstr;
	    qeInst.ArrayAdd(strArray);
    }
}


//CQueryEnumerator;
CQueryEnumerator::CQueryEnumerator(
	WCHAR** ppKeyName,
	int cArg  ):
	m_index(0),m_cNumOfRecordInSet(0),
	m_QuerySet(NULL), m_MaxSize(INITIAL_SIZE)
{
	m_QueryFields = CStringArray(
	ppKeyName,
	cArg);

}


CQueryEnumerator::CQueryEnumerator(
	CQueryEnumerator& instEnumerator)								  
	:m_index(0), m_MaxSize(INITIAL_SIZE),
	m_QuerySet(NULL), m_cNumOfRecordInSet(0)
{

	m_QueryFields = instEnumerator.m_QueryFields;
	int nSize = instEnumerator.m_cNumOfRecordInSet;
	for(int i=0; i< nSize; i++)
	{
		ArrayAdd(instEnumerator.m_QuerySet[i]);
	}
			
}


CQueryEnumerator::~CQueryEnumerator()
{	

}

/*
DWORD
CQueryEnumerator::InitEnumerator(
	WCHAR** wszFieldNames,
	int cArg,
	CSqlEval* pEval)
{
	m_QueryFields = CStringArray(
		wszFieldNames,
		cArg);
	

	return S_OK;
}
*/
const
WCHAR**
CQueryEnumerator::GetNext(int& cElement)
{
	if(m_index == m_cNumOfRecordInSet)
	{
		return NULL;
	}
	else
	{
		cElement = m_QuerySet[m_index].Size();
		return m_QuerySet[m_index++].Data();
	}
}


void
CQueryEnumerator::ArrayMerge(
	CQueryEnumerator::CStringArray& strArray)
{
	
	for(int i=0; i< m_cNumOfRecordInSet; i++)
	{
		// if all element of strArray are null, no need to proceed
		if( !strArray.IsNULL())
			m_QuerySet[i].Merge(strArray);
	}
	
}


void
CQueryEnumerator::ArrayAdd(
	CQueryEnumerator::CStringArray& strArray)
{
	// if all elements are null for strArray, means no keys are 
	// selected,we should therefore replace M_querySet this StrArray
	if(strArray.IsNULL())
		ArrayDelete();

	if(m_QuerySet == NULL)
	{
		m_QuerySet = new CStringArray[m_MaxSize];
        if ( !m_QuerySet )
        {
            return;
        }
	}

	// if array is full, then expand
	if(m_index == m_MaxSize)
	{
		CStringArray * pOldSet = m_QuerySet;
		m_MaxSize = m_MaxSize *2;
		m_QuerySet = new CStringArray[m_MaxSize];
        if ( !m_QuerySet )
        {
            return;
        }
		for( int i =0; i < m_MaxSize; i++ )
		{
			if( i < m_index )
			{
				m_QuerySet[ i ] = pOldSet[ i ];
			}
		}
        delete [] pOldSet;
	}

	if(!( m_cNumOfRecordInSet> 0 && (m_QuerySet[0]).IsNULL()))
	{
		m_QuerySet[m_index++] = strArray;
		m_cNumOfRecordInSet = m_index;
	}
}


void
CQueryEnumerator::ArrayDelete()
{
	delete [] m_QuerySet;
	m_QuerySet = NULL;
	m_cNumOfRecordInSet = 0;
	m_MaxSize = INITIAL_SIZE;
	m_index = 0;
}

void
CQueryEnumerator::And(
	CQueryEnumerator& instEnumerator)
{
	int nSize = instEnumerator.m_cNumOfRecordInSet;
	if(nSize > 0)
	{
		CQueryEnumerator qeOld= *this;
		ArrayDelete();	
		for(int i=0; i< nSize; i++)
		{   
			CQueryEnumerator qeNew = qeOld;
            if ( !qeNew.m_QuerySet )
            {
                return;
            }
			qeNew.ArrayMerge(instEnumerator.m_QuerySet[i]);
			for(int j=0; j< qeNew.m_cNumOfRecordInSet; j++)
			{
				ArrayAdd(qeNew.m_QuerySet[j]);
			}
		}
	}	
}

void
CQueryEnumerator::Or(
	CQueryEnumerator& instEnumerator)
{
	for(int i=0; i< instEnumerator.m_cNumOfRecordInSet; i++)
	{

		if(instEnumerator.m_QuerySet[i].IsNULL())
		{
			if(m_cNumOfRecordInSet > 0)
				ArrayDelete();
			ArrayAdd(instEnumerator.m_QuerySet[i]);
		}
		else
		{
			ArrayAdd(instEnumerator.m_QuerySet[i]);
		}
	}
	
}
void
CQueryEnumerator::Reset()
{
	m_index = 0;
}
// CStringArray

CQueryEnumerator::CStringArray::CStringArray()
:m_ppWstr(NULL), m_cNumString(0), m_bIsNull(TRUE)
{
}

CQueryEnumerator::CStringArray::~CStringArray()
{
	if(m_ppWstr != NULL)
	{
		for (int i=0; i< m_cNumString; i++)
		{
			delete [] m_ppWstr[i];
		}
		delete [] m_ppWstr;
	}
}

CQueryEnumerator::CStringArray::CStringArray(
	WCHAR **ppWstrInput,
	int cNumString)
	:m_ppWstr(NULL)
{
	m_cNumString = cNumString;
	m_bIsNull = !StringArrayCopy(
		&m_ppWstr,
		ppWstrInput,
		cNumString);
	
}
CQueryEnumerator::CStringArray::CStringArray(
	CQueryEnumerator::CStringArray& strArray)
	:m_ppWstr(NULL)
{
	m_cNumString = strArray.m_cNumString;
	m_bIsNull = !StringArrayCopy(
		&m_ppWstr,
		strArray.m_ppWstr,
		strArray.m_cNumString);
}

CQueryEnumerator::CStringArray&
CQueryEnumerator::CStringArray::operator =(
	CQueryEnumerator::CStringArray& strArray)
{
	if(m_ppWstr != NULL)
	{
		for (int i=0; i< m_cNumString; i++)
		{
			delete [] *m_ppWstr;
			*m_ppWstr = NULL;
		}
		delete [] m_ppWstr;
		m_ppWstr = NULL;
	}

	m_cNumString = strArray.m_cNumString;
	m_bIsNull= !StringArrayCopy(
		&m_ppWstr,
		strArray.m_ppWstr,
		strArray.m_cNumString);
	return *this;
}

int CQueryEnumerator::CStringArray::Size()
{
	return m_cNumString;
}

const 
WCHAR**
CQueryEnumerator::CStringArray::Data()
{
	return (const WCHAR**) m_ppWstr;
}

// return true if any element is copied,
// false if no element is copied, and no element set to NULL

BOOL
CQueryEnumerator::CStringArray::StringArrayCopy(
	WCHAR*** pppDest,
	WCHAR** ppSrc,
	int cArgs)
{
	BOOL bFlag = FALSE;
	if(cArgs >0 && ppSrc != NULL)
	{
		*pppDest = new WCHAR*[cArgs];
        if ( *pppDest )
        {
		    for(int i=0; i< cArgs; i++)
		    {
			    (*pppDest)[i] = NULL;
			    if(ppSrc[i] != NULL)
			    {
				    int len = wcslen(ppSrc[i]);
				    (*pppDest)[i] = new WCHAR[len+1];
                    if ( (*pppDest)[i] == NULL )
                    {
    					throw WBEM_E_OUT_OF_MEMORY;
                    }
				    wcscpy((*pppDest)[i], ppSrc[i]);
				    bFlag = TRUE;
			    }
    		}
		}
	}
	return bFlag;
}

void
CQueryEnumerator::CStringArray::Merge(
	CQueryEnumerator::CStringArray& instStrArray)
{
	if(instStrArray.Size() != m_cNumString)
		throw WBEM_E_FAILED;
	const WCHAR** ppSrc = instStrArray.Data();
	for(int i=0; i<m_cNumString; i++)
	{
		// if source is null, we leave target string as it was
		if( ppSrc[i] != NULL)
		{
			if(m_ppWstr[i] == NULL)
			{
				m_ppWstr[i] = new WCHAR[wcslen(ppSrc[i])+1];
                if ( m_ppWstr[i] == NULL )
                {
    				throw WBEM_E_OUT_OF_MEMORY;
                }
				wcscpy(m_ppWstr[i], ppSrc[i]);
			}
			else
			{
				// a key can not take two different value
				if(_wcsicmp(m_ppWstr[i], ppSrc[i]) != 0)
					throw WBEM_E_INVALID_PARAMETER;
			}
		}
	}
}