InferXmlSchema() public method

Infer the XML schema from the specified into the .
public InferXmlSchema ( Stream stream, string nsArray ) : void
stream Stream
nsArray string
return void
		public void SimpleLoad ()
		{
			string xml001 = "<root/>";
			XmlDataDocument doc = new XmlDataDocument ();
			DataSet ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml001), null);
			doc.LoadXml (xml001);

			string xml002 = "<root><child/></root>";
			doc = new XmlDataDocument ();
			ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml002), null);
			doc.LoadXml (xml002);

			string xml003 = "<root><col1>test</col1><col1></col1></root>";
			doc = new XmlDataDocument ();
			ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml003), null);
			doc.LoadXml (xml003);

			string xml004 = "<set><tab1><col1>test</col1><col1>test2</col1></tab1><tab2><col2>test3</col2><col2>test4</col2></tab2></set>";
			doc = new XmlDataDocument ();
			ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml004), null);
			doc.LoadXml (xml004);
		}
		public static void Main (string [] args)
		{
			if (args.Length == 0) {
				Console.WriteLine ("usage: mono xmldatareader.exe filename");
				return;
			}

			Console.WriteLine ("Target file: " + args [0]);

			DataSet ds = new DataSet ();
//			ds.InferXmlSchema (args [0], null);

			try {
				ds.ReadXml (args [0]);
			} catch (Exception ex) {
				Console.WriteLine ("ReadXml() borked: " + ex.Message);
				return;
			}
			Console.WriteLine ("---- DataSet ----------------");
			StringWriter sw = new StringWriter ();
			PrintDataSet (ds, sw);
			PrintDataSet (ds, Console.Out);

			ds = new DataSet ();
			ds.InferXmlSchema (args [0], null);
			XmlDataReader.ReadXml (ds, new XmlTextReader (args [0]));
			Console.WriteLine ("---- XmlDataReader ----------------");
			StringWriter sw2 = new StringWriter ();
			PrintDataSet (ds, sw2);

			if (sw.ToString () == sw2.ToString ())
				Console.WriteLine ("Successful.");
			else
				Console.WriteLine ("Different *************************************************\n" + sw2);
		}
Beispiel #3
0
        static void Main()
        {
            DataSet dataSet = new DataSet();

              string[] ignoreNamesapces = {
            "http://www.shop.com/pml",
            "http://www.shop.com/cml"
              };
              dataSet.InferXmlSchema(@"..\..\ch13\orderlist.xml", ignoreNamesapces);

              DisplaySchema.displayDataSetSchema(dataSet);
        }
Beispiel #4
0
        public static void Main(string [] args)
        {
            if (args.Length == 0)
            {
                Console.WriteLine("usage: mono xmldatareader.exe filename");
                return;
            }

            Console.WriteLine("Target file: " + args [0]);

            DataSet ds = new DataSet();

//			ds.InferXmlSchema (args [0], null);

            try
            {
                ds.ReadXml(args [0]);
            }
            catch (Exception ex)
            {
                Console.WriteLine("ReadXml() borked: " + ex.Message);
                return;
            }
            Console.WriteLine("---- DataSet ----------------");
            StringWriter sw = new StringWriter();

            PrintDataSet(ds, sw);
            PrintDataSet(ds, Console.Out);

            ds = new DataSet();
            ds.InferXmlSchema(args [0], null);
            XmlDataReader.ReadXml(ds, new XmlTextReader(args [0]));
            Console.WriteLine("---- XmlDataReader ----------------");
            StringWriter sw2 = new StringWriter();

            PrintDataSet(ds, sw2);

            if (sw.ToString() == sw2.ToString())
            {
                Console.WriteLine("Successful.");
            }
            else
            {
                Console.WriteLine("Different *************************************************\n" + sw2);
            }
        }
Beispiel #5
0
		[Test] public void InferXmlSchema_inferingTables4()
		{
			//Acroding to the msdn documantaion :
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
			//The document, or root, element will result in an inferred table if it has attributes
			//or child elements that will be inferred as columns.
			//If the document element has no attributes and no child elements that would be inferred as columns, the element will be inferred as a DataSet

			// inferingTables4
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1 attr1='value1' attr2='value2'/>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS84");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS85");
			Assert.AreEqual(1, ds.Tables.Count, "DS86");
			Assert.AreEqual("attr1", ds.Tables[0].Columns["attr1"].ColumnName, "DS87");
			Assert.AreEqual("attr2", ds.Tables[0].Columns["attr2"].ColumnName, "DS88");
		}
Beispiel #6
0
		public void InferXmlSchema_inferingTables5()
		{
			//Acroding to the msdn documantaion :
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
			//Elements that repeat will result in a single inferred table

			// inferingTables5
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1>Text1</Element1>");
			sb.Append("<Element1>Text2</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS89");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS90");
			Assert.AreEqual(1, ds.Tables.Count, "DS91");
			Assert.AreEqual("Element1_Text", ds.Tables[0].Columns["Element1_Text"].ColumnName, "DS92");
		}
