internal void ModifySelection(CubeMetadata selectionModifier, bool add) { foreach (TreeNode pNode in this.Nodes) { if (selectionModifier.Perspectives.ContainsKey((string)pNode.Tag)) { var perspective = selectionModifier.Perspectives[(string)pNode.Tag]; foreach (TreeNode mgNode in pNode.Nodes) { mgNode.Checked = perspective.MeasureGroups.ContainsKey((string)mgNode.Tag); if (perspective.MeasureGroups.ContainsKey((string)mgNode.Tag)) { var measureGroup = perspective.MeasureGroups[(string)mgNode.Tag]; foreach (TreeNode measureNode in mgNode.LastNode.Nodes) { if (measureGroup.Measures.ContainsKey((string)measureNode.Tag)) { measureNode.Checked = add; CheckParentNode(measureNode, measureNode.Checked); } } } } } } }
public void Write_TwoDimensionsSameMeasureGroup_FileIsCorrectlyBuilt() { var header = GetHeader(); var expectedContent = header + "\"p\";\"mg\";\"m1\";\"[m1]\";\"d1\";\"[d1]\";\"h1\";\"[h1]\";\"l1\";\"[l1]\";\"0\";\"p1\";\"[p1]\"\r\n" + "\"p\";\"mg\";\"m1\";\"[m1]\";\"d2\";\"[d2]\";\"h2\";\"[h2]\";\"l2\";\"[l2]\";\"1\";\"p2\";\"[p2]\"\r\n" ; var expectedFilename = Path.Combine(DiskOnFile.GetDirectoryPath(), "ExpectedCSV-" + MethodBase.GetCurrentMethod() + ".csv"); if (File.Exists(expectedFilename)) { File.Delete(expectedFilename); } File.AppendAllText(expectedFilename, expectedContent, Encoding.UTF8); var filename = Path.Combine(DiskOnFile.GetDirectoryPath(), @"ActualCSV-" + MethodBase.GetCurrentMethod() + ".csv"); var metadata = new CubeMetadata(); var p = new Perspective("p"); metadata.Perspectives.Add(p); var mg = new MeasureGroup("mg"); p.MeasureGroups.Add(mg); var m1 = new Measure("[m1]", "m1", "df"); mg.Measures.Add(m1); var d1 = new Dimension("[d1]", "d1"); mg.LinkedDimensions.Add(d1); var h1 = new Hierarchy("[h1]", "h1", "df"); d1.Hierarchies.Add(h1); var l1 = new Level("[l1]", "l1", 0); h1.Levels.Add(l1); var p1 = new Property("[p1]", "p1"); l1.Properties.Add(p1); var d2 = new Dimension("[d2]", "d2"); mg.LinkedDimensions.Add(d2); var h2 = new Hierarchy("[h2]", "h2", "df"); d2.Hierarchies.Add(h2); var l2 = new Level("[l2]", "l2", 1); h2.Levels.Add(l2); var p2 = new Property("[p2]", "p2"); l2.Properties.Add(p2); //set the object to test var mcw = new MetadataCsvWriter(filename); mcw.Write(metadata); //Assertion FileAssert.AreEqual(expectedFilename, filename); }
private CubeMetadata BuildFakeMetadata() { var metadata = new CubeMetadata(); var p = new Perspective("p"); var mg = new MeasureGroup("mg"); var h1 = new Hierarchy("[h1]", "h1", "df"); var h2 = new Hierarchy("[h2]", "h2", "df"); var hs = new HierarchyCollection(); hs.Add(h1); hs.Add(h2); var d = new Dimension("[d]", "d", hs); mg.LinkedDimensions.Add(d); var m1 = new Measure("[m1]", "m1", "df"); var m2 = new Measure("[m2]", "m2", "df"); mg.Measures.Add(m1); mg.Measures.Add(m2); p.MeasureGroups.Add(mg); metadata.Perspectives.Add(p); return(metadata); }
private void CheckForComplete(SlicingOptions options, CubeManager manager) { int expectedResults = options.TextureSliceX * options.TextureSliceY; if (StorageUtilities.GetWorkCompletedCount(TableClient, options.CloudResultPath, options.CloudResultContainer) != expectedResults) { return; } var workResults = StorageUtilities.GetWorkCompletedMetadata(TableClient, options.CloudResultPath, options.CloudResultContainer); // Write metadata CubeMetadata metadata = new CubeMetadata(options.CubeGrid) { WorldBounds = manager.ObjInstance.Size, VirtualWorldBounds = options.ForceCubicalCubes ? manager.ObjInstance.CubicalSize : manager.ObjInstance.Size, VertexCount = manager.ObjInstance.VertexList.Count }; // Configure texture slicing metadata if (!string.IsNullOrEmpty(options.Texture) && (options.TextureSliceX + options.TextureSliceY) > 2) { metadata.TextureSetSize = new Vector2(options.TextureSliceX, options.TextureSliceY); } else { metadata.TextureSetSize = new Vector2(1, 1); } var resultsList = workResults.Select(w => SerializationUtilities.DecodeMetadataFromBase64( Texture.GetCubeListFromTextureTile(options.TextureSliceY, options.TextureSliceX, w.TextureTileX, w.TextureTileY, manager.ObjInstance), w.MetadataBase64)); foreach (var result in resultsList) { foreach (var cube in result.Keys) { metadata.CubeExists[cube.X, cube.Y, cube.Z] = result[cube]; } } // Write out some json metadata string metadataPath = Path.Combine(outputPath, "metadata.json"); if (File.Exists(metadataPath)) { File.Delete(metadataPath); } string metadataString = JsonConvert.SerializeObject(metadata); File.WriteAllText(metadataPath, metadataString); StorageUtilities.UpdateSetCompleted(TableClient, options.SetKey); }
public ViewModel() { var years = Enumerable.Range(2019, 70).Select(v => v.ToString()).ToArray(); var units = new[] { "dollar", "kroner", "euro", "yen" }; var reportLevel1 = new[] { "Norway", "Sweden", "Denmark", "Germany", "Finland", "India" }; var reportLevel2 = new[] { "City 1", "City 2", "City 3", "City 4", "City 5" }; var metadataFactory = new DimensionMetadataFactory(); var values = Enumerable.Range(1, 100).Select(v => RandomString(4)).ToArray(); var numProperties = 100; var numValues = 750000; List <object> data = new List <object>(); List <string> fields = Enumerable.Range(1, numProperties).Select(v => $"Item{v}").Concat(new [] { "Value", "ReportLevel1", "ReportLevel2", "Unit", "Year" }).ToList(); var myType = _typeBuilder.GenerateType(fields.Select(f => new DynamicTypePropertyInfo { PropertyName = f, PropertyType = f.Equals("Value") ? typeof(double) : typeof(object) }).ToList()); for (int i = 0; i < numValues; i++) { var obj = Activator.CreateInstance(myType); myType.GetProperty("Unit").SetValue(obj, GetRandomFrom(units)); myType.GetProperty("Year").SetValue(obj, GetRandomFrom(years)); myType.GetProperty("ReportLevel1").SetValue(obj, GetRandomFrom(reportLevel1)); myType.GetProperty("ReportLevel2").SetValue(obj, GetRandomFrom(reportLevel2)); myType.GetProperty("Value").SetValue(obj, 1.0); data.Add(obj); } foreach (var prop in myType.GetProperties().Take(numProperties)) { for (int i = 0; i < numValues; i++) { prop.SetValue(data[i], GetRandomFrom(values), null); } } var cubeMetadata = new CubeMetadata { DataTypeFullName = _typeBuilder.DynamicTypeName, DisplayName = "Pivot" }; fields.ForEach(field => cubeMetadata.DimensionSettings.Add(metadataFactory.Create(field, field, field, field.Equals("Value")))); FlatDataSource = new FlatDataSource { ItemsSource = data, CubesSettings = { cubeMetadata }, DimensionsGenerationMode = DimensionsGenerationMode.Metadata, PreserveMembersOrder = false }; }
internal void SetSelection(CubeMetadata selection) { foreach (TreeNode pNode in this.Nodes) { pNode.Checked = selection.Perspectives.ContainsKey((string)pNode.Tag); if (pNode.Checked) { var perspective = selection.Perspectives[(string)pNode.Tag]; foreach (TreeNode mgNode in pNode.Nodes) { mgNode.Checked = perspective.MeasureGroups.ContainsKey((string)mgNode.Tag); if (mgNode.Checked) { foreach (TreeNode dimNode in mgNode.FirstNode.Nodes) { dimNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].LinkedDimensions.ContainsKey((string)dimNode.Tag); mgNode.FirstNode.Checked = dimNode.Checked || mgNode.FirstNode.Checked; if (dimNode.Checked) { foreach (TreeNode hierarchyNode in dimNode.Nodes) { hierarchyNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag]. LinkedDimensions[(string)dimNode.Tag]. Hierarchies.ContainsKey((string)hierarchyNode.Tag); if (hierarchyNode.Checked) { foreach (TreeNode levelNode in hierarchyNode.Nodes) { levelNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag]. LinkedDimensions[(string)dimNode.Tag]. Hierarchies[(string)hierarchyNode.Tag]. Levels.ContainsKey((string)levelNode.Tag); } } } } } foreach (TreeNode measureNode in mgNode.LastNode.Nodes) { measureNode.Checked = perspective.MeasureGroups[(string)mgNode.Tag].Measures.ContainsKey((string)measureNode.Tag); mgNode.LastNode.Checked = measureNode.Checked || mgNode.LastNode.Checked; } } } } } }
/// <summary> /// Import a single cube part into the cube designer from the Content\Cubes folder. /// </summary> public void Import(string path) { try { var contentPath = path.MakeContentRelative(); if (contentPath == string.Empty) { return; } // Find or create cube metadata. var metadataPath = Path.ChangeExtension(path, ".metadata"); CubeMetadata cmd; if (File.Exists(metadataPath)) { cmd = Serializer.ReadXML <CubeMetadata>(CubeMetadata.CubeMetadataSerializer, metadataPath); cmd.LoadContent(MainGame); } else { cmd = new CubeMetadata() { ContentPath = contentPath }; cmd.LoadContent(MainGame); cmd.Serialize(metadataPath); $"Creating {Path.GetFileName(metadataPath)}...".Log(); } // Deduce part type from path. var _part = contentPath.Split('\\')[1]; CubePart part = (CubePart)Enum.Parse(typeof(CubePart), _part, true); // Add to part specific collection. if (part == CubePart.Top) { CubeTopCollection.Add(new CubeDesignerItem(this, path, cmd)); } else if (part == CubePart.Base) { CubeBaseCollection.Add(new CubeDesignerItem(this, path, cmd)); } } catch (Exception e) { e.Message.Log(); } }
private void openMetadataToolStripMenuItem_Click(object sender, System.EventArgs e) { var cfg = Configuration.Project.Directories[Configuration.DirectoryCollection.DirectoryType.Metadata]; using (var ofd = new OpenFileDialog()) { ofd.InitialDirectory = cfg.FullPath; ofd.FileName = cfg.File; ofd.Filter = "CSV|*.csv|Excel 97-2003|*.xls"; if (!string.IsNullOrEmpty(cfg.File)) { ofd.FilterIndex = cfg.File.EndsWith("csv") ? 1 : 2; } if (ofd.ShowDialog() == DialogResult.OK) { var mr = MetadataFactory.GetReader(ofd.FileName); var openMetadataDetailsForm = new MetadataOpen(); if (mr.SupportSheets) { openMetadataDetailsForm.MetadataReader = mr; openMetadataDetailsForm.ShowDialog(); } StartClick(null); metadataTreeview.Nodes.Clear(); mr.ProgressStatusChanged += new ProgressStatusHandler(ProgressStatus); Metadata = mr.Read(); mr.ProgressStatusChanged -= new ProgressStatusHandler(ProgressStatus); metadataTreeview.Content = Metadata; if (mr.SupportSheets && openMetadataDetailsForm.Track != "None") { var perspTrack = mr.Read(openMetadataDetailsForm.Track); metadataTreeview.Selection = perspTrack; } cfg.FullFileName = ofd.FileName; EndClick(null); } } }
public void FindMeasures_OneLetterExistingInNoCaptions_ZeroMatches() { //Buiding object used during test var cm = new CubeMetadata(); cm.Perspectives.Add(new Perspective("p")); cm.Perspectives["p"].MeasureGroups.Add(new MeasureGroup("mg")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m1]", "m1", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m2]", "m2", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m3]", "xm3x", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m4]", "4", "df")); //Call the method to test var res = cm.FindMeasures("z"); //Assertion Assert.That(res.Perspectives.Count, Is.EqualTo(0)); }
public string[] Build(CubeMetadata metadata, string hierarchyFunction, string slicer, bool notEmpty) { var i = 0; var total = metadata.GetItemsCount(); if (ProgressStatusChanged != null) { ProgressStatusChanged(this, new ProgressStatusEventArgs(string.Format("Creating query set"))); } var res = new List <string>(); foreach (var p in metadata.Perspectives) { foreach (var mg in p.Value.MeasureGroups) { foreach (var dim in mg.Value.LinkedDimensions) { foreach (var hierarchy in dim.Value.Hierarchies) { foreach (var m in mg.Value.Measures) { var mdx = BuildMdx(p.Value.Name, m.Value.UniqueName, hierarchy.Value.UniqueName, hierarchyFunction, slicer, notEmpty); if (!string.IsNullOrEmpty(PersistancePath)) { i++; var filename = BuildFilename(p.Value.Name, mg.Value.Name, m.Value.Caption, dim.Value.Caption, hierarchy.Value.Caption); Persist(mdx, filename); if (ProgressStatusChanged != null) { ProgressStatusChanged(this, new ProgressStatusEventArgs(String.Format("Persisting query set {0} of {1}", i, total), i, total)); } } res.Add(mdx); } } } } } if (ProgressStatusChanged != null) { ProgressStatusChanged(this, new ProgressStatusEventArgs(string.Format("Query set created"))); } return(res.ToArray()); }
public void FindMeasures_ComplexRegexMatchingTwoCaptions_TwoMatches() { //Buiding object used during test var cm = new CubeMetadata(); cm.Perspectives.Add(new Perspective("p")); cm.Perspectives["p"].MeasureGroups.Add(new MeasureGroup("mg")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m1]", "m1", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m2]", "m2", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m3]", "xm3x", "df")); cm.Perspectives["p"].MeasureGroups["mg"].Measures.Add(new Measure("[m4]", "4", "df")); //Call the method to test var res = cm.FindMeasures("m[0-9]$"); //Assertion Assert.That(res.Perspectives.Count, Is.EqualTo(1)); Assert.That(res.Perspectives["p"].MeasureGroups.Count, Is.EqualTo(1)); Assert.That(res.Perspectives["p"].MeasureGroups["mg"].Measures.Count, Is.EqualTo(2)); }
private void extractMetadataToolStripMenuItem_Click(object sender, EventArgs e) { var extractForm = new MetadataExtract(); var cfg = Configuration.Project.ConnectionStrings[ Configuration.ConnectionStringCollection.ConnectionClass.Adomd, Configuration.ConnectionStringCollection.ConnectionType.Expect ]; extractForm.ConnectionString = cfg.Value; if (extractForm.ShowDialog() == System.Windows.Forms.DialogResult.OK) { StartClick(null); var metadataExtractor = extractForm.MetadataExtractor; metadataExtractor.ProgressStatusChanged += new ProgressStatusHandler(ProgressStatus); try { Metadata = metadataExtractor.GetFullMetadata(); } catch (ConnectionException ex) { MessageBox.Show(ex.Message, "Cannot connect with connectionString", MessageBoxButtons.OK, MessageBoxIcon.Exclamation); } finally { metadataExtractor.ProgressStatusChanged -= new ProgressStatusHandler(ProgressStatus); if (Metadata != null) { metadataTreeview.Content = Metadata; } cfg.Value = extractForm.ConnectionString; EndClick(null); } } }
public CubeDesignerItem(CubeDesignerViewModel viewModel, string imagePath, CubeMetadata cmd) : base(imagePath, cmd) { SourceRect = new Int32Rect(0, 0, 72, 75); ViewModel = viewModel; CubeMetadata = cmd; }
public FindMeasures(CubeMetadata metadata) { InitializeComponent(); _metadata = metadata; Settings = new SettingsFindMeasures(); }
public string[] Build(CubeMetadata metadata) { return(this.Build(metadata, "Children", "", false)); }
internal TreeNode[] MapContent(CubeMetadata metadata) { var tnc = new List <TreeNode>(); if (metadata == null) { return(tnc.ToArray()); } foreach (var perspective in metadata.Perspectives) { var pNode = new TreeNode(perspective.Value.Name); pNode.Tag = perspective.Key; tnc.Add(pNode); foreach (var mg in perspective.Value.MeasureGroups) { var mgNode = new TreeNode(mg.Value.Name); mgNode.Tag = mg.Key; pNode.Nodes.Add(mgNode); var dimsNode = new TreeNode("Linked dimensions"); mgNode.Nodes.Add(dimsNode); foreach (var dim in mg.Value.LinkedDimensions) { var dimNode = new TreeNode(dim.Value.Caption); dimNode.Tag = dim.Key; dimsNode.Nodes.Add(dimNode); foreach (var h in dim.Value.Hierarchies) { var hNode = new TreeNode(h.Value.Caption); hNode.Tag = h.Key; dimNode.Nodes.Add(hNode); foreach (var l in h.Value.Levels) { var lNode = new TreeNode(l.Value.Caption); lNode.Tag = l.Key; hNode.Nodes.Add(lNode); foreach (var p in l.Value.Properties) { var propNode = new TreeNode(p.Value.Caption); propNode.Tag = p.Key; lNode.Nodes.Add(propNode); } } } } var measuresNode = new TreeNode("Measures"); mgNode.Nodes.Add(measuresNode); foreach (var measure in mg.Value.Measures) { var measureNode = new TreeNode(measure.Value.Caption); measureNode.Tag = measure.Key; measuresNode.Nodes.Add(measureNode); } } } return(tnc.ToArray()); }
public string[] Build(CubeMetadata metadata, string hierarchyFunction, string slicer) { return(this.Build(metadata, hierarchyFunction, slicer, false)); }
public string[] Build(CubeMetadata metadata, bool notEmpty) { return(this.Build(metadata, "Children", "", notEmpty)); }
internal CubeMetadata GetSelection() { CubeMetadata sel = new CubeMetadata(); foreach (TreeNode perspNode in this.Nodes) { var selPersp = Content.Perspectives[(string)perspNode.Tag].Clone(); sel.Perspectives.Add(selPersp); foreach (TreeNode mgNode in perspNode.Nodes) { if (mgNode.Checked) { var selMg = selPersp.MeasureGroups[(string)mgNode.Tag]; foreach (TreeNode dimNode in mgNode.FirstNode.Nodes) { if (dimNode.Checked) { var cleanDim = Content.Perspectives[(string)perspNode.Tag].Dimensions[(string)dimNode.Tag].Clone(); //NOT A TRUE CLONE !!!! cleanDim.Hierarchies.Clear(); selMg.LinkedDimensions.Add(cleanDim); foreach (TreeNode hierarchyNode in dimNode.Nodes) { if (hierarchyNode.Checked) { var cleanHierarchy = Content.Perspectives[(string)perspNode.Tag] .Dimensions[(string)dimNode.Tag] .Hierarchies[(string)hierarchyNode.Tag].Clone(); cleanHierarchy.Levels.Clear(); selMg.LinkedDimensions[(string)dimNode.Tag].Hierarchies.Add(cleanHierarchy); foreach (TreeNode levelNode in hierarchyNode.Nodes) { if (levelNode.Checked) { selMg.LinkedDimensions[(string)dimNode.Tag] .Hierarchies[(string)hierarchyNode.Tag].Levels.Add((string)levelNode.Tag, Content.Perspectives[(string)perspNode.Tag] .Dimensions[(string)dimNode.Tag] .Hierarchies[(string)hierarchyNode.Tag] .Levels[(string)levelNode.Tag] .Clone()); } } } } } } foreach (TreeNode measureNode in mgNode.LastNode.Nodes) { if (measureNode.Checked) { selMg.Measures.Add(Content.Perspectives[(string)perspNode.Tag].MeasureGroups[(string)mgNode.Tag].Measures[(string)measureNode.Tag].Clone()); } } } } } return(sel); }
public static CubeMetadata GetCubeMetadata(AdomdConnection conn, string cubeName) { if (conn == null) { throw new ArgumentNullException("conn"); } if (string.IsNullOrEmpty(cubeName)) { throw new ArgumentNullException("cubeName"); } var cubeMetadata = new CubeMetadata(); cubeMetadata.CubeName = SSASHelper.RemoveBrackets(cubeName); // Measures var dtMeasures = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_MEASURES, "[MEASURE_IS_VISIBLE]", null, null, cubeName); foreach (var dr in dtMeasures.AsEnumerable()) { var newRow = cubeMetadata.Measures.NewRow(); newRow["Name"] = dr.Field <string>("MEASURE_CAPTION"); newRow["UniqueName"] = dr.Field <string>("MEASURE_UNIQUE_NAME"); newRow["MeasureGroupName"] = dr.Field <string>("MEASUREGROUP_NAME"); newRow["MeasureDisplayFolder"] = dr.Field <string>("MEASURE_DISPLAY_FOLDER"); cubeMetadata.Measures.Rows.Add(newRow); } // Dimensions var dtDimensions = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_DIMENSIONS , null, null, null, cubeName).AsEnumerable().ToList(); // Dimensions vs MG relations var listDimensionsAndMG = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_MEASUREGROUP_DIMENSIONS , string.Empty, null, null, cubeName) .AsEnumerable().ToList(); foreach (var dr in dtDimensions) { var newRow = cubeMetadata.Dimensions.NewRow(); newRow["Name"] = dr.Field <string>("DIMENSION_CAPTION"); var dimensionUniqueName = dr.Field <string>("DIMENSION_UNIQUE_NAME"); newRow["UniqueName"] = dimensionUniqueName; var type = dr.Field <short>("DIMENSION_TYPE"); // 2: Measure dimension if (type == 2) { continue; } newRow["Type"] = type.ToString(); var measureGroups = listDimensionsAndMG.Where(m => m.Field <string>("DIMENSION_UNIQUE_NAME").EqualsCI(dimensionUniqueName)) .Select(s => s.Field <string>("MEASUREGROUP_NAME")) .Distinct(); newRow["MeasureGroupName"] = string.Join(",", measureGroups); cubeMetadata.Dimensions.Rows.Add(newRow); } // Hierarchies var dtHierarchies = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_HIERARCHIES , "[HIERARCHY_IS_VISIBLE] and [HIERARCHY_UNIQUE_NAME] <> '[Measures]'", null, null, cubeName).AsEnumerable().ToList(); foreach (var hRow in dtHierarchies.AsEnumerable()) { var newRow = cubeMetadata.Hierarchies.NewRow(); newRow["Name"] = hRow.Field <string>("HIERARCHY_CAPTION"); newRow["UniqueName"] = hRow.Field <string>("HIERARCHY_UNIQUE_NAME"); newRow["Type"] = Convert.ToInt32(hRow["HIERARCHY_ORIGIN"].IgnoreDBNull()) == 1 ? "User" : "Attribute"; newRow["DimensionUniqueName"] = hRow.Field <string>("DIMENSION_UNIQUE_NAME"); cubeMetadata.Hierarchies.Rows.Add(newRow); } // Levels var dtLevels = GetSchemaRowset(conn, SSAS_RowSets.MDSCHEMA_LEVELS , "[LEVEL_IS_VISIBLE] and [HIERARCHY_UNIQUE_NAME] <> '[Measures]'", null, null, cubeName).AsEnumerable().ToList(); foreach (var dr in dtLevels) { var newRowLevel = cubeMetadata.Levels.NewRow(); newRowLevel["Name"] = dr.Field <string>("LEVEL_CAPTION"); newRowLevel["UniqueName"] = dr.Field <string>("LEVEL_UNIQUE_NAME"); newRowLevel["Type"] = dr.Field <int>("LEVEL_TYPE").ToString(); newRowLevel["HierarchyUniqueName"] = dr.Field <string>("HIERARCHY_UNIQUE_NAME"); newRowLevel["Number"] = dr.Field <uint>("LEVEL_NUMBER"); newRowLevel["Cardinality"] = dr.Field <uint>("LEVEL_CARDINALITY"); cubeMetadata.Levels.Rows.Add(newRowLevel); } return(cubeMetadata); }