ForEachChild(i, record)
{
IHqlExpression * cur = record->queryChild(i);
switch (cur->getOperator())
{
case no_record:
//MORE: If this is a public symbol it should be expanded, otherwise it will be elsewhere.
expandRecordSymbolsMeta(metaTree, cur);
break;
case no_field:
{
IPropertyTree * field = metaTree->addPropTree("Field");
field->setProp("@name", str(cur->queryId()));
StringBuffer ecltype;
cur->queryType()->getECLType(ecltype);
field->setProp("@type", ecltype);
break;
}
case no_ifblock:
{
IPropertyTree * block = metaTree->addPropTree("IfBlock");
expandRecordSymbolsMeta(block, cur->queryChild(1));
break;
}
case no_attr:
case no_attr_link:
case no_attr_expr:
{
IPropertyTree * attr = metaTree->addPropTree("Attr");
attr->setProp("@name", str(cur->queryName()));
break;
}
}
}
void HqlCppCaseInfo::addPair(IHqlExpression * expr)
{
pairs.append(*LINK(expr));
IHqlExpression * compareValue = expr->queryChild(0);
if (!compareValue->queryValue())
constantCases = false;
if (!expr->queryChild(1)->queryValue())
constantValues = false;
if (cond && !complexCompare)
{
ITypeInfo * valueType = compareValue->queryType();
if (valueType != cond->queryType())
complexCompare = isCompare3Valued(compareValue->queryType());
}
updateResultType(expr->queryChild(1));
}
void HqlCppCaseInfo::addPair(IHqlExpression * expr)
{
IHqlExpression * compareExpr = expr->queryChild(0);
IHqlExpression * resultExpr = expr->queryChild(1);
if (allResultsMatch && pairs.ordinality())
{
if (pairs.tos().queryChild(1) != resultExpr)
allResultsMatch = false;
}
pairs.append(*LINK(expr));
if (!compareExpr->queryValue())
{
constantCases = false;
}
else if (constantCases)
{
if (!lowestCompareExpr || compareValues(compareExpr, lowestCompareExpr) < 0)
lowestCompareExpr.set(compareExpr);
if (!highestCompareExpr || compareValues(compareExpr, highestCompareExpr) > 0)
highestCompareExpr.set(compareExpr);
}
if (!expr->queryChild(1)->queryValue())
constantValues = false;
if (cond && !complexCompare)
{
ITypeInfo * valueType = compareExpr->queryType();
if (valueType != cond->queryType())
complexCompare = isCompare3Valued(compareExpr->queryType());
}
updateResultType(resultExpr);
}
ForEachChild(i, record)
{
IHqlExpression * cur = record->queryChild(i);
switch (cur->getOperator())
{
case no_record:
expandFieldNames(errorProcessor, out, cur, prefix, sep, formatFunc);
break;
case no_ifblock:
expandFieldNames(errorProcessor, out, cur->queryChild(1), prefix, sep, formatFunc);
break;
case no_field:
{
StringBuffer lowerName;
lowerName.append(cur->queryName()).toLowerCase();
if (formatFunc)
{
HqlExprArray args;
args.append(*createConstant(lowerName.str()));
OwnedHqlExpr bound = createBoundFunction(NULL, formatFunc, args, NULL, true);
OwnedHqlExpr folded = foldHqlExpression(errorProcessor, bound, NULL, HFOthrowerror|HFOfoldimpure|HFOforcefold);
assertex(folded->queryValue());
lowerName.clear();
getStringValue(lowerName, folded);
}
switch (cur->queryType()->getTypeCode())
{
case type_record:
case type_row:
{
unsigned len = prefix.length();
prefix.append(lowerName).append(".");
expandFieldNames(errorProcessor, out, cur->queryRecord(), prefix, sep, formatFunc);
prefix.setLength(len);
break;
}
default:
{
if (out.length())
out.append(sep);
out.append(prefix).append(lowerName);
break;
}
}
break;
}
}
}
IHqlExpression* HqlGram::processAbstractDataset(IHqlExpression* _expr, IHqlExpression* formal, IHqlExpression* actual, IHqlExpression * mapping, const attribute& errpos, bool errorIfNotFound, bool & hadError)
{
LinkedHqlExpr transformed = _expr;
IHqlExpression* formalRecord = formal->queryRecord();
IHqlExpression* actualRecord = actual->queryRecord();
assertex(formalRecord && actualRecord);
hadError = false;
IHqlSimpleScope *actualScope = actualRecord->querySimpleScope();
unsigned numChildren = formalRecord->numChildren();
for (unsigned idx = 0; idx < numChildren; idx++)
{
IHqlExpression* kid = formalRecord->queryChild(idx);
if ((kid->getOperator() == no_ifblock) || kid->isAttribute())
continue;
IIdAtom * name = kid->queryId();
IIdAtom * mapto = fieldMapTo(mapping, name);
OwnedHqlExpr match = actualScope->lookupSymbol(mapto);
if (match)
{
if (!kid->queryType()->assignableFrom(match->queryType()))
{
StringBuffer fromType, toType;
getFriendlyTypeStr(kid,fromType);
getFriendlyTypeStr(match,toType);
reportError(ERR_DSPARAM_TYPEMISMATCH, errpos, "Can not mapping type %s(field '%s') to %s(field '%s')",
fromType.str(), str(kid->queryName()), toType.str(), str(match->queryName()));
hadError = true;
}
//MORE: This should really be mapped in a single go
if (transformed)
transformed.setown(bindField(transformed, kid, match));
}
else if (errorIfNotFound)
{
reportError(ERR_DSPARM_MISSINGFIELD,errpos,"Dataset %s has no field named '%s'", str(actual->queryName()), str(mapto));
hadError = true;
}
}
return transformed.getClear();
}