Beispiel #7
0
		[Test] public void InferXmlSchema_inferingTables1()
		{
			//Acroding to the msdn documantaion :
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
			//Elements that have attributes specified in them will result in inferred tables

			// inferingTables1
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1 attr1='value1'/>");
			sb.Append("<Element1 attr1='value2'>Text1</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS70");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS71");
			Assert.AreEqual(1, ds.Tables.Count, "DS72");
			Assert.AreEqual("attr1", ds.Tables[0].Columns["attr1"].ColumnName, "DS73");
			Assert.AreEqual("Element1_Text", ds.Tables[0].Columns["Element1_Text"].ColumnName, "DS74");
		}
Beispiel #8
0
		[Test] public void InferXmlSchema_inferingTables2()
		{
			//Acroding to the msdn documantaion :
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
			//Elements that have child elements will result in inferred tables

			// inferingTables2
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1>");
			sb.Append("<ChildElement1>Text1</ChildElement1>");
			sb.Append("</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS75");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS76");
			Assert.AreEqual(1, ds.Tables.Count, "DS77");
			Assert.AreEqual("ChildElement1", ds.Tables[0].Columns["ChildElement1"].ColumnName, "DS78");
		}
Beispiel #9
0
		[Test] public void InferXmlSchema_elementText2()
		{
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringelementtext.htm

			// elementText1
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1>");
			sb.Append("Text1");
			sb.Append("<ChildElement1>Text2</ChildElement1>");
			sb.Append("Text3");
			sb.Append("</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);

			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS149");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS150");
			Assert.AreEqual(1, ds.Tables.Count, "DS151");

			Assert.AreEqual("ChildElement1", ds.Tables["Element1"].Columns["ChildElement1"].ColumnName, "DS152");
			Assert.AreEqual(MappingType.Element, ds.Tables["Element1"].Columns["ChildElement1"].ColumnMapping , "DS153");
			Assert.AreEqual(typeof(string), ds.Tables["Element1"].Columns["ChildElement1"].DataType  , "DS154");
			Assert.AreEqual(1, ds.Tables["Element1"].Columns.Count, "DS155");
		}
	public void inferingTables4()  
	{
		//Acroding to the msdn documantaion : 
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
		//The document, or root, element will result in an inferred table if it has attributes
		//or child elements that will be inferred as columns. 
		//If the document element has no attributes and no child elements that would be inferred as columns, the element will be inferred as a DataSet

		BeginCase("inferingTables4");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1 attr1='value1' attr2='value2'/>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);
			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables.Count,1);
			Compare(ds.Tables[0].Columns["attr1"].ColumnName,"attr1");
			Compare(ds.Tables[0].Columns["attr2"].ColumnName,"attr2");
		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}
	}
