Inheritance: ISerializable
Exemple #1
0
 private static void AdjustValueFromColumnType(Cell cell, int columnIndex, ResultSet crs)
 {
     // change type was giving odd results when a culture was passed in on the thread, for example German 5.324145E1 came out as 5324145 instead of 53.24145
     // we give it invariant culture to fix this.  It will be up to the end user to apply formatting.
     cell.Value = Convert.ChangeType(cell.Value, crs.Columns[columnIndex].Type ?? ConvertXmlTypeToType(cell.Type), CultureInfo.InvariantCulture);
 }
Exemple #2
0
        private void AddRows(IEnumerable<Tuple> rows, List<Cell> cells, int rowColumnCount, ResultSet crs)
        {
            var start = 0;
            var columnCountFromColumnAxis = crs.Columns.Count - rowColumnCount;
            var finish = columnCountFromColumnAxis - 1;

            var cellsIndexer = 0;
            var cellsCount = cells.Count();
            var ordinal = 0;

            if (!rows.Any() && cells.Count > 0)
            {
                // data coming back from the cube only has cell for actual data, nulls are not represented.  We need to fill in those cells so that the data appears
                // in the correct columns
                var ordinals = cells.Select(a => a.Ordinal);
                Enumerable.Range(0, columnCountFromColumnAxis)
                          .Except(ordinals)
                          .ToList()
                          .ForEach(a => cells.Add(new Cell() { Ordinal = a}));

                cells.ForEach(a => AdjustValueFromColumnType(a, a.Ordinal, crs));

                crs.Rows.Add(new Row() { Cells = cells.OrderBy(a => a.Ordinal).ToList() });
            }
            else
            {
                // tokened maps that get properties from members in the row
                var memberProperties = _columnMap.GetMemberProperties();
                var columnsAdded = memberProperties.Count();
                AddColumnsFromRowProperties(crs, memberProperties);

                foreach (var row in rows)
                {
                    var r = new Row();

                    // main row data
                    foreach (var member in row.Members)
                    {
                        r.Cells.Add(new Cell() { FormattedValue = member.Caption, Value = member.Caption, Ordinal = ordinal++ });

                    }

                    // dimension property row data
                    // this is done as another pass since dimension properties columns are added at the end of normal columns from row
                    foreach (var property in row.Members.Where(member => member.DimensionProperties != null).SelectMany(member => member.DimensionProperties))
                    {
                        r.Cells.Add(new Cell() { FormattedValue = property.Value, Value = property.Value, Ordinal = ordinal++ });
                    }

                    // cells are in a single dimension array, have to determine which row it belongs to to intermix the row data correctly
                    for (var i = start; i <= finish; i++)
                    {
                        var cellToAdd = new Cell();

                        // cell indexer can go past its range, only try to get values while in range
                        if (!(cellsIndexer >= cellsCount))
                        {
                            // get this cell
                            var cell = cells[cellsIndexer];

                            // if the ordinal of the cell is the column we are looking at, add it's values, otherwise an empty cell is added.
                            // this is done because the xml coming back does not include nulls/empty data.  We have to fill in the gap or the subsequent objects will throw the data off
                            if (Convert.ToInt32(cell.Ordinal) == i)
                            {
                                cellToAdd = cell;
                                AdjustValueFromColumnType(cellToAdd, cell.Ordinal % (columnCountFromColumnAxis) + rowColumnCount, crs);
                                cellsIndexer++;
                            }
                        }
                        cellToAdd.Ordinal = ordinal++;
                        r.Cells.Add(cellToAdd);
                    }

                    // go threw the members again, this time for the special columns, this is done here since the columns for them are done at the end
                    // if we tried to adding the cells in the for above, it would through the ordinals off for all cells.
                    if (columnsAdded > 0)
                    {
                        for (var i = 0; i < row.Members.Count; i++ )
                        {
                            var previousCount = r.Cells.Count;
                            r.Cells.AddRange(AddCellsFromMemberProperties(memberProperties, row.Members[i], ordinal, i));
                            if (previousCount != r.Cells.Count)
                            {
                                // advance the ordinal since extra columns were added, the normal process would only take into consideration
                                // the cells visible in ssms
                                ordinal = r.Cells.Last().Ordinal + 1;
                            }
                        }
                    }

                    crs.Rows.Add(r);

                    start += columnCountFromColumnAxis;
                    finish += columnCountFromColumnAxis;
                }
            }
        }
Exemple #3
0
        private static IEnumerable<Cell> AddCellsFromMemberProperties(IEnumerable<ColumnMap> specialColumns, Member member, int cellOrdinal, int columnOrdinal)
        {
            Func<ColumnMap, Cell> newCell = (map) =>
                {
                    object formattedValue = map.GetMemberProperty(member);
                    var value = formattedValue;
                    var type = "string";
                    if (map.IsLevelNumber)
                    {
                        type = "xsd:int";
                        value = Convert.ChangeType(formattedValue, typeof (int), CultureInfo.InvariantCulture);
                    }
                    var cell = new Cell()
                        {
                            Ordinal = cellOrdinal++,
                            FormattedValue = formattedValue,
                            Type = type,
                            Value = value
                        };

                    return cell;
                };

            return specialColumns
                   .Where(a => a.DoesMapMatchMember(member, columnOrdinal))
                   .Select(newCell);
        }