atscale-3705: mdxCell incorrectly showing `1`

MdxSpecialQueryHandler.scala

def handleExcelUnionForTopCountAndBottomCount(cube: Cube, queryAxes: Map[Int, Axis], targetLevel: FlatLevel) = {
    logger.warn("ExcelUnionBothTopBottomCount applied")

    // As we go down levels we have to build out the names and keys
    case class RowLevel(fl: FlatLevel, nameIndices: Seq[Int], keyIndices: Seq[Seq[Int]])

    def getRowLevels(levels: IndexedSeq[FlatLevel], idx: Int, rowIdx: Int, prevRowLevel: Option[RowLevel]): Seq[RowLevel] = {
      if (idx < levels.size) {
        val (prevNameIndices, prevKeyIndices) = prevRowLevel.map { p => (p.nameIndices, p.keyIndices) }.getOrElse((Seq.empty, Seq.empty))
        val level = levels(idx)
        val fa = level.flatPrimary
        val sortIndex = fa.ordering match {
          case AttributeOrder.SortByFlatKey(k, _) =>
            k.key.columnCount
          case _                                  =>
            0
        }
        val allNameIndices = prevNameIndices :+ (rowIdx + sortIndex)
        val keyIndices = {
          val levelKeys =
            if (fa.key.isDefined) {
              Range(rowIdx + sortIndex + 1, rowIdx + sortIndex + 1 + fa.key.get.key.columnCount).map(i => i)
            } else {
              Seq.empty
            }

          prevKeyIndices :+ levelKeys
        }

        val rl = RowLevel(level, allNameIndices, keyIndices)
        val lastIndex = rowIdx + sortIndex + 1 + fa.key.get.key.columnCount
        rl +: getRowLevels(levels, idx + 1, lastIndex, Some(rl))
      } else {
        Seq.empty
      }
    }

    val requiredLevels = targetLevel.ancestors :+ targetLevel
    val requiredLevelsWithIndex: Seq[RowLevel] = getRowLevels(requiredLevels, 0, 0, None)
    val selection = {
      val requiredAttrs = requiredLevels.map(_.flatPrimary)
      val (selectColumns, _, _) = attributesAndKeysToSelectColumnsWithExtracts(cube, requiredAttrs)
      val ordering = selectColumns.map {
        ColumnOrdering(_, FlatAscending)
      }
      SelectColumns(selectColumns, CubeDataSelection(cube), ordering, Option(1), None)
    }

    val axis0 = {
      val measureTuples = Seq(MdxTuple(new MdxAxisMember(new MeasureMdxMember("__XLTimeValue"))(false, false, 0)))
      val axis0Props = getAxisProperties(0, queryAxes)
      MdxAxis("Axis0", Seq(measuresHierarchy), measureTuples, Some(Seq.empty), axis0Props)
    }
    val targetHier = targetLevel.hierarchy
    val allMember: MdxAxisMember = getAllMember(targetHier)
    val allMemberUniqName: String = allMember.member.uniqueName

    val resultHandler: BulkResultHandler[MdxResult] = BulkResultHandler.functionHandler {
      case SingleResultInfo(data, _) =>
        val members = IndexedSeq(allMember) ++ {
          data
            .flatMap(row =>
              requiredLevelsWithIndex
                .map { case RowLevel(level, nameIndices, keyIndices) =>
                  val mdxMember = {
                    val levelInfo = {
                      new MdxLevel(
                        hierarchy = MdxHierarchy(level.hierarchy),
                        uniqueName = level.uniqueName,
                        levelNumber = level.depth,
                          namePhysicalType = level.flatPrimary.physicalType,
                          keyPhysicalTypes = attributeKeyPhysicalTypes(level.flatPrimary),
                          parentLevelUniqueName = Option(allMemberUniqName)
                        )
                      }
                      val primary: FlatAttribute = level.flatPrimary
                      val nameCols: Seq[String] = nameIndices.map { nameIndex =>
                        val value: Any = row(nameIndex)
                        safeName(primary, value)
                      }
                      val keyCols: Seq[Seq[String]] = keyIndices.map { keyIndex =>
                        val keyCol = keyIndex.map { i =>
                          val fk = primary.key.get
                          val value = row(i)
                          safeKey(fk, i, value).toString
                        }
                        keyCol
                      }.toVector
                    val caption = nameCols.last
                    val nameAndKeyCols = nameCols.zip(keyCols)
                    DimensionMdxMember(caption, levelInfo, Seq.empty, null, nameAndKeyCols)
                  }
                  val childCount = MdxLanguageResultProcessor.fakeChildCount(level)
                  new MdxAxisMember(mdxMember)(false, false, childCount)
                }
            )
        }
        val dataSetInfo = {
          val axes = {
            val axis1 = {
              val hierarchy = MdxHierarchy(targetLevel.hierarchy)
              val axis1Props = getAxisProperties(1, queryAxes)
              MdxAxis(
                "Axis1",
                Seq(hierarchy),
                members.map(MdxTuple(_)),
                Some(requiredLevels.map(MdxLevel(_))),
                axis1Props
              )
            }
            val slicerAxis = MdxLanguageResultProcessor.getSlicerAxis(cube, pCtx.projectId, None, Set(targetHier.uniqueName))
            Vector(axis0, axis1, slicerAxis)
          }
          val cells = membersToCells(members, allMemberUniqName, Option("#"))
          new DataSetInfo(cube.name, axes, cells, Seq(CellValue))
        }
        dataSetInfo
      case other                     =>
        logger.warn(s"Unsupported Excel search query result: $other")
        throw new MdxException("Currently unsupported Excel search query result")
    }
    val result = QueryLanguageResult(LogicalPlan(pCtx.withCube(cube).cube, selection, hints), pCtx, resultHandler)
    result
  }