Beispiel #11
0
		public void Run (string[] args)
		{
			ArrayList unknownFiles = new ArrayList();
			bool generateClasses = false;
			bool readingFiles = true;
			bool schemasOptions = false;
			bool assemblyOptions = false;
			bool generateDataset = false;
			bool inference = false;

			foreach (string arg in args)
			{
				if (!arg.StartsWith ("--") && !arg.StartsWith ("/") ||
					(arg.StartsWith ("/") && arg.IndexOfAny (Path.InvalidPathChars) == -1)
					) 
				{
					if ((arg.EndsWith (".dll") || arg.EndsWith (".exe")) && !arg.Substring (1).StartsWith ("generator:") && !arg.Substring (1).StartsWith ("g:"))
					{
						if (!readingFiles) throw new ApplicationException (incorrectOrder);
						assemblies.Add (arg);
						assemblyOptions = true;
						continue;
					}
					else if (arg.EndsWith (".xsd"))
					{
						if (!readingFiles) Error (incorrectOrder);
						schemaNames.Add (arg);
						schemasOptions = true;
						continue;
					}
					else if (arg.EndsWith (".xml"))
					{
						if (generateClasses || generateDataset) Error (duplicatedParam);
						inferenceNames.Add (arg);
						inference = true;
						continue;
					}
					else if (!arg.StartsWith ("/"))
					{
						if (!readingFiles) Error (incorrectOrder);
						unknownFiles.Add (arg);
						continue;
					}
				}

				readingFiles = false;

				int i = arg.IndexOf (":");
				if (i == -1) i = arg.Length;
				string option = arg.Substring (1,i-1);
				string param = (i<arg.Length-1) ? arg.Substring (i+1) : "";

				if (option == "classes" || option == "c")
				{
					if (generateClasses || generateDataset || inference) Error (duplicatedParam, option);
					generateClasses = true;
					schemasOptions = true;
				}
				else if (option == "dataset" || option == "d")
				{
					if (generateClasses || generateDataset || inference) Error (duplicatedParam, option);
					generateDataset = true;
					schemasOptions = true;
				}
				else if (option == "element" || option == "e")
				{
					elements.Add (param);
					schemasOptions = true;
				}
				else if (option == "language" || option == "l")
				{
					if (provider != null) Error (duplicatedParam, option);
					if (language != null) Error (duplicatedParam, option);
					language = param;
					schemasOptions = true;
				}
				else if (option == "namespace" || option == "n")
				{
					if (namesp != null) Error (duplicatedParam, option);
					namesp = param;
					schemasOptions = true;
				}
				else if (option == "outputdir" || option == "o")
				{
					if (outputDir != null) Error (duplicatedParam, option);
					outputDir = param;
				}
				else if (option == "uri" || option == "u")
				{
					if (uri != null) Error (duplicatedParam, option);
					uri = param;
					schemasOptions = true;
				}
				else if (option == "type" || option == "t")
				{
					lookupTypes.Add (param);
					assemblyOptions = true;
				}
				else if (option == "generator" || option == "g")
				{
					providerOption = param;
				}
				else if (option == "help" || option == "h")
				{
					Console.WriteLine (helpString);
					return;
				}
				else if (option == "nologo")
				{
					// ignore, since we do not output a logo anyway
				}
				else
					Error (unknownOption, option);
			}

			if (!schemasOptions && !assemblyOptions && !inference)
				Error (invalidParams);

			if (schemasOptions && assemblyOptions)
				Error (incompatibleArgs);

			if (assemblies.Count > 1)
				Error (tooManyAssem);

			if (outputDir == null) outputDir = ".";

			string typename = null;
			Type generatorType = null;

			if (language != null) {
				switch (language) {
				case "CS":
					provider = new CSharpCodeProvider ();
					break;
				case "VB":
					provider = new VBCodeProvider ();
					break;
				default:
					typename = StripQuot (language);

					generatorType = Type.GetType (typename);
					if (generatorType == null)
						Error (generatorTypeNotFound, typename);
					break;
				}
			}

			if (providerOption != null) {
				string param = providerOption;
				int comma = param.IndexOf (',');
				if (comma < 0) {
					typename = StripQuot (param);
					generatorType = Type.GetType (param);
				} else {
					typename = param.Substring (0, comma);
					string asmName = param.Substring (comma + 1);
#if NET_1_1
					Assembly asm = Assembly.LoadFile (asmName);
#else
					Assembly asm = Assembly.LoadFrom (asmName);
#endif
					if (asm == null)
						Error (generatorAssemblyNotFound, asmName);
					generatorType = asm.GetType (typename);
				}
				if (generatorType == null)
					Error (generatorTypeNotFound, typename);
			}
			if (generatorType != null) {
				if (!generatorType.IsSubclassOf (typeof (CodeDomProvider)))
					Error (generatorTypeIsNotCodeGenerator, typename);
				try {
					provider = (CodeDomProvider) Activator.CreateInstance (generatorType, null);
				} catch (Exception ex) {
					Error (generatorThrewException, generatorType.AssemblyQualifiedName.ToString () + " --> " + ex.Message);
				}
				Console.WriteLine ("Loaded custom generator type " + generatorType + " .");
			}
			if (provider == null)
				provider = new CSharpCodeProvider ();

			if (schemasOptions)
			{
				if (!generateClasses && !generateDataset)
					Error (missingOutputForXsdInput);
				schemaNames.AddRange (unknownFiles);
				if (generateClasses)
					GenerateClasses ();
				else if (generateDataset)
					GenerateDataset ();
			}
			else if (inference)
			{
				foreach (string xmlfile in inferenceNames) {
					string genFile = Path.Combine (outputDir, Path.GetFileNameWithoutExtension (xmlfile) + ".xsd");
					DataSet ds = new DataSet ();
					ds.InferXmlSchema (xmlfile, null);
					ds.WriteXmlSchema (genFile);
					Console.WriteLine ("Written file " + genFile);
				}
			}
			else
			{
				assemblies.AddRange (unknownFiles);
				GenerateSchemas ();
			}
		}
