public void ExcuteTransaction(List <string> tables)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
// Open connection, disable auto-commit, and start transaction
conn.Open();
conn.AutoCommit = false;
conn.BeginGFXDTransaction(IsolationLevel.ReadCommitted);
GFXDCommand cmd = conn.CreateCommand();
cmd.CommandType = CommandType.Text;
for (int i = 0; i < tables.Count; i++)
{
string[] words = tables[i].Split('.');
cmd.CommandText = "Select * from " + tables[i] + " order by " + words[1] + "ID";;
var adapter = cmd.CreateDataAdapter();
var table = new DataTable(tables[i]);
adapter.Fill(table);
int cnt = table.Rows.Count;
var idx = (int)table.Rows[cnt - 1].ItemArray[0];
var builder = new GFXDCommandBuilder(adapter);
adapter.InsertCommand = builder.GetInsertCommand();
// Create new product row
for (int ctx = 0; ctx < 10000; ctx++)
{
DataRow row = table.NewRow();
row[0] = ++idx;
for (int j = 1; j < (table.Rows[cnt - 1].ItemArray.Count()); j++)
{
row[j] = table.Rows[cnt - 1].ItemArray[j];
}
table.Rows.Add(row);
}
// Update the underlying table
adapter.Update(table);
}
// Commit transaction
conn.Commit();
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public override void Run(object context)
{
int updateSize = 5;
DataTable[] tables = new DataTable[updateSize];
String[] tableNames = new String[updateSize];
try
{
Connection.AutoCommit = false;
Connection.BeginGFXDTransaction(IsolationLevel.Chaos);
IList <object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < updateSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
DataAdapter = Command.CreateDataAdapter();
tables[i] = new DataTable();
DataAdapter.Fill(tables[i]);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
for (int j = 0; j < tables[i].Rows.Count; j++)
{
for (int k = 1; k < tables[i].Columns.Count; k++)
{
tables[i].Rows[j][k] = data[k];
}
}
if (DataAdapter.Update(tables[i]) != tables[i].Rows.Count)
{
Fail(String.Format(
"Failed to update table {0}", tableNames[i]));
}
}
Connection.Commit();
}
catch (Exception e)
{
Fail(e);
}
finally
{
foreach (String tableName in tableNames)
{
DbRandom.DropTable(tableName);
}
base.Run(context);
}
}
public override void Run(object context)
{
int updateSize = 2;
DataTable[] tables = new DataTable[updateSize];
String[] tableNames = new String[updateSize];
try
{
Connection.AutoCommit = false;
Connection.BeginGFXDTransaction(IsolationLevel.ReadCommitted);
IList<object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < updateSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
DataAdapter = Command.CreateDataAdapter();
tables[i] = new DataTable();
DataAdapter.Fill(tables[i]);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
for (int j = 0; j < tables[i].Rows.Count; j++)
for (int k = 1; k < tables[i].Columns.Count; k++)
tables[i].Rows[j][k] = data[k];
if (DataAdapter.Update(tables[i]) != tables[i].Rows.Count)
Fail(String.Format(
"Failed to update table {0}", tableNames[i]));
}
try
{
Connection.Close();
Fail("Exception should have occurred when transaction is still active");
}
catch (Exception e)
{
Connection.Rollback();
Log(e);
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
foreach (String tableName in tableNames)
DbRandom.DropTable(tableName);
base.Run(context);
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null; ;
try
{
Connection.AutoCommit = false;
Connection.BeginGFXDTransaction(IsolationLevel.Chaos);
tableName = DbRandom.BuildRandomTable(10);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
// Adapter update
DataAdapter.Fill(table);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
IList<object> adptData = DbRandom.GetRandomRowData();
for (int i = 0; i < table.Rows.Count; i++)
for (int j = 1; j < adptData.Count; j++) // do not update identity column
table.Rows[i][j] = adptData[j];
int rowsUpdated = DataAdapter.Update(table);
if (rowsUpdated != table.Rows.Count)
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsUpdated, table.Rows.Count));
// Reader update
//Connection.ReadOnly = false;
// CHANGED Command.ReaderUpdatable = true;
object[] rdrData = DbRandom.GetRandomRowData().ToArray<object>();
DataReader = Command.ExecuteReader();
while (DataReader.Read())
{
// CHANGED DataReader.UpdateValues(rdrData);
}
// CHANGED DataReader.UpdateRow();
Connection.Commit();
}
catch (Exception e)
{
Connection.Rollback();
Fail(e);
}
finally
{
DbRandom.DropTable(tableName);
base.Run(context);
}
}
public void InsertBulkData(string tableName)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
string[] words = tableName.Split('.');
GFXDCommand cmd = conn.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "Select * from " + tableName + " order by " + words[1] + "ID";
conn.Open();
GFXDDataAdapter adapter = cmd.CreateDataAdapter();
var table = new DataTable(tableName);
adapter.Fill(table);
int cnt = table.Rows.Count;
var idx = (int)table.Rows[cnt - 1].ItemArray[0];
var builder = new GFXDCommandBuilder(adapter);
adapter.InsertCommand = builder.GetInsertCommand();
// Create new product row
for (int ctx = 0; ctx < 10000; ctx++)
{
DataRow row = table.NewRow();
row[0] = ++idx;
for (int i = 1; i < (table.Rows[cnt - 1].ItemArray.Count()); i++)
{
row[i] = table.Rows[cnt - 1].ItemArray[i];
}
table.Rows.Add(row);
}
// Update the underlying table
adapter.Update(table);
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public void UpdateBulkData(string tableName)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
conn.Open();
//GFXDCommand cmd = conn.CreateCommand();
//cmd.CommandType = CommandType.Text;
//cmd.CommandText = "Delete from Sales.SalesReason where SalesReasonID between 17000 and 19485";
//var da = new GFXDDataAdapter(cmd);
//var dt = new DataTable();
//da.Fill(dt);
GFXDCommand cmd = conn.CreateCommand();
DataTable dt = new DataTable();
var adapter = new GFXDDataAdapter();
cmd.CommandText = "SELECT * FROM Sales.SalesReason";
adapter.SelectCommand = cmd;
DbCommandBuilder builder = new GFXDCommandBuilder(adapter);
adapter.Fill(dt);
for (int i = 500; i < 1000; i++)
{
dt.Rows[i].Delete();
}
adapter.Update(dt);
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public override void Run(object context)
{
int updateSize = 5;
DataTable[] tables = new DataTable[updateSize];
String[] tableNames = new String[updateSize];
GFXDClientConnection[] conns = new GFXDClientConnection[updateSize];
GFXDCommand[] cmds = new GFXDCommand[updateSize];
GFXDDataAdapter[] adpts = new GFXDDataAdapter[updateSize];
try
{
for (int i = 0; i < updateSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
conns[i] = new GFXDClientConnection(ConnectionString);
cmds[i] = conns[i].CreateCommand();
cmds[i].CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
conns[i].Open();
conns[i].AutoCommit = false;
conns[i].BeginGFXDTransaction();
adpts[i] = cmds[i].CreateDataAdapter();
tables[i] = new DataTable();
adpts[i].Fill(tables[i]);
ParseDataTable(tables[i]);
}
IList<object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < updateSize; i++)
{
CommandBuilder = new GFXDCommandBuilder(adpts[i]);
for (int j = 0; j < tables[i].Rows.Count; j++)
for (int k = 1; k < tables[i].Columns.Count; k++)
tables[i].Rows[j][k] = data[k];
if (adpts[i].Update(tables[i]) != tables[i].Rows.Count)
Fail(String.Format(
"Failed to update table {0}", tableNames[i]));
try
{
conns[i].Commit();
}
catch (Exception e)
{
conns[i].Rollback();
Fail(e);
}
}
for (int i = 0; i < updateSize; i++)
{
tables[i].Clear();
adpts[i].Fill(tables[i]);
}
foreach (DataTable table in tables)
{
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format(
"Inconsistent updated data in table [{0}] at row [{1}] column [{2}]. "
+ "Expected [{3}]; Actual [{4}]",
table.TableName,
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
foreach (String tableName in tableNames)
DbRandom.DropTable(tableName);
base.Run(context);
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null;
try
{
tableName = DbRandom.BuildRandomTable(10);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
DataAdapter.Fill(table);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
IList <object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < table.Rows.Count; i++)
{
for (int j = 1; j < data.Count; j++) // do not update identity column
{
table.Rows[i][j] = data[j];
}
}
int rowsUpdated = DataAdapter.Update(table);
if (rowsUpdated != table.Rows.Count)
{
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsUpdated, table.Rows.Count));
}
table.Clear();
DataAdapter.Fill(table);
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format(
"Inconsistent updated data at row [{0}] column [{1}]. "
+ "Expected [{2}]; Actual [{3}]",
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
DbRandom.DropTable(tableName);
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null;
int rowsToInsert = 10;
try
{
tableName = DbRandom.BuildRandomTable(10);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
DataAdapter.Fill(table);
GFXDCommandBuilder builder = new GFXDCommandBuilder(DataAdapter);
DataAdapter.InsertCommand = builder.GetInsertCommand();
DataAdapter.UpdateCommand = builder.GetUpdateCommand();
DataAdapter.DeleteCommand = builder.GetDeleteCommand();
if (!DataAdapter.AcceptChangesDuringFill)
{
DataAdapter.AcceptChangesDuringFill = true;
}
if (!DataAdapter.AcceptChangesDuringUpdate)
{
DataAdapter.AcceptChangesDuringUpdate = true;
}
IList <object> data = DbRandom.GetRandomRowData();
long lastRowId = long.Parse(table.Rows[table.Rows.Count - 1][0].ToString());
for (int i = 0; i < rowsToInsert; i++)
{
DataRow row = table.NewRow();
row[0] = lastRowId + i + 1;
for (int j = 1; j < data.Count; j++)
{
row[j] = data[j];
}
table.Rows.Add(row);
}
int rowsUpdated = DataAdapter.Update(table);
if (rowsUpdated != rowsToInsert)
{
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsToInsert, rowsUpdated));
}
table.Clear();
DataAdapter.Fill(table);
foreach (DataRow row in table.Rows)
{
if (long.Parse(row[0].ToString()) > lastRowId)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format("Inconsistent updated data at row [{0}] column [{1}]. "
+ "Expected [{2}]; Actual [{3}]",
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
DbRandom.DropTable(tableName);
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
public void ExcuteTransaction(List<string> tables)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
// Open connection, disable auto-commit, and start transaction
conn.Open();
conn.AutoCommit = false;
conn.BeginGFXDTransaction(IsolationLevel.ReadCommitted);
GFXDCommand cmd = conn.CreateCommand();
cmd.CommandType = CommandType.Text;
for (int i = 0; i < tables.Count; i++)
{
string[] words = tables[i].Split('.');
cmd.CommandText = "Select * from " + tables[i] + " order by " + words[1] + "ID"; ;
var adapter = cmd.CreateDataAdapter();
var table = new DataTable(tables[i]);
adapter.Fill(table);
int cnt = table.Rows.Count;
var idx = (int)table.Rows[cnt - 1].ItemArray[0];
var builder = new GFXDCommandBuilder(adapter);
adapter.InsertCommand = builder.GetInsertCommand();
// Create new product row
for (int ctx = 0; ctx < 10000; ctx++)
{
DataRow row = table.NewRow();
row[0] = ++idx;
for (int j = 1; j < (table.Rows[cnt - 1].ItemArray.Count()); j++)
{
row[j] = table.Rows[cnt - 1].ItemArray[j];
}
table.Rows.Add(row);
}
// Update the underlying table
adapter.Update(table);
}
// Commit transaction
conn.Commit();
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public void UpdateBulkData(string tableName)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
conn.Open();
//GFXDCommand cmd = conn.CreateCommand();
//cmd.CommandType = CommandType.Text;
//cmd.CommandText = "Delete from Sales.SalesReason where SalesReasonID between 17000 and 19485";
//var da = new GFXDDataAdapter(cmd);
//var dt = new DataTable();
//da.Fill(dt);
GFXDCommand cmd = conn.CreateCommand();
DataTable dt = new DataTable();
var adapter = new GFXDDataAdapter();
cmd.CommandText = "SELECT * FROM Sales.SalesReason";
adapter.SelectCommand = cmd;
DbCommandBuilder builder = new GFXDCommandBuilder(adapter);
adapter.Fill(dt);
for (int i = 500; i < 1000; i++)
{
dt.Rows[i].Delete();
}
adapter.Update(dt);
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null;
int rowsToInsert = 10;
try
{
tableName = DbRandom.BuildRandomTable(10);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
DataAdapter.Fill(table);
GFXDCommandBuilder builder = new GFXDCommandBuilder(DataAdapter);
DataAdapter.InsertCommand = builder.GetInsertCommand();
DataAdapter.UpdateCommand = builder.GetUpdateCommand();
DataAdapter.DeleteCommand = builder.GetDeleteCommand();
if (!DataAdapter.AcceptChangesDuringFill)
DataAdapter.AcceptChangesDuringFill = true;
if (!DataAdapter.AcceptChangesDuringUpdate)
DataAdapter.AcceptChangesDuringUpdate = true;
IList<object> data = DbRandom.GetRandomRowData();
long lastRowId = long.Parse(table.Rows[table.Rows.Count - 1][0].ToString());
for (int i = 0; i < rowsToInsert; i++) {
DataRow row = table.NewRow();
row[0] = lastRowId + i + 1;
for(int j = 1; j < data.Count; j++)
row[j] = data[j];
table.Rows.Add(row);
}
int rowsUpdated = DataAdapter.Update(table);
if (rowsUpdated != rowsToInsert)
{
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsToInsert, rowsUpdated));
}
table.Clear();
DataAdapter.Fill(table);
foreach (DataRow row in table.Rows)
{
if (long.Parse(row[0].ToString()) > lastRowId)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format("Inconsistent updated data at row [{0}] column [{1}]. "
+ "Expected [{2}]; Actual [{3}]",
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
DbRandom.DropTable(tableName);
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
public override void Run(object context)
{
int dsSize = 10;
DataSet dataset = new DataSet();
String[] tableNames = new String[dsSize];
GFXDCommand[] commands = new GFXDCommand[dsSize];
GFXDDataAdapter[] adapters = new GFXDDataAdapter[dsSize];
try
{
for (int i = 0; i < dsSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
commands[i] = Connection.CreateCommand();
commands[i].CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
adapters[i] = commands[i].CreateDataAdapter();
adapters[i].Fill(dataset, tableNames[i]);
}
ParseDataSet(dataset);
IList <object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < dsSize; i++)
{
CommandBuilder = new GFXDCommandBuilder(adapters[i]);
for (int j = 0; j < dataset.Tables[tableNames[i]].Rows.Count; j++)
{
for (int k = 1; k < dataset.Tables[tableNames[i]].Columns.Count; k++) // do not update identity column
{
dataset.Tables[tableNames[i]].Rows[j][k] = data[k];
}
}
if (adapters[i].Update(dataset, tableNames[i])
!= dataset.Tables[tableNames[i]].Rows.Count)
{
Fail(String.Format(
"Failed to update all changed rows in table {0}", tableNames[i]));
}
}
dataset.Clear();
for (int i = 0; i < dsSize; i++)
{
adapters[i].Fill(dataset, tableNames[i]);
}
ParseDataSet(dataset);
foreach (DataTable table in dataset.Tables)
{
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format(
"Inconsistent updated data in table [{0}] at row [{1}] column [{2}]. "
+ "Expected [{3}]; Actual [{4}]",
table.TableName,
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
foreach (String tableName in tableNames)
{
DbRandom.DropTable(tableName);
}
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null;;
try
{
Connection.AutoCommit = false;
Connection.BeginGFXDTransaction(IsolationLevel.Chaos);
tableName = DbRandom.BuildRandomTable(10);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
// Adapter update
DataAdapter.Fill(table);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
IList <object> adptData = DbRandom.GetRandomRowData();
for (int i = 0; i < table.Rows.Count; i++)
{
for (int j = 1; j < adptData.Count; j++) // do not update identity column
{
table.Rows[i][j] = adptData[j];
}
}
int rowsUpdated = DataAdapter.Update(table);
if (rowsUpdated != table.Rows.Count)
{
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsUpdated, table.Rows.Count));
}
// Reader update
//Connection.ReadOnly = false;
// CHANGED Command.ReaderUpdatable = true;
object[] rdrData = DbRandom.GetRandomRowData().ToArray <object>();
DataReader = Command.ExecuteReader();
while (DataReader.Read())
{
// CHANGED DataReader.UpdateValues(rdrData);
}
// CHANGED DataReader.UpdateRow();
Connection.Commit();
}
catch (Exception e)
{
Connection.Rollback();
Fail(e);
}
finally
{
DbRandom.DropTable(tableName);
base.Run(context);
}
}
public override void Run(object context)
{
int updateSize = 5;
DataTable[] tables = new DataTable[updateSize];
String[] tableNames = new String[updateSize];
GFXDClientConnection[] conns = new GFXDClientConnection[updateSize];
GFXDCommand[] cmds = new GFXDCommand[updateSize];
GFXDDataAdapter[] adpts = new GFXDDataAdapter[updateSize];
try
{
for (int i = 0; i < updateSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
conns[i] = new GFXDClientConnection(ConnectionString);
cmds[i] = conns[i].CreateCommand();
cmds[i].CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
conns[i].Open();
conns[i].AutoCommit = false;
conns[i].BeginGFXDTransaction();
adpts[i] = cmds[i].CreateDataAdapter();
tables[i] = new DataTable();
adpts[i].Fill(tables[i]);
ParseDataTable(tables[i]);
}
IList <object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < updateSize; i++)
{
CommandBuilder = new GFXDCommandBuilder(adpts[i]);
for (int j = 0; j < tables[i].Rows.Count; j++)
{
for (int k = 1; k < tables[i].Columns.Count; k++)
{
tables[i].Rows[j][k] = data[k];
}
}
if (adpts[i].Update(tables[i]) != tables[i].Rows.Count)
{
Fail(String.Format(
"Failed to update table {0}", tableNames[i]));
}
try
{
conns[i].Commit();
}
catch (Exception e)
{
conns[i].Rollback();
Fail(e);
}
}
for (int i = 0; i < updateSize; i++)
{
tables[i].Clear();
adpts[i].Fill(tables[i]);
}
foreach (DataTable table in tables)
{
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format(
"Inconsistent updated data in table [{0}] at row [{1}] column [{2}]. "
+ "Expected [{3}]; Actual [{4}]",
table.TableName,
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
foreach (String tableName in tableNames)
{
DbRandom.DropTable(tableName);
}
base.Run(context);
}
}
public void InsertBulkData(string tableName)
{
try
{
using (var conn = new GFXDClientConnection(ConnectionString))
{
string[] words = tableName.Split('.');
GFXDCommand cmd = conn.CreateCommand();
cmd.CommandType = CommandType.Text;
cmd.CommandText = "Select * from " + tableName + " order by " + words[1] + "ID";
conn.Open();
GFXDDataAdapter adapter = cmd.CreateDataAdapter();
var table = new DataTable(tableName);
adapter.Fill(table);
int cnt = table.Rows.Count;
var idx = (int)table.Rows[cnt - 1].ItemArray[0];
var builder = new GFXDCommandBuilder(adapter);
adapter.InsertCommand = builder.GetInsertCommand();
// Create new product row
for (int ctx = 0; ctx < 10000; ctx++)
{
DataRow row = table.NewRow();
row[0] = ++idx;
for (int i = 1; i < (table.Rows[cnt - 1].ItemArray.Count()); i++)
{
row[i] = table.Rows[cnt - 1].ItemArray[i];
}
table.Rows.Add(row);
}
// Update the underlying table
adapter.Update(table);
}
}
catch (GFXDException ex)
{
string err = ex.Message;
}
catch (Exception ex)
{
string err = ex.Message;
}
}
public override void Run(object context)
{
DataTable table = new DataTable();
String tableName = null;
try
{
tableName = DbRandom.BuildRandomTable(5);
Command.CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableName);
DataAdapter.Fill(table);
ParseDataTable(table);
CommandBuilder = new GFXDCommandBuilder(DataAdapter);
DataRow[] rows = new DataRow[table.Rows.Count];
for (int i = 0; i < table.Rows.Count; i++)
rows[i] = table.Rows[i];
IList<object> data = DbRandom.GetRandomRowData();
for (int j = 0; j < rows.Length; j++)
for (int k = 1; k < table.Columns.Count; k++) // do not update identity column
rows[j][k] = data[k];
int rowsUpdated = DataAdapter.Update(rows);
if (rowsUpdated != table.Rows.Count)
{
Fail(String.Format("Failed to update all changed rows. "
+ "Expected [{0}]; Actual [{1}]",
rowsUpdated, table.Rows.Count));
}
table.Clear();
DataAdapter.Fill(table);
ParseDataTable(table);
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format("Inconsistent updated data at row [{0}] column [{1}]. "
+ "Expected [{2}]; Actual [{3}]",
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
DbRandom.DropTable(tableName);
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
public override void Run(object context)
{
int dsSize = 10;
DataSet dataset = new DataSet();
String[] tableNames = new String[dsSize];
GFXDCommand[] commands = new GFXDCommand[dsSize];
GFXDDataAdapter[] adapters = new GFXDDataAdapter[dsSize];
try
{
for (int i = 0; i < dsSize; i++)
{
tableNames[i] = DbRandom.BuildRandomTable(5);
commands[i] = Connection.CreateCommand();
commands[i].CommandText = String.Format(
"SELECT * FROM {0} ORDER BY COL_ID ASC ", tableNames[i]);
adapters[i] = commands[i].CreateDataAdapter();
adapters[i].Fill(dataset, tableNames[i]);
}
ParseDataSet(dataset);
IList<object> data = DbRandom.GetRandomRowData();
for (int i = 0; i < dsSize; i++)
{
CommandBuilder = new GFXDCommandBuilder(adapters[i]);
for (int j = 0; j < dataset.Tables[tableNames[i]].Rows.Count; j++)
for (int k = 1; k < dataset.Tables[tableNames[i]].Columns.Count; k++) // do not update identity column
dataset.Tables[tableNames[i]].Rows[j][k] = data[k];
if (adapters[i].Update(dataset, tableNames[i])
!= dataset.Tables[tableNames[i]].Rows.Count)
Fail(String.Format(
"Failed to update all changed rows in table {0}", tableNames[i]));
}
dataset.Clear();
for (int i = 0; i < dsSize; i++)
adapters[i].Fill(dataset, tableNames[i]);
ParseDataSet(dataset);
foreach (DataTable table in dataset.Tables)
{
foreach (DataRow row in table.Rows)
{
for (int i = 1; i < row.Table.Columns.Count; i++)
{
if (!DbRandom.Compare(data[i], row, i))
{
Fail(String.Format(
"Inconsistent updated data in table [{0}] at row [{1}] column [{2}]. "
+ "Expected [{3}]; Actual [{4}]",
table.TableName,
row[0].ToString(), row.Table.Columns[i].ColumnName,
data[i].ToString(), row[i].ToString()));
}
}
}
}
}
catch (Exception e)
{
Fail(e);
}
finally
{
try
{
foreach(String tableName in tableNames)
DbRandom.DropTable(tableName);
}
catch (Exception e)
{
Fail(e);
}
base.Run(context);
}
}
