able/windows-nt
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
windows-nt/Source/XPSP1/NT/admin/wmi/wbem/adapters/odbc/semantic.cpp
CryptoAlgo Inc b3cac27891 Add source files
2020-09-26 16:20:57 +08:00

5137 lines
180 KiB
C++
Raw Blame History

/***************************************************************************/
/* SEMANTIC.C */
/* Copyright (C) 1995-96 SYWARE Inc., All rights reserved */
/***************************************************************************/
// Commenting #define out - causing compiler error - not sure if needed, compiles
// okay without it.
//#define WINVER 0x0400
#include "precomp.h"
#include "wbemidl.h"
#include <comdef.h>
//smart pointer
_COM_SMARTPTR_TYPEDEF(IWbemServices, IID_IWbemServices);
_COM_SMARTPTR_TYPEDEF(IEnumWbemClassObject, IID_IEnumWbemClassObject);
//_COM_SMARTPTR_TYPEDEF(IWbemContext, IID_IWbemContext );
_COM_SMARTPTR_TYPEDEF(IWbemLocator, IID_IWbemLocator);
#include "drdbdr.h"
/***************************************************************************/
RETCODE INTFUNC FindColumn(LPSTMT lpstmt,
LPSQLTREE lpSql,
BOOL fCaseSensitive,
LPSQLNODE lpSqlNodeColumn,
SQLNODEIDX idxTable,
STRINGIDX idxQualifier)
/* Sees if the table identified by idxTable contains the column identifeid */
/* lpSqNodeColumn. If it does, the semantic information for the column */
/* is filled in. Otherwise an error is returned. */
{
LPSQLNODE lpSqlNodeTable;
LPISAMTABLEDEF lpISAMTableDef;
LPSTR lpName;
UWORD index;
LPUSTR lpTableAlias;
LPUSTR lpColumnAlias;
LPUSTR lpTableName;
BOOL matchedAlias = FALSE;
BOOL fIsPassthroughTable = FALSE;
/* Table/Column name given? */
lpName = (LPSTR) ToString(lpSql, lpSqlNodeColumn->node.column.Column);
lpSqlNodeTable = ToNode(lpSql, idxTable);
if (lpSqlNodeColumn->node.column.Tablealias != NO_STRING) {
// this can be either a tablename or an tablename alias
/* Yes. Make sure it matches */
int found = FALSE;
if (lpSqlNodeTable->node.table.Alias != NO_STRING &&
lpSqlNodeColumn->node.column.Qualifier == NO_STRING)
{
//
//Comparing Aliases
//
lpTableAlias = ToString(lpSql, lpSqlNodeTable->node.table.Alias);
lpColumnAlias = ToString(lpSql, lpSqlNodeColumn->node.column.Tablealias);
if (fCaseSensitive) {
if (!s_lstrcmp(lpTableAlias, lpColumnAlias)) {
found = TRUE;
}
}
else {
if (!s_lstrcmpi(lpTableAlias, lpColumnAlias)) {
found = TRUE;
}
}
if (!found)
return ERR_COLUMNNOTFOUND;
}
//
//Not comparing Aliases
//
if (!found) // try matching the column qualifier + alias to the table qualifier + table name
{
lpTableAlias = ToString(lpSql, lpSqlNodeTable->node.table.Qualifier);
lpColumnAlias = ToString(lpSql, lpSqlNodeColumn->node.column.Tablealias);
char *pszNewQualifier = NULL;
if (lpSqlNodeColumn->node.column.Qualifier != NO_STRING)
{
LPSTR lpColumnQualifier = (LPSTR) ToString (lpSql, lpSqlNodeColumn->node.column.Qualifier);
if ( (strlen(lpColumnQualifier) >= 4) &&
(_strnicmp("root", lpColumnQualifier, 4) == 0))
{
// absolute qualifier (no need to change)
pszNewQualifier = new char [s_lstrlen (lpColumnAlias)+
s_lstrlen (lpColumnQualifier) + 3];
s_lstrcpy (pszNewQualifier, lpColumnQualifier);
s_lstrcat (pszNewQualifier, ".");
s_lstrcat (pszNewQualifier, lpColumnAlias);
}
else
{
// concatenate the current namespace with the qualifier
LPUSTR currQual = ISAMDatabase (lpSql->node.root.lpISAM);
pszNewQualifier = new char [s_lstrlen (lpColumnAlias)+
s_lstrlen (currQual) +
s_lstrlen (lpColumnQualifier) + 3 + 2];
s_lstrcpy (pszNewQualifier, currQual);
s_lstrcat (pszNewQualifier, "\\");
s_lstrcat (pszNewQualifier, lpColumnQualifier);
s_lstrcat (pszNewQualifier, ".");
s_lstrcat (pszNewQualifier, lpColumnAlias);
}
}
else
{
LPUSTR currQual = ISAMDatabase (lpSql->node.root.lpISAM);
pszNewQualifier = new char [s_lstrlen (lpColumnAlias)+
s_lstrlen (currQual)+ 2 + 1];
s_lstrcpy (pszNewQualifier, currQual);
s_lstrcat (pszNewQualifier, ".");
s_lstrcat (pszNewQualifier, lpColumnAlias);
}
// get the table name and concatenate with the table qualifier
// before the check
lpTableName = ToString(lpSql, lpSqlNodeTable->node.table.Name);
char *lpszFQTN = new char [s_lstrlen (lpTableName) +
s_lstrlen (lpTableAlias) + 2 + 1];
s_lstrcpy (lpszFQTN, lpTableAlias);
s_lstrcat (lpszFQTN, ".");
s_lstrcat (lpszFQTN, lpTableName);
if (fCaseSensitive) {
if (!lstrcmp(lpszFQTN, pszNewQualifier)) {
found = TRUE;
}
}
else {
if (!lstrcmpi(lpszFQTN, pszNewQualifier)) {
found = TRUE;
}
}
delete [] pszNewQualifier;
delete lpszFQTN;
}
else
{
matchedAlias = TRUE;
}
//Check if this is the passthrough SQL table
if (lpSqlNodeTable->node.table.Handle->fIsPassthroughSQL)
found = TRUE;
if (!found)
return ERR_COLUMNNOTFOUND;
}
/* Search the table definition for a column with a matching name. */
lpISAMTableDef = lpSqlNodeTable->node.table.Handle;
BOOL fPassthroughSQLWithAlias = FALSE;
LPSTR lpAlias = NULL;
if ( (lpSqlNodeColumn->node.column.Tablealias != NO_STRING) && lpSqlNodeTable->node.table.Handle->fIsPassthroughSQL )
{
lpAlias = (LPSTR) ToString(lpSql, lpSqlNodeColumn->node.column.Tablealias);
if ( lpAlias && lstrlen(lpAlias) )
fPassthroughSQLWithAlias = TRUE;
}
ClassColumnInfoBase* cInfoBase = lpISAMTableDef->pColumnInfo;
if ( !cInfoBase->IsValid() )
{
return ERR_COLUMNNOTFOUND;
}
//Sai
//The current column is lpName, if this is a system property
//and SYSPROPS=FALSE then return an error
if (lpISAMTableDef && lpISAMTableDef->lpISAM)
{
if ( ! lpISAMTableDef->lpISAM->fSysProps)
{
//we are not asking for system properties
//so a system property should not be in the SELECT list
if (_strnicmp("__", lpName, 2) == 0)
{
return ERR_COLUMNNOTFOUND;
}
}
}
UWORD cNumberOfCols = cInfoBase->GetNumberOfColumns();
char pColumnName [MAX_COLUMN_NAME_LENGTH+1];
char pColumnAlias [MAX_COLUMN_NAME_LENGTH+1];
pColumnAlias[0] = 0;
BOOL fMatch = FALSE;
for (index = 0; index < cNumberOfCols; index++)
{
fMatch = FALSE;
if ( FAILED(cInfoBase->GetColumnName(index, pColumnName, pColumnAlias)) )
{
return ERR_COLUMNNOTFOUND;
}
if (fCaseSensitive)
{
if (!s_lstrcmp(lpName, pColumnName))
{
fMatch = TRUE;
// break;
}
}
else
{
if (!s_lstrcmpi(lpName, pColumnName))
{
fMatch = TRUE;
// break;
}
}
//Extra check for passthrough SQL
if (fPassthroughSQLWithAlias && fMatch)
{
fMatch = FALSE;
if (fCaseSensitive)
{
if (!s_lstrcmp(lpAlias, pColumnAlias))
break;
}
else
{
if (!s_lstrcmpi(lpAlias, pColumnAlias))
break;
}
}
if (fMatch)
break;
}
#ifdef TESTING
if (idxQualifier != NO_STRING)
{
char* lpTestQual = ToString(lpSql, lpSqlNodeTable->table.Qualifier);
char* lpOrgQual = ToString(lpSql, idxQualifier);
if (lpTestQual && lpOrgQual && strcmp(lpTestQual, lpOrgQual))
return ERR_COLUMNNOTFOUND;
}
#endif
/* Error if not found */
if (index == cNumberOfCols)
{
s_lstrcpy(lpstmt->szError, lpName);
return ERR_COLUMNNOTFOUND;
}
/* Set the table and column information in the column node. */
lpSqlNodeColumn->node.column.Table = idxTable;
lpSqlNodeColumn->node.column.Id = (UWORD) index;
if (lpSqlNodeColumn->node.column.Tablealias == NO_STRING)
{
lpSqlNodeColumn->node.column.Tablealias = lpSqlNodeTable->node.table.Name;
}
// to keep this consistent I'm going to put a flag in to say if it matched
// a table name or an alias and put the qualifier in too
lpSqlNodeColumn->node.column.MatchedAlias = matchedAlias;
lpSqlNodeColumn->node.column.Qualifier = lpSqlNodeTable->node.table.Qualifier;
// go further and set the column table reference to the table index. In fact,
// this is the best way of doing this. Not sure why SYWARE didn't go this way
// originally. Probably as it ensured every table had an alias. It really
// encapsualtes all the above info.
lpSqlNodeColumn->node.column.TableIndex = idxTable;
/* Figure out type of data */
cInfoBase->GetSQLType(index, lpSqlNodeColumn->sqlSqlType);
switch (lpSqlNodeColumn->sqlSqlType) {
case SQL_DECIMAL:
case SQL_NUMERIC:
{
lpSqlNodeColumn->sqlDataType = TYPE_NUMERIC;
UDWORD uwPrec = 0;
cInfoBase->GetPrecision(index, uwPrec);
lpSqlNodeColumn->sqlPrecision = (SWORD)uwPrec;
cInfoBase->GetScale(index, lpSqlNodeColumn->sqlScale);
}
break;
case SQL_BIGINT:
{
lpSqlNodeColumn->sqlDataType = TYPE_NUMERIC;
UDWORD uwPrec = 0;
cInfoBase->GetPrecision(index, uwPrec);
lpSqlNodeColumn->sqlPrecision = (SWORD)uwPrec;
lpSqlNodeColumn->sqlScale = 0;
}
break;
case SQL_TINYINT:
lpSqlNodeColumn->sqlDataType = TYPE_INTEGER;
lpSqlNodeColumn->sqlPrecision = 3;
lpSqlNodeColumn->sqlScale = 0;
break;
case SQL_SMALLINT:
lpSqlNodeColumn->sqlDataType = TYPE_INTEGER;
lpSqlNodeColumn->sqlPrecision = 5;
lpSqlNodeColumn->sqlScale = 0;
break;
case SQL_INTEGER:
lpSqlNodeColumn->sqlDataType = TYPE_INTEGER;
lpSqlNodeColumn->sqlPrecision = 10;
lpSqlNodeColumn->sqlScale = 0;
break;
case SQL_BIT:
lpSqlNodeColumn->sqlDataType = TYPE_INTEGER;
lpSqlNodeColumn->sqlPrecision = 1;
lpSqlNodeColumn->sqlScale = 0;
break;
case SQL_REAL:
lpSqlNodeColumn->sqlDataType = TYPE_DOUBLE;
lpSqlNodeColumn->sqlPrecision = 7;
lpSqlNodeColumn->sqlScale = NO_SCALE;
break;
case SQL_FLOAT:
case SQL_DOUBLE:
lpSqlNodeColumn->sqlDataType = TYPE_DOUBLE;
lpSqlNodeColumn->sqlPrecision = 15;
lpSqlNodeColumn->sqlScale = NO_SCALE;
break;
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
{
lpSqlNodeColumn->sqlDataType = TYPE_CHAR;
UDWORD uwPrec = 0;
cInfoBase->GetPrecision(index, uwPrec);
lpSqlNodeColumn->sqlPrecision = (SWORD)uwPrec;
if (lpSqlNodeColumn->sqlPrecision > MAX_CHAR_LITERAL_LENGTH)
lpSqlNodeColumn->sqlPrecision = MAX_CHAR_LITERAL_LENGTH;
lpSqlNodeColumn->sqlScale = NO_SCALE;
}
break;
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
{
lpSqlNodeColumn->sqlDataType = TYPE_BINARY;
UDWORD uwPrec = 0;
cInfoBase->GetPrecision(index, uwPrec);
lpSqlNodeColumn->sqlPrecision = (SWORD)uwPrec;
lpSqlNodeColumn->sqlScale = NO_SCALE;
}
break;
case SQL_DATE:
lpSqlNodeColumn->sqlDataType = TYPE_DATE;
lpSqlNodeColumn->sqlPrecision = 10;
lpSqlNodeColumn->sqlScale = NO_SCALE;
break;
case SQL_TIME:
lpSqlNodeColumn->sqlDataType = TYPE_TIME;
lpSqlNodeColumn->sqlPrecision = 8;
lpSqlNodeColumn->sqlScale = NO_SCALE;
break;
case SQL_TIMESTAMP:
lpSqlNodeColumn->sqlDataType = TYPE_TIMESTAMP;
if (TIMESTAMP_SCALE > 0)
lpSqlNodeColumn->sqlPrecision = 20 + TIMESTAMP_SCALE;
else
lpSqlNodeColumn->sqlPrecision = 19;
lpSqlNodeColumn->sqlScale = TIMESTAMP_SCALE;
break;
default:
return ERR_NOTSUPPORTED;
}
return ERR_SUCCESS;
}
/***************************************************************************/
void INTFUNC ErrorOpCode(LPSTMT lpstmt,
UWORD opCode)
/* Puts opcode in szError (as a string) */
{
switch (opCode) {
case OP_NONE:
s_lstrcpy(lpstmt->szError, "<assignment>");
break;
case OP_EQ:
s_lstrcpy(lpstmt->szError, "=");
break;
case OP_NE:
s_lstrcpy(lpstmt->szError, "<>");
break;
case OP_LE:
s_lstrcpy(lpstmt->szError, "<=");
break;
case OP_LT:
s_lstrcpy(lpstmt->szError, "<");
break;
case OP_GE:
s_lstrcpy(lpstmt->szError, ">=");
break;
case OP_GT:
s_lstrcpy(lpstmt->szError, ">");
break;
case OP_IN:
s_lstrcpy(lpstmt->szError, "IN");
break;
case OP_NOTIN:
s_lstrcpy(lpstmt->szError, "NOT IN");
break;
case OP_LIKE:
s_lstrcpy(lpstmt->szError, "LIKE");
break;
case OP_NOTLIKE:
s_lstrcpy(lpstmt->szError, "NOT LIKE");
break;
case OP_NEG:
s_lstrcpy(lpstmt->szError, "-");
break;
case OP_PLUS:
s_lstrcpy(lpstmt->szError, "+");
break;
case OP_MINUS:
s_lstrcpy(lpstmt->szError, "-");
break;
case OP_TIMES:
s_lstrcpy(lpstmt->szError, "*");
break;
case OP_DIVIDEDBY:
s_lstrcpy(lpstmt->szError, "/");
break;
case OP_NOT:
s_lstrcpy(lpstmt->szError, "NOT");
break;
case OP_AND:
s_lstrcpy(lpstmt->szError, "AND");
break;
case OP_OR:
s_lstrcpy(lpstmt->szError, "OR");
break;
case OP_EXISTS:
s_lstrcpy(lpstmt->szError, "EXISTS");
break;
default:
s_lstrcpy(lpstmt->szError, "");
break;
}
}
/***************************************************************************/
void INTFUNC ErrorAggCode(LPSTMT lpstmt,
UWORD aggCode)
/* Puts aggreagate operator code in szError (as a string) */
{
switch(aggCode) {
case AGG_AVG:
s_lstrcpy(lpstmt->szError, "AVG");
break;
case AGG_COUNT:
s_lstrcpy(lpstmt->szError, "COUNT");
break;
case AGG_MAX:
s_lstrcpy(lpstmt->szError, "MAX");
break;
case AGG_MIN:
s_lstrcpy(lpstmt->szError, "MIN");
break;
case AGG_SUM:
s_lstrcpy(lpstmt->szError, "SUM");
break;
default:
s_lstrcpy(lpstmt->szError, "");
break;
}
}
/***************************************************************************/
RETCODE INTFUNC TypeCheck(LPSTMT lpstmt,
LPSQLTREE lpSql,
SQLNODEIDX idxLeft,
SQLNODEIDX idxRight,
UWORD opCode,
SWORD FAR *pfDataType,
SWORD FAR *pfSqlType,
SDWORD FAR *pPrecision,
SWORD FAR *pScale)
/* Checks to see if the types of the two children nodes are compatible. */
/* If the type of one of the children is unknown (because it was a */
/* parameter or the value NULL), it set to the type of the other child. */
{
LPSQLNODE lpSqlNodeLeft;
LPSQLNODE lpSqlNodeRight;
SWORD fDataTypeLeft;
SWORD fSqlTypeLeft;
SDWORD precisionLeft;
SWORD scaleLeft;
SWORD fDataTypeRight;
SWORD fSqlTypeRight;
SDWORD precisionRight;
SWORD scaleRight;
SWORD fDataType;
SWORD fSqlType;
SDWORD precision;
SWORD scale;
#define MAX(a, b) ((a) > (b) ? (a) : (b))
#define MIN(a, b) ((a) < (b) ? (a) : (b))
/* Get left type */
if (idxLeft == NO_SQLNODE)
return ERR_INTERNAL;
lpSqlNodeLeft = ToNode(lpSql, idxLeft);
fDataTypeLeft = lpSqlNodeLeft->sqlDataType;
fSqlTypeLeft = lpSqlNodeLeft->sqlSqlType;
precisionLeft = lpSqlNodeLeft->sqlPrecision;
scaleLeft = lpSqlNodeLeft->sqlScale;
/* Is there a right epxression? */
if (idxRight != NO_SQLNODE) {
/* Yes. Get right type. */
lpSqlNodeRight = ToNode(lpSql, idxRight);
fDataTypeRight = lpSqlNodeRight->sqlDataType;
fSqlTypeRight = lpSqlNodeRight->sqlSqlType;
precisionRight = lpSqlNodeRight->sqlPrecision;
scaleRight = lpSqlNodeRight->sqlScale;
}
else {
/* No. This must be an arithmetic negation operator. Use left */
/* type as the right type */
if (opCode != OP_NEG)
return ERR_INTERNAL;
if (fDataTypeLeft == TYPE_UNKNOWN)
return ERR_UNKNOWNTYPE;
fDataTypeRight = fDataTypeLeft;
fSqlTypeRight = fSqlTypeLeft;
precisionRight = precisionLeft;
scaleRight = scaleLeft;
}
/* Is left side unknown? */
if (fDataTypeLeft == TYPE_UNKNOWN) {
/* Yes. Error if right side is unknown also */
if (fDataTypeRight == TYPE_UNKNOWN)
return ERR_UNKNOWNTYPE;
/* If right side is string value, make sure opcode is legal */
if (fDataTypeRight == TYPE_CHAR) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
case OP_LIKE:
case OP_NOTLIKE:
break;
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
if (fSqlTypeRight == SQL_LONGVARCHAR) {
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
break;
case OP_MINUS:
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* If right side is date value, make sure opcode is legal */
else if (fDataTypeRight == TYPE_DATE) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
break;
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
case OP_MINUS:
break;
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* Adding to a date? */
if ((fDataTypeRight == TYPE_DATE) && (opCode == OP_PLUS)) {
/* Yes. The left side must be integer */
lpSqlNodeLeft->sqlDataType = TYPE_INTEGER;
lpSqlNodeLeft->sqlSqlType = SQL_INTEGER;
lpSqlNodeLeft->sqlPrecision = 10;
lpSqlNodeLeft->sqlScale = 0;
}
else {
/* No. Use type from right as type for left */
/* Note: This disallows ? from being a date in (? - 3) */
/* Note: This disallows ? from being a date in (? + 3) */
lpSqlNodeLeft->sqlDataType = fDataTypeRight;
lpSqlNodeLeft->sqlSqlType = fSqlTypeRight;
lpSqlNodeLeft->sqlPrecision = precisionRight;
lpSqlNodeLeft->sqlScale = scaleRight;
/* If string concatenation, adjust type and precision */
if ((fDataTypeRight == TYPE_CHAR) && (opCode == OP_PLUS)) {
lpSqlNodeLeft->sqlSqlType = SQL_VARCHAR;
lpSqlNodeLeft->sqlPrecision = MAX_CHAR_LITERAL_LENGTH;
}
}
/* Adding to a date? */
if ((fDataTypeRight == TYPE_DATE) && (opCode == OP_PLUS)) {
/* Yes. The result type is a date */
if (pfDataType != NULL)
*pfDataType = lpSqlNodeRight->sqlDataType;
if (pfSqlType != NULL)
*pfSqlType = lpSqlNodeRight->sqlSqlType;
if (pPrecision != NULL)
*pPrecision = lpSqlNodeRight->sqlPrecision;
if (pScale != NULL)
*pScale = lpSqlNodeRight->sqlScale;
}
/* Calculating the differnce of two dates? */
else if ((lpSqlNodeLeft->sqlDataType == TYPE_DATE) &&
(opCode == OP_MINUS)) {
/* Yes. The result type is integer */
if (pfDataType != NULL)
*pfDataType = TYPE_INTEGER;
if (pfSqlType != NULL)
*pfSqlType = SQL_INTEGER;
if (pPrecision != NULL)
*pPrecision = 10;
if (pScale != NULL)
*pScale = 0;
}
else {
/* No. The result type is the same as the left side */
if (pfDataType != NULL)
*pfDataType = lpSqlNodeLeft->sqlDataType;
if (pfSqlType != NULL)
*pfSqlType = lpSqlNodeLeft->sqlSqlType;
if (pPrecision != NULL)
*pPrecision = lpSqlNodeLeft->sqlPrecision;
if (pScale != NULL)
*pScale = lpSqlNodeLeft->sqlScale;
}
}
/* Is right side unknown? */
else if (fDataTypeRight == TYPE_UNKNOWN) {
/* Yes. If left side is string value, make sure opcode is legal */
if (fDataTypeLeft == TYPE_CHAR) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
case OP_LIKE:
case OP_NOTLIKE:
break;
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
if (fSqlTypeLeft == SQL_LONGVARCHAR) {
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
break;
case OP_MINUS:
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* If left side is date value, make sure opcode is legal */
else if (fDataTypeLeft == TYPE_DATE) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
break;
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
case OP_MINUS:
break;
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* Adding to a date? */
if ((fDataTypeLeft == TYPE_DATE) && (opCode == OP_PLUS)) {
/* Yes. The right side must be integer */
lpSqlNodeRight->sqlDataType = TYPE_INTEGER;
lpSqlNodeRight->sqlSqlType = SQL_INTEGER;
lpSqlNodeRight->sqlPrecision = 10;
lpSqlNodeRight->sqlScale = 0;
}
else {
/* No. Use type from left as type for right */
/* Note: This disallows ? from being a number in (<date> - ? ) */
/* Note: This disallows ? from being a date in (<number> + ? ) */
lpSqlNodeRight->sqlDataType = fDataTypeLeft;
lpSqlNodeRight->sqlSqlType = fSqlTypeLeft;
lpSqlNodeRight->sqlPrecision = precisionLeft;
lpSqlNodeRight->sqlScale = scaleLeft;
/* If string concatenation, adjust type and precision */
if ((fDataTypeLeft == TYPE_CHAR) && (opCode == OP_PLUS)) {
lpSqlNodeRight->sqlSqlType = SQL_VARCHAR;
lpSqlNodeRight->sqlPrecision = MAX_CHAR_LITERAL_LENGTH;
}
}
/* Adding to a date? */
if ((fDataTypeLeft == TYPE_DATE) && (opCode == OP_PLUS)) {
/* Yes. The result type is a date */
if (pfDataType != NULL)
*pfDataType = TYPE_DATE;
if (pfSqlType != NULL)
*pfSqlType = SQL_DATE;
if (pPrecision != NULL)
*pPrecision = 10;
if (pScale != NULL)
*pScale = 0;
}
/* Calculating the difference of two dates? */
else if ((fDataTypeLeft == TYPE_DATE) && (opCode == OP_MINUS)) {
/* Yes. The result type is integer */
if (pfDataType != NULL)
*pfDataType = TYPE_INTEGER;
if (pfSqlType != NULL)
*pfSqlType = SQL_INTEGER;
if (pPrecision != NULL)
*pPrecision = 10;
if (pScale != NULL)
*pScale = 0;
}
else {
/* No. The result type is the same as the right side */
if (pfDataType != NULL)
*pfDataType = lpSqlNodeRight->sqlDataType;
if (pfSqlType != NULL)
*pfSqlType = lpSqlNodeRight->sqlSqlType;
if (pPrecision != NULL)
*pPrecision = lpSqlNodeRight->sqlPrecision;
if (pScale != NULL)
*pScale = lpSqlNodeRight->sqlScale;
}
}
/* Do types match? */
else if ((fDataTypeLeft == fDataTypeRight) ||
((fDataTypeLeft == TYPE_DOUBLE) &&
(fDataTypeRight == TYPE_NUMERIC)) ||
((fDataTypeLeft == TYPE_DOUBLE) &&
(fDataTypeRight == TYPE_INTEGER)) ||
((fDataTypeLeft == TYPE_NUMERIC) &&
(fDataTypeRight == TYPE_DOUBLE)) ||
((fDataTypeLeft == TYPE_NUMERIC) &&
(fDataTypeRight == TYPE_INTEGER)) ||
((fDataTypeLeft == TYPE_INTEGER) &&
(fDataTypeRight == TYPE_DOUBLE)) ||
((fDataTypeLeft == TYPE_INTEGER) &&
(fDataTypeRight == TYPE_NUMERIC))) {
/* Yes. If left side is string value, make sure opcode is legal */
if (fDataTypeLeft == TYPE_CHAR) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
case OP_LIKE:
case OP_NOTLIKE:
break;
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
if ((fSqlTypeRight == SQL_LONGVARCHAR) ||
(fSqlTypeLeft == SQL_LONGVARCHAR)) {
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
break;
case OP_MINUS:
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* If left side is date value, make sure opcode is legal */
else if (fDataTypeLeft == TYPE_DATE) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
break;
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
case OP_PLUS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_MINUS:
break;
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
/* Figure out resultant type */
if ((fDataTypeLeft == TYPE_NUMERIC) && (fDataTypeRight == TYPE_DOUBLE))
fDataType = TYPE_DOUBLE;
else if ((fDataTypeLeft == TYPE_INTEGER) && (fDataTypeRight == TYPE_DOUBLE))
fDataType = TYPE_DOUBLE;
else if ((fDataTypeLeft == TYPE_INTEGER) && (fDataTypeRight == TYPE_NUMERIC))
fDataType = TYPE_NUMERIC;
else
fDataType = fDataTypeLeft;
if (pfDataType != NULL)
*pfDataType = fDataType;
/* Figure out resultant SQL type, precision, and scale */
switch (fSqlTypeLeft) {
case SQL_DOUBLE:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_FLOAT:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_REAL:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
if ((fSqlTypeRight == SQL_DECIMAL) ||
(fSqlTypeLeft == SQL_DECIMAL))
fSqlType = SQL_DECIMAL;
else if ((fSqlTypeRight == SQL_NUMERIC) ||
(fSqlTypeLeft == SQL_NUMERIC))
fSqlType = SQL_NUMERIC;
else if ((fSqlTypeRight == SQL_BIGINT) ||
(fSqlTypeLeft == SQL_BIGINT))
fSqlType = SQL_BIGINT;
else if ((fSqlTypeRight == SQL_INTEGER) ||
(fSqlTypeLeft == SQL_INTEGER))
fSqlType = SQL_INTEGER;
else if ((fSqlTypeRight == SQL_SMALLINT) ||
(fSqlTypeLeft == SQL_SMALLINT))
fSqlType = SQL_SMALLINT;
else if ((fSqlTypeRight == SQL_TINYINT) ||
(fSqlTypeLeft == SQL_TINYINT))
fSqlType = SQL_TINYINT;
else
fSqlType = SQL_BIT;
if (pfSqlType != NULL)
*pfSqlType = fSqlType;
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = scaleLeft;
break;
case OP_LIKE:
case OP_NOTLIKE:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_NEG:
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = scaleLeft;
break;
case OP_PLUS:
case OP_MINUS:
scale = MAX(scaleRight, scaleLeft);
switch (fSqlType) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
return ERR_INTERNAL;
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
precision = scale + MAX(precisionRight - scaleRight,
precisionLeft - scaleLeft) + 1;
break;
case SQL_INTEGER:
precision = 10;
break;
case SQL_SMALLINT:
precision = 5;
break;
case SQL_TINYINT:
precision = 3;
break;
case SQL_BIT:
precision = 1;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
if (pPrecision != NULL)
*pPrecision = precision;
if (pScale != NULL)
*pScale = scale;
break;
case OP_TIMES:
case OP_DIVIDEDBY:
scale = scaleRight + scaleLeft;
switch (fSqlType) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
return ERR_INTERNAL;
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
precision = scale + (precisionRight - scaleRight) +
(precisionLeft - scaleLeft);
break;
case SQL_INTEGER:
precision = 10;
break;
case SQL_SMALLINT:
precision = 5;
break;
case SQL_TINYINT:
precision = 3;
break;
case SQL_BIT:
precision = 1;
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
if (pPrecision != NULL)
*pPrecision = precision;
if (pScale != NULL)
*pScale = scale;
break;
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
break;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_LONGVARCHAR:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
return ERR_INTERNAL;
case SQL_LONGVARCHAR:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_VARCHAR:
case SQL_CHAR:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL) {
if (precisionLeft > precisionRight)
*pPrecision = precisionLeft;
else
*pPrecision = precisionRight;
}
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_VARCHAR:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
return ERR_INTERNAL;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_CHAR:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
/* Adjust precision for string concatenation operator */
if ((opCode == OP_PLUS) && (pPrecision != NULL))
*pPrecision = MIN(precisionRight + precisionLeft,
MAX_CHAR_LITERAL_LENGTH);
break;
case SQL_CHAR:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
return ERR_INTERNAL;
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
/* Adjust precision for string concatenation operator */
if ((opCode == OP_PLUS) && (pPrecision != NULL))
*pPrecision = MIN(precisionRight + precisionLeft,
MAX_CHAR_LITERAL_LENGTH);
break;
case SQL_LONGVARBINARY:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
return ERR_INTERNAL;
case SQL_LONGVARBINARY:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_VARBINARY:
case SQL_BINARY:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_VARBINARY:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
return ERR_INTERNAL;
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_BINARY:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_BINARY:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
return ERR_INTERNAL;
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_DATE:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
return ERR_INTERNAL;
case SQL_DATE:
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = scaleLeft;
break;
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
case OP_PLUS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_MINUS:
if (pfDataType != NULL)
*pfDataType = TYPE_INTEGER;
if (pPrecision != NULL)
*pPrecision = 10;
if (pfSqlType != NULL)
*pfSqlType = SQL_INTEGER;
if (pScale != NULL)
*pScale = 0;
break;
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
break;
case SQL_TIME:
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_TIME:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
return ERR_INTERNAL;
case SQL_TIME:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = NO_SCALE;
break;
case SQL_TIMESTAMP:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
break;
case SQL_TIMESTAMP:
switch (fSqlTypeRight) {
case SQL_DOUBLE:
case SQL_FLOAT:
case SQL_REAL:
case SQL_DECIMAL:
case SQL_NUMERIC:
case SQL_BIGINT:
case SQL_INTEGER:
case SQL_SMALLINT:
case SQL_TINYINT:
case SQL_BIT:
case SQL_LONGVARCHAR:
case SQL_VARCHAR:
case SQL_CHAR:
case SQL_LONGVARBINARY:
case SQL_VARBINARY:
case SQL_BINARY:
case SQL_DATE:
case SQL_TIME:
return ERR_INTERNAL;
case SQL_TIMESTAMP:
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = TIMESTAMP_SCALE;
break;
default:
return ERR_NOTSUPPORTED;
}
break;
default:
return ERR_NOTSUPPORTED;
}
}
else if ((fDataTypeLeft == TYPE_DATE) &&
((fDataTypeRight == TYPE_DOUBLE) ||
(fDataTypeRight == TYPE_NUMERIC) ||
(fDataTypeRight == TYPE_INTEGER))) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
case OP_MINUS:
if (pfDataType != NULL)
*pfDataType = fDataTypeLeft;
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeLeft;
if (pPrecision != NULL)
*pPrecision = precisionLeft;
if (pScale != NULL)
*pScale = scaleLeft;
break;
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
else if ((fDataTypeRight == TYPE_DATE) &&
((fDataTypeLeft == TYPE_DOUBLE) ||
(fDataTypeLeft == TYPE_NUMERIC) ||
(fDataTypeLeft == TYPE_INTEGER))) {
switch (opCode) {
case OP_NONE:
case OP_EQ:
case OP_NE:
case OP_LE:
case OP_LT:
case OP_GE:
case OP_GT:
case OP_IN:
case OP_NOTIN:
case OP_LIKE:
case OP_NOTLIKE:
case OP_NEG:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
case OP_PLUS:
if (pfDataType != NULL)
*pfDataType = fDataTypeRight;
if (pfSqlType != NULL)
*pfSqlType = fSqlTypeRight;
if (pPrecision != NULL)
*pPrecision = precisionRight;
if (pScale != NULL)
*pScale = scaleRight;
break;
case OP_MINUS:
case OP_TIMES:
case OP_DIVIDEDBY:
case OP_NOT:
case OP_AND:
case OP_OR:
case OP_EXISTS:
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
}
else {
ErrorOpCode(lpstmt, opCode);
return ERR_INVALIDOPERAND;
}
return ERR_SUCCESS;
}
/***************************************************************************/
BOOL INTFUNC FindAggregate(LPSQLTREE lpSql, SQLNODEIDX idxNode)
/* Looks for the next aggregate function on a select list */
{
LPSQLNODE lpSqlNode;
if (idxNode == NO_SQLNODE)
return FALSE;
lpSqlNode = ToNode(lpSql, idxNode);
switch (lpSqlNode->sqlNodeType) {
case NODE_TYPE_NONE:
case NODE_TYPE_ROOT:
case NODE_TYPE_CREATE:
case NODE_TYPE_DROP:
return FALSE; /* Internal error */
case NODE_TYPE_SELECT:
return FALSE;
case NODE_TYPE_INSERT:
case NODE_TYPE_DELETE:
case NODE_TYPE_UPDATE:
case NODE_TYPE_CREATEINDEX:
case NODE_TYPE_DROPINDEX:
case NODE_TYPE_PASSTHROUGH:
case NODE_TYPE_TABLES:
return FALSE; /* Internal error */
case NODE_TYPE_VALUES:
while (TRUE) {
if (FindAggregate(lpSql, lpSqlNode->node.values.Value))
return TRUE;
if (lpSqlNode->node.values.Next == NO_SQLNODE)
return FALSE;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.values.Next);
}
case NODE_TYPE_COLUMNS:
case NODE_TYPE_SORTCOLUMNS:
case NODE_TYPE_GROUPBYCOLUMNS:
case NODE_TYPE_UPDATEVALUES:
case NODE_TYPE_CREATECOLS:
case NODE_TYPE_BOOLEAN:
case NODE_TYPE_COMPARISON:
return FALSE; /* Internal error */
case NODE_TYPE_ALGEBRAIC:
if (FindAggregate(lpSql, lpSqlNode->node.algebraic.Left))
return TRUE;
return (FindAggregate(lpSql, lpSqlNode->node.algebraic.Right));
case NODE_TYPE_SCALAR:
return (FindAggregate(lpSql, lpSqlNode->node.scalar.Arguments));
case NODE_TYPE_AGGREGATE:
return TRUE;
case NODE_TYPE_TABLE:
return FALSE; /* Internal error */
case NODE_TYPE_COLUMN:
case NODE_TYPE_STRING:
case NODE_TYPE_NUMERIC:
case NODE_TYPE_PARAMETER:
case NODE_TYPE_USER:
case NODE_TYPE_NULL:
case NODE_TYPE_DATE:
case NODE_TYPE_TIME:
case NODE_TYPE_TIMESTAMP:
return FALSE;
default:
return FALSE; /* Internal error */
}
}
/***************************************************************************/
RETCODE INTFUNC SelectCheck(LPSTMT lpstmt, LPSQLTREE FAR *lplpSql,
SQLNODEIDX idxNode, BOOL fCaseSensitive,
SQLNODEIDX idxEnclosingStatement)
/* Walks a SELECT parse tree, checks it for semantic correctness, and */
/* fills in the semantic information. */
{
LPSQLNODE lpSqlNode;
RETCODE err;
UWORD count;
UDWORD offset;
BOOL fIsGroupby;
if (idxNode == NO_SQLNODE)
return ERR_SUCCESS;
lpSqlNode = ToNode(*lplpSql, idxNode);
/* Save pointer to enclosing statement */
lpSqlNode->node.select.EnclosingStatement = idxEnclosingStatement;
/* Check the list of tables */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.select.Tables,
FALSE, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the GROUP BY columns */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.select.Groupbycolumns,
FALSE, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Is there a GROUP BY clause? */
count = 0;
offset = 1;
if (lpSqlNode->node.select.Groupbycolumns != NO_SQLNODE) {
UDWORD length;
SQLNODEIDX idxGroupbycolumns;
LPSQLNODE lpSqlNodeGroupbycolumns;
LPSQLNODE lpSqlNodeColumn;
/* Yes. Error if SELECT * */
if (lpSqlNode->node.select.Values == NO_SQLNODE)
return ERR_NOSELECTSTAR;
/* Figure out offset and length of each column when it */
/* is in the sort file */
idxGroupbycolumns = lpSqlNode->node.select.Groupbycolumns;
while (idxGroupbycolumns != NO_SQLNODE) {
/* Add this column to the count */
count++;
/* Error if too many columns */
if (count > MAX_COLUMNS_IN_GROUP_BY)
return ERR_GROUPBYTOOLARGE;
/* Save column offset */
lpSqlNodeGroupbycolumns = ToNode(*lplpSql, idxGroupbycolumns);
lpSqlNodeColumn = ToNode(*lplpSql,
lpSqlNodeGroupbycolumns->node.groupbycolumns.Column);
lpSqlNodeColumn->node.column.Offset = offset;
/* Get length of the column */
switch (lpSqlNodeColumn->sqlDataType) {
case TYPE_DOUBLE:
length = sizeof(double);
break;
case TYPE_NUMERIC:
length = 2 + lpSqlNodeColumn->sqlPrecision;
break;
case TYPE_INTEGER:
length = sizeof(double);
break;
case TYPE_CHAR:
length = lpSqlNodeColumn->sqlPrecision;
if (length > MAX_CHAR_LITERAL_LENGTH) {
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
return ERR_CANTGROUPBYONTHIS;
}
break;
case TYPE_BINARY:
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
return ERR_CANTGROUPBYONTHIS;
case TYPE_DATE:
length = 10;
break;
case TYPE_TIME:
length = 8;
break;
case TYPE_TIMESTAMP:
if (TIMESTAMP_SCALE > 0)
length = 20 + TIMESTAMP_SCALE;
else
length = 19;
break;
default:
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
return ERR_CANTGROUPBYONTHIS;
}
/* Put length of the column column description */
lpSqlNodeColumn->node.column.Length = length;
/* Go to next column */
offset += (length);
offset++; /* for the IS NULL flag */
idxGroupbycolumns = lpSqlNodeGroupbycolumns->node.groupbycolumns.Next;
}
/* Set flag */
fIsGroupby = TRUE;
}
else {
/* No. Are there any aggregates in the select list? */
if (!FindAggregate(*lplpSql, lpSqlNode->node.select.Values)) {
/* No. Error if there is a HAVING clause */
if (lpSqlNode->node.select.Having != NO_SQLNODE)
return ERR_NOGROUPBY;
/* Set flag */
fIsGroupby = FALSE;
}
else {
/* Yes. Set flags */
lpSqlNode->node.select.ImplicitGroupby = TRUE;
fIsGroupby = TRUE;
}
}
/* SELECT * ? */
if (lpSqlNode->node.select.Values == NO_SQLNODE) {
SQLNODEIDX idxTables;
LPSQLNODE lpSqlNodeTables;
SQLNODEIDX idxTable;
LPSQLNODE lpSqlNodeTable;
// STRINGIDX idxAlias;
LPISAMTABLEDEF lpTableHandle;
SQLNODEIDX idxValues;
LPSQLNODE lpSqlNodeValues;
SQLNODEIDX idxValuesPrev;
LPSQLNODE lpSqlNodeValuesPrev;
SQLNODEIDX idxColumn;
LPSQLNODE lpSqlNodeColumn;
SWORD idx;
/* Yes. Loop though all the tables in the table list */
idxValuesPrev = NO_SQLNODE;
idxTables = lpSqlNode->node.select.Tables;
while (idxTables != NO_SQLNODE) {
/* Get pointer to the next table */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
idxTables = lpSqlNodeTables->node.tables.Next;
/* Get pointer to this table */
idxTable = lpSqlNodeTables->node.tables.Table;
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
/* Loop through all the columns of this table */
lpTableHandle = lpSqlNodeTable->node.table.Handle;
ClassColumnInfoBase* cInfoBase = lpTableHandle->pColumnInfo;
LPISAM myISAM = lpTableHandle->lpISAM;
if ( !cInfoBase->IsValid() )
{
return ERR_COLUMNNOTFOUND;
}
//Store able alias before allocating memory
//in order to avoid bug
STRINGIDX idxTheAlias = lpSqlNodeTable->node.table.Alias;
STRINGIDX idxTheQual = lpSqlNodeTable->node.table.Qualifier;
UWORD cNumberOfCols = cInfoBase->GetNumberOfColumns();
char pColumnName [MAX_COLUMN_NAME_LENGTH+1];
//Sai added - fetch the column alias
//only filled in if using passthrough SQL, ignored otherwise
char pAliasName [MAX_COLUMN_NAME_LENGTH+1];
pAliasName[0] = 0;
for (idx = 0; idx < (SWORD) cNumberOfCols; idx++)
{
if ( FAILED(cInfoBase->GetColumnName(idx, pColumnName, pAliasName)) )
{
return ERR_COLUMNNOTFOUND;
}
//Ignore any OLEMS specific columns which we want to hide
if (myISAM && !(myISAM->fSysProps))
{
if (_strnicmp("__", pColumnName, 2) == 0)
{
continue;
}
}
//Ignore any 'lazy' columns
BOOL fIsLazy = FALSE;
if ( cInfoBase->IsLazy(idx, fIsLazy) )
{
if (fIsLazy)
{
continue;
}
}
//Check if this column type is support
//if not we skip this column
if (! ISAMGetColumnType(lpTableHandle, (UWORD) idx) )
{
continue;
}
/* Create a node for this column */
idxColumn = AllocateNode(lplpSql, NODE_TYPE_COLUMN);
if (idxColumn == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
//Get new pointers
lpSqlNodeColumn = ToNode(*lplpSql, idxColumn);
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
lpSqlNodeColumn->node.column.Tablealias = idxTheAlias;
if (lpSqlNodeTable->node.table.Alias != NO_STRING)
{
lpSqlNodeColumn->node.column.MatchedAlias = TRUE;
}
else
{
lpSqlNodeColumn->node.column.MatchedAlias = FALSE;
}
lpSqlNodeColumn->node.column.TableIndex = idxTable;
lpSqlNodeColumn->node.column.Qualifier = idxTheQual;
lpSqlNodeColumn->node.column.Column = AllocateString(lplpSql,
(LPUSTR)pColumnName);
//New - for identical column names when using passthrough SQL
if ( pAliasName && lstrlen(pAliasName) )
{
lpSqlNodeColumn->node.column.Tablealias = AllocateString(lplpSql,
(LPUSTR)pAliasName);
}
//To avoid bug recalc lpSqlNodeColumn
lpSqlNodeColumn = ToNode(*lplpSql, idxColumn);
if (lpSqlNodeColumn->node.column.Column == NO_STRING)
return ERR_MEMALLOCFAIL;
lpSqlNodeColumn->node.table.Handle = NULL;
lpSqlNodeColumn->node.column.Id = -1;
lpSqlNodeColumn->node.column.Value = NO_STRING;
lpSqlNodeColumn->node.column.InSortRecord = FALSE;
lpSqlNodeColumn->node.column.Offset = 0;
lpSqlNodeColumn->node.column.Length = 0;
lpSqlNodeColumn->node.column.DistinctOffset = 0;
lpSqlNodeColumn->node.column.DistinctLength = 0;
lpSqlNodeColumn->node.column.EnclosingStatement = NO_SQLNODE;
/* Put it on the list */
idxValues = AllocateNode(lplpSql, NODE_TYPE_VALUES);
if (idxValues == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
lpSqlNodeValues->node.values.Value = idxColumn;
lpSqlNodeValues->node.values.Alias = NO_STRING;
lpSqlNodeValues->node.values.Next = NO_SQLNODE;
if (idxValuesPrev == NO_SQLNODE) {
lpSqlNode = ToNode(*lplpSql, idxNode);
lpSqlNode->node.select.Values = idxValues;
}
else {
lpSqlNodeValuesPrev = ToNode(*lplpSql, idxValuesPrev);
lpSqlNodeValuesPrev->node.values.Next = idxValues;
}
idxValuesPrev = idxValues;
}
}
lpSqlNode = ToNode(*lplpSql, idxNode);
}
/* SELECT aliasname.* ? */
{
SQLNODEIDX idxValuesPrev;
SQLNODEIDX idxValues;
LPSQLNODE lpSqlNodeValues;
SQLNODEIDX idxTables;
LPSQLNODE lpSqlNodeTables;
SQLNODEIDX idxTable;
LPSQLNODE lpSqlNodeTable;
LPUSTR lpTableAlias;
LPUSTR lpValuesAlias;
LPSQLNODE lpSqlNodeValuesPrev;
LPISAMTABLEDEF lpTableHandle;
SQLNODEIDX idxColumn;
LPSQLNODE lpSqlNodeColumn;
SWORD idx;
STRINGIDX idxAlias;
SQLNODEIDX idxValuesNew;
/* Yes. Loop though all the nodes in the select list */
idxValuesPrev = NO_SQLNODE;
idxValues = lpSqlNode->node.select.Values;
while (idxValues != NO_SQLNODE) {
/* Get pointer to the values node */
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
/* Is this a <table>.* node? */
if (lpSqlNodeValues->node.values.Value != NO_SQLNODE) {
/* No. Go to next entry */
idxValuesPrev = idxValues;
idxValues = lpSqlNodeValues->node.values.Next;
continue;
}
idxValues = lpSqlNodeValues->node.values.Next;
/* Find the table */
lpValuesAlias = ToString(*lplpSql,
lpSqlNodeValues->node.values.Alias);
idxTables = lpSqlNode->node.select.Tables;
//First pass : check alias's
while (idxTables != NO_SQLNODE) {
/* Get pointer to the table */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
/* Get pointer to this table */
idxTable = lpSqlNodeTables->node.tables.Table;
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
/* Get Alias of this table */
idxAlias = lpSqlNodeTable->node.table.Alias;
/* Leave loop if it matches */
lpTableAlias = ToString(*lplpSql, idxAlias);
if (fCaseSensitive) {
if (!s_lstrcmp(lpTableAlias, lpValuesAlias))
break;
}
else {
if (!s_lstrcmpi(lpTableAlias, lpValuesAlias))
break;
}
/* It does not match. Try next table */
idxTables = lpSqlNodeTables->node.tables.Next;
}
//second pass : table name
if (idxTables == NO_SQLNODE) {
idxTables = lpSqlNode->node.select.Tables;
while (idxTables != NO_SQLNODE) {
/* Get pointer to the table */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
/* Get pointer to this table */
idxTable = lpSqlNodeTables->node.tables.Table;
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
/* Get Alias of this table */
idxAlias = lpSqlNodeTable->node.table.Name;
/* Leave loop if it matches */
lpTableAlias = ToString(*lplpSql, idxAlias);
if (fCaseSensitive) {
if (!s_lstrcmp(lpTableAlias, lpValuesAlias))
{
lpSqlNodeTable->node.table.Alias = idxAlias;
break;
}
}
else {
if (!s_lstrcmpi(lpTableAlias, lpValuesAlias))
{
lpSqlNodeTable->node.table.Alias = idxAlias;
break;
}
}
/* It does not match. Try next table */
idxTables = lpSqlNodeTables->node.tables.Next;
}
}
/* Error if not tables match */
if (idxTables == NO_SQLNODE) {
s_lstrcpy(lpstmt->szError, lpValuesAlias);
return ERR_TABLENOTFOUND;
}
/* Remove the <table>.* node */
if (idxValuesPrev == NO_SQLNODE)
lpSqlNode->node.select.Values = idxValues;
else {
lpSqlNodeValuesPrev = ToNode(*lplpSql, idxValuesPrev);
lpSqlNodeValuesPrev->node.values.Next = idxValues;
}
/* Loop through all the columns of the table */
lpTableHandle = lpSqlNodeTable->node.table.Handle;
ClassColumnInfoBase* cInfoBase = lpTableHandle->pColumnInfo;
LPISAM myISAM = lpTableHandle->lpISAM;
if ( !cInfoBase->IsValid() )
{
return ERR_COLUMNNOTFOUND;
}
//Store able alias before allocating memory
//in order to avoid bug
STRINGIDX idxTheAlias = lpSqlNodeTable->node.table.Alias;
STRINGIDX idxTheQual = lpSqlNodeTable->node.table.Qualifier;
UWORD cNumberOfCols = cInfoBase->GetNumberOfColumns();
char pColumnName [MAX_COLUMN_NAME_LENGTH+1];
//Sai added - fetch the column alias
//only filled in if using passthrough SQL, ignored otherwise
char pAliasName [MAX_COLUMN_NAME_LENGTH+1];
pAliasName[0] = 0;
for (idx = 0; idx < (SWORD) cNumberOfCols; idx++) {
if ( FAILED(cInfoBase->GetColumnName(idx, pColumnName, pAliasName)) )
{
return ERR_COLUMNNOTFOUND;
}
//Ignore any OLEMS specific columns which we want to hide
if (myISAM && !(myISAM->fSysProps))
{
if (_strnicmp("__", pColumnName, 2) == 0)
{
continue;
}
}
//Ignore any 'lazy' columns
BOOL fIsLazy = FALSE;
if ( cInfoBase->IsLazy(idx, fIsLazy) )
{
if (fIsLazy)
{
continue;
}
}
//Check if this column type is support
//if not we skip this column
if (! ISAMGetColumnType(lpTableHandle, (UWORD) idx) )
{
continue;
}
/* Create a node for this column */
idxColumn = AllocateNode(lplpSql, NODE_TYPE_COLUMN);
if (idxColumn == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
//Get new pointers
lpSqlNodeColumn = ToNode(*lplpSql, idxColumn);
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
lpSqlNodeColumn->node.column.Tablealias = idxAlias;
lpSqlNodeColumn->node.column.Column = AllocateString(lplpSql,
(LPUSTR)pColumnName);
if (lpSqlNodeColumn->node.column.Column == NO_STRING)
return ERR_MEMALLOCFAIL;
if (lpSqlNodeTable->node.table.Alias != NO_STRING)
{
lpSqlNodeColumn->node.column.MatchedAlias = TRUE;
}
else
{
lpSqlNodeColumn->node.column.MatchedAlias = FALSE;
}
//New - for identical column names when using passthrough SQL
if ( pAliasName && lstrlen(pAliasName) )
{
lpSqlNodeColumn->node.column.Tablealias = AllocateString(lplpSql,
(LPUSTR)pAliasName);
}
//To avoid bug recalc lpSqlNodeColumn
lpSqlNodeColumn = ToNode(*lplpSql, idxColumn);
lpSqlNodeColumn->node.column.TableIndex = idxTable;
lpSqlNodeColumn->node.column.Qualifier = NO_STRING; //idxTheQual;
lpSqlNodeColumn->node.table.Handle = NULL;
lpSqlNodeColumn->node.column.Table = NO_SQLNODE;
lpSqlNodeColumn->node.column.Id = -1;
lpSqlNodeColumn->node.column.Value = NO_STRING;
lpSqlNodeColumn->node.column.InSortRecord = FALSE;
lpSqlNodeColumn->node.column.Offset = 0;
lpSqlNodeColumn->node.column.Length = 0;
lpSqlNodeColumn->node.column.DistinctOffset = 0;
lpSqlNodeColumn->node.column.DistinctLength = 0;
lpSqlNodeColumn->node.column.EnclosingStatement = NO_SQLNODE;
/* Put it on the list */
idxValuesNew = AllocateNode(lplpSql, NODE_TYPE_VALUES);
if (idxValuesNew == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeValues = ToNode(*lplpSql, idxValuesNew);
lpSqlNodeValues->node.values.Value = idxColumn;
lpSqlNodeValues->node.values.Alias = NO_STRING;
lpSqlNodeValues->node.values.Next = idxValues;
if (idxValuesPrev == NO_SQLNODE) {
lpSqlNode = ToNode(*lplpSql, idxNode);
lpSqlNode->node.select.Values = idxValuesNew;
}
else {
lpSqlNodeValuesPrev = ToNode(*lplpSql, idxValuesPrev);
lpSqlNodeValuesPrev->node.values.Next = idxValuesNew;
}
idxValuesPrev = idxValuesNew;
}
}
lpSqlNode = ToNode(*lplpSql, idxNode);
}
/* Check the ORDER BY columns */
err = SemanticCheck(lpstmt, lplpSql,lpSqlNode->node.select.Sortcolumns,
fIsGroupby, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check that each group by column is on sort list (and put it */
/* there if it is not already there so the sort directive will */
/* be constructed correctly)... */
{
SQLNODEIDX idxGroupbycolumns;
LPSQLNODE lpSqlNodeGroupbycolumns;
LPSQLNODE lpSqlNodeColumnGroupby;
SQLNODEIDX idxSortcolumns;
SQLNODEIDX idxSortcolumnsPrev;
LPSQLNODE lpSqlNodeSortcolumns;
LPSQLNODE lpSqlNodeColumnSort;
SQLNODEIDX idxColumn;
SQLNODEIDX idxTableGroupby;
// LPUSTR lpszTableGroupby;
LPUSTR lpszColumnGroupby;
SQLNODEIDX idxTableSort;
// LPUSTR lpszTableSort;
LPUSTR lpszColumnSort;
idxGroupbycolumns = lpSqlNode->node.select.Groupbycolumns;
while (idxGroupbycolumns != NO_SQLNODE) {
/* Get this group by column */
lpSqlNodeGroupbycolumns = ToNode(*lplpSql, idxGroupbycolumns);
lpSqlNodeColumnGroupby = ToNode(*lplpSql,
lpSqlNodeGroupbycolumns->node.groupbycolumns.Column);
/* Get column name and table name of the group by column */
idxTableGroupby = lpSqlNodeColumnGroupby->node.column.TableIndex;
lpszColumnGroupby = ToString(*lplpSql,
lpSqlNodeColumnGroupby->node.column.Column);
/* Look for this column on the sort list. For each */
/* column in the sort list... */
idxSortcolumns = lpSqlNode->node.select.Sortcolumns;
idxSortcolumnsPrev = NO_SQLNODE;
while (idxSortcolumns != NO_SQLNODE) {
/* Get next element on the sort list */
lpSqlNodeSortcolumns = ToNode(*lplpSql, idxSortcolumns);
lpSqlNodeColumnSort = ToNode(*lplpSql,
lpSqlNodeSortcolumns->node.sortcolumns.Column);
/* Is it a column reference? */
if (lpSqlNodeColumnSort->sqlNodeType == NODE_TYPE_COLUMN) {
/* Yes. Get column name and table name of sort column */
idxTableSort = lpSqlNodeColumnSort->node.column.TableIndex;
lpszColumnSort = ToString(*lplpSql,
lpSqlNodeColumnSort->node.column.Column);
/* Leave if this sort column is the group by column */
if (idxTableSort == idxTableGroupby)
{
if (fCaseSensitive) {
// if (!s_lstrcmp(lpszTableSort, lpszTableGroupby) &&
// !s_lstrcmp(lpszColumnSort, lpszColumnGroupby))
if ( !s_lstrcmp(lpszColumnSort, lpszColumnGroupby) )
break;
}
else {
// if (!s_lstrcmpi(lpszTableSort, lpszTableGroupby) &&
// !s_lstrcmpi(lpszColumnSort, lpszColumnGroupby))
if ( !s_lstrcmpi(lpszColumnSort, lpszColumnGroupby) )
break;
}
}
}
/* Get next sort column */
idxSortcolumnsPrev = idxSortcolumns;
idxSortcolumns = lpSqlNodeSortcolumns->node.sortcolumns.Next;
}
/* Was group by columnn found in the sort list? */
if (idxSortcolumns == NO_SQLNODE) {
/* No. A new entry will be needed. Create a node for */
/* the column */
idxColumn = AllocateNode(lplpSql, NODE_TYPE_COLUMN);
if (idxColumn == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeColumnSort = ToNode(*lplpSql, idxColumn);
/* Recalculate these pointers since the Alloc above */
/* may have moved them */
/* addeed th enext line */
lpSqlNodeGroupbycolumns = ToNode (*lplpSql, idxGroupbycolumns);
lpSqlNodeColumnGroupby = ToNode(*lplpSql,
lpSqlNodeGroupbycolumns->node.groupbycolumns.Column);
/* Fill in the node */
lpSqlNodeColumnSort->node.column.Tablealias =
lpSqlNodeColumnGroupby->node.column.Tablealias;
lpSqlNodeColumnSort->node.column.Column =
lpSqlNodeColumnGroupby->node.column.Column;
lpSqlNodeColumnSort->node.column.Qualifier =
lpSqlNodeColumnGroupby->node.column.Qualifier;
lpSqlNodeColumnSort->node.column.TableIndex =
lpSqlNodeColumnGroupby->node.column.TableIndex;
lpSqlNodeColumnSort->node.column.MatchedAlias =
lpSqlNodeColumnGroupby->node.column.MatchedAlias;
lpSqlNodeColumnSort->node.column.Table = NO_SQLNODE;
lpSqlNodeColumnSort->node.column.Id = -1;
lpSqlNodeColumnSort->node.column.Value = NO_STRING;
lpSqlNodeColumnSort->node.column.InSortRecord = FALSE;
lpSqlNodeColumnSort->node.column.Offset = 0;
lpSqlNodeColumnSort->node.column.Length = 0;
lpSqlNodeColumnSort->node.column.DistinctOffset = 0;
lpSqlNodeColumnSort->node.column.DistinctLength = 0;
lpSqlNodeColumnSort->node.column.EnclosingStatement = NO_SQLNODE;
/* Create sort list element */
idxSortcolumns = AllocateNode(lplpSql,
NODE_TYPE_SORTCOLUMNS);
if (idxSortcolumns == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeSortcolumns = ToNode(*lplpSql, idxSortcolumns);
lpSqlNodeSortcolumns->node.sortcolumns.Column = idxColumn;
lpSqlNodeSortcolumns->node.sortcolumns.Descending = FALSE;
lpSqlNodeSortcolumns->node.sortcolumns.Next = NO_SQLNODE;
/* Recalculate these pointers since the Alloc above */
/* may have moved them */
lpSqlNodeGroupbycolumns =
ToNode(*lplpSql, idxGroupbycolumns);
lpSqlNode = ToNode(*lplpSql, idxNode);
/* Put it on the sort list */
if (idxSortcolumnsPrev == NO_SQLNODE)
lpSqlNode->node.select.Sortcolumns = idxSortcolumns;
else {
lpSqlNodeSortcolumns =
ToNode(*lplpSql, idxSortcolumnsPrev);
lpSqlNodeSortcolumns->node.sortcolumns.Next =
idxSortcolumns;
}
/* Semantic check the newly created nodes */
err = SemanticCheck(lpstmt, lplpSql, idxSortcolumns,
fIsGroupby, fCaseSensitive, NO_SQLNODE, idxNode);
}
/* Look at next group by column */
idxGroupbycolumns =
lpSqlNodeGroupbycolumns->node.groupbycolumns.Next;
}
}
/* Check the select list */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.select.Values,
fIsGroupby, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the WHERE clause */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.select.Predicate,
FALSE, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the HAVING clause */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.select.Having,
fIsGroupby, fCaseSensitive, NO_SQLNODE, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Build the sorting directive and determine the overall key size. */
/* At the same time check to make sure that there are not too many */
/* columns in ORDER BY and that character or binary keys are not */
/* too big. */
if (lpSqlNode->node.select.Sortcolumns != NO_SQLNODE) {
SQLNODEIDX idxSortcolumns;
LPSQLNODE lpSqlNodeSortcolumns;
LPSQLNODE lpSqlNodeColumn;
UDWORD length;
SQLNODEIDX idxTables;
LPSQLNODE lpSqlNodeTables;
#define NUM_LEN 5
UCHAR szSortDirective[10 + NUM_LEN +
(MAX_COLUMNS_IN_ORDER_BY * (6 + (2 * NUM_LEN)))
+ 3 + MAX_PATHNAME_SIZE];
szSortDirective[0] = 0;
SQLNODEIDX idxAggregate;
LPSQLNODE lpSqlNodeAggregate;
/* For each sort column... */
s_lstrcpy(szSortDirective, "S(");
idxSortcolumns = lpSqlNode->node.select.Sortcolumns;
while (idxSortcolumns != NO_SQLNODE) {
/* Is this node on the group by list ? */
lpSqlNodeSortcolumns = ToNode(*lplpSql, idxSortcolumns);
lpSqlNodeColumn = ToNode(*lplpSql,
lpSqlNodeSortcolumns->node.sortcolumns.Column);
if ((lpSqlNode->node.select.Groupbycolumns == NO_SQLNODE) ||
(lpSqlNodeColumn->sqlNodeType != NODE_TYPE_COLUMN)) {
/* No. Add this sort column to the count */
count++;
/* Error if too many sort columns */
if (count > MAX_COLUMNS_IN_ORDER_BY)
return ERR_ORDERBYTOOLARGE;
/* Get length of the column. */
switch (lpSqlNodeColumn->sqlDataType) {
case TYPE_DOUBLE:
length = sizeof(double);
break;
case TYPE_NUMERIC:
length = 2 + lpSqlNodeColumn->sqlPrecision;
break;
case TYPE_INTEGER:
length = sizeof(double);
break;
case TYPE_CHAR:
length = lpSqlNodeColumn->sqlPrecision;
if (length > MAX_CHAR_LITERAL_LENGTH) {
if (lpSqlNodeColumn->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
else
s_lstrcpy(lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
break;
case TYPE_BINARY:
length = lpSqlNodeColumn->sqlPrecision;
if (length > MAX_BINARY_LITERAL_LENGTH) {
if (lpSqlNodeColumn->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
else
s_lstrcpy(lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
break;
case TYPE_DATE:
length = 10;
break;
case TYPE_TIME:
length = 8;
break;
case TYPE_TIMESTAMP:
if (TIMESTAMP_SCALE > 0)
length = 20 + TIMESTAMP_SCALE;
else
length = 19;
break;
default:
if (lpSqlNodeColumn->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column));
else
s_lstrcpy((char*)lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
/* Put offset of the key column in the sort directive */
wsprintf((LPSTR) (szSortDirective + s_lstrlen((LPSTR)szSortDirective)),
"%lu,", offset);
/* Adjust offset */
offset += (length);
offset++; /* for the IS NULL flag */
}
else {
/* Yes. Get length */
length = lpSqlNodeColumn->node.column.Length;
/* Put offset of the key column in the sort directive */
wsprintf((LPSTR)(szSortDirective + s_lstrlen((LPSTR)szSortDirective)),
"%lu,", lpSqlNodeColumn->node.column.Offset);
}
/* Put length of the key column in the sort directive */
wsprintf((LPSTR)(szSortDirective + s_lstrlen((LPSTR)szSortDirective)),
"%lu,", length);
/* Put type of the key column in the sort directive */
switch (lpSqlNodeColumn->sqlDataType) {
case TYPE_DOUBLE:
s_lstrcat((LPSTR)szSortDirective, "E,");
break;
case TYPE_NUMERIC:
s_lstrcat((LPSTR)szSortDirective, "N,");
break;
case TYPE_INTEGER:
s_lstrcat((LPSTR)szSortDirective, "E,");
break;
case TYPE_CHAR:
case TYPE_BINARY:
case TYPE_DATE:
case TYPE_TIME:
case TYPE_TIMESTAMP:
s_lstrcat((LPSTR)szSortDirective, "C,");
break;
default:
return ERR_INTERNAL;
}
/* Put direction of the key column in the sort directive */
if (lpSqlNodeSortcolumns->node.sortcolumns.Descending)
s_lstrcat((char*)szSortDirective, "D");
else
s_lstrcat((char*)szSortDirective, "A");
/* Go to next sort column */
idxSortcolumns = lpSqlNodeSortcolumns->node.sortcolumns.Next;
if (idxSortcolumns != NO_SQLNODE)
s_lstrcat((char*)szSortDirective, ",");
}
/* Save the sort key size */
lpSqlNode->node.select.SortKeysize = offset-1;
/* Is there a GROUP BY statement? */
if ((lpSqlNode->node.select.Groupbycolumns == NO_SQLNODE) &&
(!lpSqlNode->node.select.ImplicitGroupby)) {
/* No. Save offset of the bookmark */
lpSqlNode->node.select.SortBookmarks = offset;
/* For each table in table list, add bookmark size to offset */
idxTables = lpSqlNode->node.select.Tables;
while (idxTables != NO_SQLNODE) {
/* Update offset */
offset += (sizeof(ISAMBOOKMARK));
/* Get pointer to the next table */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
idxTables = lpSqlNodeTables->node.tables.Next;
}
}
else {
/* Yes. Calculate the offset of each aggregate field */
idxAggregate = lpSqlNode->node.select.Aggregates;
while (idxAggregate != NO_SQLNODE) {
/* Save offset of the aggregate */
lpSqlNodeAggregate = ToNode(*lplpSql, idxAggregate);
lpSqlNodeAggregate->node.aggregate.Offset = offset;
/* Update offset */
offset += (lpSqlNodeAggregate->node.aggregate.Length + 1);
/* Get pointer to the next aggregate */
idxAggregate = lpSqlNodeAggregate->node.aggregate.Next;
}
}
offset--;
s_lstrcat((char*)szSortDirective, ")");
/* Put record size into sort directive */
s_lstrcat((char*)szSortDirective, "F(FIX,");
wsprintf((LPSTR)(szSortDirective + s_lstrlen((char*)szSortDirective)),
"%lu", offset);
lstrcat((char*)szSortDirective, ")");
/* Put in work drive */
s_lstrcat(szSortDirective, "W(");
#ifdef WIN32
if (!GetTempPath(MAX_PATHNAME_SIZE+1, (LPSTR)
szSortDirective + s_lstrlen(szSortDirective)))
return ERR_SORT;
if (szSortDirective[s_lstrlen(szSortDirective)-1] != '\\')
s_lstrcat(szSortDirective, "\\");
#else
GetTempFileName(NULL, "LEM", 0, (LPSTR) szSortDirective +
s_lstrlen(szSortDirective));
while (szSortDirective[s_lstrlen(szSortDirective)-1] != '\\')
szSortDirective[s_lstrlen(szSortDirective)-1] = '\0';
#endif
s_lstrcat(szSortDirective, ")");
/* Save the directive */
lpSqlNode->node.select.SortDirective = AllocateString(lplpSql,
(LPUSTR)szSortDirective);
if (lpSqlNode->node.select.SortDirective == NO_STRING)
return ERR_MEMALLOCFAIL;
/* Save the sort record size */
lpSqlNode->node.select.SortRecordsize = offset;
}
/* If there is no group by list originally but there is a group by */
/* list now, there was an aggregate in the select list. Calculate */
/* the offset of each aggregate field */
if (lpSqlNode->node.select.ImplicitGroupby) {
SQLNODEIDX idxAggregate;
LPSQLNODE lpSqlNodeAggregate;
idxAggregate = lpSqlNode->node.select.Aggregates;
while (idxAggregate != NO_SQLNODE) {
/* Save offset of the aggregate */
lpSqlNodeAggregate = ToNode(*lplpSql, idxAggregate);
lpSqlNodeAggregate->node.aggregate.Offset = offset;
/* Update offset */
offset += (lpSqlNodeAggregate->node.aggregate.Length + 1);
/* Get pointer to the next aggregate */
idxAggregate = lpSqlNodeAggregate->node.aggregate.Next;
}
/* Adjust the offset */
offset--;
/* Save the sort record size */
lpSqlNode->node.select.SortRecordsize = offset;
}
/* Build the sorting directive for SELECT DISTINCT and determine the */
/* overall key size. At the same time check to make sure that there */
/* are not too many columns in ORDER BY and that character or binary */
/* keys are not too big. */
if (lpSqlNode->node.select.Distinct) {
SQLNODEIDX idxValues;
LPSQLNODE lpSqlNodeValues;
LPSQLNODE lpSqlNodeExpression;
UDWORD length;
#define NUM_LEN 5
UCHAR szSortDirective[19 + (4 * NUM_LEN) +
(MAX_COLUMNS_IN_ORDER_BY * (6 + (2 * NUM_LEN)))
+ 3 + MAX_PATHNAME_SIZE];
/* For each sort column... */
count = 0;
offset = NUM_LEN + 1;
s_lstrcpy(szSortDirective, "S(");
idxValues = lpSqlNode->node.select.Values;
while (idxValues != NO_SQLNODE) {
/* Is this node of interest? */
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
lpSqlNodeExpression = ToNode(*lplpSql,
lpSqlNodeValues->node.values.Value);
switch (lpSqlNodeExpression->sqlNodeType) {
case NODE_TYPE_COLUMN:
case NODE_TYPE_AGGREGATE:
case NODE_TYPE_ALGEBRAIC:
case NODE_TYPE_SCALAR:
/* Yes. Add this sort column to the count */
count++;
/* Error if too many sort columns */
if (count > MAX_COLUMNS_IN_ORDER_BY)
return ERR_ORDERBYTOOLARGE;
/* Get length of the column. */
switch (lpSqlNodeExpression->sqlDataType) {
case TYPE_DOUBLE:
length = sizeof(double);
break;
case TYPE_NUMERIC:
length = 2 + lpSqlNodeExpression->sqlPrecision;
break;
case TYPE_INTEGER:
length = sizeof(double);
break;
case TYPE_CHAR:
length = lpSqlNodeExpression->sqlPrecision;
if (length > MAX_CHAR_LITERAL_LENGTH) {
if (lpSqlNodeExpression->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeExpression->node.column.Column));
else
s_lstrcpy((char*)lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
break;
case TYPE_BINARY:
length = lpSqlNodeExpression->sqlPrecision;
if (length > MAX_BINARY_LITERAL_LENGTH) {
if (lpSqlNodeExpression->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeExpression->node.column.Column));
else
s_lstrcpy((char*)lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
break;
case TYPE_DATE:
length = 10;
break;
case TYPE_TIME:
length = 8;
break;
case TYPE_TIMESTAMP:
if (TIMESTAMP_SCALE > 0)
length = 20 + TIMESTAMP_SCALE;
else
length = 19;
break;
default:
if (lpSqlNodeExpression->sqlNodeType == NODE_TYPE_COLUMN)
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNodeExpression->node.column.Column));
else
s_lstrcpy((char*)lpstmt->szError, "<expression>");
return ERR_CANTORDERBYONTHIS;
}
/* Put offset of the key column in the sort directive */
wsprintf((LPSTR)(szSortDirective + s_lstrlen((char*)szSortDirective)),
"%lu,", offset);
/* Save offset and length */
switch (lpSqlNodeExpression->sqlNodeType) {
case NODE_TYPE_COLUMN:
lpSqlNodeExpression->node.column.DistinctOffset = offset;
lpSqlNodeExpression->node.column.DistinctLength = length;
break;
case NODE_TYPE_AGGREGATE:
lpSqlNodeExpression->node.aggregate.DistinctOffset = offset;
lpSqlNodeExpression->node.aggregate.DistinctLength = length;
break;
case NODE_TYPE_ALGEBRAIC:
lpSqlNodeExpression->node.algebraic.DistinctOffset = offset;
lpSqlNodeExpression->node.algebraic.DistinctLength = length;
break;
case NODE_TYPE_SCALAR:
lpSqlNodeExpression->node.scalar.DistinctOffset = offset;
lpSqlNodeExpression->node.scalar.DistinctLength = length;
break;
default:
return ERR_INTERNAL;
}
/* Adjust offset */
offset += (length);
offset++; /* for the IS NULL flag */
/* Put length of the key column in the sort directive */
wsprintf((LPSTR)(szSortDirective + s_lstrlen((char*)szSortDirective)),
"%lu,", length);
/* Put type of the key column in the sort directive */
switch (lpSqlNodeExpression->sqlDataType) {
case TYPE_DOUBLE:
s_lstrcat(szSortDirective, "E,");
break;
case TYPE_NUMERIC:
s_lstrcat(szSortDirective, "N,");
break;
case TYPE_INTEGER:
s_lstrcat(szSortDirective, "E,");
break;
case TYPE_CHAR:
case TYPE_BINARY:
case TYPE_DATE:
case TYPE_TIME:
case TYPE_TIMESTAMP:
s_lstrcat(szSortDirective, "C,");
break;
default:
return ERR_INTERNAL;
}
/* Put direction of the key column in the sort directive */
s_lstrcat(szSortDirective, "A");
break;
case NODE_TYPE_STRING:
case NODE_TYPE_NUMERIC:
case NODE_TYPE_PARAMETER:
case NODE_TYPE_USER:
case NODE_TYPE_NULL:
case NODE_TYPE_DATE:
case NODE_TYPE_TIME:
case NODE_TYPE_TIMESTAMP:
break;
case NODE_TYPE_CREATE:
case NODE_TYPE_DROP:
case NODE_TYPE_SELECT:
case NODE_TYPE_INSERT:
case NODE_TYPE_DELETE:
case NODE_TYPE_UPDATE:
case NODE_TYPE_CREATEINDEX:
case NODE_TYPE_DROPINDEX:
case NODE_TYPE_PASSTHROUGH:
case NODE_TYPE_TABLES:
case NODE_TYPE_VALUES:
case NODE_TYPE_COLUMNS:
case NODE_TYPE_SORTCOLUMNS:
case NODE_TYPE_GROUPBYCOLUMNS:
case NODE_TYPE_UPDATEVALUES:
case NODE_TYPE_CREATECOLS:
case NODE_TYPE_BOOLEAN:
case NODE_TYPE_COMPARISON:
case NODE_TYPE_TABLE:
default:
return ERR_INTERNAL;
}
/* Go to next sort column */
idxValues = lpSqlNodeValues->node.values.Next;
if (idxValues != NO_SQLNODE)
s_lstrcat(szSortDirective, ",");
}
offset--;
/* If no fields in sort record, put a constant in */
if (offset == NUM_LEN) {
offset = 3;
s_lstrcat(szSortDirective, "1,3,C,A");
}
s_lstrcat(szSortDirective, ")");
/* Put duplicate removal into sort directive */
s_lstrcat(szSortDirective, "DUPO(B");
wsprintf((LPSTR) szSortDirective + s_lstrlen(szSortDirective),
"%lu", offset);
s_lstrcat(szSortDirective, ",");
wsprintf((LPSTR) szSortDirective + s_lstrlen(szSortDirective),
"%u", (WORD) NUM_LEN+1);
s_lstrcat(szSortDirective, ",");
wsprintf((LPSTR) szSortDirective + s_lstrlen(szSortDirective),
"%lu", offset - NUM_LEN);
s_lstrcat(szSortDirective, ")");
/* Put record size into sort directive */
s_lstrcat(szSortDirective, "F(FIX,");
wsprintf((LPSTR) szSortDirective + s_lstrlen(szSortDirective),
"%lu", offset);
s_lstrcat(szSortDirective, ")");
/* Put in work drive */
s_lstrcat(szSortDirective, "W(");
#ifdef WIN32
if (!GetTempPath(MAX_PATHNAME_SIZE+1, (LPSTR)
szSortDirective + s_lstrlen(szSortDirective)))
return ERR_SORT;
if (szSortDirective[s_lstrlen(szSortDirective)-1] != '\\')
s_lstrcat(szSortDirective, "\\");
#else
GetTempFileName(NULL, "LEM", 0, (LPSTR) szSortDirective +
+ s_lstrlen(szSortDirective));
while (szSortDirective[s_lstrlen(szSortDirective)-1] != '\\')
szSortDirective[s_lstrlen(szSortDirective)-1] = '\0';
#endif
s_lstrcat(szSortDirective, ")");
/* Save the directive */
lpSqlNode->node.select.DistinctDirective = AllocateString(lplpSql,
szSortDirective);
if (lpSqlNode->node.select.DistinctDirective == NO_STRING)
return ERR_MEMALLOCFAIL;
/* Save the sort record size */
lpSqlNode->node.select.DistinctRecordsize = offset;
}
/* Allocate space for the sortfile name if need be */
if ((lpSqlNode->node.select.Distinct) ||
(lpSqlNode->node.select.ImplicitGroupby) ||
(lpSqlNode->node.select.Groupbycolumns != NO_SQLNODE) ||
(lpSqlNode->node.select.Sortcolumns != NO_SQLNODE)) {
lpSqlNode->node.select.SortfileName = AllocateSpace(lplpSql,
MAX_PATHNAME_SIZE+1);
if (lpSqlNode->node.select.SortfileName == NO_STRING)
return ERR_MEMALLOCFAIL;
}
return ERR_SUCCESS;
}
/***************************************************************************/
RETCODE INTFUNC SemanticCheck(LPSTMT lpstmt, LPSQLTREE FAR *lplpSql,
SQLNODEIDX idxNode, BOOL fIsGroupby, BOOL fCaseSensitive,
SQLNODEIDX idxNodeTableOuterJoinFromTables,
SQLNODEIDX idxEnclosingStatement)
/* Walks a parse tree, checks it for semantic correctness, and fills in */
/* the semantic information. */
{
LPSQLNODE lpSqlNode;
RETCODE err;
LPUSTR ptr;
if (idxNode == NO_SQLNODE)
return ERR_SUCCESS;
lpSqlNode = ToNode(*lplpSql, idxNode);
err = ERR_SUCCESS;
switch (lpSqlNode->sqlNodeType) {
case NODE_TYPE_NONE:
break;
case NODE_TYPE_ROOT:
/* Check the statement */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.root.sql,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
break;
case NODE_TYPE_CREATE:
/* Make sure table name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.create.Table);
if (s_lstrlen(ptr) > ISAMMaxTableNameLength(lpstmt->lpdbc->lpISAM)) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDTABLENAME;
}
/* Check the new column definitions */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.create.Columns,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
break;
case NODE_TYPE_DROP:
/* Make sure table name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.drop.Table);
if (s_lstrlen(ptr) > ISAMMaxTableNameLength(lpstmt->lpdbc->lpISAM)) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDTABLENAME;
}
break;
case NODE_TYPE_SELECT:
err = SelectCheck(lpstmt, lplpSql, idxNode, fCaseSensitive,
idxEnclosingStatement);
break;
case NODE_TYPE_INSERT:
{
/* Check the table */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.insert.Table,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Is there a column list? */
if (lpSqlNode->node.insert.Columns == NO_SQLNODE) {
LPSQLNODE lpSqlNodeTable;
STRINGIDX idxAlias;
LPISAMTABLEDEF lpTableHandle;
SQLNODEIDX idxColumns;
LPSQLNODE lpSqlNodeColumns;
SQLNODEIDX idxColumnsPrev;
LPSQLNODE lpSqlNodeColumnsPrev;
SQLNODEIDX idxColumn;
LPSQLNODE lpSqlNodeColumn;
SWORD idx;
/* No. Get node Alias of this table */
lpSqlNodeTable = ToNode(*lplpSql, lpSqlNode->node.insert.Table);
idxAlias = lpSqlNodeTable->node.table.Alias;
/* Loop through all the columns of this table */
lpTableHandle = lpSqlNodeTable->node.table.Handle;
idxColumnsPrev = NO_SQLNODE;
ClassColumnInfoBase* cInfoBase = lpTableHandle->pColumnInfo;
if ( !cInfoBase->IsValid() )
{
return ERR_COLUMNNOTFOUND;
}
UWORD cNumberOfCols = cInfoBase->GetNumberOfColumns();
char pColumnName [MAX_COLUMN_NAME_LENGTH+1];
for (idx = 0; idx < (SWORD) cNumberOfCols; idx++)
{
if ( FAILED(cInfoBase->GetColumnName(idx, pColumnName)) )
{
return ERR_COLUMNNOTFOUND;
}
/* Create a node for this column */
idxColumn = AllocateNode(lplpSql, NODE_TYPE_COLUMN);
if (idxColumn == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeColumn = ToNode(*lplpSql, idxColumn);
lpSqlNodeColumn->node.column.Tablealias = idxAlias;
lpSqlNodeColumn->node.column.Column = AllocateString(lplpSql,
(LPUSTR)pColumnName);
if (lpSqlNodeColumn->node.column.Column == NO_STRING)
return ERR_MEMALLOCFAIL;
lpSqlNodeColumn->node.column.Table =
lpSqlNode->node.insert.Table;
lpSqlNodeColumn->node.column.Id = idx;
lpSqlNodeColumn->node.column.Value = NO_STRING;
lpSqlNodeColumn->node.column.InSortRecord = FALSE;
lpSqlNodeColumn->node.column.Offset = 0;
lpSqlNodeColumn->node.column.Length = 0;
lpSqlNodeColumn->node.column.DistinctOffset = 0;
lpSqlNodeColumn->node.column.DistinctLength = 0;
lpSqlNodeColumn->node.column.EnclosingStatement = NO_SQLNODE;
/* Put it on the list */
idxColumns = AllocateNode(lplpSql, NODE_TYPE_COLUMNS);
if (idxColumns == NO_SQLNODE)
return ERR_MEMALLOCFAIL;
lpSqlNodeColumns = ToNode(*lplpSql, idxColumns);
lpSqlNodeColumns->node.columns.Column = idxColumn;
lpSqlNodeColumns->node.columns.Next = NO_SQLNODE;
if (idxColumnsPrev == NO_SQLNODE) {
lpSqlNode = ToNode(*lplpSql, idxNode);
lpSqlNode->node.insert.Columns = idxColumns;
}
else {
lpSqlNodeColumnsPrev = ToNode(*lplpSql, idxColumnsPrev);
lpSqlNodeColumnsPrev->node.columns.Next = idxColumns;
}
idxColumnsPrev = idxColumns;
lpSqlNode = ToNode(*lplpSql, idxNode);
}
lpSqlNode = ToNode(*lplpSql, idxNode);
}
/* Check the column list */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.insert.Columns,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the value list */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.insert.Values,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Look at each value */
{
SQLNODEIDX idxValues;
LPSQLNODE lpSqlNodeValues;
LPSQLNODE lpSqlNodeValue;
SQLNODEIDX idxColumns;
LPSQLNODE lpSqlNodeColumns;
LPSQLNODE lpSqlNodeSelect;
/* Get list of insert values */
lpSqlNodeSelect = ToNode(*lplpSql, lpSqlNode->node.insert.Values);
if (lpSqlNodeSelect->sqlNodeType == NODE_TYPE_SELECT)
idxValues = lpSqlNodeSelect->node.select.Values;
else
idxValues = lpSqlNode->node.insert.Values;
/* For each value... */
idxColumns = lpSqlNode->node.insert.Columns;
while (idxValues != NO_SQLNODE) {
/* Error if no more columns */
if (idxColumns == NO_SQLNODE)
return ERR_UNEQUALINSCOLS;
/* Get the value */
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
lpSqlNodeValue = ToNode(*lplpSql, lpSqlNodeValues->node.values.Value);
/* Get the column the value is for */
lpSqlNodeColumns = ToNode(*lplpSql, idxColumns);
/* Sub-select? */
if (lpSqlNodeSelect->sqlNodeType != NODE_TYPE_SELECT) {
/* No. Make sure the value is NUMERIC, STRING, */
/* PARAMETER, USER, NULL, DATE, TIME, or TIMESTAMP */
switch (lpSqlNodeValue->sqlNodeType) {
case NODE_TYPE_ALGEBRAIC:
case NODE_TYPE_SCALAR:
case NODE_TYPE_AGGREGATE:
case NODE_TYPE_COLUMN:
return ERR_INVALIDINSVAL;
case NODE_TYPE_PARAMETER:
case NODE_TYPE_NULL:
case NODE_TYPE_NUMERIC:
case NODE_TYPE_STRING:
case NODE_TYPE_USER:
case NODE_TYPE_DATE:
case NODE_TYPE_TIME:
case NODE_TYPE_TIMESTAMP:
break;
default:
return ERR_INTERNAL;
}
}
/* Make sure value is of the proper type */
err = TypeCheck(lpstmt, *lplpSql,
lpSqlNodeColumns->node.columns.Column,
lpSqlNodeValues->node.values.Value, OP_NONE,
NULL, NULL, NULL, NULL);
if (err != ERR_SUCCESS)
return err;
/* Look at next element */
idxValues = lpSqlNodeValues->node.values.Next;
idxColumns = lpSqlNodeColumns->node.columns.Next;
}
/* Error if extra columns */
if (idxColumns != NO_SQLNODE)
return ERR_UNEQUALINSCOLS;
}
}
break;
case NODE_TYPE_DELETE:
/* Check the table */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.delet.Table,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the predicate */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.delet.Predicate,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
break;
case NODE_TYPE_UPDATE:
/* Check the table */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.update.Table,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the update values */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.update.Updatevalues,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the predicate */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.update.Predicate,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
break;
case NODE_TYPE_CREATEINDEX:
{
SQLNODEIDX idxSortcolumns;
LPSQLNODE lpSqlNodeSortcolumns;
UWORD count;
/* Make sure index name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.createindex.Index);
if (s_lstrlen(ptr) > MAX_INDEX_NAME_LENGTH) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDINDEXNAME;
}
/* Check the table */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.createindex.Table,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Check the list of columns */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.createindex.Columns,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables, idxNode);
if (err != ERR_SUCCESS)
return err;
/* Make sure there aren't too many columns */
idxSortcolumns = lpSqlNode->node.createindex.Columns;
count = 0;
while (idxSortcolumns != NO_SQLNODE) {
lpSqlNodeSortcolumns =
ToNode(lpstmt->lpSqlStmt, idxSortcolumns);
count++;
idxSortcolumns = lpSqlNodeSortcolumns->node.sortcolumns.Next;
}
if (count > MAX_COLUMNS_IN_INDEX) {
return ERR_TOOMANYINDEXCOLS;
}
}
break;
case NODE_TYPE_DROPINDEX:
/* Make sure index name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.dropindex.Index);
if (s_lstrlen(ptr) > MAX_INDEX_NAME_LENGTH) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDINDEXNAME;
}
break;
case NODE_TYPE_PASSTHROUGH:
s_lstrcpy((LPSTR)lpstmt->szError, "CREATE, DROP, SELECT, INSERT, UPDATE, or DELETE");
return ERR_EXPECTEDOTHER;
case NODE_TYPE_TABLES:
/* Check the table */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.tables.Table,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check the rest of the list */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.tables.Next,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Error if any correlation name reused */
{
LPUSTR lpstrAlias;
SQLNODEIDX idxTables;
LPSQLNODE lpSqlNodeTables;
LPSQLNODE lpSqlNodeTable;
/* Get the alias for this table */
lpSqlNodeTable = ToNode(*lplpSql, lpSqlNode->node.tables.Table);
if (lpSqlNodeTable->node.table.Alias != NO_STRING)
{
lpstrAlias = ToString(*lplpSql, lpSqlNodeTable->node.table.Alias);
/* For each table on the rest of the list */
idxTables = lpSqlNode->node.tables.Next;
while (idxTables != NO_SQLNODE) {
/* Get pointer to table node */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
lpSqlNodeTable = ToNode(*lplpSql, lpSqlNodeTables->node.tables.Table);
/* Error if its name is the same */
if (lpSqlNodeTable->node.table.Alias != NO_STRING)
{
if (fCaseSensitive) {
if (!s_lstrcmp(lpstrAlias,
ToString(*lplpSql, lpSqlNodeTable->node.table.Alias))) {
s_lstrcpy((char*)lpstmt->szError, lpstrAlias);
return ERR_ALIASINUSE;
}
}
else {
if (!s_lstrcmpi(lpstrAlias,
ToString(*lplpSql, lpSqlNodeTable->node.table.Alias))) {
s_lstrcpy((char*)lpstmt->szError, lpstrAlias);
return ERR_ALIASINUSE;
}
}
}
/* Go to next element */
idxTables = lpSqlNodeTables->node.tables.Next;
}
}
{
LPSQLNODE lpSqlNodeTable;
/* Check the outer join predicate (if any) */
lpSqlNodeTable = ToNode(*lplpSql, lpSqlNode->node.tables.Table);
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNodeTable->node.table.OuterJoinPredicate,
FALSE, fCaseSensitive,
lpSqlNodeTable->node.table.OuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
}
}
break;
case NODE_TYPE_VALUES:
while (TRUE) {
/* Check this value */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.values.Value,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check the rest of the list */
if (lpSqlNode->node.values.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.values.Next);
}
break;
case NODE_TYPE_COLUMNS:
while (TRUE) {
/* Check this column */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.columns.Column,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check the rest of the list */
if (lpSqlNode->node.columns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.columns.Next);
}
lpSqlNode = ToNode(*lplpSql, idxNode);
/* Error if any column on list more than once */
{
LPUSTR lpstrName;
SQLNODEIDX idxColumns;
LPSQLNODE lpSqlNodeColumns;
LPSQLNODE lpSqlNodeColumn;
/* Get the name for this column */
lpSqlNodeColumn = ToNode(*lplpSql, lpSqlNode->node.columns.Column);
lpstrName = ToString(*lplpSql, lpSqlNodeColumn->node.column.Column);
/* For each column on the rest of the list */
idxColumns = lpSqlNode->node.columns.Next;
while (idxColumns != NO_SQLNODE) {
/* Get pointer to table node */
lpSqlNodeColumns = ToNode(*lplpSql, idxColumns);
lpSqlNodeColumn = ToNode(*lplpSql, lpSqlNodeColumns->node.columns.Column);
/* Error if its name is the same */
if (fCaseSensitive) {
if (!s_lstrcmp(lpstrName,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column))) {
s_lstrcpy(lpstmt->szError, lpstrName);
return ERR_COLUMNONLIST;
}
}
else {
if (!s_lstrcmpi(lpstrName,
ToString(*lplpSql, lpSqlNodeColumn->node.column.Column))) {
s_lstrcpy(lpstmt->szError, lpstrName);
return ERR_COLUMNONLIST;
}
}
/* Go to next element */
idxColumns = lpSqlNodeColumns->node.columns.Next;
}
}
break;
case NODE_TYPE_SORTCOLUMNS:
while (TRUE) {
LPSQLNODE lpSqlNodeSort;
LPSQLNODE lpSqlNodeStmt;
SQLNODEIDX idxValues;
SWORD count;
LPSQLNODE lpSqlNodeValues;
LPSQLNODE lpSqlNodeColumn;
/* Check this column */
err = SemanticCheck(lpstmt,
lplpSql,lpSqlNode->node.sortcolumns.Column,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Was an ordinal position in the select list given as sort? */
lpSqlNodeSort = ToNode(*lplpSql, lpSqlNode->node.sortcolumns.Column);
if (lpSqlNodeSort->sqlNodeType == NODE_TYPE_NUMERIC) {
/* No. Get the select list */
lpSqlNodeStmt = ToNode(*lplpSql, idxEnclosingStatement);
if (lpSqlNodeStmt->sqlNodeType != NODE_TYPE_SELECT)
return ERR_INTERNAL;
/* Find the element in the select list */
idxValues = lpSqlNodeStmt->node.select.Values;
count = 1;
while (TRUE) {
if (idxValues == NO_SQLNODE)
return ERR_ORDINALTOOLARGE;
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
if (count == (SWORD) lpSqlNodeSort->node.numeric.Value)
break;
idxValues = lpSqlNodeValues->node.values.Next;
count++;
}
lpSqlNodeColumn = ToNode(*lplpSql,
lpSqlNodeValues->node.values.Value);
/* Error if a column reference was not given */
if (lpSqlNodeColumn->sqlNodeType != NODE_TYPE_COLUMN)
return ERR_ORDERBYCOLUMNONLY;
/* Convert the sort node to a column reference */
lpSqlNodeSort->sqlNodeType = NODE_TYPE_COLUMN;
lpSqlNodeSort->sqlDataType = TYPE_UNKNOWN;
lpSqlNodeSort->sqlSqlType = SQL_TYPE_NULL;
lpSqlNodeSort->sqlPrecision = 0;
lpSqlNodeSort->sqlScale = NO_SCALE;
lpSqlNodeSort->value.String = NULL;
lpSqlNodeSort->value.Double = 0.0;
lpSqlNodeSort->value.Date.year = 0;
lpSqlNodeSort->value.Date.month = 0;
lpSqlNodeSort->value.Date.day = 0;
lpSqlNodeSort->value.Time.hour = 0;
lpSqlNodeSort->value.Time.minute = 0;
lpSqlNodeSort->value.Time.second = 0;
lpSqlNodeSort->value.Timestamp.year = 0;
lpSqlNodeSort->value.Timestamp.month = 0;
lpSqlNodeSort->value.Timestamp.day = 0;
lpSqlNodeSort->value.Timestamp.hour = 0;
lpSqlNodeSort->value.Timestamp.minute = 0;
lpSqlNodeSort->value.Timestamp.second = 0;
lpSqlNodeSort->value.Timestamp.fraction = 0;
lpSqlNodeSort->value.Binary = NULL;
lpSqlNodeSort->sqlIsNull = TRUE;
lpSqlNodeSort->node.column.Tablealias = lpSqlNodeColumn->node.column.Tablealias;
lpSqlNodeSort->node.column.Qualifier = lpSqlNodeColumn->node.column.Qualifier;
lpSqlNodeSort->node.column.MatchedAlias = lpSqlNodeColumn->node.column.MatchedAlias;
lpSqlNodeSort->node.column.Column = lpSqlNodeColumn->node.column.Column;
lpSqlNodeSort->node.column.TableIndex = lpSqlNodeColumn->node.column.TableIndex;
// lpSqlNodeSort->node.table.Handle = NULL;
lpSqlNodeSort->node.column.Id = -1;
lpSqlNodeSort->node.column.Value = NO_STRING;
lpSqlNodeSort->node.column.InSortRecord = FALSE;
lpSqlNodeSort->node.column.Offset = 0;
lpSqlNodeSort->node.column.Length = 0;
lpSqlNodeSort->node.column.DistinctOffset = 0;
lpSqlNodeSort->node.column.DistinctLength = 0;
lpSqlNodeSort->node.column.EnclosingStatement = NO_SQLNODE;
/* Semantic check the newly created node */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.sortcolumns.Column,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
}
/* Check the rest of the list */
if (lpSqlNode->node.sortcolumns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.sortcolumns.Next);
}
break;
case NODE_TYPE_GROUPBYCOLUMNS:
while (TRUE) {
/* Check this column */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.groupbycolumns.Column,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check the rest of the list */
if (lpSqlNode->node.groupbycolumns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.groupbycolumns.Next);
}
break;
case NODE_TYPE_UPDATEVALUES:
while (TRUE) {
/* Check this column */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.updatevalues.Column, fIsGroupby,
fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check the value being assigned to the column */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.updatevalues.Value, fIsGroupby,
fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Error if value has incompatible type */
err = TypeCheck(lpstmt, *lplpSql, lpSqlNode->node.updatevalues.Column,
lpSqlNode->node.updatevalues.Value, OP_NONE, NULL, NULL,
NULL, NULL);
if (err != ERR_SUCCESS)
return err;
/* Check the rest of the list */
if (lpSqlNode->node.updatevalues.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.updatevalues.Next);
}
break;
case NODE_TYPE_CREATECOLS:
while (TRUE) {
UWORD count;
UWORD idx;
/* Make sure column name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.createcols.Name);
if (s_lstrlen(ptr)>ISAMMaxColumnNameLength(lpstmt->lpdbc->lpISAM)) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDCOLNAME;
}
/* Find data type */
ptr = ToString(*lplpSql, lpSqlNode->node.createcols.Type);
for (idx = 0; idx < lpstmt->lpdbc->lpISAM->cSQLTypes; idx++) {
if (lpstmt->lpdbc->lpISAM->SQLTypes[idx].supported &&
!s_lstrcmpi(lpstmt->lpdbc->lpISAM->SQLTypes[idx].name, ptr))
break;
}
if (idx >= lpstmt->lpdbc->lpISAM->cSQLTypes) {
s_lstrcpy(lpstmt->szError, ptr);
return ERR_NOSUCHTYPE;
}
lpSqlNode->node.createcols.iSqlType = idx;
/* Count the number of create parameters */
count = 0;
ptr = lpstmt->lpdbc->lpISAM->SQLTypes[idx].params;
if (ptr != NULL) {
count = 1;
for (; *ptr; ptr++) {
if (*ptr == ',')
count++;
}
}
/* Error if wrong number of parameters */
if (count != lpSqlNode->node.createcols.Params) {
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.createcols.Type));
return ERR_BADPARAMCOUNT;
}
/* Check next one on list */
if (lpSqlNode->node.createcols.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.createcols.Next);
}
break;
case NODE_TYPE_BOOLEAN:
while (TRUE) {
/* Check left child */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.boolean.Left,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* The result is always a boolean */
lpSqlNode->sqlDataType = TYPE_INTEGER;
lpSqlNode->sqlSqlType = SQL_BIT;
lpSqlNode->sqlPrecision = 1;
lpSqlNode->sqlScale = 0;
/* Leave loop if no right child */
if (lpSqlNode->node.boolean.Right == NO_SQLNODE)
break;
/* Is right child a NODE_TYPE_BOOLEAN node? */
if (ToNode(*lplpSql, lpSqlNode->node.boolean.Right)->sqlNodeType !=
NODE_TYPE_BOOLEAN) {
/* No. Semantic check that and leave the loop */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.boolean.Right,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
break;
}
/* Semantic check the right node on next iteration of the loop */
lpSqlNode = ToNode(*lplpSql, lpSqlNode->node.boolean.Right);
}
break;
case NODE_TYPE_COMPARISON:
/* Check left child */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.comparison.Left,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check right child */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.comparison.Right,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Is this an IN or NOT IN comparison against a sub-select? */
if (((lpSqlNode->node.comparison.Operator == OP_IN) ||
(lpSqlNode->node.comparison.Operator == OP_NOTIN)) &&
(ToNode(*lplpSql, lpSqlNode->node.comparison.Right)->sqlNodeType
== NODE_TYPE_SELECT)) {
/* Yes. Convert it to a regular comparison */
if (lpSqlNode->node.comparison.Operator == OP_IN) {
lpSqlNode->node.comparison.Operator = OP_EQ;
lpSqlNode->node.comparison.SelectModifier = SELECT_ANY;
}
else if (lpSqlNode->node.comparison.Operator == OP_NOTIN) {
lpSqlNode->node.comparison.Operator = OP_NE;
lpSqlNode->node.comparison.SelectModifier = SELECT_ALL;
}
}
/* Is this an EXISTS operation ? */
if (lpSqlNode->node.comparison.Operator == OP_EXISTS) {
/* Yes. Nothing else to do */
;
}
/* Is this an IN or NOT IN comparison? */
else if ((lpSqlNode->node.comparison.Operator != OP_IN) &&
(lpSqlNode->node.comparison.Operator != OP_NOTIN)) {
/* No. Is the right child NODE_TYPE_SELECT? */
switch (lpSqlNode->node.comparison.SelectModifier) {
case SELECT_NOTSELECT:
break;
case SELECT_ALL:
case SELECT_ANY:
case SELECT_ONE:
{
LPSQLNODE lpSqlNodeSelect;
LPSQLNODE lpSqlNodeValues;
LPSQLNODE lpSqlNodeValue;
/* Yes. Get the select list */
lpSqlNodeSelect = ToNode(*lplpSql,
lpSqlNode->node.comparison.Right);
lpSqlNodeValues = ToNode(*lplpSql,
lpSqlNodeSelect->node.select.Values);
/* If more than one value on the list, error */
if (lpSqlNodeValues->node.values.Next != NO_SQLNODE)
return ERR_MULTICOLUMNSELECT;
/* If long value, error */
lpSqlNodeValue = ToNode(*lplpSql,
lpSqlNodeValues->node.values.Value);
if ((lpSqlNodeValue->sqlSqlType == SQL_LONGVARCHAR) ||
(lpSqlNodeValue->sqlSqlType == SQL_LONGVARBINARY)) {
ErrorOpCode(lpstmt,
lpSqlNode->node.comparison.Operator);
return ERR_INVALIDOPERAND;
}
/* Set the type of the value returned by the sub-query */
lpSqlNodeSelect->sqlDataType = lpSqlNodeValue->sqlDataType;
lpSqlNodeSelect->sqlSqlType = lpSqlNodeValue->sqlSqlType;
lpSqlNodeSelect->sqlPrecision = lpSqlNodeValue->sqlPrecision;
lpSqlNodeSelect->sqlScale = lpSqlNodeValue->sqlScale;
}
break;
case SELECT_EXISTS:
default:
return ERR_INTERNAL;
}
/* Error if incompatible types */
err = TypeCheck(lpstmt, *lplpSql, lpSqlNode->node.comparison.Left,
lpSqlNode->node.comparison.Right,
lpSqlNode->node.comparison.Operator,
&(lpSqlNode->sqlDataType), &(lpSqlNode->sqlSqlType),
&(lpSqlNode->sqlPrecision), &(lpSqlNode->sqlScale));
if (err != ERR_SUCCESS)
return err;
/* Error if "LIKE" or "NOT LIKE" used for non-char data */
if ((lpSqlNode->sqlDataType != TYPE_CHAR) &&
((lpSqlNode->node.comparison.Operator == OP_LIKE) ||
(lpSqlNode->node.comparison.Operator == OP_NOTLIKE))) {
ErrorOpCode(lpstmt, lpSqlNode->node.comparison.Operator);
return ERR_INVALIDOPERAND;
}
/* Error if binary data */
if (lpSqlNode->sqlDataType == TYPE_BINARY) {
if (((lpSqlNode->node.comparison.Operator != OP_EQ) &&
(lpSqlNode->node.comparison.Operator != OP_NE)) ||
(lpSqlNode->sqlPrecision > MAX_BINARY_LITERAL_LENGTH)) {
ErrorOpCode(lpstmt, lpSqlNode->node.comparison.Operator);
return ERR_INVALIDOPERAND;
}
}
}
else {
/* Yes. Look at each value */
SQLNODEIDX idxValues;
LPSQLNODE lpSqlNodeValues;
LPSQLNODE lpSqlNodeValue;
/* For each value... */
idxValues = lpSqlNode->node.comparison.Right;
while (idxValues != NO_SQLNODE) {
/* Get the value */
lpSqlNodeValues = ToNode(*lplpSql, idxValues);
lpSqlNodeValue = ToNode(*lplpSql, lpSqlNodeValues->node.values.Value);
/* Make sure the value is NUMERIC, STRING, */
/* PARAMETER, USER, DATE, TIME, or TIMESTAMP */
switch (lpSqlNodeValue->sqlNodeType) {
case NODE_TYPE_ALGEBRAIC:
case NODE_TYPE_SCALAR:
case NODE_TYPE_AGGREGATE:
case NODE_TYPE_COLUMN:
return ERR_INVALIDINVAL;
case NODE_TYPE_PARAMETER:
case NODE_TYPE_NUMERIC:
case NODE_TYPE_STRING:
case NODE_TYPE_USER:
case NODE_TYPE_DATE:
case NODE_TYPE_TIME:
case NODE_TYPE_TIMESTAMP:
/* Make sure value is of the proper type */
err = TypeCheck(lpstmt, *lplpSql,
lpSqlNode->node.comparison.Left,
lpSqlNodeValues->node.values.Value,
lpSqlNode->node.comparison.Operator,
&(lpSqlNode->sqlDataType),
&(lpSqlNode->sqlSqlType),
&(lpSqlNode->sqlPrecision),
&(lpSqlNode->sqlScale));
if (err != ERR_SUCCESS)
return err;
break;
case NODE_TYPE_NULL:
return ERR_INVALIDINVAL;
default:
return ERR_INTERNAL;
}
/* Look at next element */
idxValues = lpSqlNodeValues->node.values.Next;
}
}
/* The result is always a boolean */
lpSqlNode->sqlDataType = TYPE_INTEGER;
lpSqlNode->sqlSqlType = SQL_BIT;
lpSqlNode->sqlPrecision = 1;
lpSqlNode->sqlScale = 0;
break;
case NODE_TYPE_ALGEBRAIC:
/* Save pointer to enclosing statement */
lpSqlNode->node.algebraic.EnclosingStatement = idxEnclosingStatement;
{
LPSQLNODE lpSqlNodeLeft;
LPUSTR lpszToken;
UCHAR szTempToken[MAX_TOKEN_SIZE + 1];
/* Check left child */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.algebraic.Left,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check right child */
err = SemanticCheck(lpstmt, lplpSql, lpSqlNode->node.algebraic.Right,
fIsGroupby, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Check data type compatibility */
err = TypeCheck(lpstmt, *lplpSql, lpSqlNode->node.algebraic.Left,
lpSqlNode->node.algebraic.Right,
lpSqlNode->node.algebraic.Operator,
&(lpSqlNode->sqlDataType), &(lpSqlNode->sqlSqlType),
&(lpSqlNode->sqlPrecision), &(lpSqlNode->sqlScale));
if (err != ERR_SUCCESS)
return err;
/* Allocate space for the column value and make sure the */
/* result is numeric, date, or string */
switch (lpSqlNode->sqlDataType) {
case TYPE_DOUBLE:
case TYPE_INTEGER:
break;
case TYPE_NUMERIC:
lpSqlNode->node.algebraic.Value = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
if (lpSqlNode->node.algebraic.Operator == OP_TIMES) {
lpSqlNode->node.algebraic.WorkBuffer1 = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.WorkBuffer1 == NO_STRING)
return ERR_MEMALLOCFAIL;
}
else if (lpSqlNode->node.algebraic.Operator == OP_DIVIDEDBY) {
lpSqlNode->node.algebraic.WorkBuffer1 = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.WorkBuffer1 == NO_STRING)
return ERR_MEMALLOCFAIL;
lpSqlNode->node.algebraic.WorkBuffer2 = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.WorkBuffer2 == NO_STRING)
return ERR_MEMALLOCFAIL;
lpSqlNode->node.algebraic.WorkBuffer3 = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.WorkBuffer3 == NO_STRING)
return ERR_MEMALLOCFAIL;
}
break;
case TYPE_CHAR:
lpSqlNode->node.algebraic.Value = AllocateSpace(lplpSql,
(SWORD) (1 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.algebraic.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_BINARY:
ErrorOpCode(lpstmt, lpSqlNode->node.algebraic.Operator);
return ERR_INVALIDOPERAND;
case TYPE_DATE:
break;
case TYPE_TIME:
case TYPE_TIMESTAMP:
ErrorOpCode(lpstmt, lpSqlNode->node.algebraic.Operator);
return ERR_INVALIDOPERAND;
default:
return ERR_NOTSUPPORTED;
}
/* If this is just negation of a numeric value, collapse the */
/* two nodes into one */
lpSqlNodeLeft = ToNode(*lplpSql, lpSqlNode->node.algebraic.Left);
if ((lpSqlNode->node.algebraic.Operator == OP_NEG) &&
(lpSqlNodeLeft->sqlNodeType == NODE_TYPE_NUMERIC)) {
*lpSqlNode = *lpSqlNodeLeft;
lpSqlNode->node.numeric.Value = -(lpSqlNode->node.numeric.Value);
lpszToken = ToString(*lplpSql, lpSqlNode->node.numeric.Numeric);
if (*lpszToken != '-') {
s_lstrcpy((char*)szTempToken, lpszToken);
s_lstrcpy(lpszToken, "-");
s_lstrcat(lpszToken, (char*)szTempToken);
BCDNormalize(lpszToken, s_lstrlen(lpszToken),
lpszToken, s_lstrlen(lpszToken) + 1,
lpSqlNode->sqlPrecision,
lpSqlNode->sqlScale);
}
else {
s_lstrcpy((char*)szTempToken, lpszToken);
s_lstrcpy(lpszToken, (char*) (szTempToken+1));
}
}
}
break;
case NODE_TYPE_SCALAR:
/* Save pointer to enclosing statement */
lpSqlNode->node.scalar.EnclosingStatement = idxEnclosingStatement;
/* Check the node */
err = ScalarCheck(lpstmt, lplpSql, idxNode, fIsGroupby,
fCaseSensitive, idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Allocate space as need be */
switch (lpSqlNode->sqlDataType) {
case TYPE_DOUBLE:
break;
case TYPE_NUMERIC:
lpSqlNode->node.scalar.Value = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.scalar.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_INTEGER:
break;
case TYPE_CHAR:
lpSqlNode->node.scalar.Value = AllocateSpace(lplpSql,
(SWORD) (1 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.scalar.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_BINARY:
lpSqlNode->node.scalar.Value = AllocateSpace(lplpSql,
(SWORD) (sizeof(SDWORD) + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.scalar.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_DATE:
break;
case TYPE_TIME:
break;
case TYPE_TIMESTAMP:
break;
default:
return ERR_NOTSUPPORTED;
}
break;
case NODE_TYPE_AGGREGATE:
/* Save pointer to enclosing statement */
lpSqlNode->node.aggregate.EnclosingStatement = idxEnclosingStatement;
{
LPSQLNODE lpSqlNodeExpression;
LPSQLNODE lpSqlNodeSelect;
LPSQLNODE lpSqlNodeAggregate;
SQLNODEIDX idxAggregate;
/* Error if no group by */
if (!fIsGroupby) {
ErrorAggCode(lpstmt, lpSqlNode->node.aggregate.Operator);
return ERR_AGGNOTALLOWED;
}
/* Check expression */
err = SemanticCheck(lpstmt, lplpSql,
lpSqlNode->node.aggregate.Expression,
FALSE, fCaseSensitive,
idxNodeTableOuterJoinFromTables,
idxEnclosingStatement);
if (err != ERR_SUCCESS)
return err;
/* Figure out type of result */
if (lpSqlNode->node.aggregate.Operator != AGG_COUNT)
lpSqlNodeExpression =
ToNode(*lplpSql, lpSqlNode->node.aggregate.Expression);
switch(lpSqlNode->node.aggregate.Operator) {
case AGG_AVG:
switch (lpSqlNodeExpression->sqlDataType) {
case TYPE_DOUBLE:
case TYPE_NUMERIC:
case TYPE_INTEGER:
lpSqlNode->sqlDataType = TYPE_DOUBLE;
lpSqlNode->sqlSqlType = SQL_DOUBLE;
lpSqlNode->sqlPrecision = 15;
lpSqlNode->sqlScale = NO_SCALE;
break;
case TYPE_CHAR:
case TYPE_DATE:
case TYPE_TIME:
case TYPE_TIMESTAMP:
case TYPE_BINARY:
ErrorAggCode(lpstmt, lpSqlNode->node.aggregate.Operator);
return ERR_INVALIDOPERAND;
default:
return ERR_NOTSUPPORTED;
}
break;
case AGG_COUNT:
lpSqlNode->sqlDataType = TYPE_INTEGER;
lpSqlNode->sqlSqlType = SQL_INTEGER;
lpSqlNode->sqlPrecision = 10;
lpSqlNode->sqlScale = 0;
break;
case AGG_MAX:
case AGG_MIN:
switch (lpSqlNodeExpression->sqlDataType) {
case TYPE_DOUBLE:
case TYPE_NUMERIC:
case TYPE_INTEGER:
case TYPE_CHAR:
case TYPE_DATE:
case TYPE_TIME:
case TYPE_TIMESTAMP:
lpSqlNode->sqlDataType = lpSqlNodeExpression->sqlDataType;
lpSqlNode->sqlSqlType = lpSqlNodeExpression->sqlSqlType;
lpSqlNode->sqlPrecision = lpSqlNodeExpression->sqlPrecision;
lpSqlNode->sqlScale = lpSqlNodeExpression->sqlScale;
break;
case TYPE_BINARY:
ErrorAggCode(lpstmt, lpSqlNode->node.aggregate.Operator);
return ERR_INVALIDOPERAND;
default:
return ERR_NOTSUPPORTED;
}
break;
case AGG_SUM:
switch (lpSqlNodeExpression->sqlDataType) {
case TYPE_DOUBLE:
case TYPE_NUMERIC:
case TYPE_INTEGER:
lpSqlNode->sqlDataType = lpSqlNodeExpression->sqlDataType;
lpSqlNode->sqlSqlType = lpSqlNodeExpression->sqlSqlType;
lpSqlNode->sqlPrecision = lpSqlNodeExpression->sqlPrecision;
lpSqlNode->sqlScale = lpSqlNodeExpression->sqlScale;
break;
case TYPE_CHAR:
case TYPE_DATE:
case TYPE_TIME:
case TYPE_TIMESTAMP:
case TYPE_BINARY:
ErrorAggCode(lpstmt, lpSqlNode->node.aggregate.Operator);
return ERR_INVALIDOPERAND;
default:
return ERR_NOTSUPPORTED;
}
break;
default:
return ERR_INTERNAL;
}
/* Allocate space for the aggregate value */
switch (lpSqlNode->sqlDataType) {
case TYPE_DOUBLE:
lpSqlNode->node.aggregate.Length = sizeof(double);
break;
case TYPE_NUMERIC:
switch (lpSqlNode->sqlSqlType) {
case SQL_NUMERIC:
case SQL_DECIMAL:
lpSqlNode->node.aggregate.Length =
lpSqlNodeExpression->sqlPrecision + 2;
break;
case SQL_BIGINT:
lpSqlNode->node.aggregate.Length =
lpSqlNodeExpression->sqlPrecision + 1;
break;
case SQL_TINYINT:
case SQL_SMALLINT:
case SQL_INTEGER:
case SQL_BIT:
case SQL_REAL:
case SQL_FLOAT:
case SQL_DOUBLE:
case SQL_CHAR:
case SQL_VARCHAR:
case SQL_LONGVARCHAR:
case SQL_BINARY:
case SQL_VARBINARY:
case SQL_LONGVARBINARY:
case SQL_DATE:
case SQL_TIME:
case SQL_TIMESTAMP:
default:
return ERR_INTERNAL;
}
lpSqlNode->node.aggregate.Value =
AllocateSpace(lplpSql, (SWORD)
(lpSqlNode->node.aggregate.Length + 1));
if (lpSqlNode->node.aggregate.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_INTEGER:
lpSqlNode->node.aggregate.Length = sizeof(double);
break;
case TYPE_CHAR:
lpSqlNode->node.aggregate.Length =
lpSqlNodeExpression->sqlPrecision;
lpSqlNode->node.aggregate.Value =
AllocateSpace(lplpSql, (SWORD)
(lpSqlNode->node.aggregate.Length + 1));
if (lpSqlNode->node.aggregate.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_DATE:
lpSqlNode->node.aggregate.Length = 10;
break;
case TYPE_TIME:
lpSqlNode->node.aggregate.Length = 8;
break;
case TYPE_TIMESTAMP:
if (TIMESTAMP_SCALE > 0)
lpSqlNode->node.aggregate.Length = 20 + TIMESTAMP_SCALE;
else
lpSqlNode->node.aggregate.Length = 19;
break;
case TYPE_BINARY:
return ERR_INTERNAL;
default:
return ERR_NOTSUPPORTED;
}
/* Get SELECT statement node */
lpSqlNodeSelect = ToNode(*lplpSql, idxEnclosingStatement);
if (lpSqlNodeSelect->sqlNodeType != NODE_TYPE_SELECT)
return ERR_INTERNAL;
/* Add to list of AGG functions in the select node */
lpSqlNodeAggregate = NULL;
idxAggregate = lpSqlNodeSelect->node.select.Aggregates;
while (idxAggregate != NO_SQLNODE) {
lpSqlNodeAggregate = ToNode(*lplpSql, idxAggregate);
idxAggregate = lpSqlNodeAggregate->node.aggregate.Next;
}
if (lpSqlNodeAggregate != NULL)
lpSqlNodeAggregate->node.aggregate.Next = idxNode;
else
lpSqlNodeSelect->node.select.Aggregates = idxNode;
}
break;
case NODE_TYPE_TABLE:
{
LPSQLNODE lpSqlNodeRoot;
LPSQLNODE lpSqlNodeStmt;
BOOL fReadOnly;
char tableNameBuff [MAX_TABLE_NAME_LENGTH + 1];
/* Make sure table name is not too long */
ptr = ToString(*lplpSql, lpSqlNode->node.table.Name);
if (s_lstrlen(ptr) > ISAMMaxTableNameLength(lpstmt->lpdbc->lpISAM)){
s_lstrcpy(lpstmt->szError, ptr);
return ERR_INVALIDTABLENAME;
}
else
{
//Copy table name
tableNameBuff[0] = 0;
s_lstrcpy (tableNameBuff, ptr);
}
/* Figure out if write access is needed */
lpSqlNodeStmt = ToNode(*lplpSql, idxEnclosingStatement);
switch (lpSqlNodeStmt->sqlNodeType) {
case NODE_TYPE_SELECT:
fReadOnly = TRUE;
break;
case NODE_TYPE_INSERT:
fReadOnly = FALSE;
break;
case NODE_TYPE_UPDATE:
fReadOnly = FALSE;
break;
case NODE_TYPE_DELETE:
fReadOnly = FALSE;
break;
case NODE_TYPE_CREATEINDEX:
fReadOnly = FALSE;
break;
case NODE_TYPE_DROPINDEX:
fReadOnly = FALSE;
break;
default:
return ERR_INTERNAL;
}
/* resolve qualifier */
if (lpSqlNode->node.table.Qualifier != NO_STRING)
{
LPSTR pQual = (LPSTR) ToString(*lplpSql, lpSqlNode->node.table.Qualifier);
if (lstrlen(pQual) > ISAMMaxTableNameLength(lpstmt->lpdbc->lpISAM)) {
s_lstrcpy((char*)lpstmt->szError, ptr);
return ERR_INVALIDTABLENAME;
}
if ( (lstrlen(pQual) >= 4) && (_strnicmp("root", pQual, 4) == 0) )
{
// absolute qualifier [starts with 'root'] (no need to change)
}
else
{
// concatenate the current namespace with the qualifier
LPUSTR currQual = ISAMDatabase (lpstmt->lpdbc->lpISAM);
char * pszNewQualifier = new char [strlen (pQual)+
s_lstrlen (currQual)+2+1];
s_lstrcpy (pszNewQualifier, currQual);
s_lstrcat (pszNewQualifier, "\\");
s_lstrcat (pszNewQualifier, pQual);
lpSqlNode->node.table.Qualifier = AllocateString (lplpSql, (LPUSTR)pszNewQualifier);
delete [] pszNewQualifier;
}
}
else
{
// the current namespace is the qualifier
LPUSTR currQual = ISAMDatabase (lpstmt->lpdbc->lpISAM);
lpSqlNode->node.table.Qualifier = AllocateString (lplpSql, (LPUSTR)currQual);
}
#ifdef TESTING
//Create extra test class with dummy values for testing
// IMosProvider* pDummyProv = ISAMGetGatewayServer(lpstmt->lpdbc->lpISAM);
// CreateClassAndInstance(pDummyProv);
#endif
/* Open the table */
LPUSTR pQual = ToString(*lplpSql, lpSqlNode->node.table.Qualifier);
lpSqlNodeRoot = ToNode(*lplpSql, ROOT_SQLNODE);
//If this the special Passthrough SQL table ?
char* virTbl = WBEMDR32_VIRTUAL_TABLE2;
if (s_lstrcmp(tableNameBuff, virTbl) == 0)
{
//Yes this is the Passthrough SQL table
err = ISAMOpenTable(lpSqlNodeRoot->node.root.lpISAM,
(LPUSTR) pQual, (SWORD) s_lstrlen (pQual),
(LPUSTR) tableNameBuff, fReadOnly,
&(lpSqlNode->node.table.Handle),
lpstmt);
}
else
{
//No normal table
err = ISAMOpenTable(lpSqlNodeRoot->node.root.lpISAM,
(LPUSTR) pQual, (SWORD) s_lstrlen (pQual),
(LPUSTR) tableNameBuff, fReadOnly,
&(lpSqlNode->node.table.Handle));
}
if (err != NO_ISAM_ERR) {
lpSqlNode->node.table.Handle = NULL;
ISAMGetErrorMessage(lpSqlNodeRoot->node.root.lpISAM,
(LPUSTR)lpstmt->szISAMError);
return err;
}
if (lpstmt->lpdbc->lpISAM->fSchemaInfoTransactioned)
lpstmt->fISAMTxnStarted = TRUE;
err = ERR_SUCCESS;
}
break;
case NODE_TYPE_COLUMN:
/* Save pointer to enclosing statement */
lpSqlNode->node.column.EnclosingStatement = idxEnclosingStatement;
//Sai Wong table column info
/* Is this column node in an outer join predicate? */
if (idxNodeTableOuterJoinFromTables == NO_SQLNODE) {
/* No. Resolve it against the table lists */
LPSQLNODE lpSqlNodeStmt;
LPSQLNODE lpSqlNodeTables;
SQLNODEIDX idxTables;
SQLNODEIDX idxStatement;
STRINGIDX idxOriginalAlias;
STRINGIDX idxAlias;
BOOL fFoundMatch;
STRINGIDX idxQualifier, idxOriginalQualifier;
/* No. Search up all the enclosing statements for the column */
idxStatement = idxEnclosingStatement;
while (idxStatement != NO_SQLNODE) {
/* Get node of the statement */
lpSqlNodeStmt = ToNode(*lplpSql, idxStatement);
/* Resolve column */
switch (lpSqlNodeStmt->sqlNodeType) {
case NODE_TYPE_SELECT:
/* Save the table alias and qualifier specified */
idxAlias = lpSqlNode->node.column.Tablealias;
idxOriginalAlias = lpSqlNode->node.column.Tablealias;
idxQualifier = idxOriginalQualifier = lpSqlNode->node.column.Qualifier;
/* Look through the list of tables */
fFoundMatch = FALSE;
err = ERR_COLUMNNOTFOUND;
for (idxTables = lpSqlNodeStmt->node.select.Tables;
idxTables != NO_SQLNODE;
idxTables = lpSqlNodeTables->node.tables.Next) {
/* Is the column in this table? */
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive,
lpSqlNode, lpSqlNodeTables->node.tables.Table, idxQualifier);
if (err == ERR_SUCCESS)
{
/* Yes. Error if column also in another table */
if (fFoundMatch) {
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNFOUND;
}
fFoundMatch = TRUE;
/* If a table alias was specified for column, */
/* there is no need to check the other tables */
/* I'm going to remove this check as there is the */
/* possibility of a clash between an alias-qualified*/
/* name and a namespace qualified name. This clash */
/* is not picked up during the semantic check of the*/
/* table list */
//if (idxOriginalAlias != NO_STRING)
// break;
/* Save the alias of the table found */
idxAlias = lpSqlNode->node.column.Tablealias;
idxQualifier = lpSqlNode->node.column.Qualifier;
/* Restore the original alias and keep looking */
//Added by Sai Wong
lpSqlNode->node.column.Tablealias = idxOriginalAlias; //NO_STRING;
lpSqlNode->node.column.Qualifier = idxOriginalQualifier;
}
else if (err != ERR_COLUMNNOTFOUND)
return err;
}
/* Restore the alias found */
lpSqlNode->node.column.Tablealias = idxAlias;
lpSqlNode->node.column.Qualifier = idxQualifier;
/* Was the column found in this statement? */
if (fFoundMatch)
err = ERR_SUCCESS;
else
err = ERR_COLUMNNOTFOUND;
break;
case NODE_TYPE_INSERT:
if (idxStatement == idxEnclosingStatement)
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive,
lpSqlNode, lpSqlNodeStmt->node.insert.Table,
NO_STRING);
else
err = ERR_COLUMNNOTFOUND;
break;
case NODE_TYPE_UPDATE:
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive, lpSqlNode,
lpSqlNodeStmt->node.update.Table, NO_STRING);
break;
case NODE_TYPE_DELETE:
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive, lpSqlNode,
lpSqlNodeStmt->node.delet.Table, NO_STRING);
break;
case NODE_TYPE_CREATEINDEX:
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive, lpSqlNode,
lpSqlNodeStmt->node.createindex.Table, NO_STRING);
break;
default:
return ERR_INTERNAL;
}
if ((err != ERR_SUCCESS) && (err != ERR_COLUMNNOTFOUND))
return err;
/* If the column was found in this statement, use it */
if (err == ERR_SUCCESS)
break;
/* Try looking in the enclosing statement (if any) */
if (lpSqlNodeStmt->sqlNodeType != NODE_TYPE_SELECT)
break;
idxStatement = lpSqlNodeStmt->node.select.EnclosingStatement;
}
/* If column not found, error */
if (err == ERR_COLUMNNOTFOUND) {
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNNOTFOUND;
}
}
else {
/* Yes. Resolve it against the table lists */
STRINGIDX idxAlias;
STRINGIDX idxOriginalAlias;
BOOL fFoundMatch;
SQLNODEIDX idxTables;
LPSQLNODE lpSqlNodeTables;
SQLNODEIDX idxTable;
LPSQLNODE lpSqlNodeTable;
STRINGIDX idxQualifier, idxOriginalQualifier;
/* Save the table alias specified */
idxAlias = lpSqlNode->node.column.Tablealias;
idxOriginalAlias = lpSqlNode->node.column.Tablealias;
idxQualifier = idxOriginalQualifier = lpSqlNode->node.column.Qualifier;
/* Is the column in a table in the outer join expression? */
idxTables = idxNodeTableOuterJoinFromTables;
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
idxTable = lpSqlNodeTables->node.tables.Table;
fFoundMatch = FALSE;
while (TRUE) {
/* Is it in this table? */
err = FindColumn(lpstmt, *lplpSql, fCaseSensitive,
lpSqlNode, idxTable, lpSqlNodeTables->node.column.Qualifier);
if (err == ERR_SUCCESS) {
/* Yes. Error if it matches another table too */
if (fFoundMatch) {
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNFOUND;
}
/* Set flag */
fFoundMatch = TRUE;
/* Save the alias of the table found */
idxAlias = lpSqlNode->node.column.Tablealias;
idxQualifier = lpSqlNode->node.column.Qualifier;
/* Restore the original alias if need be */
//Added by Sai Wong
// if (idxOriginalAlias == NO_STRING)
lpSqlNode->node.column.Tablealias = idxOriginalAlias; //NO_STRING;
lpSqlNode->node.column.Qualifier = idxOriginalQualifier;
}
else if (err != ERR_COLUMNNOTFOUND)
return err;
/* Look in next table on list */
idxTables = lpSqlNodeTables->node.tables.Next;
if (idxTables == NO_SQLNODE)
break;
lpSqlNodeTables = ToNode(*lplpSql, idxTables);
idxTable = lpSqlNodeTables->node.tables.Table;
lpSqlNodeTable = ToNode(*lplpSql, idxTable);
/* If this table is not in the outer-join, stop looking */
if (lpSqlNodeTable->node.table.OuterJoinFromTables ==
NO_SQLNODE)
break;
}
/* Error if column was not found */
if (!fFoundMatch) {
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNNOTFOUND;
}
/* Restore the alias found */
lpSqlNode->node.column.Tablealias = idxAlias;
lpSqlNode->node.column.Qualifier = idxQualifier;
err = ERR_SUCCESS;
}
/* Does the column have to be a group by column? */
if (fIsGroupby) {
LPUSTR lpszColumn;
LPUSTR lpszTable;
LPSQLNODE lpSqlNodeStmt;
SQLNODEIDX idxGroupbycolumns;
LPSQLNODE lpSqlNodeGroupbycolumns;
LPSQLNODE lpSqlNodeColumnGroupby;
LPUSTR lpszColumnGroupby;
LPUSTR lpszTableGroupby;
BOOL fMatch;
/* Yes. Get the name of the column and table */
lpszColumn = ToString(*lplpSql, lpSqlNode->node.column.Column);
lpszTable = ToString(*lplpSql, lpSqlNode->node.column.Tablealias);
/* Get list of group by columns */
lpSqlNodeStmt = ToNode(*lplpSql, idxEnclosingStatement);
if (lpSqlNodeStmt->sqlNodeType != NODE_TYPE_SELECT)
return ERR_INTERNAL;
idxGroupbycolumns = lpSqlNodeStmt->node.select.Groupbycolumns;
/* Error if implicit group by */
if (lpSqlNodeStmt->node.select.ImplicitGroupby) {
s_lstrcpy(lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNNOTFOUND;
}
/* Find the column in the group by lists */
while (TRUE) {
/* Get this group by column */
lpSqlNodeGroupbycolumns = ToNode(*lplpSql, idxGroupbycolumns);
if (lpSqlNodeGroupbycolumns->node.groupbycolumns.Column !=
NO_SQLNODE) {
lpSqlNodeColumnGroupby = ToNode(*lplpSql,
lpSqlNodeGroupbycolumns->node.groupbycolumns.Column);
/* Get column name and table name of the group by column */
lpszTableGroupby = ToString(*lplpSql,
lpSqlNodeColumnGroupby->node.column.Tablealias);
lpszColumnGroupby = ToString(*lplpSql,
lpSqlNodeColumnGroupby->node.column.Column);
/* Do the column name match? */
fMatch = FALSE;
if (fCaseSensitive) {
if (!s_lstrcmp(lpszColumnGroupby, lpszColumn) &&
!s_lstrcmp(lpszTableGroupby, lpszTable))
fMatch = TRUE;
}
else {
if (!s_lstrcmpi(lpszColumnGroupby, lpszColumn) &&
!s_lstrcmpi(lpszTableGroupby, lpszTable))
fMatch = TRUE;
}
}
else
fMatch = FALSE;
/* Does this column match a group by column? */
if (fMatch) {
/* Yes. Fill in semantic information for the column */
lpSqlNode->node.column.InSortRecord = TRUE;
lpSqlNode->node.column.Offset =
lpSqlNodeColumnGroupby->node.column.Offset;
lpSqlNode->node.column.Length =
lpSqlNodeColumnGroupby->node.column.Length;
lpSqlNode->node.column.DistinctOffset =
lpSqlNodeColumnGroupby->node.column.DistinctOffset;
lpSqlNode->node.column.DistinctLength =
lpSqlNodeColumnGroupby->node.column.DistinctLength;
break;
}
/* Not found yet. Check next column */
idxGroupbycolumns =
lpSqlNodeGroupbycolumns->node.groupbycolumns.Next;
/* Error if column not found */
if (idxGroupbycolumns == NO_SQLNODE) {
s_lstrcpy((char*)lpstmt->szError,
ToString(*lplpSql, lpSqlNode->node.column.Column));
return ERR_COLUMNNOTFOUND;
}
}
}
/* Allocate space for the column value */
switch (lpSqlNode->sqlDataType) {
case TYPE_DOUBLE:
break;
case TYPE_NUMERIC:
lpSqlNode->node.column.Value = AllocateSpace(lplpSql,
(SWORD) (1 + 2 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.column.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_INTEGER:
break;
case TYPE_CHAR:
lpSqlNode->node.column.Value = AllocateSpace(lplpSql,
(SWORD) (1 + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.column.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_BINARY:
lpSqlNode->node.column.Value = AllocateSpace(lplpSql,
(SWORD) (sizeof(SDWORD) + lpSqlNode->sqlPrecision));
if (lpSqlNode->node.column.Value == NO_STRING)
return ERR_MEMALLOCFAIL;
break;
case TYPE_DATE:
break;
case TYPE_TIME:
break;
case TYPE_TIMESTAMP:
break;
default:
return ERR_NOTSUPPORTED;
}
break;
case NODE_TYPE_STRING:
lpSqlNode->sqlDataType = TYPE_CHAR;
lpSqlNode->sqlSqlType = SQL_VARCHAR;
ptr = ToString(*lplpSql, lpSqlNode->node.string.Value);
lpSqlNode->sqlPrecision = s_lstrlen(ptr);
lpSqlNode->sqlScale = NO_SCALE;
break;
case NODE_TYPE_NUMERIC:
if (lpSqlNode->sqlDataType == TYPE_UNKNOWN) {
lpSqlNode->sqlDataType = TYPE_DOUBLE;
lpSqlNode->sqlSqlType = SQL_DOUBLE;
lpSqlNode->sqlPrecision = 15;
lpSqlNode->sqlScale = NO_SCALE;
}
break;
case NODE_TYPE_PARAMETER:
lpSqlNode->sqlDataType = TYPE_UNKNOWN;
lpSqlNode->sqlSqlType = SQL_TYPE_NULL;
lpSqlNode->sqlPrecision = 0;
lpSqlNode->sqlScale = NO_SCALE;
break;
case NODE_TYPE_USER:
lpSqlNode->sqlDataType = TYPE_CHAR;
lpSqlNode->sqlSqlType = SQL_VARCHAR;
lpSqlNode->sqlPrecision = s_lstrlen(
ISAMUser(ToNode(*lplpSql, ROOT_SQLNODE)->node.root.lpISAM));
lpSqlNode->sqlScale = NO_SCALE;
break;
case NODE_TYPE_NULL:
lpSqlNode->sqlDataType = TYPE_UNKNOWN;
lpSqlNode->sqlSqlType = SQL_TYPE_NULL;
lpSqlNode->sqlPrecision = 0;
lpSqlNode->sqlScale = NO_SCALE;
break;
case NODE_TYPE_DATE:
lpSqlNode->sqlDataType = TYPE_DATE;
if (lpSqlNode->sqlSqlType == SQL_TYPE_NULL) {
lpSqlNode->sqlSqlType = SQL_DATE;
lpSqlNode->sqlPrecision = 10;
lpSqlNode->sqlScale = NO_SCALE;
}
break;
case NODE_TYPE_TIME:
lpSqlNode->sqlDataType = TYPE_TIME;
if (lpSqlNode->sqlSqlType == SQL_TYPE_NULL) {
lpSqlNode->sqlSqlType = SQL_TIME;
lpSqlNode->sqlPrecision = 8;
lpSqlNode->sqlScale = NO_SCALE;
}
break;
case NODE_TYPE_TIMESTAMP:
lpSqlNode->sqlDataType = TYPE_TIMESTAMP;
if (lpSqlNode->sqlSqlType == SQL_TYPE_NULL) {
lpSqlNode->sqlSqlType = SQL_TIMESTAMP;
if (TIMESTAMP_SCALE != 0)
lpSqlNode->sqlPrecision = 20 + TIMESTAMP_SCALE;
else
lpSqlNode->sqlPrecision = 19;
lpSqlNode->sqlScale = TIMESTAMP_SCALE;
}
break;
default:
return ERR_INTERNAL;
}
return err;
}
/***************************************************************************/
void INTFUNC FreeTreeSemantic(LPSQLTREE lpSql, SQLNODEIDX idxNode)
/* Deallocates semantic information in a parse tree */
{
LPSQLNODE lpSqlNode;
SQLNODEIDX idxParameter;
SQLNODEIDX idxParameterNext;
if (idxNode == NO_SQLNODE)
return;
lpSqlNode = ToNode(lpSql, idxNode);
switch (lpSqlNode->sqlNodeType) {
case NODE_TYPE_NONE:
break;
case NODE_TYPE_ROOT:
FreeTreeSemantic(lpSql, lpSqlNode->node.root.sql);
if (lpSqlNode->node.root.passthroughParams) {
idxParameter = lpSqlNode->node.root.parameters;
while (idxParameter != NO_SQLNODE) {
lpSqlNode = ToNode(lpSql, idxParameter);
idxParameterNext = lpSqlNode->node.parameter.Next;
FreeTreeSemantic(lpSql, idxParameter);
idxParameter = idxParameterNext;
}
}
break;
case NODE_TYPE_CREATE:
FreeTreeSemantic(lpSql, lpSqlNode->node.create.Columns);
break;
case NODE_TYPE_DROP:
break;
case NODE_TYPE_SELECT:
FreeTreeSemantic(lpSql, lpSqlNode->node.select.Values);
FreeTreeSemantic(lpSql, lpSqlNode->node.select.Tables);
FreeTreeSemantic(lpSql, lpSqlNode->node.select.Predicate);
FreeTreeSemantic(lpSql, lpSqlNode->node.select.Groupbycolumns);
FreeTreeSemantic(lpSql, lpSqlNode->node.select.Sortcolumns);
if (lpSqlNode->node.select.Sortfile != HFILE_ERROR) {
LPUSTR lpszSortfile;
_lclose(lpSqlNode->node.select.Sortfile);
lpSqlNode->node.select.Sortfile = HFILE_ERROR;
lpszSortfile = ToString(lpSql,
lpSqlNode->node.select.SortfileName);
DeleteFile((LPCSTR) lpszSortfile);
s_lstrcpy(lpszSortfile, "");
}
break;
case NODE_TYPE_INSERT:
FreeTreeSemantic(lpSql, lpSqlNode->node.insert.Table);
FreeTreeSemantic(lpSql, lpSqlNode->node.insert.Columns);
FreeTreeSemantic(lpSql, lpSqlNode->node.insert.Values);
break;
case NODE_TYPE_DELETE:
FreeTreeSemantic(lpSql, lpSqlNode->node.delet.Table);
FreeTreeSemantic(lpSql, lpSqlNode->node.delet.Predicate);
break;
case NODE_TYPE_UPDATE:
FreeTreeSemantic(lpSql, lpSqlNode->node.update.Table);
FreeTreeSemantic(lpSql, lpSqlNode->node.update.Updatevalues);
FreeTreeSemantic(lpSql, lpSqlNode->node.update.Predicate);
break;
case NODE_TYPE_CREATEINDEX:
FreeTreeSemantic(lpSql, lpSqlNode->node.createindex.Table);
FreeTreeSemantic(lpSql, lpSqlNode->node.createindex.Columns);
break;
case NODE_TYPE_DROPINDEX:
break;
case NODE_TYPE_PASSTHROUGH:
break;
case NODE_TYPE_TABLES:
FreeTreeSemantic(lpSql, lpSqlNode->node.tables.Table);
FreeTreeSemantic(lpSql, lpSqlNode->node.tables.Next);
break;
case NODE_TYPE_VALUES:
while (TRUE) {
FreeTreeSemantic(lpSql, lpSqlNode->node.values.Value);
if (lpSqlNode->node.values.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.values.Next);
}
break;
case NODE_TYPE_COLUMNS:
while (TRUE) {
FreeTreeSemantic(lpSql, lpSqlNode->node.columns.Column);
if (lpSqlNode->node.columns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.columns.Next);
}
break;
case NODE_TYPE_SORTCOLUMNS:
while (TRUE) {
FreeTreeSemantic(lpSql, lpSqlNode->node.sortcolumns.Column);
if (lpSqlNode->node.sortcolumns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.sortcolumns.Next);
}
break;
case NODE_TYPE_GROUPBYCOLUMNS:
while (TRUE) {
FreeTreeSemantic(lpSql, lpSqlNode->node.groupbycolumns.Column);
if (lpSqlNode->node.groupbycolumns.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.groupbycolumns.Next);
}
break;
case NODE_TYPE_UPDATEVALUES:
while (TRUE) {
FreeTreeSemantic(lpSql, lpSqlNode->node.updatevalues.Column);
FreeTreeSemantic(lpSql, lpSqlNode->node.updatevalues.Value);
if (lpSqlNode->node.updatevalues.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.updatevalues.Next);
}
break;
case NODE_TYPE_CREATECOLS:
while (TRUE) {
if (lpSqlNode->node.createcols.Next == NO_SQLNODE)
break;
lpSqlNode = ToNode(lpSql, lpSqlNode->node.createcols.Next);
}
break;
case NODE_TYPE_BOOLEAN:
FreeTreeSemantic(lpSql, lpSqlNode->node.boolean.Left);
FreeTreeSemantic(lpSql, lpSqlNode->node.boolean.Right);
break;
case NODE_TYPE_COMPARISON:
FreeTreeSemantic(lpSql, lpSqlNode->node.comparison.Left);
FreeTreeSemantic(lpSql, lpSqlNode->node.comparison.Right);
break;
case NODE_TYPE_ALGEBRAIC:
FreeTreeSemantic(lpSql, lpSqlNode->node.algebraic.Left);
FreeTreeSemantic(lpSql, lpSqlNode->node.algebraic.Right);
break;
case NODE_TYPE_SCALAR:
FreeTreeSemantic(lpSql, lpSqlNode->node.scalar.Arguments);
break;
case NODE_TYPE_AGGREGATE:
FreeTreeSemantic(lpSql, lpSqlNode->node.aggregate.Expression);
break;
case NODE_TYPE_TABLE:
if (lpSqlNode->node.table.Handle != NULL) {
ISAMCloseTable(lpSqlNode->node.table.Handle);
lpSqlNode->node.table.Handle = NULL;
}
FreeTreeSemantic(lpSql, lpSqlNode->node.table.OuterJoinPredicate);
break;
case NODE_TYPE_COLUMN:
break;
case NODE_TYPE_STRING:
break;
case NODE_TYPE_NUMERIC:
break;
case NODE_TYPE_PARAMETER:
break;
case NODE_TYPE_USER:
break;
case NODE_TYPE_NULL:
break;
case NODE_TYPE_DATE:
break;
case NODE_TYPE_TIME:
break;
case NODE_TYPE_TIMESTAMP:
break;
default:
break;
}
}
/***************************************************************************/
Reference in a new issue View git blame Copy permalink