Beispiel #12
0
		[Test] public void InferXmlSchema_inferringRelationships1()
		{
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringrelationships.htm

			// inferringRelationships1
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1>");
			sb.Append("<ChildElement1 attr1='value1' attr2='value2'/>");
			sb.Append("<ChildElement2>Text2</ChildElement2>");
			sb.Append("</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS111");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS112");
			Assert.AreEqual("ChildElement1", ds.Tables[1].TableName, "DS113");
			Assert.AreEqual(2, ds.Tables.Count, "DS114");

			Assert.AreEqual("Element1_Id", ds.Tables["Element1"].Columns["Element1_Id"].ColumnName, "DS115");
			Assert.AreEqual(MappingType.Hidden, ds.Tables["Element1"].Columns["Element1_Id"].ColumnMapping , "DS116");
			Assert.AreEqual(typeof(Int32), ds.Tables["Element1"].Columns["Element1_Id"].DataType  , "DS117");

			Assert.AreEqual("ChildElement2", ds.Tables["Element1"].Columns["ChildElement2"].ColumnName, "DS118");
			Assert.AreEqual(MappingType.Element, ds.Tables["Element1"].Columns["ChildElement2"].ColumnMapping , "DS119");
			Assert.AreEqual(typeof(string), ds.Tables["Element1"].Columns["ChildElement2"].DataType  , "DS120");

			Assert.AreEqual("attr1", ds.Tables["ChildElement1"].Columns["attr1"].ColumnName, "DS121");
			Assert.AreEqual(MappingType.Attribute, ds.Tables["ChildElement1"].Columns["attr1"].ColumnMapping , "DS122");
			Assert.AreEqual(typeof(string), ds.Tables["ChildElement1"].Columns["attr1"].DataType  , "DS123");

			Assert.AreEqual("attr2", ds.Tables["ChildElement1"].Columns["attr2"].ColumnName, "DS124");
			Assert.AreEqual(MappingType.Attribute, ds.Tables["ChildElement1"].Columns["attr2"].ColumnMapping , "DS125");
			Assert.AreEqual(typeof(string), ds.Tables["ChildElement1"].Columns["attr2"].DataType  , "DS126");

			Assert.AreEqual("Element1_Id", ds.Tables["ChildElement1"].Columns["Element1_Id"].ColumnName, "DS127");
			Assert.AreEqual(MappingType.Hidden, ds.Tables["ChildElement1"].Columns["Element1_Id"].ColumnMapping , "DS128");
			Assert.AreEqual(typeof(Int32), ds.Tables["ChildElement1"].Columns["Element1_Id"].DataType  , "DS129");

			//Checking dataRelation :
			Assert.AreEqual("Element1", ds.Relations["Element1_ChildElement1"].ParentTable.TableName, "DS130");
			Assert.AreEqual("Element1_Id", ds.Relations["Element1_ChildElement1"].ParentColumns[0].ColumnName, "DS131");
			Assert.AreEqual("ChildElement1", ds.Relations["Element1_ChildElement1"].ChildTable.TableName, "DS132");
			Assert.AreEqual("Element1_Id", ds.Relations["Element1_ChildElement1"].ChildColumns[0].ColumnName, "DS133");
			Assert.AreEqual(true, ds.Relations["Element1_ChildElement1"].Nested, "DS134");

			//Checking ForeignKeyConstraint

			ForeignKeyConstraint con = (ForeignKeyConstraint)ds.Tables["ChildElement1"].Constraints["Element1_ChildElement1"];

			Assert.AreEqual("Element1_Id", con.Columns[0].ColumnName, "DS135");
			Assert.AreEqual(Rule.Cascade, con.DeleteRule, "DS136");
			Assert.AreEqual(AcceptRejectRule.None, con.AcceptRejectRule, "DS137");
			Assert.AreEqual("Element1", con.RelatedTable.TableName, "DS138");
			Assert.AreEqual("ChildElement1", con.Table.TableName, "DS139");
		}
	public void inferringRelationships1()
	{
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringrelationships.htm

		BeginCase("inferringRelationships1");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1>");
		sb.Append("<ChildElement1 attr1='value1' attr2='value2'/>");
		sb.Append("<ChildElement2>Text2</ChildElement2>");
		sb.Append("</Element1>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);
			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables[1].TableName,"ChildElement1");
			Compare(ds.Tables.Count,2);

			Compare(ds.Tables["Element1"].Columns["Element1_Id"].ColumnName,"Element1_Id");
			Compare(ds.Tables["Element1"].Columns["Element1_Id"].ColumnMapping ,MappingType.Hidden);
			Compare(ds.Tables["Element1"].Columns["Element1_Id"].DataType  ,typeof(Int32));


			Compare(ds.Tables["Element1"].Columns["ChildElement2"].ColumnName,"ChildElement2");
			Compare(ds.Tables["Element1"].Columns["ChildElement2"].ColumnMapping ,MappingType.Element);
			Compare(ds.Tables["Element1"].Columns["ChildElement2"].DataType  ,typeof(string));


			Compare(ds.Tables["ChildElement1"].Columns["attr1"].ColumnName,"attr1");
			Compare(ds.Tables["ChildElement1"].Columns["attr1"].ColumnMapping ,MappingType.Attribute);
			Compare(ds.Tables["ChildElement1"].Columns["attr1"].DataType  ,typeof(string));

			Compare(ds.Tables["ChildElement1"].Columns["attr2"].ColumnName,"attr2");
			Compare(ds.Tables["ChildElement1"].Columns["attr2"].ColumnMapping ,MappingType.Attribute);
			Compare(ds.Tables["ChildElement1"].Columns["attr2"].DataType  ,typeof(string));

			Compare(ds.Tables["ChildElement1"].Columns["Element1_Id"].ColumnName,"Element1_Id");
			Compare(ds.Tables["ChildElement1"].Columns["Element1_Id"].ColumnMapping ,MappingType.Hidden);
			Compare(ds.Tables["ChildElement1"].Columns["Element1_Id"].DataType  ,typeof(Int32));

			//Checking dataRelation :
			Compare(ds.Relations["Element1_ChildElement1"].ParentTable.TableName,"Element1");
			Compare(ds.Relations["Element1_ChildElement1"].ParentColumns[0].ColumnName,"Element1_Id");
			Compare(ds.Relations["Element1_ChildElement1"].ChildTable.TableName,"ChildElement1");
			Compare(ds.Relations["Element1_ChildElement1"].ChildColumns[0].ColumnName,"Element1_Id");
			Compare(ds.Relations["Element1_ChildElement1"].Nested,true);

			//Checking ForeignKeyConstraint

			ForeignKeyConstraint con = (ForeignKeyConstraint)ds.Tables["ChildElement1"].Constraints["Element1_ChildElement1"];

			Compare(con.Columns[0].ColumnName,"Element1_Id");
			Compare(con.DeleteRule,Rule.Cascade);
			Compare(con.AcceptRejectRule,AcceptRejectRule.None);
			Compare(con.RelatedTable.TableName,"Element1");
			Compare(con.Table.TableName,"ChildElement1");

		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}

	}
	public void elementText2()
	{
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringelementtext.htm
		
		BeginCase("elementText1");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1>");
		sb.Append("Text1");
		sb.Append("<ChildElement1>Text2</ChildElement1>");
		sb.Append("Text3");
		sb.Append("</Element1>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);

			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables.Count,1);

			Compare(ds.Tables["Element1"].Columns["ChildElement1"].ColumnName,"ChildElement1");
			Compare(ds.Tables["Element1"].Columns["ChildElement1"].ColumnMapping ,MappingType.Element);
			Compare(ds.Tables["Element1"].Columns["ChildElement1"].DataType  ,typeof(string));
			Compare(ds.Tables["Element1"].Columns.Count,1);

			
		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}

	}
	public void inferringColumns2()
	{
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringcolumns.htm
		//If an element has no child elements or attributes, it will be inferred as a column. 
		//The ColumnMapping property of the column will be set to MappingType.Element. 
		//The text for child elements is stored in a row in the table

		BeginCase("inferringColumns2");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1>");
		sb.Append("<ChildElement1>Text1</ChildElement1>");
		sb.Append("<ChildElement2>Text2</ChildElement2>");
		sb.Append("</Element1>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);
			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables.Count,1);
			Compare(ds.Tables[0].Columns["ChildElement1"].ColumnName,"ChildElement1");
			Compare(ds.Tables[0].Columns["ChildElement2"].ColumnName,"ChildElement2");
			Compare(ds.Tables[0].Columns["ChildElement1"].ColumnMapping ,MappingType.Element);
			Compare(ds.Tables[0].Columns["ChildElement2"].ColumnMapping ,MappingType.Element);
			Compare(ds.Tables[0].Columns["ChildElement1"].DataType  ,typeof(string));
			Compare(ds.Tables[0].Columns["ChildElement2"].DataType  ,typeof(string));
		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}


	}
	public void inferringColumns1()
	{
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringcolumns.htm
		BeginCase("inferringColumns1");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1 attr1='value1' attr2='value2'/>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);
			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables.Count,1);
			Compare(ds.Tables[0].Columns["attr1"].ColumnName,"attr1");
			Compare(ds.Tables[0].Columns["attr2"].ColumnName,"attr2");
			Compare(ds.Tables[0].Columns["attr1"].ColumnMapping ,MappingType.Attribute);
			Compare(ds.Tables[0].Columns["attr2"].ColumnMapping ,MappingType.Attribute);
			Compare(ds.Tables[0].Columns["attr1"].DataType  ,typeof(string));
			Compare(ds.Tables[0].Columns["attr2"].DataType  ,typeof(string));
		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}


	}
	public void inferingTables5()  
	{
		//Acroding to the msdn documantaion : 
		//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringtables.htm
		//Elements that repeat will result in a single inferred table

		BeginCase("inferingTables5");
		Exception exp=null;
		StringBuilder sb  = new StringBuilder();

		sb.Append("<DocumentElement>");
		sb.Append("<Element1>Text1</Element1>");
		sb.Append("<Element1>Text2</Element1>");
		sb.Append("</DocumentElement>");
		DataSet ds = new DataSet();
		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
		try
		{
			ds.InferXmlSchema(myStream,null);
			Compare(ds.DataSetName,"DocumentElement");
			Compare(ds.Tables[0].TableName,"Element1");
			Compare(ds.Tables.Count,1);
			Compare(ds.Tables[0].Columns["Element1_Text"].ColumnName,"Element1_Text");
		}
		catch (Exception ex)
		{
			exp = ex;
		}
		finally
		{
			EndCase(exp);
		}
	}
