public void Ctor() { UniqueConstraint cst; //Success case cst = new UniqueConstraint(_table.Columns[0]); cst = new UniqueConstraint(new DataColumn[] { _table.Columns[0], _table.Columns[1]}); //table is set on ctor cst = new UniqueConstraint(_table.Columns[0]); Assert.Same(_table, cst.Table); //table is set on ctor cst = new UniqueConstraint(new DataColumn[] { _table.Columns[0], _table.Columns[1]}); Assert.Same(_table, cst.Table); cst = new UniqueConstraint("MyName", _table.Columns[0], true); //Test ctor parm set for ConstraintName & IsPrimaryKey Assert.Equal("MyName", cst.ConstraintName); Assert.False(cst.IsPrimaryKey); _table.Constraints.Add(cst); Assert.True(cst.IsPrimaryKey); Assert.Equal(1, _table.PrimaryKey.Length); Assert.True(_table.PrimaryKey[0].Unique); }
public void Columns() { DataTable dtParent = DataProvider.CreateParentDataTable(); UniqueConstraint uc = null; uc = new UniqueConstraint(dtParent.Columns[0]); // Columns 1 Assert.Equal(1, uc.Columns.Length); // Columns 2 Assert.Equal(dtParent.Columns[0], uc.Columns[0]); }
public void Equals_O() { var ds = new DataSet(); DataTable dtParent = DataProvider.CreateParentDataTable(); ds.Tables.Add(dtParent); UniqueConstraint uc1, uc2; uc1 = new UniqueConstraint(dtParent.Columns[0]); uc2 = new UniqueConstraint(dtParent.Columns[1]); // different columnn Assert.Equal(false, uc1.Equals(uc2)); //Two System.Data.ForeignKeyConstraint are equal if they constrain the same columns. // same column uc2 = new UniqueConstraint(dtParent.Columns[0]); Assert.Equal(true, uc1.Equals(uc2)); }
public void IsPrimaryKey() { DataTable dtParent = DataProvider.CreateParentDataTable(); UniqueConstraint uc = null; uc = new UniqueConstraint(dtParent.Columns[0], false); dtParent.Constraints.Add(uc); // primary key 1 Assert.Equal(false, uc.IsPrimaryKey); dtParent.Constraints.Remove(uc); uc = new UniqueConstraint(dtParent.Columns[0], true); dtParent.Constraints.Add(uc); // primary key 2 Assert.Equal(true, uc.IsPrimaryKey); }
public void BuildTable() { DataTable table = new DataTable(_table); DataColumnCollection cols = table.Columns; cols.Add(_id, typeof(int)); cols.Add(_name, typeof(string)); cols.Add(_state, typeof(string)); cols.Add(_urlImage, typeof(string)); cols.Add(_price, typeof(float)); cols.Add(_WarrantyMonth, typeof(int)); cols.Add(_ispromotion, typeof(int)); cols.Add(_shortnote, typeof(string)); cols.Add(_ispec, typeof(string)); cols.Add(_stateid, typeof(int)); UniqueConstraint uc = new UniqueConstraint(cols[_id], true); table.Constraints.Add(uc); this.Tables.Add(table); }
[Test] public void IndexOf_ByName() { DataTable dt = DataProvider.CreateUniqueConstraint(); dt.Constraints[0].ConstraintName = "name1"; Assert.AreEqual(0, dt.Constraints.IndexOf("name1"), "CN21"); //Add new constraint Constraint con = new UniqueConstraint(dt.Columns["String1"], false); con.ConstraintName = "name2"; dt.Constraints.Add(con); Assert.AreEqual(1, dt.Constraints.IndexOf("name2"), "CN22"); //Remove it and try to look for it dt.Constraints.Remove(con); Assert.AreEqual(-1, dt.Constraints.IndexOf("name2"), "CN23"); }
public void Indexer() { var c1 = new UniqueConstraint(_table.Columns[0]) { ConstraintName = "first" }; var c2 = new UniqueConstraint(_table.Columns[1]) { ConstraintName = "second" }; _table.Constraints.Add(c1); _table.Constraints.Add(c2); Assert.Same(c1, _table.Constraints[0]); Assert.Same(c2, _table.Constraints[1]); Assert.Same(c1, _table.Constraints["first"]); Assert.Same(c2, _table.Constraints["sEcond"]); // case insensitive }
public void Equals_O() { var ds = new DataSet(); DataTable dtParent = DataProvider.CreateParentDataTable(); ds.Tables.Add(dtParent); UniqueConstraint uc1, uc2; uc1 = new UniqueConstraint(dtParent.Columns[0]); uc2 = new UniqueConstraint(dtParent.Columns[1]); // different columnn Assert.False(uc1.Equals(uc2)); //Two System.Data.ForeignKeyConstraint are equal if they constrain the same columns. // same column uc2 = new UniqueConstraint(dtParent.Columns[0]); Assert.True(uc1.Equals(uc2)); }
public void AddRange() { _constraint1.ConstraintName = "UK1"; _constraint2.ConstraintName = "UK12"; var _constraint3 = new ForeignKeyConstraint("FK2", _table.Columns[0], _table2.Columns[0]); var _constraint4 = new UniqueConstraint("UK2", _table2.Columns[1]); // Add the constraints. Constraint[] constraints = { _constraint1, _constraint2 }; _table.Constraints.AddRange(constraints); Constraint[] constraints1 = { _constraint3, _constraint4 }; _table2.Constraints.AddRange(constraints1); Assert.Equal("UK1", _table.Constraints[0].ConstraintName); Assert.Equal("UK12", _table.Constraints[1].ConstraintName); Assert.Equal("FK2", _table2.Constraints[0].ConstraintName); Assert.Equal("UK2", _table2.Constraints[1].ConstraintName); }
public static DataSet GetClientes(sbyte frm) { MySqlConnection SqlConnection1 = DALBase.GetConnection(); MySqlDataAdapter SqlDataAdapter1 = new MySqlDataAdapter(); MySqlCommand SqlSelectCommand1 = new MySqlCommand("Clientes_Listar", SqlConnection1); SqlSelectCommand1.Parameters.AddWithValue("p_frm", frm); SqlDataAdapter1.SelectCommand = SqlSelectCommand1; SqlSelectCommand1.CommandType = CommandType.StoredProcedure; DataSet dt = new DataSet(); SqlDataAdapter1.Fill(dt, "Clientes"); if (!dt.Tables[0].Constraints.Contains("correoConstraint")) { UniqueConstraint uniqueConstraint = new UniqueConstraint("correoConstraint", dt.Tables[0].Columns["CorreoCLI"]); // dt.Tables[0].Constraints.Add(uniqueConstraint); } SqlConnection1.Close(); return(dt); }
private void ConstraintCollection_IndexOf_S1() { DataTable dt = GHTUtils.DataProvider.CreateUniqueConstraint(); dt.Constraints[0].ConstraintName = "name1"; Compare(dt.Constraints.IndexOf("name1"), 0); //Add new constraint Constraint con = new UniqueConstraint(dt.Columns["String1"], false); con.ConstraintName = "name2"; dt.Constraints.Add(con); Compare(dt.Constraints.IndexOf("name2"), 1); //Remove it and try to look for it dt.Constraints.Remove(con); Compare(dt.Constraints.IndexOf("name2"), -1); }
public void Ctor () { UniqueConstraint cst; //Success case try { cst = new UniqueConstraint (_table.Columns [0]); } catch (Exception exc) { Assert.Fail ("A1: Failed to ctor. " + exc.ToString ()); } try { cst = new UniqueConstraint (new DataColumn [] { _table.Columns[0], _table.Columns[1]}); } catch (Exception exc) { Assert.Fail ("A2: Failed to ctor. " + exc.ToString ()); } //table is set on ctor cst = new UniqueConstraint (_table.Columns [0]); Assert.That (cst.Table, Is.SameAs (_table), "B1"); //table is set on ctor cst = new UniqueConstraint (new DataColumn [] { _table.Columns[0], _table.Columns[1]}); Assert.That (cst.Table, Is.SameAs (_table), "B2"); cst = new UniqueConstraint ("MyName", _table.Columns [0], true); //Test ctor parm set for ConstraintName & IsPrimaryKey Assert.That (cst.ConstraintName, Is.EqualTo ("MyName"), "ConstraintName not set in ctor."); Assert.That (cst.IsPrimaryKey, Is.False, "IsPrimaryKey already set."); _table.Constraints.Add (cst); Assert.That (cst.IsPrimaryKey, Is.True, "IsPrimaryKey not set set."); Assert.That (_table.PrimaryKey.Length, Is.EqualTo (1), "PrimaryKey not set."); Assert.That (_table.PrimaryKey [0].Unique, Is.True, "Not unigue."); }
public override bool PerformSaveChanges() { GoobizFrame.Windows.Public.OrderHashtable hashtableControls = new GoobizFrame.Windows.Public.OrderHashtable(); hashtableControls.Add(gridView1.Columns["Ma_Tinh"], ""); hashtableControls.Add(gridView1.Columns["Ten_Tinh"], ""); hashtableControls.Add(gridView1.Columns["Id_Quocgia"], ""); if (!GoobizFrame.Windows.MdiUtils.Validator.CheckNullGrid(hashtableControls, gridView1)) { return(false); } try { dgrex_Dm_Tinh.EmbeddedNavigator.Buttons.DoClick(dgrex_Dm_Tinh.EmbeddedNavigator.Buttons.EndEdit); ds_Tinh.Tables[0].Columns["Ma_Tinh"].Unique = true; Constraint constraint = new UniqueConstraint("constraint1", new DataColumn[] { ds_Tinh.Tables[0].Columns["Ten_Tinh"], ds_Tinh.Tables[0].Columns["Id_Quocgia"] }, false); ds_Tinh.Tables[0].Constraints.Add(constraint); objMasterService.Update_Rex_Dm_Tinh_Collection(this.ds_Tinh); } catch (Exception ex) { if (ex.ToString().IndexOf("contains non-unique values") != -1) { GoobizFrame.Windows.Forms.UserMessage.Show("SYS_ALREADY_EXIST", new string[] { lblMa_Tinh.Text, lblMa_Tinh.Text }); return(false); } if (ex.ToString().IndexOf("These columns don't currently have unique values") != -1) { GoobizFrame.Windows.Forms.UserMessage.Show("SYS_ALREADY_EXIST", new string[] { lblTen_Tinh.Text, lblTen_Tinh.Text }); return(false); } //MessageBox.Show(ex.ToString()); } this.DisplayInfo(); return(true); }
internal void SetUniqueConstraints(IList <UniqueConstraintInfo> constraints) { var ucs = this.DecoratedObject.UniqueConstraints; var props = this.DecoratedObject.Properties; ucs.Clear(); foreach (var uc in constraints) { var constraint = new UniqueConstraint(); foreach (string name in uc.PropertyNames) { int idx = props.IndexOf(name); if (idx >= 0) { constraint.Properties.Add((DataPropertyDefinition)props[idx]); } } ucs.Add(constraint); } OnPropertyChanged("UniqueConstraints"); }
protected virtual void PopulateUniques() { foreach (Constraint constraint in this.Table.Constraints) { UniqueConstraint unique = constraint as UniqueConstraint; if (unique == null) { continue; } MethodUniqueValidator muv = this.CreateMethodUniqueValidator(unique); if (muv != null) { this.uniques.Add(muv); continue; } IUniqueValidator uv = new DictionaryUniqueValidator(this, unique); this.uniques.Add(uv); } }
// Even after EndInit(), MS.NET does not fill Table property // on UniqueConstraint. public void TestAddRange2() { DataTable table = new DataTable("Table"); DataColumn column1 = new DataColumn("col1"); DataColumn column2 = new DataColumn("col2"); DataColumn column3 = new DataColumn("col3"); table.Columns.Add(column1); table.Columns.Add(column2); table.Columns.Add(column3); string [] columnNames = { "col1", "col2", "col3" }; Constraint [] constraints = new Constraint[3]; constraints [0] = new UniqueConstraint("Unique1", column1); constraints [1] = new UniqueConstraint("Unique2", column2); constraints [2] = new UniqueConstraint("Unique3", columnNames, true); table.BeginInit(); //Console.WriteLine(table.InitStatus == DataTable.initStatus.BeginInit); table.Constraints.AddRange(constraints); //Check the table property of UniqueConstraint Object try { Assertion.AssertNull("#01", constraints [2].Table); } catch (Exception e) { Assertion.Assert("#A02", "System.NullReferenceException".Equals(e.GetType().ToString())); } table.EndInit(); // After EndInit is called the constraints associated with most recent call to AddRange() must be // added to the ConstraintCollection Assertion.Assert("#A03", constraints [2].Table.ToString().Equals("Table")); Assertion.Assert("#A04", table.Constraints.Contains("Unique1")); Assertion.Assert("#A05", table.Constraints.Contains("Unique2")); Assertion.Assert("#A06", table.Constraints.Contains("Unique3")); }
public void TestAddRange2() { DataTable table = new DataTable("Table"); DataColumn column1 = new DataColumn("col1"); DataColumn column2 = new DataColumn("col2"); DataColumn column3 = new DataColumn("col3"); table.Columns.Add(column1); table.Columns.Add(column2); table.Columns.Add(column3); string [] columnNames = { "col1", "col2", "col3" }; Constraint [] constraints = new Constraint[3]; constraints [0] = new UniqueConstraint("Unique1", column1); constraints [1] = new UniqueConstraint("Unique2", column2); constraints [2] = new UniqueConstraint("Unique3", columnNames, true); table.BeginInit(); //Console.WriteLine(table.InitStatus == DataTable.initStatus.BeginInit); table.Constraints.AddRange(constraints); //Check the table property of UniqueConstraint Object try { Assert.That(constraints [2].Table, Is.Null, "#A01"); } catch (Exception e) { Assert.That(e, Is.TypeOf(typeof(NullReferenceException)), "#A02"); } table.EndInit(); // After EndInit is called the constraints associated with most recent call to AddRange() must be // added to the ConstraintCollection /* dunno if the above is true, but it crashes on .NET either. Disabling. * Assert.That (constraints [2].Table.ToString (), Is.EqualTo ("Table"), "#A03"); * Assert.That (table.Constraints.Contains ("Unique1"), Is.True, "#A04"); * Assert.That (table.Constraints.Contains ("Unique3"), Is.True, "#A06"); * Assert.That (table.Constraints.Contains ("Unique2"), Is.True, "#A05"); */ }
static void Main(string[] args) { var table = new DataTable("MyTable"); var column = new DataColumn("PrimaryColumn", typeof(string)); table.Columns.Add(column); var pk_firstColumn = new UniqueConstraint(column, false); //isPrimaryKey = true table.Constraints.Add(pk_firstColumn); Console.WriteLine(table.Columns[0].Unique); //primary key gives uniquity Console.WriteLine(table.PrimaryKey.Length); //how much primary keys are there //Console.WriteLine(table.PrimaryKey[0].ColumnName); //which column is primary key Console.WriteLine(table.PrimaryKey.Length == 0 ? "there's no primary key" : $"{table.PrimaryKey[0].ColumnName} is primary key column"); Console.ReadKey(); }
protected void btnEliminaGWDet_Click(object sender, EventArgs e) { try { GridViewRow gridDetalleDelete = (GridViewRow)(((LinkButton)sender).Parent.Parent); DataTable dt = new DataTable("dtVacioDetalle"); dt.Columns.Add("Id_producto"); dt.Columns.Add("Nombre"); dt.Columns.Add("cantidad"); dt.Columns.Add("pvp"); dt.Columns.Add("total"); UniqueConstraint PrimaryKey = new UniqueConstraint(dt.Columns["Id_producto"], true); dt.Constraints.Add(PrimaryKey); if (grwDetalle.Rows.Count > 0) { foreach (GridViewRow gridDetalle in this.grwDetalle.Rows) { DataRow dr = dt.NewRow(); dr[0] = grwDetalle.DataKeys[gridDetalle.RowIndex].Value.ToString(); dr[1] = ((Label)gridDetalle.Cells[1].Controls[1]).Text; //PRODUCTO dr[2] = ((TextBox)gridDetalle.Cells[2].Controls[1]).Text; //Cantidad; dr[3] = ((TextBox)gridDetalle.Cells[3].Controls[1]).Text; //PRECIO; dt.Rows.Add(dr); } dt.Rows[gridDetalleDelete.RowIndex].Delete(); dt.AcceptChanges(); grwDetalle.DataSource = dt; grwDetalle.DataBind(); dt.Dispose(); } } catch (Exception E) { lblAlertas.Text = E.GetBaseException().ToString(); }finally { CalculadoraGrid(); } }
public void EnforceConstraint() { int id = 100; // Setup stuff DataSet ds = new DataSet(); DataTable parent = ds.Tables.Add("parent"); parent.Columns.Add("id", typeof(int)); DataTable child = ds.Tables.Add("child"); child.Columns.Add("idref", typeof(int)); Constraint uniqueId = null; parent.Constraints.Add(uniqueId = new UniqueConstraint("uniqueId", new DataColumn[] { parent.Columns["id"] }, true)); ForeignKeyConstraint fkc = new ForeignKeyConstraint("ParentChildConstraint", new DataColumn[] { parent.Columns["id"] }, new DataColumn[] { child.Columns["idref"] }); child.Constraints.Add(fkc); DataRelation relateParentChild = new DataRelation("relateParentChild", new DataColumn[] { parent.Columns["id"] }, new DataColumn[] { child.Columns["idref"] }, false); ds.Relations.Add(relateParentChild); ds.EnforceConstraints = false; DataRow parentRow = parent.Rows.Add(new object[] { id }); DataRow childRow = child.Rows.Add(new object[] { id }); if (parentRow == childRow.GetParentRow(relateParentChild)) { foreach (DataColumn dc in parent.Columns) { AssertEquals(100, parentRow[dc]); } } }
//Activate This Construntor to log All To Standard output //public TestClass():base(true){} //Activate this constructor to log Failures to a log file //public TestClass(System.IO.TextWriter tw):base(tw, false){} //Activate this constructor to log All to a log file //public TestClass(System.IO.TextWriter tw):base(tw, true){} //BY DEFAULT LOGGING IS DONE TO THE STANDARD OUTPUT ONLY FOR FAILURES public void run() { Exception exp = null; DataTable dtParent = GHTUtils.DataProvider.CreateParentDataTable(); UniqueConstraint uc = null; uc = new UniqueConstraint(dtParent.Columns[0], false); dtParent.Constraints.Add(uc); try { BeginCase("Ctor"); Compare(uc == null, false); } catch (Exception ex) { exp = ex; } finally { EndCase(exp); exp = null; } try { BeginCase("primary key 1"); Compare(dtParent.PrimaryKey.Length, 0); } catch (Exception ex) { exp = ex; } finally { EndCase(exp); exp = null; } dtParent.Constraints.Remove(uc); uc = new UniqueConstraint(dtParent.Columns[0], true); dtParent.Constraints.Add(uc); try { BeginCase("primary key 2"); Compare(dtParent.PrimaryKey.Length, 1); } catch (Exception ex) { exp = ex; } finally { EndCase(exp); exp = null; } }
public void ctor_DataColumnNoPrimary() { DataTable dtParent = DataProvider.CreateParentDataTable(); UniqueConstraint uc = null; uc = new UniqueConstraint(dtParent.Columns[0], false); dtParent.Constraints.Add(uc); // Ctor Assert.False(uc == null); // primary key 1 Assert.Equal(0, dtParent.PrimaryKey.Length); dtParent.Constraints.Remove(uc); uc = new UniqueConstraint(dtParent.Columns[0], true); dtParent.Constraints.Add(uc); // primary key 2 Assert.Equal(1, dtParent.PrimaryKey.Length); }
[Test] public void ctor_DataColumnPrimary() { DataTable dtParent = DataProvider.CreateParentDataTable(); UniqueConstraint uc = null; uc = new UniqueConstraint(dtParent.Columns[0], false); dtParent.Constraints.Add(uc); // Ctor Assert.AreEqual(false, uc == null, "UC22"); // primary key 1 Assert.AreEqual(0, dtParent.PrimaryKey.Length, "UC23"); dtParent.Constraints.Remove(uc); uc = new UniqueConstraint(dtParent.Columns[0], true); dtParent.Constraints.Add(uc); // primary key 2 Assert.AreEqual(1, dtParent.PrimaryKey.Length, "UC24"); }
public void AddUniqueExceptions() { //UC: can't create unique constraint because duplicate values already exist try { _table.Rows.Add(new object [] { 1 }); _table.Rows.Add(new object [] { 1 }); UniqueConstraint uc = new UniqueConstraint(_table.Columns[0]); _table.Constraints.Add(uc); //should throw Fail("B1: Failed to throw ArgumentException."); } catch (ArgumentException) {} catch (AssertionException exc) { throw exc; } catch (Exception exc) { Fail("A1: Wrong Exception type. " + exc.ToString()); } }
// Create a DataSet with two tables and populate it. private void MakeDataSet() { // Create a DataSet. myDataSet = new DataSet("myDataSet"); // Create a DataTable. DataTable myCustomerTable = new DataTable("Customers"); // Create two columns, and add them to the first table. DataColumn myCustomerColumnID = new DataColumn("CustID", typeof(int)); DataColumn myCustomerName = new DataColumn("CustName"); myCustomerTable.Columns.Add(myCustomerColumnID); myCustomerTable.Columns.Add(myCustomerName); // Add the tables to the DataSet. myDataSet.Tables.Add(myCustomerTable); DataRow newRow1; // Create three customers in the Customers Table. for (int i = 1; i < 4; i++) { newRow1 = myCustomerTable.NewRow(); newRow1["custID"] = i; // Add the row to the Customers table. myCustomerTable.Rows.Add(newRow1); } // Give each customer a distinct name. myCustomerTable.Rows[0]["custName"] = "Alpha"; myCustomerTable.Rows[1]["custName"] = "Beta"; myCustomerTable.Rows[2]["custName"] = "Omega"; UniqueConstraint idKeyRestraint = new UniqueConstraint(myCustomerColumnID); myCustomerTable.Constraints.Add(idKeyRestraint); myDataSet.EnforceConstraints = true; }
/* prepares a table with a unique constaint */ void PrepareData() { DataColumn column; column = table.Columns.Add("ID", typeof(int)); column.AutoIncrement = true; column.AutoIncrementSeed = 1; column.AllowDBNull = false; column = table.Columns.Add("Code", typeof(string)); /* adding a unique constraint */ UniqueConstraint constraint = new UniqueConstraint("UC_Code_Material", column); table.Constraints.Add(constraint); /* a unique constaint can be added in many ways * column.Unique = true; * or * table.Constraints.Add("UC_Code_Material", column, false); */ column = table.Columns.Add("Name", typeof(string)); column = table.Columns.Add("Price", typeof(double)); column.DefaultValue = 0.0; DataRow row; row = table.NewRow(); row["Code"] = "00"; row["Name"] = "Hard disk"; row["Price"] = 60.45; table.Rows.Add(row); Grid.DataSource = table; }
/* * Gets unique constraints availabe on the datatable. ***Serialized unique constraints format : [constraintName]->[columnIndexes]->[IsPrimaryKey]->[extendedProperties]*** */ private ArrayList GetUniqueConstraints(DataTable dt) { Debug.Assert(dt != null); ArrayList constraintList = new ArrayList(); for (int i = 0; i < dt.Constraints.Count; i++) { Constraint c = dt.Constraints[i]; UniqueConstraint uc = c as UniqueConstraint; if (uc != null) { string constraintName = c.ConstraintName; int[] colInfo = new int[uc.Columns.Length]; for (int j = 0; j < colInfo.Length; j++) { colInfo[j] = uc.Columns[j].Ordinal; } ArrayList list = new ArrayList(); list.Add(constraintName); list.Add(colInfo); list.Add(uc.IsPrimaryKey); Hashtable extendedProperties = new Hashtable(); if (uc.ExtendedProperties.Keys.Count > 0) { foreach (object propertyKey in uc.ExtendedProperties.Keys) { extendedProperties.Add(propertyKey, uc.ExtendedProperties[propertyKey]); } } list.Add(extendedProperties); constraintList.Add(list); } } return(constraintList); }
private void LoadData() { while (this.dgrdv.ColumnCount > PSNGridIndex) { this.dgrdv.Columns.RemoveAt(PSNGridIndex); } DataTable dtblPsns = this.accPieceworkItems.GetDataGroupPieceworkItemsPersonnelByDateManuf(this.dtpDateManuf.Value.Date).Tables[0]; foreach (DataRow drow in dtblPsns.Rows) { this.AddPsnColumn((int)drow["PsnID"], drow["PsnCode"].ToString(), drow["PsnName"].ToString()); } this.dtblPiecework = this.accPiecework.GetDataGroupPieceworkForSetting(this.dtpDateManuf.Value.Date).Tables[0]; UniqueConstraint c = new UniqueConstraint("c", new DataColumn[] { this.dtblPiecework.Columns ["ProcessTypeID"], this.dtblPiecework.Columns ["PrdID"], this.dtblPiecework.Columns ["ReworkFlag"] }); this.dtblPiecework.Constraints.Add(c); this.dtblPiecework.Columns["ReworkFlag"].DefaultValue = false; this.dgrdv.DataSource = this.dtblPiecework; }
public string CreateUniqueConstraint(UniqueConstraint uniqueConstraint) { var clusteredPrefix = uniqueConstraint.Clustered != null ? uniqueConstraint.Clustered == true ? "CLUSTERED " : "NONCLUSTERED " : null; var sb = new StringBuilder(); sb.Append("ALTER TABLE ") .Append(GetSimplifiedSchemaAndTableName(uniqueConstraint.SqlTable.SchemaAndTableName)) .Append(" ADD CONSTRAINT ") .Append(GuardKeywords(uniqueConstraint.Name)) .Append(" UNIQUE ") .Append(clusteredPrefix) .AppendLine(" (") .AppendLine(string.Join(", \r\n", uniqueConstraint.SqlColumns.Select(c => $"{GuardKeywords(c.SqlColumn.Name)}"))) // Index column list .AppendLine(");"); return(sb.ToString()); }
public Form1() { InitializeComponent(); table = dataSet1.Tables.Add("table"); table.Columns.Add("id", typeof(Int32)); table.Columns.Add("name", typeof(String)); table.Columns["name"].DefaultValue = "def"; table.Constraints.Add("PK_table", table.Columns["id"], true); table.Columns["id"].AutoIncrement = true; table.Columns["id"].AutoIncrementSeed = 1; Constraint c = new UniqueConstraint(table.Columns["name"]); table.Constraints.Add(c); dataGridView1.DataSource = dataSet1; dataGridView1.DataMember = "table"; }
public void Ctor_NameDataColumnsPrimary() { DataTable dtParent = DataProvider.CreateParentDataTable(); UniqueConstraint uc = new UniqueConstraint("myConstraint", new DataColumn[] { dtParent.Columns[0] }, false); dtParent.Constraints.Add(uc); // primary key 1 Assert.Equal(0, dtParent.PrimaryKey.Length); // Ctor name 1 Assert.Equal("myConstraint", uc.ConstraintName); dtParent.Constraints.Remove(uc); uc = new UniqueConstraint("myConstraint", new DataColumn[] { dtParent.Columns[0] }, true); dtParent.Constraints.Add(uc); // primary key 2 Assert.Equal(1, dtParent.PrimaryKey.Length); // Ctor name 2 Assert.Equal("myConstraint", uc.ConstraintName); }
public void EqualsAndHashCode() { UniqueConstraint cst = new UniqueConstraint(new DataColumn[] { _table.Columns[0], _table.Columns[1] }); UniqueConstraint cst2 = new UniqueConstraint(new DataColumn[] { _table.Columns[1], _table.Columns[0] }); UniqueConstraint cst3 = new UniqueConstraint(_table.Columns[0]); UniqueConstraint cst4 = new UniqueConstraint(_table.Columns[2]); //true Assert.True(cst.Equals(cst2)); //false Assert.False(cst.Equals(23)); Assert.False(cst.Equals(cst3)); Assert.False(cst3.Equals(cst)); Assert.False(cst.Equals(cst4)); Assert.NotEqual(cst3.GetHashCode(), cst.GetHashCode()); }
protected void AddUniqueConstraint(UniqueConstraint uniqueConstraint, string firstColumn = null) { var countToMerge = 0; var table = uniqueConstraint.SqlTable; foreach (var indexColumn in uniqueConstraint.SqlColumns) { if (firstColumn != null) { Write(table.SchemaAndTableName, firstColumn); } Write(table.SchemaAndTableName, uniqueConstraint.Name); WriteLine(table.SchemaAndTableName, indexColumn.SqlColumn.Name); countToMerge++; } if (countToMerge > 1) { MergeUpFromPreviousRow(table.SchemaAndTableName, countToMerge - 1); } }
public static void displayConstraint(DataTable dataTable) { Console.WriteLine("[제약 조건]"); DataColumn[] pkDataColumns = dataTable.PrimaryKey; foreach (DataColumn dataColumn in pkDataColumns) { Console.WriteLine("Prymary Key"); Console.WriteLine("\t" + dataColumn.ColumnName); } ConstraintCollection constraintCollection = dataTable.Constraints; foreach (Constraint constraint in constraintCollection) { Console.WriteLine(constraint.GetType()); if (constraint is UniqueConstraint) { UniqueConstraint uniqueConstraint = (UniqueConstraint)constraint; DataColumn[] dataColumns = uniqueConstraint.Columns; foreach (DataColumn dataColumn in dataColumns) { Console.WriteLine("\t" + uniqueConstraint.ConstraintName + ":\t" + dataColumn.ColumnName); } } else if (constraint is ForeignKeyConstraint) { ForeignKeyConstraint foreignKeyConstraint = (ForeignKeyConstraint)constraint; DataColumn[] dataColumns = foreignKeyConstraint.Columns; foreach (DataColumn dataColumn in dataColumns) { Console.WriteLine("\t" + foreignKeyConstraint.ConstraintName + ":\t" + dataColumn.ColumnName); } } } }
public void IndexOf_ByName() { DataTable dt = DataProvider.CreateUniqueConstraint(); dt.Constraints[0].ConstraintName = "name1"; Assert.Equal(0, dt.Constraints.IndexOf("name1")); //Add new constraint Constraint con = new UniqueConstraint(dt.Columns["String1"], false); con.ConstraintName = "name2"; dt.Constraints.Add(con); Assert.Equal(1, dt.Constraints.IndexOf("name2")); //Remove it and try to look for it dt.Constraints.Remove(con); Assert.Equal(-1, dt.Constraints.IndexOf("name2")); }
public void InsertAt() { _tbl.Columns.Add(); _tbl.Columns.Add(); _tbl.Columns.Add(); DataRowCollection Rows = _tbl.Rows; Rows.Add(new object[] { "a", "aa", "aaa" }); Rows.Add(new object[] { "b", "bb", "bbb" }); Rows.Add(new object[] { "c", "cc", "ccc" }); Rows.Add(new object[] { "d", "dd", "ddd" }); DataRow Row = _tbl.NewRow(); Row[0] = "e"; Row[1] = "ee"; Row[2] = "eee"; try { Rows.InsertAt(Row, -1); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(IndexOutOfRangeException), e.GetType()); // Never premise English. //Assert.Equal ("The row insert position -1 is invalid.", e.Message); } Rows.InsertAt(Row, 0); Assert.Equal("e", Rows[0][0]); Assert.Equal("a", Rows[1][0]); Row = _tbl.NewRow(); Row[0] = "f"; Row[1] = "ff"; Row[2] = "fff"; Rows.InsertAt(Row, 5); Assert.Equal("f", Rows[5][0]); Row = _tbl.NewRow(); Row[0] = "g"; Row[1] = "gg"; Row[2] = "ggg"; Rows.InsertAt(Row, 500); Assert.Equal("g", Rows[6][0]); try { Rows.InsertAt(Row, 6); //Row already belongs to the table Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(ArgumentException), e.GetType()); // Never premise English. //Assert.Equal ("This row already belongs to this table.", e.Message); } DataTable table = new DataTable(); DataColumn col = new DataColumn("Name"); table.Columns.Add(col); Row = table.NewRow(); Row["Name"] = "Abc"; table.Rows.Add(Row); try { Rows.InsertAt(Row, 6); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(ArgumentException), e.GetType()); // Never premise English. //Assert.Equal ("This row already belongs to another table.", e.Message); } table = new DataTable(); col = new DataColumn("Name"); col.DataType = typeof(string); table.Columns.Add(col); UniqueConstraint uk = new UniqueConstraint(col); table.Constraints.Add(uk); Row = table.NewRow(); Row["Name"] = "aaa"; table.Rows.InsertAt(Row, 0); Row = table.NewRow(); Row["Name"] = "aaa"; try { table.Rows.InsertAt(Row, 1); Assert.False(true); } catch (Exception e) { Assert.Equal(typeof(ConstraintException), e.GetType()); } try { table.Rows.InsertAt(null, 1); } catch (Exception e) { Assert.Equal(typeof(ArgumentNullException), e.GetType()); } }
private string _UniqueConstraintDefinition(UniqueConstraint constraint) { return string.Format( "UNIQUE({0})", string.Join(", ", (from column in constraint.columns select nameEscaper(column)).ToArray()) ); }
public void RemoveAt_Integer() { DataTable dt = DataProvider.CreateUniqueConstraint(); dt.Constraints.RemoveAt(0); Assert.Equal(0, dt.Constraints.Count); dt = DataProvider.CreateUniqueConstraint(); Constraint con = new UniqueConstraint(dt.Columns["String1"], false); dt.Constraints[0].ConstraintName = "constraint1"; con.ConstraintName = "constraint2"; dt.Constraints.Add(con); dt.Constraints.RemoveAt(0); Assert.Equal(1, dt.Constraints.Count); Assert.Equal("constraint2", dt.Constraints[0].ConstraintName); dt = DataProvider.CreateUniqueConstraint(); dt.Constraints.CollectionChanged += new CollectionChangeEventHandler(Constraints_CollectionChanged); dt.Constraints.RemoveAt(0); Assert.Equal(true, _collectionChanged); ArrayList arr = new ArrayList(1); arr.Add(new IndexOutOfRangeException()); TestException(new testExceptionMethodCallback(RemoveAt_I), arr); }
/// <summary> /// Drops the <see cref="UniqueConstraint"/> with the specified <paramref name="name"/>. /// </summary> /// <param name="name">The constraint's name.</param> /// <returns>The constraint.</returns> public UniqueConstraint DropUniqueConstraint(string name) { var c = new UniqueConstraint(this, name, Modifier.Drop); Database.MigrationSteps.EnqueueBefore(c, (e => e == this)); return c; }
/// <summary> /// Adds the unique <see cref="Constraint"/> to this <see cref="Table"/>. /// </summary> /// <param name="name">The name of the constraint.</param> /// <param name="columnNames">The names of the columns that in conjunctions need to be unique.</param> /// <returns>The unique constraint.</returns> public UniqueConstraint AddUniqueConstraint(string name, string[] columnNames) { var c = new UniqueConstraint(this, name, Modifier.Add) { ColumnNames = columnNames }; Database.MigrationSteps.Enqueue(c); return c; }
public void EqualsAndHashCode() { UniqueConstraint cst = new UniqueConstraint(new DataColumn[] { _table.Columns[0], _table.Columns[1]}); UniqueConstraint cst2 = new UniqueConstraint(new DataColumn[] { _table.Columns[1], _table.Columns[0]}); UniqueConstraint cst3 = new UniqueConstraint(_table.Columns[0]); UniqueConstraint cst4 = new UniqueConstraint(_table.Columns[2]); //true Assert.True(cst.Equals(cst2)); //false Assert.False(cst.Equals(23)); Assert.False(cst.Equals(cst3)); Assert.False(cst3.Equals(cst)); Assert.False(cst.Equals(cst4)); Assert.NotEqual(cst3.GetHashCode(), cst.GetHashCode()); }
public void Unique() { UniqueConstraint U = new UniqueConstraint(_table.Columns[0]); Assert.False(_table.Columns[0].Unique); U = new UniqueConstraint(new DataColumn[] { _table.Columns[0], _table.Columns[1] }); Assert.False(_table.Columns[0].Unique); Assert.False(_table.Columns[1].Unique); Assert.False(_table.Columns[2].Unique); _table.Constraints.Add(U); Assert.False(_table.Columns[0].Unique); Assert.False(_table.Columns[1].Unique); Assert.False(_table.Columns[2].Unique); }
public void ApplyDefaultSort() { UniqueConstraint uc = new UniqueConstraint(_dataTable.Columns["itemId"]); _dataTable.Constraints.Add(uc); _dataView.ApplyDefaultSort = true; // dataView.Sort = "itemName"; // AssertEquals ("test#01","item 1",dataView[0]["itemId"]); Assert.Equal(ListChangedType.Reset, _listChangedArgs.ListChangedType); // UnComment the line below to see if dataView is sorted // PrintTableOrView (dataView,"* OnApplyDefaultSort"); }
public abstract void Visit(UniqueConstraint constraint);
/// <summary> /// Enumerates the SQL commands that are necessary to drop /// the specified <paramref name="uniqueConstraint"/>. /// </summary> /// <param name="uniqueConstraint">The unique constraint.</param> /// <returns>The SQL commands.</returns> protected virtual IEnumerable<string> DropUniqueConstraint(UniqueConstraint uniqueConstraint) { yield return string.Format("ALTER TABLE {0} DROP CONSTRAINT {1};", EscapeTableName(uniqueConstraint.Table.Name), EscapeConstraintName(uniqueConstraint.Name) ); }
public static DataTable CreateUniqueConstraint(DataTable dt) { Constraint con = new UniqueConstraint(dt.Columns["ParentId"]); dt.Constraints.Add(con); return dt; }
public void AssertUniqueConstraint(string label, UniqueConstraint uc, string name, bool isPrimaryKey, string[] colNames) { Assert.Equal(name, uc.ConstraintName); Assert.Equal(isPrimaryKey, uc.IsPrimaryKey); for (int i = 0; i < colNames.Length; i++) Assert.Equal(colNames[i], uc.Columns[i].ColumnName); Assert.Equal(colNames.Length, uc.Columns.Length); }
public void EnforceConstraint() { int id = 100; // Setup stuff var ds = new DataSet(); DataTable parent = ds.Tables.Add("parent"); parent.Columns.Add("id", typeof(int)); DataTable child = ds.Tables.Add("child"); child.Columns.Add("idref", typeof(int)); Constraint uniqueId = null; parent.Constraints.Add(uniqueId = new UniqueConstraint("uniqueId", new DataColumn[] { parent.Columns["id"] }, true)); ForeignKeyConstraint fkc = new ForeignKeyConstraint("ParentChildConstraint", new DataColumn[] { parent.Columns["id"] }, new DataColumn[] { child.Columns["idref"] }); child.Constraints.Add(fkc); DataRelation relateParentChild = new DataRelation("relateParentChild", new DataColumn[] { parent.Columns["id"] }, new DataColumn[] { child.Columns["idref"] }, false); ds.Relations.Add(relateParentChild); ds.EnforceConstraints = false; DataRow parentRow = parent.Rows.Add(new object[] { id }); DataRow childRow = child.Rows.Add(new object[] { id }); if (parentRow == childRow.GetParentRow(relateParentChild)) { foreach (DataColumn dc in parent.Columns) Assert.Equal(100, parentRow[dc]); } }
public void Remove_ByNameWithAdd() { DataTable dt = DataProvider.CreateUniqueConstraint(); dt.Constraints[0].ConstraintName = "constraint1"; Constraint con = new UniqueConstraint(dt.Columns["String1"], false); dt.Constraints.Add(con); dt.Constraints.Remove(con); Assert.Equal(1, dt.Constraints.Count); Assert.Equal("constraint1", dt.Constraints[0].ConstraintName); }
/// <summary> /// Create a new UniqueConstraint object. /// </summary> /// <param name="id">Initial value of Id.</param> /// <param name="name">Initial value of Name.</param> /// <param name="isDeferrable">Initial value of IsDeferrable.</param> /// <param name="isInitiallyDeferred">Initial value of IsInitiallyDeferred.</param> public static UniqueConstraint CreateUniqueConstraint(string id, string name, bool isDeferrable, bool isInitiallyDeferred) { UniqueConstraint uniqueConstraint = new UniqueConstraint(); uniqueConstraint.Id = id; uniqueConstraint.Name = name; uniqueConstraint.IsDeferrable = isDeferrable; uniqueConstraint.IsInitiallyDeferred = isInitiallyDeferred; return uniqueConstraint; }
private int PurgeAffectedConstraints(string className, UniqueConstraint[] constraints) { if (constraints == null || constraints.Count() == 0) return 0; int removed = 0; var cls = _schema.Classes.Cast<ClassDefinition>().Where(c => c.Name == className).FirstOrDefault(); if (cls != null) { foreach (var uc in constraints) { cls.UniqueConstraints.Remove(uc); removed++; } } return removed; }
public void AddRange_C3() { Assert.Throws<ArgumentException>(() => { var ds = new DataSet(); ds.Tables.Add(DataProvider.CreateParentDataTable()); ds.Tables.Add(DataProvider.CreateChildDataTable()); Constraint badConstraint = new UniqueConstraint(ds.Tables[0].Columns[0]); ds.Tables[1].Constraints.AddRange(new Constraint[] { badConstraint }); //Cuz foreign key belongs to child table }); }
private Constraint[] GetConstraintArray(DataSet ds) { DataTable parent = ds.Tables[0]; DataTable child = ds.Tables[1]; Constraint[] constArray = new Constraint[2]; //Create unique constArray[0] = new UniqueConstraint("Unique1", child.Columns["ChildDouble"]); //Create foreign constArray[1] = new ForeignKeyConstraint(parent.Columns[0], child.Columns[1]); return constArray; }
public void Generate() { DataTable dtParent = DataProvider.CreateParentDataTable(); DataTable dtChild = DataProvider.CreateChildDataTable(); var ds = new DataSet(); ds.Tables.Add(dtChild); ds.Tables.Add(dtParent); //------ check UniqueConstraint --------- //create unique constraint UniqueConstraint uc; //Column type = int uc = new UniqueConstraint(dtParent.Columns[0]); dtParent.Constraints.Add(uc); Assert.Throws<ConstraintException>(() => dtParent.Rows.Add(dtParent.Rows[0].ItemArray)); //add exisiting value - will raise exception //Column type = DateTime dtParent.Constraints.Clear(); uc = new UniqueConstraint(dtParent.Columns["ParentDateTime"]); dtParent.Constraints.Add(uc); Assert.Throws<ConstraintException>(() => dtParent.Rows.Add(dtParent.Rows[0].ItemArray)); //add exisiting value - will raise exception //Column type = double dtParent.Constraints.Clear(); uc = new UniqueConstraint(dtParent.Columns["ParentDouble"]); dtParent.Constraints.Add(uc); Assert.Throws<ConstraintException>(() => dtParent.Rows.Add(dtParent.Rows[0].ItemArray)); //add exisiting value - will raise exception //Column type = string dtParent.Constraints.Clear(); uc = new UniqueConstraint(dtParent.Columns["String1"]); dtParent.Constraints.Add(uc); Assert.Throws<ConstraintException>(() => dtParent.Rows.Add(dtParent.Rows[0].ItemArray)); //add exisiting value - will raise exception //Column type = string, ds.CaseSensitive = false; ds.CaseSensitive = false; dtParent.Constraints.Clear(); uc = new UniqueConstraint(dtParent.Columns["String1"]); dtParent.Constraints.Add(uc); DataRow dr = dtParent.NewRow(); dr.ItemArray = dtParent.Rows[0].ItemArray; dr["String1"] = dr["String1"].ToString().ToUpper(); // UniqueConstraint Exception - Column type = String, CaseSensitive = false; Assert.Throws<ConstraintException>(() => dtParent.Rows.Add(dr)); ds.CaseSensitive = true; //Column type = string, ds.CaseSensitive = true; dtParent.Constraints.Clear(); uc = new UniqueConstraint(dtParent.Columns["String1"]); dtParent.Constraints.Add(uc); // No UniqueConstraint Exception - Column type = String, CaseSensitive = true; dtParent.Rows.Add(dr); // Column type = string, ds.CaseSensitive = false; // UniqueConstraint Exception - Column type = String, Enable CaseSensitive = true; Assert.Throws<ConstraintException>(() => ds.CaseSensitive = false); dtChild.Constraints.Add(new UniqueConstraint(new DataColumn[] { dtChild.Columns[0], dtChild.Columns[1] })); ds.EnforceConstraints = false; dtChild.Rows.Add(dtChild.Rows[0].ItemArray); // UniqueConstraint Exception - ds.EnforceConstraints Assert.Throws<ConstraintException>(() => ds.EnforceConstraints = true); }
/// <summary> /// Enumerates the SQL commands that are necessary to create /// the specified <paramref name="uniqueConstraint"/>. /// </summary> /// <param name="uniqueConstraint">The unique constraint.</param> /// <returns>The SQL commands.</returns> protected virtual IEnumerable<string> AddUniqueConstraint(UniqueConstraint uniqueConstraint) { yield return string.Format( "ALTER TABLE {0} ADD CONSTRAINT {1} UNIQUE ({2});", EscapeTableName(uniqueConstraint.Table.Name), EscapeConstraintName(uniqueConstraint.Name), string.Join(", ", EscapeColumnNames(uniqueConstraint.ColumnNames)) ); }
/// <summary> /// Utility method to copy all unique constraints of a class /// </summary> /// <param name="source"></param> /// <param name="target"></param> private static void CopyUniqueConstraints(UniqueConstraintCollection source, ClassDefinition target) { if (source.Count == 0) return; var props = target.Properties; foreach (UniqueConstraint uniq in source) { var ucs = new UniqueConstraint(); foreach (DataPropertyDefinition dp in uniq.Properties) { if (props.Contains(dp.Name)) { var prop = props[dp.Name]; if (prop.PropertyType == PropertyType.PropertyType_DataProperty) ucs.Properties.Add((DataPropertyDefinition)prop); } } target.UniqueConstraints.Add(ucs); } }
private object[] SetupSchemaWithKeyInfo(MissingMappingAction mappingAction, MissingSchemaAction schemaAction, bool gettingData, DataColumn parentChapterColumn, object chapterValue) { // must sort rows from schema table by ordinal because Jet is sorted by coumn name DbSchemaRow[] schemaRows = DbSchemaRow.GetSortedSchemaRows(_schemaTable, _dataReader.ReturnProviderSpecificTypes); Debug.Assert(null != schemaRows, "SchemaSetup - null DbSchemaRow[]"); Debug.Assert(_dataReader.FieldCount <= schemaRows.Length, "unexpected fewer rows in Schema than FieldCount"); if (0 == schemaRows.Length) { _dataTable = null; return null; } // Everett behavior, always add a primary key if a primary key didn't exist before // Whidbey behavior, same as Everett unless using LoadOption then add primary key only if no columns previously existed bool addPrimaryKeys = (((0 == _dataTable.PrimaryKey.Length) && ((4 <= (int)_loadOption) || (0 == _dataTable.Rows.Count))) || (0 == _dataTable.Columns.Count)); DataColumn[] keys = null; int keyCount = 0; bool isPrimary = true; // assume key info (if any) is about a primary key string keyBaseTable = null; string commonBaseTable = null; bool keyFromMultiTable = false; bool commonFromMultiTable = false; int[] columnIndexMap = null; bool[] chapterIndexMap = null; int mappingCount = 0; object[] dataValues = null; List<object> addedItems = null; DataColumnCollection columnCollection = _dataTable.Columns; try { for (int sortedIndex = 0; sortedIndex < schemaRows.Length; ++sortedIndex) { DbSchemaRow schemaRow = schemaRows[sortedIndex]; int unsortedIndex = schemaRow.UnsortedIndex; bool ischapter = false; Type fieldType = schemaRow.DataType; if (null == fieldType) { fieldType = _dataReader.GetFieldType(sortedIndex); } if (null == fieldType) { throw ADP.MissingDataReaderFieldType(sortedIndex); } // if IDataReader, hierarchy exists and we will use an Int32,AutoIncrementColumn in this table if (typeof(IDataReader).IsAssignableFrom(fieldType)) { if (null == chapterIndexMap) { chapterIndexMap = new bool[schemaRows.Length]; } chapterIndexMap[unsortedIndex] = ischapter = true; fieldType = typeof(int); } else if (typeof(System.Data.SqlTypes.SqlXml).IsAssignableFrom(fieldType)) { if (null == _xmlMap) { _xmlMap = new int[schemaRows.Length]; } _xmlMap[sortedIndex] = SqlXml; } else if (typeof(System.Xml.XmlReader).IsAssignableFrom(fieldType)) { fieldType = typeof(string); if (null == _xmlMap) { _xmlMap = new int[schemaRows.Length]; } _xmlMap[sortedIndex] = XmlDocument; } DataColumn dataColumn = null; if (!schemaRow.IsHidden) { dataColumn = _tableMapping.GetDataColumn(_fieldNames[sortedIndex], fieldType, _dataTable, mappingAction, schemaAction); } string basetable = /*schemaRow.BaseServerName+schemaRow.BaseCatalogName+schemaRow.BaseSchemaName+*/ schemaRow.BaseTableName; if (null == dataColumn) { if (null == columnIndexMap) { columnIndexMap = CreateIndexMap(schemaRows.Length, unsortedIndex); } columnIndexMap[unsortedIndex] = -1; // if the column is not mapped and it is a key, then don't add any key information if (schemaRow.IsKey) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: partial primary key detected"); } #endif // if the hidden key comes from a different table - don't throw away the primary key // example SELECT [T2].[ID], [T2].[ProdID], [T2].[VendorName] FROM [Vendor] AS [T2], [Prod] AS [T1] WHERE (([T1].[ProdID] = [T2].[ProdID])) if (keyFromMultiTable || (schemaRow.BaseTableName == keyBaseTable)) { addPrimaryKeys = false; // don't add any future keys now keys = null; // get rid of any keys we've seen } } continue; // null means ignore (mapped to nothing) } else if ((null != _xmlMap) && (0 != _xmlMap[sortedIndex])) { if (typeof(System.Data.SqlTypes.SqlXml) == dataColumn.DataType) { _xmlMap[sortedIndex] = SqlXml; } else if (typeof(System.Xml.XmlDocument) == dataColumn.DataType) { _xmlMap[sortedIndex] = XmlDocument; } else { _xmlMap[sortedIndex] = 0; // datacolumn is not a specific Xml dataType, i.e. string int total = 0; for (int x = 0; x < _xmlMap.Length; ++x) { total += _xmlMap[x]; } if (0 == total) { // not mapping to a specific Xml datatype, get rid of the map _xmlMap = null; } } } if (schemaRow.IsKey) { if (basetable != keyBaseTable) { if (null == keyBaseTable) { keyBaseTable = basetable; } else keyFromMultiTable = true; } } if (ischapter) { if (null == dataColumn.Table) { dataColumn.AllowDBNull = false; dataColumn.AutoIncrement = true; dataColumn.ReadOnly = true; } else if (!dataColumn.AutoIncrement) { throw ADP.FillChapterAutoIncrement(); } } else { if (!commonFromMultiTable) { if ((basetable != commonBaseTable) && (!string.IsNullOrEmpty(basetable))) { if (null == commonBaseTable) { commonBaseTable = basetable; } else { commonFromMultiTable = true; } } } if (4 <= (int)_loadOption) { if (schemaRow.IsAutoIncrement && DataColumn.IsAutoIncrementType(fieldType)) { // CONSIDER: use T-SQL "IDENT_INCR('table_or_view')" and "IDENT_SEED('table_or_view')" // functions to obtain the actual increment and seed values dataColumn.AutoIncrement = true; if (!schemaRow.AllowDBNull) { dataColumn.AllowDBNull = false; } } // setup maxLength, only for string columns since this is all the DataSet supports if (fieldType == typeof(string)) { // schemaRow.Size is count of characters for string columns, count of bytes otherwise dataColumn.MaxLength = schemaRow.Size > 0 ? schemaRow.Size : -1; } if (schemaRow.IsReadOnly) { dataColumn.ReadOnly = true; } if (!schemaRow.AllowDBNull && (!schemaRow.IsReadOnly || schemaRow.IsKey)) { dataColumn.AllowDBNull = false; } if (schemaRow.IsUnique && !schemaRow.IsKey && !fieldType.IsArray) { // note, arrays are not comparable so only mark non-arrays as unique, ie timestamp columns // are unique, but not comparable dataColumn.Unique = true; if (!schemaRow.AllowDBNull) { dataColumn.AllowDBNull = false; } } } else if (null == dataColumn.Table) { dataColumn.AutoIncrement = schemaRow.IsAutoIncrement; dataColumn.AllowDBNull = schemaRow.AllowDBNull; dataColumn.ReadOnly = schemaRow.IsReadOnly; dataColumn.Unique = schemaRow.IsUnique; if (fieldType == typeof(string) || (fieldType == typeof(SqlTypes.SqlString))) { // schemaRow.Size is count of characters for string columns, count of bytes otherwise dataColumn.MaxLength = schemaRow.Size; } } } if (null == dataColumn.Table) { if (4 > (int)_loadOption) { AddAdditionalProperties(dataColumn, schemaRow.DataRow); } AddItemToAllowRollback(ref addedItems, dataColumn); columnCollection.Add(dataColumn); } // The server sends us one key per table according to these rules. // // 1. If the table has a primary key, the server sends us this key. // 2. If the table has a primary key and a unique key, it sends us the primary key // 3. if the table has no primary key but has a unique key, it sends us the unique key // // In case 3, we will promote a unique key to a primary key IFF all the columns that compose // that key are not nullable since no columns in a primary key can be null. If one or more // of the keys is nullable, then we will add a unique constraint. // if (addPrimaryKeys && schemaRow.IsKey) { if (keys == null) { keys = new DataColumn[schemaRows.Length]; } keys[keyCount++] = dataColumn; #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: building list of " + ((isPrimary) ? "PrimaryKey" : "UniqueConstraint")); } #endif // see case 3 above, we do want dataColumn.AllowDBNull not schemaRow.AllowDBNull // otherwise adding PrimaryKey will change AllowDBNull to false if (isPrimary && dataColumn.AllowDBNull) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: changing PrimaryKey into UniqueContraint"); } #endif isPrimary = false; } } if (null != columnIndexMap) { columnIndexMap[unsortedIndex] = dataColumn.Ordinal; } else if (unsortedIndex != dataColumn.Ordinal) { columnIndexMap = CreateIndexMap(schemaRows.Length, unsortedIndex); columnIndexMap[unsortedIndex] = dataColumn.Ordinal; } mappingCount++; } bool addDataRelation = false; DataColumn chapterColumn = null; if (null != chapterValue) { // add the extra column in the child table Type fieldType = chapterValue.GetType(); chapterColumn = _tableMapping.GetDataColumn(_tableMapping.SourceTable, fieldType, _dataTable, mappingAction, schemaAction); if (null != chapterColumn) { if (null == chapterColumn.Table) { chapterColumn.ReadOnly = true; chapterColumn.AllowDBNull = false; AddItemToAllowRollback(ref addedItems, chapterColumn); columnCollection.Add(chapterColumn); addDataRelation = (null != parentChapterColumn); } mappingCount++; } } if (0 < mappingCount) { if ((null != _dataSet) && null == _dataTable.DataSet) { AddItemToAllowRollback(ref addedItems, _dataTable); _dataSet.Tables.Add(_dataTable); } // setup the key if (addPrimaryKeys && (null != keys)) { if (keyCount < keys.Length) { keys = ResizeColumnArray(keys, keyCount); } if (isPrimary) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: set_PrimaryKey"); } #endif _dataTable.PrimaryKey = keys; } else { UniqueConstraint unique = new UniqueConstraint("", keys); ConstraintCollection constraints = _dataTable.Constraints; int constraintCount = constraints.Count; for (int i = 0; i < constraintCount; ++i) { if (unique.Equals(constraints[i])) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: duplicate Contraint detected"); } #endif unique = null; break; } } if (null != unique) { #if DEBUG if (AdapterSwitches.DataSchema.TraceVerbose) { Debug.WriteLine("SetupSchema: adding new UniqueConstraint"); } #endif constraints.Add(unique); } } } if (!commonFromMultiTable && !string.IsNullOrEmpty(commonBaseTable) && string.IsNullOrEmpty(_dataTable.TableName)) { _dataTable.TableName = commonBaseTable; } if (gettingData) { _indexMap = columnIndexMap; _chapterMap = chapterIndexMap; dataValues = SetupMapping(schemaRows.Length, columnCollection, chapterColumn, chapterValue); } else { // debug only, but for retail debug ability _mappedMode = -1; } } else { _dataTable = null; } if (addDataRelation) { AddRelation(parentChapterColumn, chapterColumn); } } catch (Exception e) when (ADP.IsCatchableOrSecurityExceptionType(e)) { RollbackAddedItems(addedItems); throw; } return dataValues; }
/// <summary> /// Builds the SQL fragment that describes a unqiue constraint /// within a CREATE TABLE statement. /// </summary> /// <param name="uniqueConstraint">The unique constraint.</param> /// <returns>The SQL fragment.</returns> protected virtual string BuildCreateTableUniqueConstraint(UniqueConstraint uniqueConstraint) { if (uniqueConstraint.Name != null) { return string.Format("CONSTRAINT {0} UNIQUE ({1})", EscapeConstraintName(uniqueConstraint.Name), string.Join(", ", EscapeColumnNames(uniqueConstraint.ColumnNames)) ); } else { return string.Format("UNIQUE ({0})", string.Join(", ", EscapeColumnNames(uniqueConstraint.ColumnNames)) ); } }
public void CloneCopy() { DataTable table = new DataTable("pTable"); DataTable table1 = new DataTable("cTable"); DataSet set = new DataSet(); set.Tables.Add(table); set.Tables.Add(table1); DataColumn col = new DataColumn(); col.ColumnName = "Id"; col.DataType = Type.GetType("System.Int32"); table.Columns.Add(col); UniqueConstraint uc = new UniqueConstraint("UK1", table.Columns[0]); table.Constraints.Add(uc); col = new DataColumn(); col.ColumnName = "Name"; col.DataType = Type.GetType("System.String"); table.Columns.Add(col); col = new DataColumn(); col.ColumnName = "Id"; col.DataType = Type.GetType("System.Int32"); table1.Columns.Add(col); col = new DataColumn(); col.ColumnName = "Name"; col.DataType = Type.GetType("System.String"); table1.Columns.Add(col); ForeignKeyConstraint fc = new ForeignKeyConstraint("FK1", table.Columns[0], table1.Columns[0]); table1.Constraints.Add(fc); DataRow row = table.NewRow(); row["Id"] = 147; row["name"] = "Row1"; row.RowError = "Error#1"; table.Rows.Add(row); // Set column to RO as commonly used by auto-increment fields. // ds.Copy() has to omit the RO check when cloning DataRows table.Columns["Id"].ReadOnly = true; row = table1.NewRow(); row["Id"] = 147; row["Name"] = "Row1"; table1.Rows.Add(row); //Setting properties of DataSet set.CaseSensitive = true; set.DataSetName = "My DataSet"; set.EnforceConstraints = false; set.Namespace = "Namespace#1"; set.Prefix = "Prefix:1"; DataRelation dr = new DataRelation("DR", table.Columns[0], table1.Columns[0]); set.Relations.Add(dr); set.ExtendedProperties.Add("TimeStamp", DateTime.Now); CultureInfo cultureInfo = new CultureInfo("ar-SA"); set.Locale = cultureInfo; //Testing Copy () DataSet copySet = set.Copy(); Assert.Equal(set.CaseSensitive, copySet.CaseSensitive); Assert.Equal(set.DataSetName, copySet.DataSetName); Assert.Equal(set.EnforceConstraints, copySet.EnforceConstraints); Assert.Equal(set.HasErrors, copySet.HasErrors); Assert.Equal(set.Namespace, copySet.Namespace); Assert.Equal(set.Prefix, copySet.Prefix); Assert.Equal(set.Relations.Count, copySet.Relations.Count); Assert.Equal(set.Tables.Count, copySet.Tables.Count); Assert.Equal(set.ExtendedProperties["TimeStamp"], copySet.ExtendedProperties["TimeStamp"]); for (int i = 0; i < copySet.Tables.Count; i++) { Assert.Equal(set.Tables[i].Rows.Count, copySet.Tables[i].Rows.Count); Assert.Equal(set.Tables[i].Columns.Count, copySet.Tables[i].Columns.Count); } //Testing Clone () copySet = set.Clone(); Assert.Equal(set.CaseSensitive, copySet.CaseSensitive); Assert.Equal(set.DataSetName, copySet.DataSetName); Assert.Equal(set.EnforceConstraints, copySet.EnforceConstraints); Assert.False(copySet.HasErrors); Assert.Equal(set.Namespace, copySet.Namespace); Assert.Equal(set.Prefix, copySet.Prefix); Assert.Equal(set.Relations.Count, copySet.Relations.Count); Assert.Equal(set.Tables.Count, copySet.Tables.Count); Assert.Equal(set.ExtendedProperties["TimeStamp"], copySet.ExtendedProperties["TimeStamp"]); for (int i = 0; i < copySet.Tables.Count; i++) { Assert.Equal(0, copySet.Tables[i].Rows.Count); Assert.Equal(set.Tables[i].Columns.Count, copySet.Tables[i].Columns.Count); } }
public void CloneCopyTest() { DataTable table = new DataTable(); table.TableName = "Table#1"; DataTable table1 = new DataTable(); table1.TableName = "Table#2"; table.AcceptChanges(); DataSet set = new DataSet("Data Set#1"); set.DataSetName = "Dataset#1"; set.Tables.Add(table); set.Tables.Add(table1); DataColumn col = new DataColumn(); col.ColumnName = "Id"; col.DataType = typeof(int); table.Columns.Add(col); UniqueConstraint uc = new UniqueConstraint("UK1", table.Columns[0]); table.Constraints.Add(uc); col = new DataColumn(); col.ColumnName = "Id"; col.DataType = typeof(int); table1.Columns.Add(col); col = new DataColumn(); col.ColumnName = "Name"; col.DataType = typeof(string); table.Columns.Add(col); col = new DataColumn(); col.ColumnName = "Name"; col.DataType = typeof(string); table1.Columns.Add(col); DataRow row = table.NewRow(); row["Id"] = 147; row["name"] = "Abc"; row.RowError = "Error#1"; table.Rows.Add(row); row = table.NewRow(); row["Id"] = 47; row["name"] = "Efg"; table.Rows.Add(row); table.AcceptChanges(); table.CaseSensitive = true; table1.CaseSensitive = true; table.MinimumCapacity = 100; table.Prefix = "PrefixNo:1"; table.Namespace = "Namespace#1"; table.DisplayExpression = "Id / Name + (Id * Id)"; DataColumn[] colArray = { table.Columns[0] }; table.PrimaryKey = colArray; table.ExtendedProperties.Add("TimeStamp", DateTime.Now); row = table1.NewRow(); row["Name"] = "Abc"; row["Id"] = 147; table1.Rows.Add(row); row = table1.NewRow(); row["Id"] = 47; row["Name"] = "Efg"; table1.Rows.Add(row); DataRelation dr = new DataRelation("DR", table.Columns[0], table1.Columns[0]); set.Relations.Add(dr); //Testing properties of clone DataTable cloneTable = table.Clone(); Assert.True(cloneTable.CaseSensitive); Assert.Equal(0, cloneTable.ChildRelations.Count); Assert.Equal(0, cloneTable.ParentRelations.Count); Assert.Equal(2, cloneTable.Columns.Count); Assert.Equal(1, cloneTable.Constraints.Count); Assert.Equal("Id / Name + (Id * Id)", cloneTable.DisplayExpression); Assert.Equal(1, cloneTable.ExtendedProperties.Count); Assert.False(cloneTable.HasErrors); Assert.Equal(100, cloneTable.MinimumCapacity); Assert.Equal("Namespace#1", cloneTable.Namespace); Assert.Equal("PrefixNo:1", cloneTable.Prefix); Assert.Equal("Id", cloneTable.PrimaryKey[0].ColumnName); Assert.Equal(0, cloneTable.Rows.Count); Assert.Equal("Table#1", cloneTable.TableName); //Testing properties of copy DataTable copyTable = table.Copy(); Assert.True(copyTable.CaseSensitive); Assert.Equal(0, copyTable.ChildRelations.Count); Assert.Equal(0, copyTable.ParentRelations.Count); Assert.Equal(2, copyTable.Columns.Count); Assert.Equal(1, copyTable.Constraints.Count); Assert.Equal("Id / Name + (Id * Id)", copyTable.DisplayExpression); Assert.Equal(1, copyTable.ExtendedProperties.Count); Assert.True(copyTable.HasErrors); Assert.Equal(100, copyTable.MinimumCapacity); Assert.Equal("Namespace#1", copyTable.Namespace); Assert.Equal("PrefixNo:1", copyTable.Prefix); Assert.Equal("Id", copyTable.PrimaryKey[0].ColumnName); Assert.Equal(2, copyTable.Rows.Count); Assert.Equal("Table#1", copyTable.TableName); }