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)); }