Beispiel #18
0
		[Test] public void InferXmlSchema_inferringColumns1()
		{
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringcolumns.htm
			// inferringColumns1
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1 attr1='value1' attr2='value2'/>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS93");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS94");
			Assert.AreEqual(1, ds.Tables.Count, "DS95");
			Assert.AreEqual("attr1", ds.Tables[0].Columns["attr1"].ColumnName, "DS96");
			Assert.AreEqual("attr2", ds.Tables[0].Columns["attr2"].ColumnName, "DS97");
			Assert.AreEqual(MappingType.Attribute, ds.Tables[0].Columns["attr1"].ColumnMapping , "DS98");
			Assert.AreEqual(MappingType.Attribute, ds.Tables[0].Columns["attr2"].ColumnMapping , "DS99");
			Assert.AreEqual(typeof(string), ds.Tables[0].Columns["attr1"].DataType  , "DS100");
			Assert.AreEqual(typeof(string), ds.Tables[0].Columns["attr2"].DataType  , "DS101");
		}
Beispiel #19
0
	  /*
		// simple diffgram
		string xml23 = @"<set>
  <xs:schema xmlns:xs='http://www.w3.org/2001/XMLSchema'>
    <xs:element name='table'>
      <xs:complexType>
      <xs:choice>
        <xs:any />
      </xs:choice>
      </xs:complexType>
    </xs:element>
  </xs:schema>
  <diffgr:diffgram
        xmlns:msdata='urn:schemas-microsoft-com:xml-msdata'
        xmlns:diffgr='urn:schemas-microsoft-com:xml-diffgram-v1'>
    <table>
      <col>1</col>
    </table>
  </diffgr:diffgram>
</set>";
		// just deep table
		string xml24 = "<p1><p2><p3><p4><p5><p6/></p5></p4></p3></p2></p1>";
	  */

		private DataSet GetDataSet (string xml, string [] nss)
		{
			DataSet ds = new DataSet ();
			ds.InferXmlSchema (new XmlTextReader (xml, XmlNodeType.Document, null), nss);
			return ds;
		}
