public void ConvertDataSetToDict()
{
DateTime now = DateTime.Now;
DateTime secondDate = now.AddDays(1);
const string tableName = "MyTable";
DataTable dt1 = CreateTable(tableName + "1", now, secondDate);
DataTable dt2 = CreateTable(tableName + "2", now, secondDate);
DataSet ds = new DataSet();
ds.Tables.Add(dt1);
ds.Tables.Add(dt2);
c.Dict dict = ds.ToDict();
string[] columnNames = (string[])dict.x;
object[] columnValues = (object[])dict.y;
Assert.AreEqual(2, columnNames.Length);
Assert.AreEqual(2, columnValues.Length);
Assert.AreEqual(tableName + "1", columnNames[0]);
Assert.AreEqual(tableName + "2", columnNames[1]);
c.Dict d1 = ((c.Dict[])columnValues[0])[0];
DataTable tableToCheck1 = d1.ToDataTable(tableName);
CheckDataTable(now, secondDate, tableToCheck1, tableName);
c.Dict d2 = ((c.Dict[])columnValues[1])[0];
DataTable tableToCheck2 = d2.ToDataTable(tableName);
CheckDataTable(now, secondDate, tableToCheck2, tableName);
}
public void ConnectionReturnsExpectedLengthForDict()
{
const int expected = 1;
c.Dict dict = new c.Dict(new[] { "Key_1" }, new object[] { "Value_1" });
int count = c.n(dict);
Assert.AreEqual(expected, count);
}
public void ConvertEmptyDataTableToDictTest()
{
DataTable dt = new DataTable();
c.Dict dict = dt.ToDict();
string[] columnNames = (string[])dict.x;
object[] columnValues = (object[])dict.y;
Assert.AreEqual(0, columnNames.Length);
Assert.AreEqual(0, columnValues.Length);
}
public void ConvertSimpleDictToDataTableTest()
{
DateTime firstDate = DateTime.Now;
DateTime secondDate = firstDate.AddDays(1);
const string tableName = "MyTable";
c.Dict dict = CreateDict(firstDate, secondDate);
DataTable dt = dict.ToDataTable(tableName);
CheckDataTable(firstDate, secondDate, dt, tableName);
}
private static KdbMultipleResult CreateMultipleResult()
{
c.Dict table1 = CreateTable(new string[] { "id1" }, // Key column names.
new object[] { new object[] { 1, 2, 3 } }, // Key column values.
new string[] { "columnA" }, // Column names.
new object[] { new object[] { "A1", "A2", "A3" } }); // Column calues.
c.Dict table2 = CreateTable(new string[] { "id1" },
new object[] { new object[] { 1, 2, 3 } },
new string[] { "columnB", "columnC" },
new object[] { new object[] { "B1", "B2", "B3" }, new object[] { "C1", "C2", "C3" } });
return(new KdbMultipleResult(new c.Dict(new string[] { "table1", "table2" }, new c.Dict[] { table1, table2 })));
}
public void ConvertSimpleDataTableToDict()
{
DateTime now = DateTime.Now;
DateTime secondDate = now.AddDays(1);
const string tableName = "MyTable";
DataTable dt = CreateTable(tableName, now, secondDate);
c.Dict dict = dt.ToDict();
DataTable tableToCheck = dict.ToDataTable(tableName);
CheckDataTable(now, secondDate, tableToCheck, tableName);
}
public void ConnectionTableReturnsExpectedTableIfObjectIsDict()
{
c.Dict dict = new c.Dict
(
new c.Flip(new c.Dict(new[] { "Key_1" }, new object[] { new object[] { "Value_1" } })),
new c.Flip(new c.Dict(new[] { "Key_1" }, new object[] { new object[] { "Value_1" } }))
);
object result = c.td(dict);
Assert.IsNotNull(result);
Assert.IsTrue(result is c.Flip);
}
public void ConnectionSerialisesAndDeserialisesDictInput()
{
c.Dict expected = new c.Dict(new string[] { "Key_1" }, new object[] { "Value_1" });
using (var connection = new c())
{
byte[] serialisedData = connection.Serialize(1, expected);
c.Dict result = connection.Deserialize(serialisedData) as c.Dict;
Assert.IsNotNull(result);
Assert.IsTrue(Enumerable.SequenceEqual(expected.x as string[], result.x as string[]));
Assert.IsTrue(Enumerable.SequenceEqual(expected.y as object[], result.y as object[]));
}
}
/// <summary>
/// Creates a c.Flip object only containing the version number of a fictional
/// db, then loads it into the q session.
/// </summary>
private void ConvertDBVersionDataIntoFlip()
{
string[] colnames = new string[1];
colnames[0] = "dbversion";
object[] colData = new object[1];
string[] dbVersion = new string[1];
dbVersion[0] = "dbversion";
colData[0] = dbVersion;
c.Dict dict = new c.Dict(colnames, colData);
c.Flip flipData = new c.Flip(dict);
_queries.LoadDBVersionData(flipData);
}
/// <summary>
/// Converts c.Dict into DataTable.
/// </summary>
/// <param name="dict">The dict.</param>
/// <param name="tableName">Name of the table.</param>
/// <returns></returns>
public static DataTable ToDataTable(this c.Dict dict, string tableName)
{
Guard.ThrowIfNull(dict, "dict");
if (String.IsNullOrEmpty(tableName))
{
tableName = "Table1";
}
KdbPlusDataReader reader = new KdbPlusDataReader(new c.Flip(dict));
DataTable table = new DataTable(tableName);
table.Load(reader);
return(table);
}
/// <summary>
/// Converts the list of students into a c.Flip object, to be inserted as a table in the db.
/// </summary>
private void ConvertListIntoFlip()
{
string[] colNames = new string[5];
colNames[0] = "name";
colNames[1] = "gender";
colNames[2] = "age";
colNames[3] = "dob";
colNames[4] = "outstandingfee";
object[] colData = new object[5];
string[] names = new string[StudentNames.Count];
string[] genders = new string[StudentNames.Count];
int[] ages = new int[StudentNames.Count];
DateTime[] dobs = new DateTime[StudentNames.Count];
double[] outstandingFees = new double[StudentNames.Count];
int a = 0;
foreach (Student stud in StudentNames)
{
names[a] = stud.Name;
genders[a] = stud.Gender;
ages[a] = stud.Age;
dobs[a] = stud.DOB;
outstandingFees[a] = stud.OutStandingFee;
a++;
}
colData[0] = names;
colData[1] = genders;
colData[2] = ages;
colData[3] = dobs;
colData[4] = outstandingFees;
c.Dict dict = new c.Dict(colNames, colData);
c.Flip flipData = new c.Flip(dict);
_queries.LoadStudentsToDB(flipData);
}
public void ConvertDictToDataSet()
{
DateTime firstDate = DateTime.Now;
DateTime secondDate = firstDate.AddDays(1);
const string tableName = "MyTable";
c.Dict dict1 = CreateDict(firstDate, secondDate);
c.Dict dict2 = CreateDict(firstDate, secondDate);
c.Dict composite = new c.Dict(new string[] { tableName + "1", tableName + "2" }, new object[] { new c.Dict[] { dict1 }, new c.Dict[] { dict2 } });
DataSet ds = composite.ToDataSet();
Assert.AreEqual(2, ds.Tables.Count);
DataTable dt1 = ds.Tables[0];
CheckDataTable(firstDate, secondDate, dt1, tableName + "1");
DataTable dt2 = ds.Tables[1];
CheckDataTable(firstDate, secondDate, dt2, tableName + "2");
}
private static DataReaderCollection CreateReaders(c.Dict kdbResult)
{
Dictionary <string, IDataReader> tableReaders = new Dictionary <string, IDataReader>();
string[] tableNames = (string[])kdbResult.x;
object[] tables = (object[])kdbResult.y;
for (int i = 0; i < tableNames.Length; i++)
{
object[] temp = tables[i] as object[];
if (temp != null && temp.Length == 0)
{
tableReaders[tableNames[i]] = KdbPlusDataReader.CreateEmptyReader();
}
else
{
tableReaders[tableNames[i]] = new KdbPlusDataReader(c.td(tables[i]));
}
}
return(new DataReaderCollection(tableReaders));
}
/// <summary>
/// Converts the DataSet into the graph of c.Dict objects.
/// </summary>
/// <param name="dataSet">The data set.</param>
/// <returns></returns>
public static c.Dict ToDict(this DataSet dataSet)
{
Guard.ThrowIfNull(dataSet, "dataSet");
int tableCount = dataSet.Tables.Count;
if (tableCount == 0)
{
return(CreateEmptyDict());
}
string[] columnNames = new string[tableCount];
object[] columns = new object[tableCount];
c.Dict result = new c.Dict(columnNames, columns);
for (int i = 0; i < tableCount; i++)
{
DataTable table = dataSet.Tables[i];
columnNames[i] = table.TableName ?? String.Empty;
columns[i] = new c.Dict[] { table.ToDict() };
}
return(result);
}
/// <summary>
/// Converts the graph of c.Dict into DataSet
/// </summary>
/// <param name="dict">The dict.</param>
/// <returns></returns>
public static DataSet ToDataSet(this c.Dict dict)
{
Guard.ThrowIfNull(dict, "dict");
string[] tableNames = (string[])dict.x;
object[] dicts = (object[])dict.y;
DataSet ds = new DataSet();
int tableCount = tableNames.Length;
if (tableCount == 0)
{
return(ds);
}
for (int i = 0; i < tableCount; i++)
{
c.Dict tableDict = (c.Dict)((Array)dicts[i]).GetValue(0);
ds.Tables.Add(tableDict.ToDataTable(tableNames[i]));
}
return(ds);
}
public void ConnectionIsQNullReturnsFalseForDict()
{
c.Dict input = new c.Dict(new string[] { }, new object[] { });
Assert.IsFalse(c.qn(input));
}
/// <summary>
/// Converts c.Dict into DataTable.
/// </summary>
/// <param name="dict">The dict.</param>
/// <returns></returns>
public static DataTable ToDataTable(this c.Dict dict)
{
return(ToDataTable(dict, null));
}
public void DictInitialises()
{
var dict = new c.Dict(new string[] { "Key_1" }, new object[] { "Value_1" });
Assert.IsNotNull(dict);
}
/// <summary>
/// Creates the reader from collection.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
internal static DbDataReader CreateReaderFromCollection(object result)
{
var d = new c.Dict(new[] { "Result" }, new[] { result });
return(new KdbPlusDataReader(new c.Flip(d)));
}
/// <summary>
/// Creates the reader from primitive.
/// </summary>
/// <param name="result">The result.</param>
/// <returns></returns>
internal static DbDataReader CreateReaderFromPrimitive(object result)
{
var d = new c.Dict(new[] { "Result" }, new object[] { new[] { result } });
return(new KdbPlusDataReader(new c.Flip(d)));
}
public KdbMultipleResult(c.Dict kdbResult)
{
Guard.ThrowIfNull(kdbResult, "kdbResult");
_readers = CreateReaders(kdbResult);
}
