private bool ProcessLeftMouseDown(TreeNode node) { var predicate = null; var func2 = null; RelationNode rNode = node as RelationNode; if (rNode != null) { TreeNode parent = rNode.Parent.Parent; if (!(parent is DynamicSchemaNode)) { parent = parent.Parent; } if (predicate == null) { predicate = < > h__TransparentIdentifier50 => (< > h__TransparentIdentifier50.relationNode != rNode) && (< > h__TransparentIdentifier50.relationNode.Relation == rNode.Relation); } TreeNode node3 = (from <> h__TransparentIdentifier50 in (from tableNode in parent.Nodes.Cast <TreeNode>() from relationNode in tableNode.Nodes.OfType <RelationNode>() select new { tableNode = tableNode, relationNode = relationNode }).Where(predicate) select <> h__TransparentIdentifier50.tableNode).FirstOrDefault <TreeNode>(); if (node3 == null) { if (func2 == null) { func2 = < > h__TransparentIdentifier52 => (< > h__TransparentIdentifier52.relationNode != rNode) && (< > h__TransparentIdentifier52.relationNode.Relation == rNode.Relation); } node3 = (from <> h__TransparentIdentifier52 in (from schemaNode in parent.Nodes.Cast <TreeNode>() from tableNode in schemaNode.Nodes.Cast <TreeNode>() from relationNode in tableNode.Nodes.OfType <RelationNode>() select new { < > h__TransparentIdentifier51 = < > h__TransparentIdentifier51, relationNode = relationNode }).Where(func2) select <> h__TransparentIdentifier52.< > h__TransparentIdentifier51.tableNode).FirstOrDefault <TreeNode>();
private IEnumerator LoadBundle(RelationNode node, LayerLoadParam param) { if (node.Nodes.Count() > 0) { LayerLoadParam layerParam = new LayerLoadParam(); layerParam.layer = param.layer + 1; layerParam.num = 0; for (int i = 0, count = node.Nodes.Count; i < count; i++) { CoroutineHelper.CreateCoroutineHelper(LoadBundle(node.Nodes[i], layerParam)); } while (layerParam.num >= 0 && layerParam.num < node.Nodes.Count) { yield return(null); } if (layerParam.num < 0) { UnLoad(); param.num = -100000; yield break; } } ResLoader.LoadByName(node.File, EndLoadBundle, new LoadInfo() { name = node.File, param = param }, true); }
public void TestRemoveBidirectionalRelation() { TableNode tn; ColumnNode cn; // Returns the Orders table node PrepareEmployeeOrder(out tn, out cn); Assertion.Assert(!cn.Column.IsMapped); Assertion.Assert(!cn.Column.IsMapped); NDOTreeNode treeNode = (NDOTreeNode)FindNode(tn.Nodes, "EmployeeID"); Assertion.AssertNotNull(treeNode); Assertion.Assert("Wrong type #1", treeNode is RelationNode); RelationNode rn = (RelationNode)treeNode; TableNode relTn = rn.RelatedTableNode; // tn is Orders, relTn is Employees treeNode = (NDOTreeNode)FindNode(relTn.Nodes, "EmployeeID", typeof(RelationNode)); Assertion.AssertNotNull(treeNode); RelationNode rn2 = (RelationNode)treeNode; Assertion.Assert(rn2.Relation is ForeignFkRelation); rn.DeleteFkRelation(null, EventArgs.Empty); treeNode = (NDOTreeNode)FindNode(tn.Nodes, "EmployeeID", typeof(RelationNode)); Assertion.AssertNull(treeNode); treeNode = (NDOTreeNode)FindNode(relTn.Nodes, "EmployeeID", typeof(RelationNode)); Assertion.AssertNull(treeNode); }
public void UnmapIntermediateClass(TableNode tn) { foreach (NDOTreeNode trn in tn.Nodes) { RelationNode rn = trn as RelationNode; if (rn == null) { continue; } rn.Remove(); FkRelation fkRelation = rn.Relation as FkRelation; if (fkRelation != null) { if (fkRelation.RelationDirection != RelationDirection.DirectedFromMe) { TableNode relTn = databaseNode.FindTableNode(fkRelation.RelatedTable, true); RelationNode nodeToRemove = relTn.FindRelationNode(rn.Text, tn.Text); if (nodeToRemove != null) { nodeToRemove.Remove(); } } } } }
public void TestIntermediateClassRemove2() { TableNode tn; PrepareOrderDetails(out tn); TreeNodeCollection nodes = ApplicationController.Instance.DatabaseNode.Nodes; TableNode tnOrders = (TableNode)FindNode(nodes, "Orders"); TableNode tnProducts = (TableNode)FindNode(nodes, "Products"); tnProducts.UnmapClass(null, EventArgs.Empty); Assertion.Assert("Mapping type wrong #1", tn.Table.MappingType == TableMappingType.NotMapped); RelationNode rn = tn.FindRelationNode("OrderID", "Orders"); Assertion.AssertNull("Relation to Orders should be removed", rn); rn = tn.FindRelationNode("ProductID", "Products"); Assertion.AssertNull("Relation to Products should be removed", rn); rn = tnOrders.FindRelationNode("OrderID", "Order Details"); Assertion.AssertNull("Relation should be removed", rn); // ApplicationController.Instance.GenerateAssembly(); }
public static FuncDescriptor GetDescriptor(RelationIdentity relation, MetadataIdentity source) { FuncKey key = new FuncKey(relation, source); return(cache.GetOrAdd(key, _ => { ListBuilder listBuilder = new ListBuilder(relation, source); RelationNode relationNode = listBuilder.Build(); FuncBuilder funcBuilder = new FuncBuilder(relationNode); return funcBuilder.Build(); })); }
public void TestIntermediateClass() { TableNode tn; PrepareOrderDetails(out tn); Assertion.Assert("Mapping type wrong #1", tn.Table.MappingType == TableMappingType.MappedAsIntermediateClass); TreeNodeCollection nodes = ApplicationController.Instance.DatabaseNode.Nodes; object o = FindNode(nodes, tn.Text); Assertion.AssertNotNull("Intermediate Class '" + tn.Text + "' not found", o); Assertion.AssertSame("Node should be the same table node", tn, o); RelationNode rn = tn.FindRelationNode("OrderID", "Orders"); Assertion.AssertNotNull("Relation to Orders should be there", rn); Assertion.Assert("Wrong relation type", rn.Relation is FkRelation); rn = tn.FindRelationNode("ProductID", "Products"); Assertion.AssertNotNull("Relation to Products should be there", rn); Assertion.Assert("Wrong relation type", rn.Relation is FkRelation); TableNode tnOrders = (TableNode)FindNode(nodes, "Orders"); rn = tnOrders.FindRelationNode("OrderID", "Order Details"); Assertion.AssertNotNull("OrderID relation not found", rn); TableNode tnProducts = (TableNode)FindNode(nodes, "Products"); // foreach(NDOTreeNode trn in tnProducts.Nodes) // { // RelationNode rn2 = trn as RelationNode; // if (rn2 != null) // { // Debug.WriteLine(rn2.Text + " " + rn2.Relation.GetType().Name); // ForeignFkRelation fkr = rn2.Relation as ForeignFkRelation; // if (fkr != null) // Debug.WriteLine(fkr.RelatedTable); // } // } rn = tnProducts.FindRelationNode("ProductID", "Order Details"); Assertion.AssertNull("Relation is directed", rn); tn.UnmapIntermediateClass(null, EventArgs.Empty); Assertion.Assert("Mapping type wrong #1", tn.Table.MappingType == TableMappingType.NotMapped); rn = tn.FindRelationNode("OrderID", "Orders"); Assertion.AssertNull("Relation to Orders should be removed", rn); rn = tn.FindRelationNode("ProductID", "Products"); Assertion.AssertNull("Relation to Products should be removed", rn); rn = tnOrders.FindRelationNode("OrderID", "Order Details"); Assertion.AssertNull("Relation should be removed", rn); }
public void AddRelSymbol(RelationNode relationNode) { if (symbols.ContainsKey(relationNode.RelationName)) { throw new QueryException($"Symbol {relationNode.RelationName} already present."); } Symbol symbol = new RelationSymbol(relationNode); if (!symbols.ContainsKey(relationNode.RelationName)) { symbols.Add(relationNode.RelationName, symbol); } }
void RemoveRelationNodeFromTable(string tableName, string nodeName) { TableNode tn = (TableNode)databaseNode.FindNode(tableName); if (tn != null) { RelationNode relNode = (RelationNode)tn.FindNode(nodeName, typeof(RelationNode)); if (relNode != null) { relNode.Remove(); } //tn.Nodes. Remove(relNode); } }
/// <summary> /// Builds a normalized relation graph of the anime directly/indirectly realted to the specified anime ID. /// </summary> /// <param name="rootAnimeId">The ID of the anime we're building the graph from.</param> /// <param name="nodes">Returns the graph nodes (Keyed by anime ID).</param> /// <param name="edges">Returns the graph edges.</param> /// <returns><c>true</c> if a graph was built; otherwise, <c>false</c> /// (e.g. if the specified anime has no relations).</returns> private bool BuildGroupGraph(int rootAnimeId, out Dictionary <int, RelationNode> nodes, out HashSet <RelationEdge> edges) { var toVisit = new Queue <int>(); bool first = true; edges = null; nodes = null; toVisit.Enqueue(rootAnimeId); // Traverse the relation graph to build node and edge sets while (toVisit.Count > 0) { int animeId = toVisit.Dequeue(); foreach (AnimeRelation relation in _relationMap[animeId].Where(ShouldConsiderAnimeRelation)) { // For the very first relationship we encounter we need to add a relation node for // the anime it is from (i.e. the "anchor" anime we're using as our starting point for graph traversal) if (first) { var startNode = new RelationNode(relation.FromId, relation.FromType, relation.FromAirDate); edges = new HashSet <RelationEdge>(); nodes = new Dictionary <int, RelationNode> { [relation.FromId] = startNode }; first = false; } var relEdge = new RelationEdge(relation.RelationType, relation.FromId, relation.ToId); edges.Add(relEdge); if (nodes.ContainsKey(relation.ToId)) { continue; // We've already visited this anime } var node = new RelationNode(relation.ToId, relation.ToType, relation.ToAirDate); nodes.Add(node.AnimeId, node); toVisit.Enqueue(node.AnimeId); } } return(nodes != null); }
public RelationNode FindRelationNode(string text, string relatedTableName) { foreach (NDOTreeNode tn in Nodes) { RelationNode rn = tn as RelationNode; if (rn == null) { continue; } if (rn.Text == text && rn.RelatedTableNode.Text == relatedTableName) { return(rn); } } return(null); }
public void DeleteRelation(RelationNode relationNode) { FkRelation fkRelation = relationNode.Relation as FkRelation; TableNode parentNode = null; if (fkRelation == null) { ForeignFkRelation ffkrel = relationNode.Relation as ForeignFkRelation; if (ffkrel == null) { return; } parentNode = (TableNode)this.databaseNode.FindNode(ffkrel.RelatedTable, typeof(TableNode)); relationNode = parentNode.FindRelationNode(relationNode.Text, relationNode.Parent.Text); //(RelationNode) parentNode.FindNode(relationNode.Text, typeof(RelationNode)); fkRelation = (FkRelation)relationNode.Relation; if (parentNode.Table.MappingType == TableMappingType.MappedAsIntermediateClass) { parentNode.UnmapIntermediateClass(null, EventArgs.Empty); return; } } else { parentNode = (TableNode)relationNode.Parent; } //parentNode.Nodes. Remove(relationNode); relationNode.Remove(); parentNode.Nodes.Add(relationNode.OriginalColumnNode); Debug.Assert(fkRelation != null); if (fkRelation != null) { if (fkRelation.RelationDirection != RelationDirection.DirectedFromMe) { TableNode tn = databaseNode.FindTableNode(fkRelation.RelatedTable, true); RelationNode nodeToRemove = tn.FindRelationNode(relationNode.Text, parentNode.Text); if (nodeToRemove != null) { nodeToRemove.Remove(); } } } }
public void MakeForeignKey(ColumnNode columnNode, ForeignKeyWizModel model) { FkRelation fkRelation = null; RelationNode relationNode = null; if (model == null) { fkRelation = new FkRelation(columnNode.Name); relationNode = new RelationNode(fkRelation, columnNode.Parent); } else { fkRelation = (FkRelation)model.RelationNode.Relation; relationNode = model.RelationNode; } fkRelation.OwningTable = ((TableNode)relationNode.Parent).Table.Name; fkRelation.OwningType = ((TableNode)relationNode.Parent).Table.ClassName; IList tableNodes = new ArrayList(); if (model == null) { foreach (TableNode tnode in ((DatabaseNode)columnNode.Parent.Parent).TableNodes) { if (tnode.Table.MappingType == TableMappingType.MappedAsClass) { tableNodes.Add(tnode); } } model = new ForeignKeyWizModel(relationNode, tableNodes); IWizardController controller = ApplicationController.wizardControllerFactory.Create ("ForeignKeyWizController", "ForeignKeyWiz", "Foreign Key Wizard"); //controller.FrameSize = new Size( 544, 408 ); DialogResult r = controller.Run(model); if (r == DialogResult.OK) { MakeForeignKeyRelation(relationNode, columnNode, model); } } else { MakeForeignKeyRelation(relationNode, columnNode, model); } }
public void TestIntermediateTable() { TableNode tn; PrepareEmployeeTerritories(out tn); DatabaseNode dbn = (DatabaseNode)tn.Parent; IntermediateTableNode itn = (IntermediateTableNode)FindNode(dbn.Nodes, "EmployeeTerritories", typeof(IntermediateTableNode)); Assertion.AssertNotNull("IntermediateTableNode not found", itn); Assertion.AssertEquals("Wrong original table", tn, itn.OriginalTableNode); Assertion.AssertEquals("Wrong image", itn.SelectedImageIndex, 13); tn = (TableNode)FindNode(dbn.Nodes, "Employees"); RelationNode rn = (RelationNode)FindNode(tn.Nodes, "EmployeeID", typeof(RelationNode)); Assertion.AssertNotNull("Relation node should exist #1", rn); tn = (TableNode)FindNode(dbn.Nodes, "Territories"); rn = (RelationNode)FindNode(tn.Nodes, "TerritoryID", typeof(RelationNode)); Assertion.AssertNotNull("Relation node should exist #2", rn); // Now unmap and test itn.UnmapIntermediateTable(null, EventArgs.Empty); itn = (IntermediateTableNode)FindNode(dbn.Nodes, "EmployeeTerritories", typeof(IntermediateTableNode)); Assertion.AssertNull("itn should be null", itn); tn = (TableNode)FindNode(dbn.Nodes, "EmployeeTerritories", typeof(TableNode)); Assertion.AssertNotNull("Table node should be back", tn); tn = (TableNode)FindNode(dbn.Nodes, "Employees"); rn = (RelationNode)FindNode(tn.Nodes, "EmployeeID", typeof(RelationNode)); Assertion.AssertNull("Relation node shouldn't be there", rn); tn = (TableNode)FindNode(dbn.Nodes, "Territories"); rn = (RelationNode)FindNode(tn.Nodes, "TerritoryID", typeof(RelationNode)); Assertion.AssertNull("Relation node shouldn't be there #2", rn); }
private void MakeForeignKeyRelation(RelationNode relationNode, ColumnNode columnNode, ForeignKeyWizModel model) { FkRelation fkRelation = (FkRelation)relationNode.Relation; fkRelation.RelatedTable = relationNode.RelatedTableNode.Table.Name; fkRelation.RelatedType = relationNode.RelatedTableNode.Table.ClassName; TableNode tn = (TableNode)columnNode.Parent; //tn.Nodes. Remove(columnNode); columnNode.Remove(); tn.Nodes.Add(relationNode); relationNode.OriginalColumnNode = columnNode; this.assemblyNode.Refresh(); if (fkRelation.RelationDirection == RelationDirection.DirectedToMe || fkRelation.RelationDirection == RelationDirection.Bidirectional) { tn = databaseNode.FindTableNode(fkRelation.RelatedTable, true); RelationNode rn = new RelationNode(fkRelation.ForeignRelation, tn); rn.RelatedTableNode = (TableNode)columnNode.Parent; tn.Nodes.Add(rn); } }
public void MapIntermediateTable(TableNode tn) { IntermediateTable it = new IntermediateTable(tn.Text); IntermediateTableNode itn = new IntermediateTableNode(it, tn); IList tableNodes = databaseNode.TableNodes; tableNodes.Remove(tn); IntermediateTableWizardModel model = new IntermediateTableWizardModel(itn, tableNodes); IWizardController controller = ApplicationController.wizardControllerFactory.Create ("IntermediateTableWizController", "IntTblWiz", "Intermediate Table Wizard"); //controller.FrameSize = new Size(544, 416); DialogResult r = controller.Run(model); if (r == DialogResult.OK) { DatabaseNode parent = (DatabaseNode)tn.Parent; //tn.Parent.Nodes. Remove(tn); int index = parent.Nodes.IndexOf(tn); tn.Remove(); tn.Parent.Nodes.Insert(index, itn); itn.TreeView.SelectedNode = itn; itn.Nodes.Add(tn); // This ensures persisting the column nodes with file/save. RelatedTableInfo rti0 = it[0]; RelatedTableInfo rti1 = it[1]; TableNode relTn0 = null; TableNode relTn1 = null; RelationNode relNode0 = null; RelationNode relNode1 = null; foreach (TableNode loopTn in tableNodes) { if (loopTn.Text == rti0.Table) { relTn0 = loopTn; if (rti0.RelationDirection != RelationDirection.DirectedToMe) { ForeignIntermediateTableRelation fitr = new ForeignIntermediateTableRelation(rti0, tn.Text); relNode0 = new RelationNode(fitr, relTn0); relTn0.Nodes.Add(relNode0); } } if (loopTn.Text == rti1.Table) { relTn1 = loopTn; if (rti1.RelationDirection != RelationDirection.DirectedToMe) { ForeignIntermediateTableRelation fitr = new ForeignIntermediateTableRelation(rti1, tn.Text); relNode1 = new RelationNode(fitr, relTn1); relTn1.Nodes.Add(relNode1); } } } if (relNode0 != null) { relNode0.RelatedTableNode = relTn1; } if (relNode1 != null) { relNode1.RelatedTableNode = relTn0; } } }
/// <summary> /// Initializes static members of the <see cref="RelationBuilder"/> class. /// </summary> static RelationBuilder() { _dataflowToDsd = new RelationNode(RelationType.Descendant, SdmxStructureEnumType.Dataflow, SdmxStructureEnumType.Dsd); _categorisationToDataflow = new RelationNode(RelationType.Descendant, SdmxStructureEnumType.Categorisation, SdmxStructureEnumType.Dataflow); _categorySchemeToCategorisation = new RelationNode(RelationType.Parent, SdmxStructureEnumType.CategoryScheme, SdmxStructureEnumType.Categorisation); _dataflowToCategorisation = new RelationNode(RelationType.Parent, SdmxStructureEnumType.Dataflow, SdmxStructureEnumType.Categorisation); _dsdToDataflow = new RelationNode(RelationType.Parent, SdmxStructureEnumType.Dsd, SdmxStructureEnumType.Dataflow); _codeListToDsd = new RelationNode(RelationType.Parent, SdmxStructureEnumType.CodeList, SdmxStructureEnumType.Dsd); _conceptSchemeToDsd = new RelationNode(RelationType.Parent, SdmxStructureEnumType.ConceptScheme, SdmxStructureEnumType.Dsd); }
public FuncBuilder(RelationNode relationNode) { this.relationNode = relationNode; this.args = new FuncArguments(relationNode.Items.Count); }
public PropertyGenerator(RelationNode rn) { this.relationNode = rn; this.relation = rn.Relation; }
public void RelationNodeTest_TypeCoercion() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L); Expression operandB = Expression.Constant(3.4D); RelationNode sut = new RelationNode(RelationNode.Operator.EQ, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new SimpleValueTestNode(operandB, FieldValueType.FLOAT), expectedLocation); Assert.AreEqual(TNode.RELATION, sut.NodeType); Assert.AreEqual(expectedLocation, sut.Location); Assert.IsTrue(sut.Description.Contains("RELATION")); Assert.IsInstanceOfType(sut.SubExpression, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.Equal, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); Assert.IsInstanceOfType(((BinaryExpression)sut.SubExpression).Left, typeof(UnaryExpression)); UnaryExpression cast = (UnaryExpression)((BinaryExpression)sut.SubExpression).Left; Assert.AreEqual(ExpressionType.Convert, cast.NodeType); Assert.AreEqual(operandA, cast.Operand); Assert.AreEqual(operandB, ((BinaryExpression)sut.SubExpression).Right); }
public RelationSymbol GetRelationSymbol(RelationNode node) { return((RelationSymbol)symbols[node.RelationName]); }
public void RelationNodeTest_TypeMismatch() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L); Expression operandB = Expression.Constant("34"); RelationNode sut = new RelationNode(RelationNode.Operator.EQ, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new SimpleValueTestNode(operandB, FieldValueType.TEXT), expectedLocation); }
public bool MapIntermediateClass(TableNode tn) { // IntermediateClass ic = new IntermediateClass(); // IntermediateClassNode icn = new IntermediateClassNode(ic, tn); IList tableNodes = new ArrayList(); foreach (TableNode tnode in databaseNode.TableNodes) { if (tn.Text == tnode.Text) { continue; } if (tnode.Table.MappingType == TableMappingType.MappedAsClass) { tableNodes.Add(tnode); } } IntermediateClassWizardModel model = new IntermediateClassWizardModel(tn, tableNodes); IWizardController controller = ApplicationController.wizardControllerFactory.Create ("IntermediateClassWizController", "IntClassWiz", "Intermediate Class Wizard"); //controller.FrameSize = new Size(544, 500); model[0].RelationDirection = RelationDirection.Bidirectional; model[1].RelationDirection = RelationDirection.Bidirectional; DialogResult r = controller.Run(model); if (r == DialogResult.OK) { DatabaseNode parent = (DatabaseNode)tn.Parent; // Nothing to remove, because we use the original table node // tn.Remove(); // tn.Parent.Nodes.Add(icn); for (int i = 0; i < 2; i++) { ColumnNode columnNode = (ColumnNode)tn.FindNode(model[i].ForeignKeyColumnName, typeof(ColumnNode)); FkRelation fkr = new FkRelation(columnNode.Text); IntermediateClassInfo intermClInfo = model[i]; fkr.FieldName = intermClInfo.OwnFieldName; fkr.ForeignCodingStyle = intermClInfo.CodingStyle; fkr.ForeignFieldName = intermClInfo.ForeignFieldName; fkr.ForeignIsComposite = false; fkr.IsComposite = false; fkr.OwningTable = tn.Text; fkr.OwningType = tn.Table.ClassName; fkr.RelatedTable = intermClInfo.Table; fkr.RelatedType = intermClInfo.Type; fkr.RelationDirection = intermClInfo.RelationDirection; fkr.RelationName = string.Empty; //ForeignFkRelation ffkr = fkr.ForeignRelation; RelationNode relationNode = new RelationNode(fkr, tn); relationNode.RelatedTableNode = (TableNode)databaseNode.FindNode(intermClInfo.Table); ForeignKeyWizModel fkwizModel = new ForeignKeyWizModel(relationNode, new ArrayList()); tn.DualKeyRelations[i] = intermClInfo.OwnFieldName; MakeForeignKeyRelation(relationNode, columnNode, fkwizModel); } return(true); } return(false); }
/// <summary> /// Returns the method that retrieves the /// </summary> /// <param name="crossReferenceManager"> /// The cross reference manager. /// </param> /// <param name="returnStub"> /// The return stub. /// </param> /// <param name="allowedDataflows"> /// The allowed dataflows. /// </param> /// <param name="relationNode"> /// The relation node. /// </param> /// <returns> /// The function that returns /// </returns> private static Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> GetFunc( IAuthCrossReferenceMutableRetrievalManager crossReferenceManager, bool returnStub, IList<IMaintainableRefObject> allowedDataflows, RelationNode relationNode) { Func<IMaintainableMutableObject, IList<IMaintainableMutableObject>> func = x => new IMaintainableMutableObject[0]; var destinationType = SdmxStructureType.GetFromEnum(relationNode.DestType); switch (relationNode.RelationType) { case RelationType.Parent: func = x => crossReferenceManager.GetCrossReferencingStructures(x, returnStub, allowedDataflows, destinationType); break; case RelationType.Descendant: func = x => crossReferenceManager.GetCrossReferencedStructures(x, returnStub, allowedDataflows, destinationType); break; } return func; }
public void RelationNodeTest_NE() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L); Expression operandB = Expression.Constant(34L); RelationNode sut = new RelationNode(RelationNode.Operator.NE, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new SimpleValueTestNode(operandB, FieldValueType.INTEGER), expectedLocation); Assert.AreEqual(TNode.RELATION, sut.NodeType); Assert.AreEqual(expectedLocation, sut.Location); Assert.IsTrue(sut.Description.Contains("RELATION")); Assert.IsInstanceOfType(sut.SubExpression, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.NotEqual, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); Assert.AreEqual(operandA, ((BinaryExpression)sut.SubExpression).Left); Assert.AreEqual(operandB, ((BinaryExpression)sut.SubExpression).Right); }
/// <summary> /// Processes the node. /// </summary> /// <param name="crossReferenceManager">The cross reference manager.</param> /// <param name="maintainable">The maintainable.</param> /// <param name="specificStructureType">Type of the specific structure.</param> /// <param name="returnStub">if set to <c>true</c> [return stub].</param> /// <param name="allowedDataflows">The allowed dataflows.</param> /// <param name="rootNode">The root node.</param> /// <param name="specificObjects">The specific objects.</param> /// <param name="stack">The stack.</param> private static void ProcessNode( IAuthCrossReferenceMutableRetrievalManager crossReferenceManager, IMaintainableMutableObject maintainable, BaseConstantType<SdmxStructureEnumType> specificStructureType, bool returnStub, IList<IMaintainableRefObject> allowedDataflows, RelationNode rootNode, ICollection<IMaintainableMutableObject> specificObjects, Stack<IMaintainableMutableObject> stack) { var isTarget = rootNode.DestType == specificStructureType.EnumType; bool getStub; Action<IMaintainableMutableObject> action; if (isTarget) { getStub = returnStub; action = specificObjects.Add; } else { getStub = rootNode.DestType != SdmxStructureEnumType.Categorisation; action = stack.Push; } var rootFunc = GetFunc(crossReferenceManager, getStub, allowedDataflows, rootNode); foreach (var maintainableMutableObject in rootFunc(maintainable)) { action(maintainableMutableObject); } }
public ForeignKeyWizModel(RelationNode relationNode, IList tableNodes) { this.relationNode = relationNode; this.tableNodes = tableNodes; }
public void RelationNodeTest_IN_Range_Inclusive() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L, typeof(long?)); SimpleValueNode rangeLow = new NumberNode("34", new StreamLocation()); SimpleValueNode rangeHigh = new NumberNode("68", new StreamLocation()); RelationNode sut = new RelationNode(RelationNode.Operator.IN, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new RangeNode(rangeLow, true, rangeHigh, true, new StreamLocation()), expectedLocation); Assert.AreEqual(TNode.RELATION, sut.NodeType); Assert.AreEqual(expectedLocation, sut.Location); Assert.IsTrue(sut.Description.Contains("RELATION")); Assert.IsInstanceOfType(sut.SubExpression, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.And, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); { Expression left = ((BinaryExpression)sut.SubExpression).Left; Assert.IsInstanceOfType(left, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.GreaterThanOrEqual, left.NodeType); Assert.AreEqual(operandA, ((BinaryExpression)left).Left); Assert.AreEqual(rangeLow.SubExpression, ((BinaryExpression)left).Right); } { Expression right = ((BinaryExpression)sut.SubExpression).Right; Assert.IsInstanceOfType(right, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.LessThanOrEqual, right.NodeType); Assert.AreEqual(operandA, ((BinaryExpression)right).Left); Assert.AreEqual(rangeHigh.SubExpression, ((BinaryExpression)right).Right); } }
public RelationGenerator(RelationNode relationNode, NamespaceWrapper namespaceWrapper) { this.relationNode = relationNode; this.namespaceWrapper = namespaceWrapper; }
public void MakeForeignKey(DataRelation dataRelation) { // The FkRelation is owned by the child table, because it holds // the foreign key. // Therefore the XPath has to be stored in the ForeignFkRelation. string xpath = (string)dataRelation.ExtendedProperties["xpath"]; TableNode ownTableNode = this.databaseNode[dataRelation.ChildTable.TableName]; TableNode foreignTableNode = this.databaseNode[dataRelation.ParentTable.TableName]; ColumnNode cn = ownTableNode[dataRelation.ChildColumns[0].ColumnName]; FkRelation fkRelation = new FkRelation(cn.Text); RelationNode relationNode = new RelationNode(fkRelation, cn.Parent); ForeignKeyWizModel model = new ForeignKeyWizModel(relationNode, null); fkRelation.CodingStyle = CodingStyle.ArrayList; fkRelation.FieldName = MakeCamelCase(foreignTableNode.Text); fkRelation.RelationDirection = RelationDirection.DirectedToMe;// Bidirectional; relationNode.RelatedTableNode = foreignTableNode; fkRelation.RelatedTable = dataRelation.ParentTable.TableName; fkRelation.RelatedType = relationNode.RelatedTableNode.Table.ClassName; fkRelation.IsComposite = false; string singularFieldName = null; if (xpath != null) { singularFieldName = MakePascalCase(xpath.Substring(xpath.LastIndexOf('/') + 1)); } else { singularFieldName = MakePascalCase(ownTableNode.Text); } singularFieldName = singularFieldName.Substring(singularFieldName.IndexOf(':') + 1); string foreignFieldName = MakeCamelCase(singularFieldName); if (foreignFieldName.EndsWith("y")) { char c = char.ToLower(foreignFieldName[foreignFieldName.Length - 2]); if (c == 'a' || c == 'e' || c == 'i' || c == 'o' || c == 'u') { foreignFieldName += "s"; } else { foreignFieldName = foreignFieldName.Substring(0, foreignFieldName.Length - 1) + "ies"; } } else if (foreignFieldName.EndsWith("s")) { foreignFieldName += "es"; } else if (foreignFieldName.EndsWith("f")) { foreignFieldName = foreignFieldName.Substring(0, foreignFieldName.Length - 1) + "ves"; } else { foreignFieldName += "s"; } fkRelation.ForeignFieldName = foreignFieldName; fkRelation.ForeignIsComposite = true; fkRelation.ForeignCodingStyle = CodingStyle.ArrayList; fkRelation.RelationName = string.Empty; MakeForeignKey(cn, model); fkRelation.ForeignRelation.SingularFieldName = MakePascalCase(singularFieldName); fkRelation.ForeignRelation.XPath = xpath; }
public void RelationNodeTest_IN_Set() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L, typeof(long?)); List<ConstantExpression> testExprs = new List<ConstantExpression>() { Expression.Constant(34L, typeof(long?)), Expression.Constant(64L, typeof(long?)) }; ISet<SimpleValueNode> testSet = new HashSet<SimpleValueNode>(); foreach (ConstantExpression expr in testExprs) { testSet.Add(new SimpleValueTestNode(expr, FieldValueType.INTEGER)); } RelationNode sut = new RelationNode(RelationNode.Operator.IN, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new SetNode(testSet, new StreamLocation()), expectedLocation); Assert.AreEqual(TNode.RELATION, sut.NodeType); Assert.AreEqual(expectedLocation, sut.Location); Assert.IsTrue(sut.Description.Contains("RELATION")); Assert.IsInstanceOfType(sut.SubExpression, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.Or, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); List<ConstantExpression> resultExprs = new List<ConstantExpression>(); { Expression left = ((BinaryExpression)sut.SubExpression).Left; Assert.IsInstanceOfType(left, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.Or, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); { Expression leftLeft = ((BinaryExpression)left).Left; Assert.IsInstanceOfType(leftLeft, typeof(ConstantExpression)); Assert.AreEqual(ExpressionType.Constant, leftLeft.NodeType); Assert.AreEqual(typeof(bool), leftLeft.Type); Assert.AreEqual(false, ((ConstantExpression)leftLeft).Value); } { Expression leftRight = ((BinaryExpression)left).Right; Assert.IsInstanceOfType(leftRight, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.Equal, leftRight.NodeType); Assert.AreEqual(operandA, ((BinaryExpression)leftRight).Left); resultExprs.Add((ConstantExpression)((BinaryExpression)leftRight).Right); } } { Expression right = ((BinaryExpression)sut.SubExpression).Right; Assert.IsInstanceOfType(right, typeof(BinaryExpression)); Assert.AreEqual(ExpressionType.Equal, right.NodeType); Assert.AreEqual(operandA, ((BinaryExpression)right).Left); resultExprs.Add((ConstantExpression)((BinaryExpression)right).Right); } CollectionAssert.AreEquivalent(testExprs, resultExprs); }
// Constructor public TargetNode(RelationNode parent, bool isEnabled, BplClass targetClass) { Class = targetClass; IsEnabled = isEnabled; Name = targetClass.Name; Parent = parent; }
public void RelationNodeTest_IN_EmptySet() { StreamLocation expectedLocation = new StreamLocation(3, 2, 1); Expression operandA = Expression.Constant(43L, typeof(long?)); List<ConstantExpression> testExprs = new List<ConstantExpression>(); ISet<SimpleValueNode> testSet = new HashSet<SimpleValueNode>(); foreach (ConstantExpression expr in testExprs) { testSet.Add(new SimpleValueTestNode(expr, FieldValueType.INTEGER)); } RelationNode sut = new RelationNode(RelationNode.Operator.IN, new SimpleValueTestNode(operandA, FieldValueType.INTEGER), new SetNode(testSet, new StreamLocation()), expectedLocation); Assert.AreEqual(TNode.RELATION, sut.NodeType); Assert.AreEqual(expectedLocation, sut.Location); Assert.IsTrue(sut.Description.Contains("RELATION")); Assert.IsInstanceOfType(sut.SubExpression, typeof(ConstantExpression)); Assert.AreEqual(ExpressionType.Constant, sut.SubExpression.NodeType); Assert.AreEqual(typeof(bool), sut.SubExpression.Type); Assert.AreEqual(false, ((ConstantExpression)sut.SubExpression).Value); }