Beispiel #20
0
		[Test] public void InferXmlSchema_inferringColumns2()
		{
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringcolumns.htm
			//If an element has no child elements or attributes, it will be inferred as a column.
			//The ColumnMapping property of the column will be set to MappingType.Element.
			//The text for child elements is stored in a row in the table

			// inferringColumns2
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1>");
			sb.Append("<ChildElement1>Text1</ChildElement1>");
			sb.Append("<ChildElement2>Text2</ChildElement2>");
			sb.Append("</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);
			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS102");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS103");
			Assert.AreEqual(1, ds.Tables.Count, "DS104");
			Assert.AreEqual("ChildElement1", ds.Tables[0].Columns["ChildElement1"].ColumnName, "DS105");
			Assert.AreEqual("ChildElement2", ds.Tables[0].Columns["ChildElement2"].ColumnName, "DS106");
			Assert.AreEqual(MappingType.Element, ds.Tables[0].Columns["ChildElement1"].ColumnMapping , "DS107");
			Assert.AreEqual(MappingType.Element, ds.Tables[0].Columns["ChildElement2"].ColumnMapping , "DS108");
			Assert.AreEqual(typeof(string), ds.Tables[0].Columns["ChildElement1"].DataType  , "DS109");
			Assert.AreEqual(typeof(string), ds.Tables[0].Columns["ChildElement2"].DataType  , "DS110");
		}
Beispiel #21
0
		public void SignificantWhitespaceIgnored2 ()
		{
			// To make sure, create pure significant whitespace element
			// using XmlNodeReader (that does not have xml:space attribute
			// column).
			DataSet ds = new DataSet ();
			XmlDocument doc = new XmlDocument ();
			doc.AppendChild (doc.CreateElement ("root"));
			doc.DocumentElement.AppendChild (doc.CreateSignificantWhitespace
			("      \n\n"));
			XmlReader xr = new XmlNodeReader (doc);
			ds.InferXmlSchema (xr, null);
			AssertDataSet ("pure_whitespace", ds, "root", 0, 0);
		}
