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);
}
