void SqlCompiler::checkExpressionType(InsertColumnExpression &col) {
const SyntaxNode *p = findFirstTableReference(col.m_expr);
if(p != NULL)
syntaxError(p,SQL_INVALID_EXPR_TYPE,_T("Columnnames not allowed in valuelist"));
p = findFirstAggregateFunction(col.m_expr);
if(p != NULL)
syntaxError(p,SQL_INVALID_EXPR_TYPE,_T("Aggregation not allowed in valuelist"));
DbMainType exprtype = checkValueExpressionMainType(col.m_expr);
DbMainType coltype = getMainType(col.getType());
if(!isCompatibleType(exprtype,coltype)) {
switch(coltype) {
case MAINTYPE_NUMERIC :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be numeric"));
break;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be String"));
break;
case MAINTYPE_DATE :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be Date"));
break;
case MAINTYPE_TIME :
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be time"));
break;
case MAINTYPE_TIMESTAMP:
syntaxError(col.m_expr,SQL_INVALID_EXPR_TYPE,_T("Illegal type of expression. Must be Timestamp"));
break;
default :
stopcomp(col.m_expr);
}
}
}
bool vesUniform::getElement(unsigned int index, vesMatrix4x4f &value) const
{
if (index >= this->m_numberElements || !isCompatibleType(FloatMat4))
return false;
for (unsigned int i = 0; i < 16; ++i)
value.data()[i] = (&m_floatArray->front())[i];
return true;
}
bool vesUniform::getElement(unsigned int index, float &value) const
{
if (index >= this->m_numberElements || !isCompatibleType(Float))
return false;
unsigned int j = index * getTypeNumberOfComponents(this->m_type);
value = (*this->m_floatArray)[j];
return true;
}
bool vesUniform::setElement(unsigned int index, bool value)
{
if (index >= this->m_numberElements || !isCompatibleType(Bool))
return false;
unsigned int j = index * getTypeNumberOfComponents(getType());
(*this->m_intArray)[j] = value;
// \todo: Make state dirty.
return true;
}
bool vesUniform::setElement(unsigned int index, const vesMatrix4x4f &matrix)
{
if (index >= this->m_numberElements || !isCompatibleType(FloatMat4))
return false;
unsigned int j = index * getTypeNumberOfComponents(this->m_type);
for (int i = 0; i < 16; ++i)
(*this->m_floatArray)[j+i] = matrix.data()[i];
// \todo: Make state dirty.
return true;
}
bool vesUniform::setElement(unsigned int index, const vesVector2f &vector)
{
if (index >= this->m_numberElements || !isCompatibleType(FloatVec2))
return false;
unsigned int j = index * getTypeNumberOfComponents(this->m_type);
(*this->m_floatArray)[j] = vector[0];
(*this->m_floatArray)[j+1] = vector[1];
// \todo: Make state dirty.
return true;
}
TableCursorKey::TableCursorKey(const KeyFileDefinition &keydef, const Tuple *keytuple, UINT fieldCount, RelationType relop) : m_keydef(keydef) {
m_fieldCount = fieldCount;
m_key.init();
m_relop = relop;
if(relop == RELOP_FALSE || relop == RELOP_TRUE) return;
if(relop == RELOP_NQ) {
m_relop = RELOP_TRUE;
m_fieldCount = 0;
return;
}
if(fieldCount == 0) {
return;
}
if(keytuple == NULL) {
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:No Tuple specified but field = %d"),fieldCount);
}
const Tuple &tuple = *keytuple;
if(fieldCount > tuple.size()) {
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:invalid fieldCount (=%d) specified. Tuple.size = %zd")
,fieldCount,tuple.size());
}
for(UINT i = 0; i < fieldCount; i++) {
DbFieldType tupleType = tuple[i].getType();
DbFieldType keyType = keydef.getFieldDef(i).getType();
if(!isCompatibleType(keyType,tupleType)) {
throwSqlError(SQL_TYPEMISMATCH,_T("Incompatible types in keydefinition(%s) and tupledefinition(%s)")
,getTypeString(keyType)
,getTypeString(tupleType));
}
const TupleField &tupField = tuple[i];
switch(getMainType(tupleType)) {
case MAINTYPE_NUMERIC :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
double d;
tupField.get(d);
if(putField(i,d)) return;
break;
}
case MAINTYPE_STRING :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
String str;
tupField.get(str);
switch(getMainType(keyType)) {
case MAINTYPE_STRING:
if(putField(i,str)) return;
break;
case MAINTYPE_VARCHAR:
{ varchar vch(str.cstr());
if(putField(i,vch)) return;
}
}
}
break;
case MAINTYPE_VARCHAR :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
varchar vch;
tupField.get(vch);
switch(getMainType(keyType)) {
case MAINTYPE_STRING:
{ String str((TCHAR*)vch.data());
if(putField(i,str)) return;
break;
}
case MAINTYPE_VARCHAR:
if(putField(i,vch)) return;
break;
}
}
break;
case MAINTYPE_DATE :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Date d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
case MAINTYPE_TIME :
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Time d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
case MAINTYPE_TIMESTAMP:
{ if(!tupField.isDefined()) {
setUndefinedField(i);
return;
}
Timestamp d;
tupField.get(d);
keydef.put(m_key, i, d);
}
break;
default:
throwSqlError(SQL_FATAL_ERROR,_T("TableCursorKey:Invalid DbMainType :%d")
,getMainType(tupleType));
break;
}
}
}
DbMainType SqlCompiler::checkValueExpressionMainType(const SyntaxNode *expr) {
DbMainType m1,m2,m3;
int i;
switch(expr->token()) {
case MULT :
case DIVOP :
case MODOP :
case EXPO :
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
if(m1 != MAINTYPE_NUMERIC && m1 != MAINTYPE_VOID)
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case PLUS :
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
m2 = checkValueExpressionMainType(expr->child(1));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
switch(checkValueExpressionMainType(expr->child(1))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_DATE;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_DATE :
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
break;
case MAINTYPE_VOID:
m2 = checkValueExpressionMainType(expr->child(1));
if(m2 != MAINTYPE_NUMERIC && m2 != MAINTYPE_VOID)
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_VOID;
}
break;
case MINUS :
if(expr->childCount() < 2) {
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
syntaxError(expr,SQL_INVALID_EXPR_TYPE,_T("Unary minus not allowed on Date"));
return MAINTYPE_DATE;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
}
else {
switch(checkValueExpressionMainType(expr->child(0))) {
case MAINTYPE_NUMERIC:
if(checkValueExpressionMainType(expr->child(1)) != MAINTYPE_NUMERIC)
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case MAINTYPE_DATE :
switch(checkValueExpressionMainType(expr->child(1))) {
case MAINTYPE_NUMERIC:
return MAINTYPE_DATE;
case MAINTYPE_STRING :
case MAINTYPE_VARCHAR:
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_DATE;
case MAINTYPE_DATE :
return MAINTYPE_NUMERIC;
case MAINTYPE_VOID :
return MAINTYPE_VOID;
}
break;
case MAINTYPE_VOID:
return MAINTYPE_VOID;
}
}
break;
case SUBSTRING:
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
m3 = checkValueExpressionMainType(expr->child(2));
if(!isCompatibleType(m1,MAINTYPE_STRING))
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m2,MAINTYPE_NUMERIC))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m3,MAINTYPE_NUMERIC))
syntaxError(expr->child(2),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_STRING;
case CONCAT:
m1 = checkValueExpressionMainType(expr->child(0));
m2 = checkValueExpressionMainType(expr->child(1));
if(!isCompatibleType(m1,MAINTYPE_STRING))
syntaxError(expr->child(0),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
if(!isCompatibleType(m2,MAINTYPE_STRING))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_STRING;
case TYPEDATE:
for(i = 0; i < 3; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_DATE;
case TYPETIME:
for(i = 0; i < 3; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_TIME;
case TYPETIMESTAMP:
for(i = 0; i < 6; i++) {
m1 = checkValueExpressionMainType(expr->child(i));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(i),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
}
return MAINTYPE_TIMESTAMP;
case COUNT :
if(expr->child(0)->token() == STAR)
return MAINTYPE_NUMERIC;
else
checkValueExpressionMainType(expr->child(0)->child(0));
return MAINTYPE_NUMERIC;
case MIN :
case MAX :
return checkValueExpressionMainType(expr->child(2));
case SUM :
m1 = checkValueExpressionMainType(expr->child(2));
if(!isCompatibleType(m1,MAINTYPE_NUMERIC))
syntaxError(expr->child(1),SQL_INVALID_EXPR_TYPE,_T("Illegal type of operand"));
return MAINTYPE_NUMERIC;
case NAME :
case DOT :
return MAINTYPE_NUMERIC;
case NUMBER :
return MAINTYPE_NUMERIC;
case STRING :
return MAINTYPE_STRING;
case DATECONST :
return MAINTYPE_DATE;
case TIMECONST :
return MAINTYPE_TIME;
case TIMESTAMPCONST :
return MAINTYPE_TIMESTAMP;
case HOSTVAR :
return getMainType(m_bndstmt.m_inHost[expr->getHostVarIndex()].getType());
case NULLVAL :
return MAINTYPE_VOID;
case CURRENTDATE :
return MAINTYPE_DATE;
case CURRENTTIME :
return MAINTYPE_TIME;
case CURRENTTIMESTAMP:
return MAINTYPE_TIMESTAMP;
case CAST :
{ checkValueExpressionMainType(expr->child(0));
CastParameter p = genCastParameter(expr->child(1));
return getMainType(p.getType());
}
default :
stopcomp(expr);
}
return MAINTYPE_VOID;
}