bool HqlCppCaseInfo::buildReturn(BuildCtx & ctx)
{
if (pairs.ordinality() == 0)
{
translator.buildReturn(ctx, defaultValue);
}
else if (cond.get() && constantCases)
{
processBranches();
BuildCtx subctx(ctx);
CHqlBoundExpr test;
buildSwitchCondition(ctx, test);
if (complexCompare)
{
buildGeneralReturn(subctx);
}
else
{
//if canBuildArrayLookup(test)
//if use a lookup table to map value->constants
if (test.queryType()->getTypeCode() != type_real)
buildSwitchMap(subctx, NULL, test.expr);
else
buildGeneralReturn(subctx);
}
}
else
buildGeneralReturn(ctx);
return true;
}
void CChildSetColumnInfo::setColumn(HqlCppTranslator & translator, BuildCtx & ctx, IReferenceSelector * selector, IHqlExpression * _value)
{
OwnedHqlExpr address = getColumnAddress(translator, ctx, selector, boolType, 0);
OwnedHqlExpr addressSize = getColumnAddress(translator, ctx, selector, sizetType, sizeof(bool));
OwnedHqlExpr addressData = getColumnAddress(translator, ctx, selector, queryType(), sizeof(bool)+sizeof(size32_t));
OwnedHqlExpr isAllTarget = convertAddressToValue(address, boolType);
OwnedHqlExpr lengthTarget = convertAddressToValue(addressSize, sizetType);
ITypeInfo * columnType = column->queryType();
ITypeInfo * elementType = columnType->queryChildType();
OwnedHqlExpr value = ensureExprType(_value, columnType);
OwnedHqlExpr inlineSize;
switch (value->getOperator())
{
case no_list:
if ((value->numChildren() != 0) && ::isFixedSize(elementType))
inlineSize.setown(getSizetConstant(value->numChildren() * elementType->getSize()));
break;
}
if (inlineSize)
{
checkAssignOk(translator, ctx, selector, inlineSize, sizeof(size32_t)+sizeof(bool));
Owned<IHqlCppSetBuilder> builder = translator.createInlineSetBuilder(elementType, isAllTarget, inlineSize, addressData);
builder->buildDeclare(ctx);
translator.buildSetAssign(ctx, builder, value);
CHqlBoundTarget boundTarget;
boundTarget.length.set(lengthTarget);
builder->buildFinish(ctx, boundTarget);
}
else
{
CHqlBoundExpr bound;
if ((value->getOperator() == no_list) && value->numChildren())
{
CHqlBoundTarget tempTarget;
translator.createTempFor(ctx, columnType, tempTarget, typemod_none, FormatNatural);
translator.buildExprAssign(ctx, tempTarget, value);
bound.setFromTarget(tempTarget);
}
else
translator.buildExpr(ctx, value, bound);
ensureSimpleLength(translator, ctx, bound);
OwnedHqlExpr isAll = bound.getIsAll();
OwnedHqlExpr length = translator.getBoundLength(bound);
OwnedHqlExpr size = createValue(no_translated, LINK(sizetType), translator.getBoundSize(bound));
checkAssignOk(translator, ctx, selector, size, sizeof(size32_t)+sizeof(bool));
translator.assignBoundToTemp(ctx, isAllTarget, isAll);
translator.assignBoundToTemp(ctx, lengthTarget, length);
translator.buildBlockCopy(ctx, addressData, bound);
ensureSimpleLength(translator, ctx, bound);
OwnedHqlExpr boundSize = translator.getBoundSize(bound);
associateSizeOf(ctx, selector, boundSize, sizeof(size32_t)+sizeof(bool));
}
}
void HqlCppCaseInfo::buildChop2Map(BuildCtx & ctx, const CHqlBoundTarget & target, CHqlBoundExpr & test, unsigned start, unsigned end)
{
BuildCtx subctx(ctx);
if ((end - start) <= 3) // (1,2,3) avg(2) cf. (2,2,3) avg(2.3)
{
//optimize the case where they all create the same value
bool same = true;
unsigned index;
for (index=start+1; index < end; ++index)
{
if (queryReturn(index-1) != queryReturn(index))
{
same = false;
break;
}
}
if (same)
{
CompoundBuilder cb(no_or);
for (index=start; index < end; ++index)
{
IHqlExpression * compare = queryCompare(index);
IHqlExpression * cond = createCompareExpr(no_eq, test.getTranslatedExpr(), LINK(compare));
cb.addOperand(cond);
}
OwnedHqlExpr compound = cb.getCompound();
translator.buildFilter(subctx, compound);
translator.buildExprAssign(subctx, target, queryReturn(start));
}
else
{
IHqlStmt * stmt = NULL;
for (index=start; index < end; ++index)
{
if (stmt)
subctx.selectElse(stmt);
IHqlExpression * compare = queryCompare(index);
OwnedHqlExpr cond = createCompareExpr(no_eq, test.getTranslatedExpr(), LINK(compare));
CHqlBoundExpr bound;
translator.buildExpr(subctx, cond, bound);
stmt = subctx.addFilter(bound.expr);
translator.buildExprAssign(subctx, target, queryReturn(index));
}
}
}
else
{
unsigned mid = start + (end - start) / 2;
IHqlExpression * compare = queryCompare(mid);
OwnedHqlExpr cond = createCompareExpr(no_lt, test.getTranslatedExpr(), LINK(compare));
CHqlBoundExpr bound;
translator.buildExpr(subctx, cond, bound);
IHqlStmt * stmt = subctx.addFilter(bound.expr);
buildChop2Map(subctx, target, test, start, mid);
subctx.selectElse(stmt);
buildChop2Map(subctx, target, test, mid, end);
}
}
bool HqlCppCaseInfo::buildAssign(BuildCtx & ctx, const CHqlBoundTarget & target)
{
if (pairs.ordinality() == 0)
{
translator.buildExprAssign(ctx, target, defaultValue);
}
else if (cond.get() && constantCases)
{
processBranches();
BuildCtx subctx(ctx);
CHqlBoundExpr test;
buildSwitchCondition(ctx, test);
if (complexCompare)
{
if (pairs.ordinality() > INLINE_COMPARE_THRESHOLD)
{
if (okToAlwaysEvaluateDefault() || hasLibraryChop())
buildLoopChopMap(subctx, target, test);
else
buildGeneralAssign(subctx, target);
}
else
{
if (okToAlwaysEvaluateDefault())
buildChop3Map(subctx, target, test);
else
buildGeneralAssign(subctx, target);
}
}
else
{
ITypeInfo * condType = test.queryType()->queryPromotedType();
if (!queryBuildArrayLookup(subctx, target, test))
{
if (condType->getTypeCode() != type_real)
{
OwnedHqlExpr search = test.getTranslatedExpr();
if (constantValues && (condType->getTypeCode() == type_int) && (pairs.ordinality() > INTEGER_SEARCH_THRESHOLD) && canBuildStaticList(resultType))
buildIntegerSearchMap(subctx, target, search);
else
buildSwitchMap(subctx, &target, test.expr);
}
else
{
if (okToAlwaysEvaluateDefault() && pairs.ordinality() > 4)
{
translator.buildExprAssign(ctx, target, defaultValue);
buildChop2Map(subctx, target, test, 0, pairs.ordinality());
}
else
buildGeneralAssign(subctx, target);
}
}
}
}
else
buildGeneralAssign(ctx, target);
return true;
}
virtual void getBound(CHqlBoundExpr & result) {
result.set(bound);
}
IHqlExpression * HqlCppCaseInfo::buildIndexedMap(BuildCtx & ctx, const CHqlBoundExpr & test)
{
ITypeInfo * compareType = test.queryType()->queryPromotedType();
type_t compareTypeCode = compareType->getTypeCode();
HqlExprArray values;
IHqlExpression * dft = queryActiveTableSelector(); // value doesn't matter as long as it will not occur
__int64 lower = getIntValue(lowerTableBound, 0);
unsigned num = (getIntValue(upperTableBound, 0)-lower)+1;
CHqlBoundExpr indexExpr;
switch (compareTypeCode)
{
case type_int:
indexExpr.set(test);
break;
case type_string:
indexExpr.expr.setown(createValue(no_index, makeCharType(), LINK(test.expr), getZero()));
indexExpr.expr.setown(createValue(no_cast, makeIntType(1, false), LINK(indexExpr.expr)));
break;
default:
throwUnexpectedType(compareType);
}
if (useRangeIndex && (num != 1))
translator.ensureSimpleExpr(ctx, indexExpr);
OwnedHqlExpr mapped;
ITypeInfo * retType = resultType;
//if num == pairs.ordinality() and all results are identical, avoid the table lookup.
if (allResultsMatch && (num == pairs.ordinality()))
{
mapped.set(pairs.item(0).queryChild(1));
}
else
{
values.ensure(num);
unsigned idx;
for (idx = 0; idx < num; idx++)
values.append(*LINK(dft));
ForEachItemIn(idx2, pairs)
{
IHqlExpression & cur = pairs.item(idx2);
IValue * value = cur.queryChild(0)->queryValue();
unsigned replaceIndex;
switch (compareTypeCode)
{
case type_int:
replaceIndex = (unsigned)(value->getIntValue()-lower);
break;
case type_string:
{
StringBuffer temp;
value->getStringValue(temp);
replaceIndex = (unsigned)((unsigned char)temp.charAt(0)-lower);
break;
}
default:
throwUnexpectedType(compareType);
}
IHqlExpression * mapTo = cur.queryChild(1);
if (mapTo->getOperator() != no_constant)
throwUnexpected();
if (replaceIndex >= num)
translator.reportWarning(CategoryIgnored, HQLWRN_CaseCanNeverMatch, "CASE entry %d can never match the test condition", replaceIndex);
else
values.replace(*LINK(mapTo),replaceIndex);
}
//Now replace the placeholders with the default values.
for (idx = 0; idx < num; idx++)
{
if (&values.item(idx) == dft)
values.replace(*defaultValue.getLink(),idx);
}
// use a var string type to get better C++ generated...
ITypeInfo * storeType = getArrayElementType(resultType);
ITypeInfo * listType = makeArrayType(storeType, values.ordinality());
OwnedHqlExpr lvalues = createValue(no_list, listType, values);
CHqlBoundExpr boundTable;
translator.buildExpr(ctx, lvalues, boundTable);
LinkedHqlExpr tableIndex = indexExpr.expr;
if (getIntValue(lowerTableBound, 0))
tableIndex.setown(createValue(no_sub, tableIndex->getType(), LINK(tableIndex), LINK(lowerTableBound)));
IHqlExpression * ret = createValue(no_index, LINK(retType), LINK(boundTable.expr), LINK(tableIndex));
mapped.setown(createTranslatedOwned(ret));
}
