public static void QueryInsertQuery(ICRUDDataStore store)
{
var query = new Query("CRUD.Patient.List")
{
new Query.Param("LN", "%loff")
};
var result = store.Load(query);
Assert.AreEqual(1, result.Count);
var rowset = result[0];
Assert.AreEqual(0, rowset.Count);
var row = new DynamicRow(rowset.Schema);
row["ssn"] = "999-88-9012";
row["First_Name"] = "Jack";
row["Last_Name"] = "Kozloff";
row["DOB"] = new DateTime(1980, 1, 12);
Assert.IsNull(row.Validate());
store.Insert(row);
result = store.Load(query);
Assert.AreEqual(1, result.Count);
rowset = result[0];
Assert.AreEqual(1, rowset.Count);
Assert.AreEqual("Jack", rowset[0]["First_Name"]);
}
public void BuildUsingAdHockSchema()
{
var schema = new Schema("TEZT",
new Schema.FieldDef("ID", typeof(int), new List <FieldAttribute> {
new FieldAttribute(required: true, key: true)
}),
new Schema.FieldDef("Description", typeof(string), new List <FieldAttribute> {
new FieldAttribute(required: true)
})
);
var tbl = new Rowset(schema);
for (var i = 0; i < 1000; i++)
{
var row = new DynamicRow(tbl.Schema);
row["ID"] = i;
row["Description"] = "Item-{0}".Args(i);
tbl.Insert(row);
}
Assert.AreEqual(1000, tbl.Count);
var match = tbl.FindByKey(178);
Assert.IsNotNull(match);
Assert.AreEqual("Item-178", match["Description"]);
}
public void initDDL()
{
//template.Bindings["Value"];
//template.Bindings["Key"];
string tableName = this["Table"].GetValue <string>();
string displayFieldName = this["DisplayField"].GetValue <string>();
valueFieldName = this["ValueField"].GetValue <string>();
SelectCriteria sc = new SelectCriteria();
sc.fields = new System.Collections.ArrayList();
sc.fields.Add(displayFieldName);
sc.fields.Add(valueFieldName);
myRows = DynamicRow.FindRows(tableName, sc);
foreach (DynamicRow row in myRows)
{
ctl.Items.Add(row[displayFieldName].AsObject());
}
ctl.SelectedIndexChanged += new EventHandler(ctl_SelectedIndexChanged);
}
public void T_09_DynamicRow()
{
var schema = new Schema("Dynamic Schema",
new Schema.FieldDef("ID", typeof(int), new List <FieldAttribute> {
new FieldAttribute(required: true, key: true)
}),
new Schema.FieldDef("Description", typeof(string), new List <FieldAttribute> {
new FieldAttribute(required: true)
})
);
var row = new DynamicRow(schema);
row["ID"] = 123;
row["Description"] = "T-90 Tank";
var rc = new RowConverter();
var doc = rc.RowToBSONDocument(row, "A");
Console.WriteLine(doc.ToString());
var row2 = new DynamicRow(schema);
rc.BSONDocumentToRow(doc, row2, "A");
Assert.AreEqual(123, row2["ID"]);
Assert.AreEqual("T-90 Tank", row2["Description"]);
}
public void DynamicRows()
{
var tbl = new Table(Schema.GetForTypedRow(typeof(Person)));
var row = new DynamicRow(tbl.Schema);
row["ID"] = "POP1";
row["FirstName"] = "Oleg";
row["LastName"] = "Popov-1";
row["DOB"] = new DateTime(1953, 12, 10);
row["YearsInSpace"] = 12;
tbl.Insert(row);
var ser = new SlimSerializer();
using (var ms = new MemoryStream())
{
ser.Serialize(ms, tbl);
ms.Position = 0;
var tbl2 = ser.Deserialize(ms) as Table;
Assert.IsNotNull(tbl2);
Assert.IsFalse(object.ReferenceEquals(tbl, tbl2));
Assert.IsFalse(object.ReferenceEquals(tbl.Schema, tbl2.Schema));
Assert.IsTrue(tbl.Schema.IsEquivalentTo(tbl2.Schema));
}
}
public static void GetSchemaAndTestVariousTypes(ICRUDDataStore store)
{
var schema = store.GetSchema(new Query("CRUD.Types.Load"));
var row = new DynamicRow(schema);
row["GDID"] = new GDID(0, 145);
row["SCREEN_NAME"] = "User1";
row["STRING_NAME"] = "Some user 1";
row["CHAR_NAME"] = "Some user 2";
row["BOOL_CHAR"] = 'T';
row["BOOL_BOOL"] = true;
row["AMOUNT"] = 145670.23m;
row["DOB"] = new DateTime(1980, 12, 1);
store.Insert(row);
var row2 = store.LoadOneRow(new Query("CRUD.Types.Load", new GDID(0, 145)));
Assert.NotNull(row2);
Assert.AreEqual(145, row2["GDID"]);
Assert.AreEqual("User1", row2["Screen_Name"]);
Assert.AreEqual("Some user 1", row2["String_Name"]);
Assert.AreEqual("Some user 2", row2["Char_Name"]);
Assert.AreEqual(true, row2["BOOL_Char"].AsBool());
Assert.AreEqual(true, row2["BOOL_BOOL"].AsBool());
Assert.AreEqual(145670.23m, row2["Amount"]);
Assert.AreEqual(1980, row2["DOB"].AsDateTime().Year);
}
public static void ASYNC_QueryInsertQuery(ICRUDDataStore store)
{
var query = new Query("CRUD.Patient.List")
{
new Query.Param("LN", "%loff")
};
var task = store.LoadAsync(query);
Aver.AreEqual(1, task.Result.Count);
var rowset = task.Result[0];
Aver.AreEqual(0, rowset.Count);
var row = new DynamicRow(rowset.Schema);
row["ssn"] = "999-88-9012";
row["First_Name"] = "Jack";
row["Last_Name"] = "Kozloff";
row["DOB"] = new DateTime(1980, 1, 12);
Aver.IsNull(row.Validate());
store.InsertAsync(row).Wait();
task = store.LoadAsync(query);
Aver.AreEqual(1, task.Result.Count);
rowset = task.Result[0];
Aver.AreEqual(1, rowset.Count);
Aver.AreObjectsEqual("Jack", rowset[0]["First_Name"]);
}
public void CopyFields_ExtendedDynamicRow_To_DynamicRow()
{
var schema = Schema.GetForTypedRow(typeof(Person));
var fieldDefs = schema.FieldDefs.ToList();
fieldDefs.Add(new Schema.FieldDef("Info", typeof(string), new QuerySource.ColumnDef("Info")));
fieldDefs.Add(new Schema.FieldDef("Count", typeof(long), new QuerySource.ColumnDef("Info")));
var extendedSchema = new Schema("sname", fieldDefs.ToArray());
var from = new DynamicRow(extendedSchema);
from["FirstName"] = "Ivan";
from["Amount"] = 10;
from["DOB"] = new DateTime(1990, 2, 16);
from["GoodPerson"] = true;
from["Info"] = "extended info";
from["Count"] = long.MaxValue;
var to = new DynamicRow(schema);
from.CopyFields(to);
Aver.AreObjectsEqual(to["FirstName"], from["FirstName"]);
Aver.AreObjectsEqual(to["Amount"], from["Amount"]);
Aver.AreObjectsEqual(to["DOB"], from["DOB"]);
Aver.AreObjectsEqual(to["GoodPerson"], from["GoodPerson"]);
}
public virtual string SerializeDbData(Func <string, bool> tableNamePredicate = null)
{
var tables = this.DbInspector.GetTables(true, tableNamePredicate);
var dbData =
new DynamicRow(); // it is strange to store entire data in 'dynamic' 'row', but why to invent new dynamic ancestor?
using (var command = this.Connection.CreateCommand())
{
foreach (var table in tables)
{
var sql = this.Cruder.ScriptBuilder.BuildSelectAllScript(table);
command.CommandText = sql;
var rows = DbUtils
.GetCommandRows(command);
dbData.SetValue(table.Name, rows);
}
}
var json = JsonConvert.SerializeObject(dbData, Formatting.Indented);
return(json);
}
public void CopyFields_DynamicRow_To_Amorphous_IncludeAmorphous()
{
var schema = Schema.GetForTypedRow(typeof(Person));
var from = new DynamicRow(schema);
from["FirstName"] = "Ivan";
from["Amount"] = 10;
from["DOB"] = new DateTime(1990, 2, 16);
from["GoodPerson"] = true;
var to = new AmorphousDynamicRow(Schema.GetForTypedRow(typeof(Empty)));
to.AmorphousData["field1"] = 123;
to.AmorphousData["FirstName"] = "John";
from.CopyFields(to, true);
Aver.AreEqual(0, to.Schema.FieldCount);
Aver.AreEqual(12, to.AmorphousData.Count);
Aver.AreObjectsEqual(123, to.AmorphousData["field1"]);
Aver.AreObjectsEqual(from["FirstName"], to.AmorphousData["FirstName"]);
Aver.AreObjectsEqual(from["Amount"], to.AmorphousData["Amount"]);
Aver.AreObjectsEqual(from["DOB"], to.AmorphousData["DOB"]);
Aver.AreObjectsEqual(from["GoodPerson"], to.AmorphousData["GoodPerson"]);
}
public void InsertRow_RowWithEnums_Inserts()
{
// Arrange
var foo = new DynamicRow(new
{
id = 1,
name = "Vasya",
enum_int32 = (ushort)1,
enum_string = UserRole.Admin,
});
// Act
_cruder.GetTableValuesConverter("foo").SetColumnConverter("enum_int32", new EnumValueConverter <Town>(EnumValueConverterBehaviour.Integer));
_cruder.GetTableValuesConverter("foo").SetColumnConverter("enum_string", new EnumValueConverter <UserRole>(EnumValueConverterBehaviour.String));
_cruder.InsertRow("foo", foo);
// Assert
using (var command = this.Connection.CreateCommand())
{
command.CommandText = @"SELECT [id], [name], [enum_int32], [enum_string] FROM [foo] WHERE [id] = 1";
var row = DbUtils.GetCommandRows(command).Single();
Assert.That(row.id, Is.EqualTo(1));
Assert.That(row.name, Is.EqualTo("Vasya"));
Assert.That(row.enum_int32, Is.EqualTo(1));
Assert.That(row.enum_string, Is.EqualTo(UserRole.Admin.ToString()));
}
}
public static void GetSchemaAndTestFullGDID(ICRUDDataStore store)
{
var schema = store.GetSchema(new Query("CRUD.FullGDID.Load"));
var row = new DynamicRow(schema);
var key = new GDID(179, 1, 1234567890);
Console.WriteLine(key.Bytes.ToDumpString(DumpFormat.Hex));
row["GDID"] = new GDID(179, 1, 1234567890);
Console.WriteLine(((byte[])row["GDID"]).ToDumpString(DumpFormat.Hex));
row["VARGDID"] = new GDID(12, 9, 9876543210);
row["STRING_NAME"] = "DA DA DA!";
store.Insert(row);
var row2 = store.LoadOneRow(new Query("CRUD.FullGDID.Load", key, typeof(FullGDID))) as FullGDID;
Assert.NotNull(row2);
Assert.AreEqual(key, row2.GDID);
Assert.AreEqual(new GDID(12, 9, 9876543210), row2.VARGDID);
Assert.AreEqual("DA DA DA!", row2["String_Name"]);
}
public void CopyFields_DynamicRow()
{
var from = new DynamicRow(Schema.GetForTypedRow(typeof(Person)));
from["FirstName"] = "Ivan";
from["LastName"] = "Petrov";
from["Amount"] = 10;
from["Classification"] = "class1";
from["Description"] = null;
from["DOB"] = new DateTime(1990, 2, 16);
from["GoodPerson"] = true;
from["ID"] = "abc";
from["LuckRatio"] = 12345.6789D;
from["YearsInSpace"] = 20;
from["YearsWithCompany"] = null;
var to = new DynamicRow(Schema.GetForTypedRow(typeof(Person)));
to["Description"] = "descr";
to["YearsWithCompany"] = 30;
from.CopyFields(to);
Aver.AreObjectsEqual(to["FirstName"], from["FirstName"]);
Aver.AreObjectsEqual(to["LastName"], from["LastName"]);
Aver.AreObjectsEqual(to["Amount"], from["Amount"]);
Aver.AreObjectsEqual(to["Classification"], from["Classification"]);
Aver.AreObjectsEqual(to["Description"], from["Description"]);
Aver.AreObjectsEqual(to["DOB"], from["DOB"]);
Aver.AreObjectsEqual(to["GoodPerson"], from["GoodPerson"]);
Aver.AreObjectsEqual(to["ID"], from["ID"]);
Aver.AreObjectsEqual(to["LuckRatio"], from["LuckRatio"]);
Aver.AreObjectsEqual(to["YearsInSpace"], from["YearsInSpace"]);
Aver.AreObjectsEqual(to["YearsWithCompany"], from["YearsWithCompany"]);
}
public void PopulateAndFindKey_DynamicRows()
{
var tbl = new Rowset(Schema.GetForTypedRow(typeof(Person)));
for (var i = 0; i < 1000; i++)
{
var row = new DynamicRow(tbl.Schema);
row["ID"] = "POP{0}".Args(i);
row["FirstName"] = "Oleg";
row["LastName"] = "Popov-{0}".Args(i);
row["DOB"] = new DateTime(1953, 12, 10);
row["YearsInSpace"] = 12;
tbl.Insert(row);
}
Assert.AreEqual(1000, tbl.Count);
var match1 = tbl.FindByKey("POP35");
Assert.IsNotNull(match1);
Assert.AreEqual("Popov-35", match1["LastName"]);
var match2 = tbl.FindByKey("POP36") as DynamicRow;
Assert.IsNotNull(match2);
Assert.AreEqual("Popov-36", match2["LastName"]);
var match3 = tbl.FindByKey("DoesNotExist");
Assert.IsNull(match3);
}
public void InferSchema()
{
var doc = new BSONDocument();
doc.Set(new BSONStringElement("FullName", "Alex Bobby"));
doc.Set(new BSONInt32Element("Age", 123));
doc.Set(new BSONBooleanElement("IsGood", true));
var c = new RowConverter();
var schema = c.InferSchemaFromBSONDocument(doc);
Assert.AreEqual(3, schema.FieldCount);
Assert.AreEqual(0, schema["FullName"].Order);
Assert.AreEqual(1, schema["Age"].Order);
Assert.AreEqual(2, schema["IsGood"].Order);
Assert.AreEqual(typeof(object), schema["FullName"].NonNullableType);
Assert.AreEqual(typeof(object), schema["Age"].NonNullableType);
Assert.AreEqual(typeof(object), schema["IsGood"].NonNullableType);
var row = new DynamicRow(schema);
c.BSONDocumentToRow(doc, row, null);
Assert.AreEqual("Alex Bobby", row[0]);
Assert.AreEqual(123, row[1]);
Assert.AreEqual(true, row[2]);
Assert.AreEqual("Alex Bobby", row["FullName"]);
Assert.AreEqual(123, row["Age"]);
Assert.AreEqual(true, row["IsGood"]);
}
public void Validate_Error_ValueList()
{
var person = new DynamicRow(Schema.GetForTypedRow(typeof(Person)));
person["ID"] = "POP1";
person["FirstName"] = "Oleg";
person["LastName"] = "Popov";
person["DOB"] = new DateTime(1981, 2, 12);
person["YearsInSpace"] = 45;
person["Amount"] = 100;
person["Description"] = "0123";
person["Classification"] = "INVALID";
var error = person.Validate();
Console.WriteLine(error);
Assert.IsInstanceOf(typeof(CRUDFieldValidationException), error);
Assert.AreEqual("Classification", ((CRUDFieldValidationException)error).FieldName);
Assert.IsTrue(error.Message.Contains("not in list of permitted values"));
person["Classification"] = "good";
Assert.IsNull(person.Validate());
person["Classification"] = "bad";
Assert.IsNull(person.Validate());
person["Classification"] = "ugly";
Assert.IsNull(person.Validate());
}
public void Equality()
{
var person1 = new DynamicRow(Schema.GetForTypedRow(typeof(Person)));
person1["ID"] = "POP1";
person1["FirstName"] = "Oleg";
person1["LastName"] = "Popov";
person1["DOB"] = new DateTime(1981, 2, 12);
person1["YearsInSpace"] = 45;
person1["Amount"] = 100;
person1["Description"] = "Wanted to go to the moon";
var person2 = new DynamicRow(Schema.GetForTypedRow(typeof(Person)));
person2["ID"] = "POP1";
person2["FirstName"] = "Egor";
person2["LastName"] = "Pedorov";
person2["DOB"] = new DateTime(1982, 5, 2);
person2["YearsInSpace"] = 4;
person2["Amount"] = 1000000;
Assert.IsTrue(person1.Equals(person2));
person2["ID"] = "POP2";
Assert.IsFalse(person1.Equals(person2));
}
public void Slim_SerializeTable_DynamicRows()
{
var tbl = new Table(Schema.GetForTypedRow(typeof(Person)));
for (var i = 0; i < 1000; i++)
{
var row = new DynamicRow(tbl.Schema);
row["ID"] = "POP{0}".Args(i);
row["FirstName"] = "Oleg";
row["LastName"] = "Popov-{0}".Args(i);
row["DOB"] = new DateTime(1953, 12, 10);
row["YearsInSpace"] = 12;
tbl.Insert(row);
}
var ser = new SlimSerializer();
using (var ms = new MemoryStream())
{
ser.Serialize(ms, tbl);
Console.WriteLine("{0} rows took {1} bytes".Args(tbl.Count, ms.Position));
ms.Position = 0;
var tbl2 = ser.Deserialize(ms) as Table;
Assert.IsNotNull(tbl2);
Assert.IsFalse(object.ReferenceEquals(tbl, tbl2));
Assert.AreEqual(1000, tbl2.Count);
Assert.IsTrue(tbl.SequenceEqual(tbl2));
}
}
public void FindIndexByKey_DynamicRows()
{
var tbl = new Table(Schema.GetForTypedRow(typeof(Person)));
for (var i = 0; i < 10; i++)
{
var row = new DynamicRow(tbl.Schema);
row["ID"] = "POP{0}".Args(i);
row["FirstName"] = "Oleg";
row["LastName"] = "DynamicPopov-{0}".Args(i);
row["DOB"] = new DateTime(1953, 12, 10);
row["YearsInSpace"] = 12;
tbl.Insert(row);
}
Assert.AreEqual(10, tbl.Count);
var idx1 = tbl.FindIndexByKey("POP5");
Assert.AreEqual(5, idx1);
var idx2 = tbl.FindIndexByKey("POP6");
Assert.AreEqual(6, idx2);
var idx3 = tbl.FindIndexByKey("DoesNotExist");
Assert.AreEqual(-1, idx3);
}
public BrushSection()
{
var layout = new DynamicLayout {
DefaultSpacing = new Size(5, 5), Padding = new Padding(10)
};
// defaults
ScaleX = 100f;
ScaleY = 100f;
Center = new PointF(110, 60);
GradientOrigin = new PointF(150, 90);
Radius = new SizeF(100f, 50f);
StartPoint = new PointF(50, 50);
EndPoint = new PointF(100, 100);
Angle = 0;
Opacity = 1f;
drawable = new Drawable {
Size = new Size(450, 400)
};
drawable.Paint += (sender, pe) => Draw(pe.Graphics);
if ((Platform.SupportedFeatures & PlatformFeatures.DrawableWithTransparentContent) == 0)
{
layout.AddSeparateRow(null, BrushControl(), UseBackgroundColorControl(), CreateModeControl(), null);
}
else
{
layout.AddSeparateRow(null, BrushControl(), UseBackgroundColorControl(), WithContent(), CreateModeControl(), null);
}
if (Platform.Supports <NumericStepper>())
{
matrixRow = layout.AddSeparateRow(null, new Label {
Text = "Rot"
}, RotationControl(), new Label {
Text = "Sx"
}, ScaleXControl(), new Label {
Text = "Sy"
}, ScaleYControl(), new Label {
Text = "Ox"
}, OffsetXControl(), new Label {
Text = "Oy"
}, OffsetYControl(), null);
matrixRow.Table.Visible = false;
}
gradientRow = layout.AddSeparateRow(null, GradientWrapControl(), null);
gradientRow.Table.Visible = false;
radialRow = layout.AddSeparateRow(null, "Center:", CenterControl(), "GradientOrigin:", GradientOriginControl(), null);
radiusRow = layout.AddSeparateRow(null, "Radius:", RadiusControl(), null);
linearRow = layout.AddSeparateRow(null, "Start:", StartPointControl(), "End:", EndPointControl(), null);
angleRow = layout.AddSeparateRow(null, "Angle:", AngleControl(), null);
textureRow = layout.AddSeparateRow(null, "Opacity:", CreateOpacityControl(), null);
colorStartEndRow = layout.AddSeparateRow(null, "Start:", CreateStartColor(), "End:", CreateEndColor(), null);
layout.AddSeparateRow(null, drawable, null);
layout.Add(null);
this.Content = layout;
}
public static void CurrentBindDynamicRow(
this DbDataReader reader,
List<DynamicColumn> columns,
ref DynamicRow row)
{
if(null == reader) { return; }
if(columns.IsNullOrEmpty()) { return; }
var dbValues = new object[columns.Count];
reader.GetValues(dbValues);
var flatValues = new List<Any>();
var values = new List<Any>();
var hashCodes = new List<Any>();
var dbNulls = new List<string>();
var columnIndex = -1;
foreach(var column in columns) {
columnIndex++;
var value = dbValues[columnIndex];
if(DBNull.Value == value) {
dbNulls.Add(column.BaseColumnName);
value = null;
}
flatValues.SafeAdd(column.ColumnName, value);
flatValues.SafeAdd(column.BaseColumnName, value);
values.Add(column.BaseColumnName, value);
if(null != value) {
int hashCode = value.GetHashCode();
hashCodes.Add(
column.BaseColumnName, hashCode
);
}
}
row.__ReturnAny = true;
row.__DatabaseFirst = true;
row.__DynamicColumns = columns;
row.__FlatValues = flatValues;
row.__DynamicValues = values;
row.__DynamicOriginalValues = values;
row.__OriginalHashCodes = hashCodes;
row.__DynamicDbNulls = dbNulls;
row.__OriginalHashCode = row.GetHashCode();
if(dbNulls.Any()) {
foreach(var dbNull in dbNulls) {
hashCodes.Add(
dbNull,
row.__OriginalHashCode
);
}
}
row.__OriginalHashCodes = hashCodes;
}
public static DynamicRow GetValues(this ControllerBase ctrl)
{
var result = new DynamicRow();
foreach (var o in ctrl.Bag)
{
result.SetMember(o.Key, o.Value);
}
return(result);
}
private static DynamicRow GetRow(IDataReader dr)
{
var row = new DynamicRow();
for (int i = 0; i < dr.FieldCount; i++)
{
row.SetMember(dr.GetName(i), dr.GetValue(i));
}
return(row);
}
public void FeedRow(int id)
{
row = DynamicRow.FindRow <int>("TABLE1", id);
string form = this["Form"].GetValue <string>("");
foreach (string name in row.FieldNames)
{
blockWeb[form][name].AttachEndPoint(row.GetFieldValue(name));
}
}
public void CantSetValuesExplicitly()
{
var map = new Dictionary <string, int> {
{ "A", 0 },
{ "B", 1 }
};
var obj = new object[] { "Xyz", 25 };
dynamic row = new DynamicRow(obj, map);
Assert.Throws <InvalidOperationException>(() => row.B = "abc");
}
public Row ToRow()
{
var result = new DynamicRow(m_Schema);
foreach (var field in this.Fields)
{
result[field.FieldName] = field.ValueAsObject;
}
return(result);
}
public void CantSetValuesExplicitly()
{
var map = new Dictionary<string, int> {
{ "A", 0 },
{ "B", 1 }
};
var obj = new object[] { "Xyz", 25 };
dynamic row = new DynamicRow(obj, map);
Assert.Throws<InvalidOperationException>(() => row.B = "abc");
}
public void CanGetValues()
{
var map = new Dictionary <string, int> {
{ "A", 0 },
{ "B", 1 }
};
var obj = new object[] { "Xyz", 25 };
dynamic row = new DynamicRow(obj, map);
Assert.AreEqual("Xyz", row.A);
Assert.AreEqual(25, row.B);
}
public void CanGetValues()
{
var map = new Dictionary<string, int> {
{ "A", 0 },
{ "B", 1 }
};
var obj = new object[] { "Xyz", 25 };
dynamic row = new DynamicRow(obj, map);
Assert.AreEqual("Xyz", row.A);
Assert.AreEqual(25, row.B);
}
public TestDefinition DynamicRow_ControlArray()
{
DynRow1 = new DynamicRow(typeof(Gtk.Button), new object[] { "button" });
TestDefinition info = new TestDefinition();
info.testName = "DynamicRow_ControlArray";
info.testDesc = "Test that sets a DynamicRow with a control type.";
info.testWidget = DynRow1;
return(info);
}
public TestDefinition DynamicRow_UpdatedArray()
{
DynRow3 = new DynamicRow(typeof(Gtk.Button), new object[] { "button" });
TestDefinition info = new TestDefinition();
info.testName = "DynamicRow_UpdatedArray";
info.testDesc = "Test that sets a DynamicRow and on the button click, updates the set of control.";
info.testWidget = DynRow3;
info.buttonClick1 = OnClickUpdateArray;
return(info);
}
public void SetKey(ConnectorSysEventArgs eventArgs)
{
if (eventArgs.EndPointValue != null)
{
string table = this["Table"].GetValue <string>();
string displayField = this["DisplayField"].GetValue <string>();
string pkField = this["PKField"].GetValue <string>();
//seelct displayField from targetTable where PK_ID = eventArgs.EndPointValue
DynamicRow myRow = DynamicRow.FindRow <long>(table, (long)eventArgs.EndPointValue);
ctl.Text = "pk=" + (eventArgs.EndPointValue.ToString()) + " value=" + myRow[displayField].fValue.ToString();
}
}
public TestDefinition DynamicRow_ChangedMax()
{
DynRow2 = new DynamicRow(typeof(Gtk.Button), new object[] { "button" });
DynRow2.UpdateMaxCount(12);
TestDefinition info = new TestDefinition();
info.testName = "DynamicRow_ChangedMax";
info.testDesc = "Test that sets a DynamicRow with a larger number of controls.";
info.testWidget = DynRow2;
return(info);
}
public void ColumnDoesNotExist()
{
var map = new Dictionary<string, int> {
{ "A", 0 }
};
var obj = new object[] { "Xyz" };
dynamic row = new DynamicRow(obj, map);
Assert.AreEqual("Xyz", row.A);
object dummy;
Assert.AreEqual("Xyz", row.A);
Assert.Throws<ColumnDoesNotExistException>(() => dummy = row.B);
}
public static List<dynamic>[] ToDynamics(
this DbDataReader reader, int pageSize, int pageIndex)
{
var all = new List<List<dynamic>>();
if(null == reader || !reader.HasRows) {
return all.ToArray();
}
bool paging = pageSize > 0 && pageIndex > 0;
do {
var list = new List<dynamic>();
int index = 0;
var columns = reader.GetColumns();
while(reader.Read()) {
index++;
if(paging) {
if((pageIndex - 1) * pageSize > index) {
continue;
}
if(pageIndex * pageSize > index) {
break;
}
}
DynamicRow row = new DynamicRow();
reader.CurrentBindDynamicRow(columns, ref row);
list.Add(row as dynamic);
}
all.Add(list);
}
while(reader.NextResult());
return all.ToArray();
}
public static List<dynamic> ToDynamics(
this DbDataReader reader, int pageSize, int pageIndex)
{
var list = new List<dynamic>();
if(null == reader) { return list; }
bool paging = pageSize > 0 && pageIndex > 0;
int index = 0;
var schema = reader.GetSchemaTable();
var tableName = schema.TableName;
var columns = new List<string>();
for(int i = 0; i < reader.FieldCount; i++) {
string s = reader.GetName(i);
columns.Add(s);
}
var dbValues = new object[reader.FieldCount];
while(reader.Read()) {
index++;
if(paging) {
if((pageIndex - 1) * pageSize > index) {
continue;
}
if(pageIndex * pageSize > index) {
break;
}
}
reader.GetValues(dbValues);
//var row = schema.NewRow();
var values = new List<Any>();
var hashCodes = new List<Any>();
var dbNulls = new List<string>();
var columnIndex = -1;
foreach(var column in columns) {
columnIndex++;
var value = dbValues[columnIndex];
if(DBNull.Value == value) {
dbNulls.Add(column);
value = null;
}
values.Add(column, value);
if(null != value) {
int hashCode = value.GetHashCode();
hashCodes.Add(column, hashCode);
}
}
var data = new DynamicRow() {
__ReturnAny = true,
__DatabaseFirst = true,
__TableName = tableName,
__Values = values,
__HashCodes = hashCodes,
__DbNulls = dbNulls,
};
data.__OriginalHashCode = data.GetHashCode();
if(dbNulls.Any()) {
foreach(var dbNull in dbNulls) {
hashCodes.Add(
dbNull,
data.__OriginalHashCode
);
}
}
data.__HashCodes = hashCodes;
list.Add(data as dynamic);
}
return list;
}
