void Write51_XmlSchemaUnique(XmlSchemaUnique o) { if ((object)o == null) { return; } System.Type t = o.GetType(); WriteStartElement("unique"); WriteAttribute(@"id", @"", ((System.String)o.@Id)); WriteAttribute(@"name", @"", ((System.String)o.@Name)); WriteAttributes((XmlAttribute[])o.@UnhandledAttributes, o); Write5_XmlSchemaAnnotation((XmlSchemaAnnotation)o.@Annotation); Write49_XmlSchemaXPath("selector", "", (XmlSchemaXPath)o.@Selector); XmlSchemaObjectCollection a = (XmlSchemaObjectCollection)o.@Fields; if (a != null) { for (int ia = 0; ia < a.Count; ia++) { Write49_XmlSchemaXPath("field", "", (XmlSchemaXPath)a[ia]); } } WriteEndElement(); }
private void WriteUniques(XmlSchema schema, XmlSchemaElement element, CremaDataTable dataTable) { foreach (var item in dataTable.Columns) { if (item.Unique == false) { continue; } if (item.IsKey == true && dataTable.PrimaryKey.Length == 1) { continue; } var unique = new XmlSchemaUnique() { Name = dataTable.Name + "." + item.ColumnName + "." + "Unique", Selector = new XmlSchemaXPath() }; unique.Selector.XPath = dataTable.GetSelectorXPath(CremaSchema.TableTypePrefix, schema.TargetNamespace); var field = new XmlSchemaXPath() { XPath = CremaSchema.TableTypePrefix + ":" + item.ColumnName }; unique.Fields.Add(field); element.Constraints.Add(unique); } }
/// <summary> /// Creates a constraint that forces a set of columns to be unique. /// </summary> /// <param name="dataModelSchema">The parent data model schema.</param> /// <param name="xmlSchemaUnique">The XmlSchema description of the constraint.</param> public UniqueConstraintSchema(DataModelSchema dataModelSchema, XmlSchemaUnique xmlSchemaUnique) : base(dataModelSchema, xmlSchemaUnique) { // This determines whether the constraint should be used as the primary key for a table. XmlAttribute xmlAttribute = ObjectSchema.GetUnhandledAttribute(xmlSchemaUnique, QualifiedName.PrimaryKey); this.isPrimaryKey = xmlAttribute == null ? false : Convert.ToBoolean(xmlAttribute.Value); }
public static XmlSchemaIdentityConstraint FindKey(XmlSchemaKeyref xmlSchemaKeyref) { foreach (XmlSchemaObject xmlSchemaObject in GetXmlSchema(xmlSchemaKeyref).Items) { if (xmlSchemaObject is XmlSchemaElement) { XmlSchemaElement xmlSchemaElement = xmlSchemaObject as XmlSchemaElement; if (IsDataSetElement(xmlSchemaElement)) { XmlSchemaElement dataSetElement = xmlSchemaObject as XmlSchemaElement; foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in dataSetElement.Constraints) { if (xmlSchemaIdentityConstraint is XmlSchemaUnique) { XmlSchemaUnique xmlSchemaUnique = xmlSchemaIdentityConstraint as XmlSchemaUnique; if (xmlSchemaUnique.QualifiedName.Namespace == xmlSchemaKeyref.Refer.Namespace && xmlSchemaUnique.QualifiedName.Name == xmlSchemaKeyref.Refer.Name) { return(xmlSchemaUnique); } } if (xmlSchemaIdentityConstraint is XmlSchemaKey) { XmlSchemaKey xmlSchemaKey = xmlSchemaIdentityConstraint as XmlSchemaKey; if (xmlSchemaKey.QualifiedName.Namespace == xmlSchemaKeyref.Refer.Namespace && xmlSchemaKey.QualifiedName.Name == xmlSchemaKeyref.Refer.Name) { return(xmlSchemaKey); } } } } else { foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in xmlSchemaElement.Constraints) { if (xmlSchemaIdentityConstraint is XmlSchemaKey) { XmlSchemaKey xmlSchemaKey = xmlSchemaIdentityConstraint as XmlSchemaKey; if (xmlSchemaKey.QualifiedName.Namespace == xmlSchemaKeyref.Refer.Namespace && xmlSchemaKey.QualifiedName.Name == xmlSchemaKeyref.Refer.Name) { return(xmlSchemaKey); } } } } } } return(null); }
private void WriteUniques(XmlSchema schema, XmlSchemaElement element, CremaDataTable dataTable) { //var query = from item in dataTable.Columns // where item.Unique == true // select item; //if (query.Any() == false) // return; //var unique = new XmlSchemaUnique() //{ // Name = dataTable.UniqueTypeName, // Selector = new XmlSchemaXPath() //}; //unique.Selector.XPath = dataTable.GetSelectorXPath(CremaSchema.TableTypePrefix, schema.TargetNamespace); //foreach (var item in query) //{ // var field = new XmlSchemaXPath() // { // XPath = CremaSchema.TableTypePrefix + ":" + item.ColumnName // }; // unique.Fields.Add(field); //} //element.Constraints.Add(unique); foreach (var item in dataTable.Columns) { if (item.Unique == false) { continue; } if (item.IsKey == true && dataTable.PrimaryKey.Length == 1) { continue; } var unique = new XmlSchemaUnique() { Name = dataTable.Name + "." + item.ColumnName + "." + "Unique", Selector = new XmlSchemaXPath() }; unique.Selector.XPath = dataTable.GetSelectorXPath(CremaSchema.TableTypePrefix, schema.TargetNamespace); var field = new XmlSchemaXPath() { XPath = CremaSchema.TableTypePrefix + ":" + item.ColumnName }; unique.Fields.Add(field); element.Constraints.Add(unique); } }
/// <summary> /// Creates a collection of tables found in the schema. /// </summary> /// <param name="xmlSchema">The schema that describes the data model.</param> /// <returns>A list of TableSchema objects that describe the tables found in the data model schema.</returns> private void FirstPass(XmlSchemaSet xmlSchemaSet) { // Scan through the schema set looking for table elements. These can either be defined at the root element for a standard // schema or they can be found as choices of a special element describing a 'DataSet' for the Microsoft version of a // schema. foreach (XmlSchemaElement xmlSchemaElement in xmlSchemaSet.GlobalElements.Values) { // If the element read from the schema is the Microsoft DataSet element, then the tables are described as choices // associated with an implicit complex type on that element. if (ObjectSchema.IsDataSetElement(xmlSchemaElement)) { // The tables are described as an choices of an implicit (nested) complex type. if (xmlSchemaElement.SchemaType is XmlSchemaComplexType) { // The complex type describes the table. XmlSchemaComplexType xmlSchemaComplexType = xmlSchemaElement.SchemaType as XmlSchemaComplexType; // The data model is described as a set of one or more choices of tables. if (xmlSchemaComplexType.Particle is XmlSchemaChoice) { // The data model is described as a set of choices. Each choice represents a table. XmlSchemaChoice xmlSchemaChoice = xmlSchemaComplexType.Particle as XmlSchemaChoice; // Create a table for each of the choices described in the complex type. foreach (XmlSchemaObject choiceObject in xmlSchemaChoice.Items) { if (choiceObject is XmlSchemaElement) { XmlSchemaElement tableElement = choiceObject as XmlSchemaElement; this.tableList.Add(tableElement.Name, new TableSchema(this, tableElement)); } } } } // The constraints describe the columns that are unique for a table. foreach (XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint in xmlSchemaElement.Constraints) { // This describes the columns that must be unique within a table. if (xmlSchemaIdentityConstraint is XmlSchemaUnique) { XmlSchemaUnique xmlSchemaUnique = xmlSchemaIdentityConstraint as XmlSchemaUnique; UniqueConstraintSchema uniqueConstraintSchema = new UniqueConstraintSchema(this, xmlSchemaUnique); uniqueConstraintSchema.Table.Add(uniqueConstraintSchema); } } } } }
private void ReadUnique(XmlSchemaUnique unique) { var dataTable = this.GetTable(unique, CremaSchema.UniqueTypeNameExtension); lock (CremaSchema.lockobj) { foreach (var item in unique.GetFields()) { var columnName = item.XPath.Replace(CremaSchema.TableTypePrefix + ":", string.Empty); var dataColumn = dataTable.Columns[columnName]; dataColumn.InternalUnique = true; } } }
private void Write51_XmlSchemaUnique(XmlSchemaUnique o) { if (o != null) { o.GetType(); this.WriteStartElement("unique"); this.WriteAttribute("id", "", o.Id); this.WriteAttribute("name", "", o.Name); this.WriteAttributes(o.UnhandledAttributes, o); this.Write5_XmlSchemaAnnotation(o.Annotation); this.Write49_XmlSchemaXPath("selector", "", o.Selector); XmlSchemaObjectCollection fields = o.Fields; if (fields != null) { for (int i = 0; i < fields.Count; i++) { this.Write49_XmlSchemaXPath("field", "", (XmlSchemaXPath)fields[i]); } } this.WriteEndElement(); } }
public bool GetPrimaryKeyStatus(XmlSchemaIdentityConstraint xmlSchemaIdentityConstraint) { if (xmlSchemaIdentityConstraint is XmlSchemaUnique) { XmlSchemaUnique xmlSchemaUnique = xmlSchemaIdentityConstraint as XmlSchemaUnique; if (xmlSchemaUnique.UnhandledAttributes != null) { foreach (XmlAttribute xmlAttribute in xmlSchemaUnique.UnhandledAttributes) { if (xmlAttribute.NamespaceURI == KeySchema.primaryKeyAttributeName.Namespace && xmlAttribute.LocalName == KeySchema.primaryKeyAttributeName.Name) { return(Convert.ToBoolean(xmlAttribute.Value)); } } } } if (xmlSchemaIdentityConstraint is XmlSchemaKey) { XmlSchemaKey xmlSchemaKey = xmlSchemaIdentityConstraint as XmlSchemaKey; if (xmlSchemaKey.UnhandledAttributes != null) { foreach (XmlAttribute xmlAttribute in xmlSchemaKey.UnhandledAttributes) { if (xmlAttribute.NamespaceURI == KeySchema.primaryKeyAttributeName.Namespace && xmlAttribute.LocalName == KeySchema.primaryKeyAttributeName.Name) { return(Convert.ToBoolean(xmlAttribute.Value)); } } } } return(false); }
public static void Main() { XmlSchema schema = new XmlSchema(); // <xs:complexType name="customerOrderType"> XmlSchemaComplexType customerOrderType = new XmlSchemaComplexType(); customerOrderType.Name = "customerOrderType"; // <xs:sequence> XmlSchemaSequence sequence1 = new XmlSchemaSequence(); // <xs:element name="item" minOccurs="0" maxOccurs="unbounded"> XmlSchemaElement item = new XmlSchemaElement(); item.MinOccurs = 0; item.MaxOccursString = "unbounded"; item.Name = "item"; // <xs:complexType> XmlSchemaComplexType ct1 = new XmlSchemaComplexType(); // <xs:attribute name="itemID" type="xs:string"/> XmlSchemaAttribute itemID = new XmlSchemaAttribute(); itemID.Name = "itemID"; itemID.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); // </xs:complexType> ct1.Attributes.Add(itemID); // </xs:element> item.SchemaType = ct1; // </xs:sequence> sequence1.Items.Add(item); customerOrderType.Particle = sequence1; // <xs:attribute name="CustomerID" type="xs:string"/> XmlSchemaAttribute CustomerID = new XmlSchemaAttribute(); CustomerID.Name = "CustomerID"; CustomerID.SchemaTypeName = new XmlQualifiedName("string", "http://www.w3.org/2001/XMLSchema"); customerOrderType.Attributes.Add(CustomerID); // </xs:complexType> schema.Items.Add(customerOrderType); // <xs:element name="ordersByCustomer"> XmlSchemaElement ordersByCustomer = new XmlSchemaElement(); ordersByCustomer.Name = "ordersByCustomer"; // <xs:complexType> XmlSchemaComplexType ct2 = new XmlSchemaComplexType(); // <xs:sequence> XmlSchemaSequence sequence2 = new XmlSchemaSequence(); // <xs:element name="customerOrders" type="customerOrderType" minOccurs="0" maxOccurs="unbounded" /> XmlSchemaElement customerOrders = new XmlSchemaElement(); customerOrders.MinOccurs = 0; customerOrders.MaxOccursString = "unbounded"; customerOrders.Name = "customerOrders"; customerOrders.SchemaTypeName = new XmlQualifiedName("customerOrderType", ""); // </xs:sequence> sequence2.Items.Add(customerOrders); // </xs:complexType> ct2.Particle = sequence2; ordersByCustomer.SchemaType = ct2; // <xs:unique name="oneCustomerOrdersforEachCustomerID"> XmlSchemaUnique element_unique = new XmlSchemaUnique(); element_unique.Name = "oneCustomerOrdersforEachCustomerID"; // <xs:selector xpath="customerOrders"/> element_unique.Selector = new XmlSchemaXPath(); element_unique.Selector.XPath = "customerOrders"; // <xs:field xpath="@customerID"/> XmlSchemaXPath field = new XmlSchemaXPath(); field.XPath = "@customerID"; // </xs:unique> element_unique.Fields.Add(field); ordersByCustomer.Constraints.Add(element_unique); // </xs:element> schema.Items.Add(ordersByCustomer); XmlSchemaSet schemaSet = new XmlSchemaSet(); schemaSet.ValidationEventHandler += new ValidationEventHandler(ValidationCallbackOne); schemaSet.Add(schema); schemaSet.Compile(); XmlSchema compiledSchema = null; foreach (XmlSchema schema1 in schemaSet.Schemas()) { compiledSchema = schema1; } XmlNamespaceManager nsmgr = new XmlNamespaceManager(new NameTable()); nsmgr.AddNamespace("xs", "http://www.w3.org/2001/XMLSchema"); compiledSchema.Write(Console.Out, nsmgr); }
private static void Equal(XmlSchemaUnique expected, XmlSchemaUnique actual) { throw new NotImplementedException(); }
public UniqueSchema(DataModelSchema schema, XmlSchemaUnique xmlSchemaUnique) : base(schema, xmlSchemaUnique) { // Initialize the object this.xmlSchemaUnique = xmlSchemaUnique; }
protected override void Visit(XmlSchemaUnique unique) { _writer.WriteConstraintRow(_context, ArtItem.Unique, "Unique", unique); }
protected virtual void Visit(XmlSchemaUnique unique) { Traverse(unique.Selector); Traverse(unique.Fields); }
private void handleObject(XmlSchemaObject o) { string str = "unknown"; XmlSchemaObjectCollection children = new XmlSchemaObjectCollection(); if (o is XmlSchema) { str = "root"; children = ((XmlSchema)o).Items; } else if (o is XmlSchemaComplexType) { XmlSchemaComplexType type = (XmlSchemaComplexType)o; startNewDbFile(type); str = type.Name; children = type.Attributes; infos = new List <TypeInfo> (); } else if (o is XmlSchemaAttribute) { XmlSchemaAttribute attribute = (XmlSchemaAttribute)o; addDbAttribute(attribute); str = string.Format("{0} ({1})", attribute.Name, attribute.AttributeSchemaType.TypeCode); } else if (o is XmlSchemaElement) { // children = ((XmlSchemaElement)o). XmlSchemaElement element = (XmlSchemaElement)o; foreach (XmlSchemaObject constraint in element.Constraints) { if (constraint is XmlSchemaUnique) { XmlSchemaUnique unique = (XmlSchemaUnique)constraint; List <string> fields = new List <string> (unique.Fields.Count); foreach (XmlSchemaObject field in unique.Fields) { if (field is XmlSchemaXPath) { fields.Add(((XmlSchemaXPath)field).XPath); } } constraints.Add(new TableConstraint { Name = unique.Name, Table = unique.Selector.XPath, Fields = fields }); } else if (constraint is XmlSchemaKeyref) { XmlSchemaKeyref reference = (XmlSchemaKeyref)constraint; string fromTable = reference.Selector.XPath.Substring(3).Replace("_tables", ""); string fromRow = ((XmlSchemaXPath)reference.Fields [0]).XPath.Substring(1); try { TableReferenceEntry tableRef = resolveReference(reference.Name, fromTable, fromRow, reference.Refer.Name); if (tableRef != null) { Console.WriteLine("{0}#{1} - {2}#{3}", tableRef.fromTable, tableRef.fromTableIndex, tableRef.toTable, tableRef.toTableIndex); } else { Console.WriteLine("could not resolve reference"); } } catch (Exception x) { Console.WriteLine(x); } } } } else { Console.WriteLine("unknown type: {0}", o); } if (o is XmlSchemaAnnotated && ((XmlSchemaAnnotated)o).UnhandledAttributes != null) { string attlist = ""; new List <XmlAttribute> (((XmlSchemaAnnotated)o).UnhandledAttributes).ForEach(uh => attlist += " " + uh); str = string.Format("{0} (unhandled: {1})", str, attlist); } foreach (XmlSchemaObject child in children) { handleObject(child); } }
private CremaDataTable GetTable(XmlSchemaUnique constraint, string extension) { if (this.version.Major == CremaSchema.MajorVersion) { var keyName = constraint.Name.Substring(0, constraint.Name.Length - extension.Length); if (this.version.Minor >= 5) // 3.5 { var items = StringUtility.Split(keyName, '.'); keyName = string.Join(".", items.Take(items.Length - 1)); } if (this.itemName == null) { return(this.tables[keyName]); } else { var tableName = CremaDataSet.GetTableName(this.dataSet, constraint.QualifiedName.Namespace); if (keyName == tableName) { return(this.tables[this.itemName.Name]); } else { tableName = Regex.Replace(keyName, string.Format("(^{0})([.].*)", tableName), this.itemName.Name + "$2"); return(this.tables[tableName]); } } } else { var keyName = GetTableNameObsolete(constraint); if (this.itemName == null) { var tableName = CremaDataSet.GetTableName(CremaSchemaObsolete.TableNamespaceObsolete, constraint.QualifiedName.Namespace); var categoryPath = CremaDataSet.GetTableCategoryPath(CremaSchemaObsolete.TableNamespaceObsolete, constraint.QualifiedName.Namespace); if (keyName == tableName) { return(this.dataSet.Tables[tableName, categoryPath]); } else { return(this.dataSet.Tables[tableName + "." + keyName, categoryPath]); } } else { var tableName = CremaDataSet.GetTableName(CremaSchemaObsolete.TableNamespaceObsolete, constraint.QualifiedName.Namespace); var categoryPath = CremaDataSet.GetTableCategoryPath(CremaSchemaObsolete.TableNamespaceObsolete, constraint.QualifiedName.Namespace); if (keyName == tableName) { return(this.dataSet.Tables[itemName.Name, itemName.CategoryPath]); } else { return(this.dataSet.Tables[itemName.Name + "." + keyName, itemName.CategoryPath]); } } } throw new CremaDataException(); }