Beispiel #22
0
		[Test] public void InferXmlSchema_elementText1()
		{
			//ms-help://MS.MSDNQTR.2003FEB.1033/cpguide/html/cpconinferringelementtext.htm

			// elementText1
			StringBuilder sb  = new StringBuilder();

			sb.Append("<DocumentElement>");
			sb.Append("<Element1 attr1='value1'>Text1</Element1>");
			sb.Append("</DocumentElement>");
			DataSet ds = new DataSet();
			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			ds.InferXmlSchema(myStream,null);

			Assert.AreEqual("DocumentElement", ds.DataSetName, "DS140");
			Assert.AreEqual("Element1", ds.Tables[0].TableName, "DS141");
			Assert.AreEqual(1, ds.Tables.Count, "DS142");

			Assert.AreEqual("attr1", ds.Tables["Element1"].Columns["attr1"].ColumnName, "DS143");
			Assert.AreEqual(MappingType.Attribute, ds.Tables["Element1"].Columns["attr1"].ColumnMapping , "DS144");
			Assert.AreEqual(typeof(string), ds.Tables["Element1"].Columns["attr1"].DataType  , "DS145");

			Assert.AreEqual("Element1_Text", ds.Tables["Element1"].Columns["Element1_Text"].ColumnName, "DS146");
			Assert.AreEqual(MappingType.SimpleContent, ds.Tables["Element1"].Columns["Element1_Text"].ColumnMapping , "DS147");
			Assert.AreEqual(typeof(string), ds.Tables["Element1"].Columns["Element1_Text"].DataType  , "DS148");
		}
	public void test5()
	{
		StringBuilder sb  = new StringBuilder();
		sb.Append("<NewDataSet xmlns:od='urn:schemas-microsoft-com:officedata'>");
		sb.Append("<Categories>");
		sb.Append("<CategoryID od:adotype='3'>1</CategoryID>");
		sb.Append("<CategoryName od:maxLength='15' adotype='130'>Beverages</CategoryName>");
		sb.Append("<Description od:adotype='203'>Soft drinks and teas</Description>");
		sb.Append("</Categories>");
		sb.Append("<Products>");
		sb.Append("<ProductID od:adotype='20'>1</ProductID>");
		sb.Append("<ReorderLevel od:adotype='3'>10</ReorderLevel>");
		sb.Append("<Discontinued od:adotype='11'>0</Discontinued>");
		sb.Append("</Products>");
		sb.Append("</NewDataSet>");

		MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));

		DataSet ds = new DataSet();
		//	ds.ReadXml(myStream);
		ds.InferXmlSchema(myStream, new string[] {"urn:schemas-microsoft-com:officedata"});
		Compare(ds.Tables.Count,3);

		Compare(ds.Tables[0].Columns.Count,3);
		Compare(ds.Tables[0].Columns["CategoryID"].ColumnName,"CategoryID"); 
		Compare(ds.Tables[0].Columns["Categories_Id"].ColumnName,"Categories_Id");//Hidden
		Compare(ds.Tables[0].Columns["Description"].ColumnName,"Description");
		

		Compare(ds.Tables[1].Columns.Count,3);
		Compare(ds.Tables[1].Columns["adotype"].ColumnName,"adotype");
		Compare(ds.Tables[1].Columns["CategoryName_Text"].ColumnName,"CategoryName_Text");
		Compare(ds.Tables[1].Columns["Categories_Id"].ColumnName,"Categories_Id");//Hidden

		Compare(ds.Tables[2].Columns.Count,3);
		Compare(ds.Tables[2].Columns["ProductID"].ColumnName,"ProductID");
		Compare(ds.Tables[2].Columns["ReorderLevel"].ColumnName,"ReorderLevel");
		Compare(ds.Tables[2].Columns["Discontinued"].ColumnName,"Discontinued");
	}
Beispiel #24
0
		[Test] public void InferXmlSchema_WithoutIgnoreNameSpaces()
		{
			StringBuilder sb  = new StringBuilder();
			sb.Append("<NewDataSet xmlns:od='urn:schemas-microsoft-com:officedata'>");
			sb.Append("<Categories>");
			sb.Append("<CategoryID od:adotype='3'>1</CategoryID>");
			sb.Append("<CategoryName od:maxLength='15' od:adotype='130'>Beverages</CategoryName>");
			sb.Append("<Description od:adotype='203'>Soft drinks and teas</Description>");
			sb.Append("</Categories>");
			sb.Append("<Products>");
			sb.Append("<ProductID od:adotype='20'>1</ProductID>");
			sb.Append("<ReorderLevel od:adotype='3'>10</ReorderLevel>");
			sb.Append("<Discontinued od:adotype='11'>0</Discontinued>");
			sb.Append("</Products>");
			sb.Append("</NewDataSet>");

			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));

			DataSet ds = new DataSet();
			//ds.ReadXml(myStream);
			ds.InferXmlSchema(myStream,new string[] {"urn:schemas-microsoft-com:officedata1"});
			Assert.AreEqual(8, ds.Tables.Count, "DS52");
		}
	public void test2() //Ignoring 2 namespaces
	{
		Exception exp = null;
		try
		{
			StringBuilder sb  = new StringBuilder();
			sb.Append("<h:html xmlns:xdc='http://www.xml.com/books' xmlns:h='http://www.w3.org/HTML/1998/html4'>");
			sb.Append("<h:head><h:title>Book Review</h:title></h:head>");
			sb.Append("<h:body>");
			sb.Append("<xdc:bookreview>");
			sb.Append("<xdc:title h:attrib1='1' xdc:attrib2='2' >XML: A Primer</xdc:title>");
			sb.Append("</xdc:bookreview>");
			sb.Append("</h:body>");
			sb.Append("</h:html>");

			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			DataSet tempDs = new DataSet();
			tempDs.ReadXml(myStream);
			myStream.Seek(0,SeekOrigin.Begin);
			DataSet ds = new DataSet();
			ds.InferXmlSchema(myStream, new string[] {"http://www.xml.com/books","http://www.w3.org/HTML/1998/html4"});
			//Compare(ds.Tables.Count,8);

//			string str1 = tempDs.GetXmlSchema(); //DataProvider.GetDSSchema(tempDs);
//			string str2 = ds.GetXmlSchema(); //DataProvider.GetDSSchema(ds);
			Compare(ds.Tables.Count,3);
			Compare(ds.Tables[2].TableName,"bookreview");
			Compare(ds.Tables[2].Columns.Count,2);
		}
		catch(Exception ex)
		{exp = ex;}
	
	}
Beispiel #26
0
		public void NullFileName ()
		{
			DataSet ds = new DataSet ();
			ds.InferXmlSchema ((XmlReader) null, null);
			AssertDataSet ("null", ds, "NewDataSet", 0, 0);
		}
