public Sqlite3MasterTable(Sqlite3Database db, Sqlite3Table table)
{
Tables = new List <Sqlite3SchemaRow>();
IEnumerable <Sqlite3Row> rows = table.EnumerateRows();
foreach (Sqlite3Row row in rows)
{
Sqlite3SchemaRow other = new Sqlite3SchemaRow();
other.Database = db;
row.TryGetOrdinal(0, out string str);
other.Type = str;
row.TryGetOrdinal(1, out str);
other.Name = str;
row.TryGetOrdinal(2, out str);
other.TableName = str;
row.TryGetOrdinal(3, out long lng);
other.RootPage = (uint)lng;
row.TryGetOrdinal(4, out str);
other.Sql = str;
Tables.Add(other);
}
}
public void GettingNonExistentTableShouldFail()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Assert.ThrowsAny <Exception>(() => db.GetTable("BadTable"));
}
}
public void TestEncodingSet(SqliteEncoding encoding)
{
using (Sqlite3Database db = new Sqlite3Database(Get(encoding)))
{
Assert.Equal(encoding, db.Header.TextEncoding);
}
}
public void GettingExistingTableShouldSucceed()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Assert.NotNull(db.GetTable("MyTable"));
}
}
public void TestIntegerData(int id, long expectedInteger, long?expectedNewInteger)
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("MyTable");
IEnumerable <Sqlite3Row> rows = tbl.EnumerateRows();
foreach (Sqlite3Row row in rows)
{
Assert.True(row.TryGetOrdinal(1, out long actual));
if (row.RowId == id)
{
Assert.Equal(expectedInteger, actual);
if (expectedNewInteger.HasValue)
{
Assert.True(row.TryGetOrdinal(2, out long actualOther));
Assert.Equal(expectedNewInteger.Value, actualOther);
}
else
{
Assert.False(row.TryGetOrdinal(2, out long _));
}
return;
}
}
Assert.True(false, "Number is missing");
}
}
public void TryGetTableNonExistingShouldFail()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Assert.False(db.TryGetTable("BadTable", out var tbl));
Assert.Null(tbl);
}
}
public void TryGetTableExistingShouldSucceed()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Assert.True(db.TryGetTable("MyTable", out var tbl));
Assert.NotNull(tbl);
}
}
public void TestIntegerRowCount(int expected)
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("IntegerTable");
IEnumerable <Sqlite3Row> rows = tbl.EnumerateRows();
int actual = rows.Count();
Assert.Equal(expected, actual);
}
}
public void TestTableRowCount()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("MyTable");
IEnumerable <Sqlite3Row> rows = tbl.EnumerateRows();
int actual = rows.Count();
Assert.Equal(11, actual);
}
}
public void TestIntegerData(int id, long expected)
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("IntegerTable");
Sqlite3Row row = tbl.GetRowById(id);
Assert.NotNull(row);
Assert.True(row.TryGetOrdinal(1, out long actual));
Assert.Equal(expected, actual);
}
}
public void TestRealRowCount()
{
int expected = _testData.Count;
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("RealTable");
IEnumerable <Sqlite3Row> rows = tbl.EnumerateRows();
int actual = rows.Count();
Assert.Equal(expected, actual);
}
}
public void TestStringDataContents(SqliteEncoding encoding, int id, string expectedLanguage, string expectedString)
{
using (Sqlite3Database db = new Sqlite3Database(Get(encoding)))
{
Sqlite3Table tbl = db.GetTable("EncodingTable" + encoding);
Sqlite3Row row = tbl.GetRowById(id);
Assert.NotNull(row);
Assert.True(row.TryGetOrdinal(1, out string actualLang));
Assert.True(row.TryGetOrdinal(2, out string actualText));
Assert.Equal(expectedLanguage, actualLang);
Assert.Equal(expectedString, actualText);
}
}
public void TestRealData()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("DataTable");
List <Sqlite3Row> rows = tbl.EnumerateRows().ToList();
Assert.Single(rows);
Sqlite3Row row = rows.Single();
Assert.Equal(1, row.RowId);
Assert.True(row.TryGetOrdinal(1, out byte[] actual));
Assert.Equal(_expected, actual);
}
}
public void TestTableRowCounts()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
List <Sqlite3SchemaRow> tables = db.GetTables().ToList();
Assert.Equal(50, tables.Count);
List <string> actualNames = tables.Select(s => s.TableName).ToList();
foreach (string name in actualNames)
{
int actualCount = db.GetTable(name).EnumerateRows().Count();
Assert.Equal(500, actualCount);
}
}
}
public void TestTableNames()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
List <Sqlite3SchemaRow> tables = db.GetTables().ToList();
Assert.Equal(50, tables.Count);
List <string> actualNames = tables.Select(s => s.TableName).ToList();
for (int i = 0; i < 50; i++)
{
string expectedName = $"Table{i:00}";
Assert.Contains(expectedName, actualNames);
}
}
}
public void TestLongText()
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("urls");
List <Sqlite3Row> rows = tbl.EnumerateRows().ToList();
Assert.Single(rows);
Sqlite3Row row = rows.Single();
Assert.Equal(6014, row.RowId);
Assert.True(row.TryGetOrdinal(1, out string actual));
Assert.Equal(_expected, actual);
}
}
public void TestRealData(int id, long expectedLong)
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("RealTable");
Sqlite3Row row = tbl.GetRowById(id);
Assert.NotNull(row);
Assert.True(row.TryGetOrdinal(1, out double actual));
long actualLong = BitConverter.DoubleToInt64Bits(actual);
// Note: There is a loss of precision in the sqlite3 cli when generating the test database
// This, and the similar loss of precision in C# / floating points here leads to the code below
Assert.True(Math.Abs(expectedLong - actualLong) <= 2);
}
}
private static bool TryReadFile(string path, out Stream stream, out Sqlite3Database db, out List <Sqlite3SchemaRow> tables)
{
stream = null;
db = null;
tables = null;
try
{
stream = File.OpenRead(path);
db = new Sqlite3Database(stream);
tables = db.GetTables().ToList();
}
catch (Exception e)
{
Console.WriteLine(e.Message);
return(false);
}
return(true);
}
public void TestIntegerData(int id, long expectedInteger, long?expectedNewInteger)
{
using (Sqlite3Database db = new Sqlite3Database(_stream))
{
Sqlite3Table tbl = db.GetTable("MyTable");
Sqlite3Row row = tbl.GetRowById(id);
Assert.NotNull(row);
Assert.True(row.TryGetOrdinal(1, out long actual));
Assert.Equal(expectedInteger, actual);
if (expectedNewInteger.HasValue)
{
Assert.True(row.TryGetOrdinal(2, out long actualOther));
Assert.Equal(expectedNewInteger.Value, actualOther);
}
else
{
Assert.False(row.TryGetOrdinal(2, out long _));
}
}
}
public void ReadCreateStatementsFromDbTests(string dbFile, SqlTestData data)
{
Assembly assembly = typeof(SqlCreateStatements).Assembly;
using (MemoryStream ms = new MemoryStream())
{
using (Stream fs = assembly.GetManifestResourceStream(dbFile))
using (GZipStream gz = new GZipStream(fs, CompressionMode.Decompress))
{
gz.CopyTo(ms);
ms.Seek(0, SeekOrigin.Begin);
}
// Ensure that the DB matches the expectations
using (Sqlite3Database db = new Sqlite3Database(ms))
{
List <Sqlite3SchemaRow> dbTables = db.GetTables().Where(s => !s.TableName.StartsWith("sqlite_", StringComparison.Ordinal)).Where(s => s.Type == "table").ToList();
Assert.Equal(data.Statements.Count, dbTables.Count);
List <string> dbTableNames = dbTables.Select(s => s.TableName).ToList();
List <string> expectedTabledNames = data.Statements.Select(s => s.Name).ToList();
Assert.All(dbTableNames, x => Assert.Contains(x, expectedTabledNames));
Assert.All(expectedTabledNames, x => Assert.Contains(x, dbTableNames));
Assert.All(dbTables, tbl =>
{
SqlTestData.ExpectedTable expected = data.Statements.First(s => s.Name == tbl.TableName);
SqlTableDefinition definition = tbl.GetTableDefinition();
SqlTestData.Compare(definition, expected);
});
}
}
}