Beispiel #27
0
		[Test] public void InferXmlSchema_IgnoreNameSpace()
		{
			StringBuilder sb  = new StringBuilder();
			sb.Append("<NewDataSet xmlns:od='urn:schemas-microsoft-com:officedata'>");
			sb.Append("<Categories>");
			sb.Append("<CategoryID od:adotype='3'>1</CategoryID>");
			sb.Append("<CategoryName od:maxLength='15' adotype='130'>Beverages</CategoryName>");
			sb.Append("<Description od:adotype='203'>Soft drinks and teas</Description>");
			sb.Append("</Categories>");
			sb.Append("<Products>");
			sb.Append("<ProductID od:adotype='20'>1</ProductID>");
			sb.Append("<ReorderLevel od:adotype='3'>10</ReorderLevel>");
			sb.Append("<Discontinued od:adotype='11'>0</Discontinued>");
			sb.Append("</Products>");
			sb.Append("</NewDataSet>");

			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));

			DataSet ds = new DataSet();
			//	ds.ReadXml(myStream);
			ds.InferXmlSchema(myStream, new string[] {"urn:schemas-microsoft-com:officedata"});
			Assert.AreEqual(3, ds.Tables.Count, "DS53");

			Assert.AreEqual(3, ds.Tables[0].Columns.Count, "DS54");
			Assert.AreEqual("CategoryID", ds.Tables[0].Columns["CategoryID"].ColumnName, "DS55");
			Assert.AreEqual("Categories_Id", ds.Tables[0].Columns["Categories_Id"].ColumnName, "DS56");//Hidden
			Assert.AreEqual("Description", ds.Tables[0].Columns["Description"].ColumnName, "DS57");

			Assert.AreEqual(3, ds.Tables[1].Columns.Count, "DS58");
			Assert.AreEqual("adotype", ds.Tables[1].Columns["adotype"].ColumnName, "DS59");
			Assert.AreEqual("CategoryName_Text", ds.Tables[1].Columns["CategoryName_Text"].ColumnName, "DS60");
			Assert.AreEqual("Categories_Id", ds.Tables[1].Columns["Categories_Id"].ColumnName, "DS61");//Hidden

			Assert.AreEqual(3, ds.Tables[2].Columns.Count, "DS62");
			Assert.AreEqual("ProductID", ds.Tables[2].Columns["ProductID"].ColumnName, "DS63");
			Assert.AreEqual("ReorderLevel", ds.Tables[2].Columns["ReorderLevel"].ColumnName, "DS64");
			Assert.AreEqual("Discontinued", ds.Tables[2].Columns["Discontinued"].ColumnName, "DS65");
		}
Beispiel #28
0
		public void IgnoredNamespaces ()
		{
			string xml = "<root attr='val' xmlns:a='urn:foo' a:foo='hogehoge' />";
			DataSet ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml), null);
			AssertDataSet ("ds", ds, "NewDataSet", 1, 0);
			AssertDataTable ("dt", ds.Tables [0], "root", 2, 0, 0, 0, 0, 0);

			ds = new DataSet ();
			ds.InferXmlSchema (new StringReader (xml), new string [] {"urn:foo"});
			AssertDataSet ("ds", ds, "NewDataSet", 1, 0);
			// a:foo is ignored
			AssertDataTable ("dt", ds.Tables [0], "root", 1, 0, 0, 0, 0, 0);
		}
Beispiel #29
0
		[Test] public void InferXmlSchema_IgnoreNameSpaces() //Ignoring 2 namespaces
		{
			StringBuilder sb  = new StringBuilder();
			sb.Append("<h:html xmlns:xdc='http://www.xml.com/books' xmlns:h='http://www.w3.org/HTML/1998/html4'>");
			sb.Append("<h:head><h:title>Book Review</h:title></h:head>");
			sb.Append("<h:body>");
			sb.Append("<xdc:bookreview>");
			sb.Append("<xdc:title h:attrib1='1' xdc:attrib2='2' >XML: A Primer</xdc:title>");
			sb.Append("</xdc:bookreview>");
			sb.Append("</h:body>");
			sb.Append("</h:html>");

			MemoryStream myStream = new MemoryStream(new ASCIIEncoding().GetBytes(sb.ToString()));
			DataSet tempDs = new DataSet();
			tempDs.ReadXml(myStream);
			myStream.Seek(0,SeekOrigin.Begin);
			DataSet ds = new DataSet();
			ds.InferXmlSchema(myStream, new string[] {"http://www.xml.com/books","http://www.w3.org/HTML/1998/html4"});
			//Assert.AreEqual(8, ds.Tables.Count, "DS66");

			//			string str1 = tempDs.GetXmlSchema(); //DataProvider.GetDSSchema(tempDs);
			//			string str2 = ds.GetXmlSchema(); //DataProvider.GetDSSchema(ds);
			Assert.AreEqual(3, ds.Tables.Count, "DS67");
			Assert.AreEqual("bookreview", ds.Tables[2].TableName, "DS68");
			Assert.AreEqual(2, ds.Tables[2].Columns.Count, "DS69");
		}