public void SetUp()
{
Connection = new SQLiteConnection("Data Source=:memory:");
Connection.Open();
Scheduler = new TaskScheduler();
Wrapper = new ConnectionWrapper(Scheduler, Connection);
}
public void TestDisposal()
{
DoQuery("DROP TABLE IF EXISTS Test");
DoQuery("CREATE TABLE Test (value int)");
for (int i = 0; i < 10; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
TaskEnumerator <IDataRecord> iter;
IFuture f;
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q = qm.BuildQuery("SELECT * FROM Test");
var q2 = qm.BuildQuery("SELECT COUNT(*) FROM Test");
iter = q.Execute();
scheduler.Start(iter.Fetch());
f = q2.ExecuteScalar();
}
iter.Dispose();
try {
int count = (int)f.Result;
Assert.Fail("Future's result was not a ConnectionDisposedException");
} catch (FutureException fe) {
Assert.IsInstanceOfType(typeof(ConnectionDisposedException), fe.InnerException);
}
}
public virtual Future <ConnectionWrapper> Clone(string extraConnectionParameters = null)
{
var newConnectionString = _Connection.ConnectionString;
if (extraConnectionParameters != null)
{
newConnectionString = newConnectionString + ";" + extraConnectionParameters;
}
var newConnection = _Connection.GetType().GetConstructor(System.Type.EmptyTypes).Invoke(null);
newConnection.GetType().GetProperty("ConnectionString").SetValue(newConnection, newConnectionString, null);
var openMethod = newConnection.GetType().GetMethod("Open");
var f = new Future <ConnectionWrapper>();
f.RegisterOnComplete((_) => {
NotifyQueryCompleted(f);
});
Action openAndReturn = () => {
try {
openMethod.Invoke(newConnection, null);
var result = new ConnectionWrapper(_Scheduler, (IDbConnection)newConnection, true);
f.SetResult(result, null);
} catch (Exception e) {
f.SetResult(null, e);
}
};
EnqueueQuery(f, openAndReturn);
return(f);
}
public void TestClonePipelining()
{
DoQuery("DROP TABLE IF EXISTS Test");
DoQuery("CREATE TABLE Test (value int)");
for (int i = 0; i < 10; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q = qm.BuildQuery("SELECT * FROM Test");
var iter = q.Execute();
var iterF = scheduler.Start(iter.Fetch());
var fClone = qm.Clone();
Assert.IsFalse(fClone.Completed);
iter.Dispose();
iterF.Dispose();
scheduler.WaitFor(fClone);
using (var dupe = fClone.Result) {
q = dupe.BuildQuery("SELECT COUNT(value) FROM Test WHERE value = ?");
var f = q.ExecuteScalar(5);
var result = scheduler.WaitFor(f);
Assert.AreEqual(result, 1);
}
}
}
public void TestTransactionPipelining()
{
DoQuery("CREATE TEMPORARY TABLE Test (value int)");
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var getNumValues = qm.BuildQuery("SELECT COUNT(value) FROM test");
var addValue = qm.BuildQuery("INSERT INTO test (value) VALUES (?)");
var t = qm.CreateTransaction();
var fq = addValue.ExecuteNonQuery(1);
var fr = t.Rollback();
scheduler.WaitFor(Future.WaitForAll(t.Future, fq, fr));
var fgnv = getNumValues.ExecuteScalar();
long numValues = Convert.ToInt64(
scheduler.WaitFor(fgnv)
);
Assert.AreEqual(0, numValues);
t = qm.CreateTransaction();
fq = addValue.ExecuteNonQuery(1);
var fc = t.Commit();
scheduler.WaitFor(Future.WaitForAll(t.Future, fq, fc));
fgnv = getNumValues.ExecuteScalar();
numValues = Convert.ToInt64(
scheduler.WaitFor(fgnv)
);
Assert.AreEqual(1, numValues);
}
}
public void TestTransactionAutoRollback()
{
DoQuery("CREATE TEMPORARY TABLE Test (value int)");
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var getNumValues = qm.BuildQuery("SELECT COUNT(value) FROM test");
var addValue = qm.BuildQuery("INSERT INTO test (value) VALUES (?)");
var f = scheduler.Start(CrashyTransactionTask(qm, addValue));
try {
scheduler.WaitFor(f);
Assert.Fail("Did not throw");
} catch (FutureException fe) {
Exception inner = fe.InnerException;
Assert.IsInstanceOfType(typeof(InvalidOperationException), inner);
}
var fgnv = getNumValues.ExecuteScalar();
long numValues = Convert.ToInt64(
scheduler.WaitFor(fgnv)
);
Assert.AreEqual(0, numValues);
}
}
static IEnumerator <object> SequentialInsertTask(ConnectionWrapper cw, Query query, int numInsertions)
{
for (int i = 0; i < numInsertions; i++)
{
yield return(query.ExecuteNonQuery(i, i * 2));
}
}
public void InsertBenchmark(int warmupLength, int numInsertions, Func <IJobQueue> jobQueueFactory, Func <ConnectionWrapper, Query, int, IEnumerator <object> > insertTask)
{
DoQuery("CREATE TABLE Test (A INTEGER NOT NULL, B INTEGER NOT NULL)");
var jobQueue = jobQueueFactory();
var wjq = jobQueue as WindowsMessageJobQueue;
using (var scheduler = new TaskScheduler(() => jobQueue))
using (var cw = new ConnectionWrapper(scheduler, Connection))
using (var query = cw.BuildQuery("INSERT INTO Test (A, B) VALUES (?, ?)")) {
scheduler.WaitFor(insertTask(cw, query, warmupLength));
DoQuery("DELETE FROM Test");
var e = insertTask(cw, query, numInsertions);
long timeStart = Time.Ticks;
scheduler.WaitFor(e);
long elapsed = Time.Ticks - timeStart;
var elapsedSeconds = (decimal)elapsed / Time.SecondInTicks;
Console.WriteLine(
"Inserted {0} row(s) in {1:00.000} second(s) at ~{2:000000.00} rows/sec.",
numInsertions, elapsedSeconds, numInsertions / elapsedSeconds
);
}
}
IEnumerator <object> CrashyTransactionTask(ConnectionWrapper cw, Query addValue)
{
using (var trans = cw.CreateTransaction()) {
yield return(addValue.ExecuteNonQuery(1));
yield return(addValue.ExecuteNonQuery());
yield return(trans.Commit());
}
}
public DatabasePropertySerializer(
ConnectionWrapper database, string tableName,
string nameColumn = "name", string valueColumn = "value"
) : this(
database, tableName,
nameColumn, valueColumn,
GetDefaultMemberName
)
{
}
private static ConnectionWrapper make_ConnectionWrapper()
{
var scheduler = new TaskScheduler();
var filename = "file.txt";
string connectionString = String.Format("Data Source={0}", filename);
var nativeConnection = new SQLiteConnection(connectionString);
////nativeConnection.Open();
var connection = new ConnectionWrapper(scheduler, nativeConnection);
return(connection);
}
public DatabasePropertySerializer(
ConnectionWrapper database, string tableName,
string nameColumn, string valueColumn,
Func <IBoundMember, string> getMemberName
) : this(
database.BuildQuery(String.Format("REPLACE INTO {0} ({1}, {2}) VALUES (?, ?)", tableName, nameColumn, valueColumn)),
database.BuildQuery(String.Format("SELECT {2} FROM {0} WHERE {1} = ? LIMIT 1", tableName, nameColumn, valueColumn)),
getMemberName
)
{
}
public void TestQueryParameters()
{
using (var scheduler = new TaskScheduler())
using (var wrapper = new ConnectionWrapper(scheduler, Connection)) {
scheduler.WaitFor(wrapper.ExecuteSQL("CREATE TEMPORARY TABLE Test (a INTEGER, b VARIANT)"));
using (var q = wrapper.BuildQuery("INSERT INTO Test (a, b) VALUES (?, ?)")) {
q.Parameters[1].DbType = DbType.Object;
Assert.AreEqual(DbType.Object, q.Parameters[1].DbType);
}
}
}
public void TestConnectionWrapper()
{
DoQuery("CREATE TEMPORARY TABLE Test (value int)");
for (int i = 0; i < 100; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q = qm.BuildQuery("SELECT COUNT(value) FROM Test WHERE value = ?");
var f = q.ExecuteScalar(5);
var result = scheduler.WaitFor(f);
Assert.AreEqual(result, 1);
q = qm.BuildQuery("SELECT @p0 - @p1");
f = q.ExecuteScalar(2, 3);
result = scheduler.WaitFor(f);
Assert.AreEqual(result, -1);
f = q.ExecuteScalar(new NamedParam {
N = "p0", V = 4
}, new NamedParam {
N = "p1", V = 3
});
result = scheduler.WaitFor(f);
Assert.AreEqual(result, 1);
f = q.ExecuteScalar(5, new NamedParam {
N = "p1", V = 3
});
result = scheduler.WaitFor(f);
Assert.AreEqual(result, 2);
q = qm.BuildQuery("SELECT @parm1-@parm2");
f = q.ExecuteScalar(new NamedParam {
N = "parm1", V = 1
}, new NamedParam {
N = "parm2", V = 2
});
result = scheduler.WaitFor(f);
Assert.AreEqual(result, -1);
}
}
static IEnumerator <object> TransactionalSequentialInsertTask(ConnectionWrapper cw, Query query, int numInsertions)
{
using (var xact = cw.CreateTransaction()) {
yield return(xact);
for (int i = 0; i < numInsertions; i++)
{
yield return(query.ExecuteNonQuery(i, i * 2));
}
yield return(xact.Commit());
}
}
public void TestQueryPipelining()
{
DoQuery("CREATE TEMPORARY TABLE Test (value int)");
for (int i = 0; i < 100; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q1 = qm.BuildQuery("SELECT value FROM test");
var q2 = qm.BuildQuery("INSERT INTO test (value) VALUES (?)");
var iterator = q1.Execute();
var f1 = scheduler.Start(iterator.Fetch());
var f2 = q2.ExecuteNonQuery(200);
f1.RegisterOnComplete((f) => {
Assert.IsNull(f.Error);
Assert.AreEqual(f1, f);
Assert.AreEqual(true, f.Result);
Assert.IsTrue(f1.Completed);
Assert.IsFalse(f2.Completed);
});
f2.RegisterOnComplete((f) => {
Assert.IsNull(f.Error);
Assert.AreEqual(f2, f);
Assert.IsTrue(f1.Completed);
Assert.IsTrue(f2.Completed);
});
scheduler.WaitFor(f1);
scheduler.WaitFor(scheduler.Start(new Sleep(1.0)));
Assert.IsFalse(f2.Completed);
iterator.Dispose();
scheduler.WaitFor(f2);
}
}
public void TestCloneConnectionWrapper()
{
DoQuery("DROP TABLE IF EXISTS Test");
DoQuery("CREATE TABLE Test (value int)");
for (int i = 0; i < 10; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var fClone = qm.Clone();
using (var dupe = scheduler.WaitFor(fClone)) {
var q = dupe.BuildQuery("SELECT COUNT(value) FROM Test WHERE value = ?");
var f = q.ExecuteScalar(5);
var result = scheduler.WaitFor(f);
Assert.AreEqual(result, 1);
}
}
}
public void TestDbTaskIterator()
{
DoQuery("CREATE TEMPORARY TABLE Test (value int)");
for (int i = 0; i < 100; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q = qm.BuildQuery("SELECT value FROM Test WHERE value = ?");
using (var iterator = q.Execute(5)) {
scheduler.WaitFor(iterator.Fetch());
using (var e = iterator.CurrentItems) {
Assert.IsTrue(e.MoveNext());
Assert.AreEqual(e.Current.GetInt32(0), 5);
}
}
}
}
public void TestGetResultAsObject()
{
DoQuery("DROP TABLE IF EXISTS Test");
DoQuery("CREATE TABLE Test (value int)");
for (int i = 0; i < 10; i++)
{
DoQuery(String.Format("INSERT INTO Test (value) VALUES ({0})", i));
}
using (var scheduler = new TaskScheduler())
using (var qm = new ConnectionWrapper(scheduler, Connection)) {
var q = qm.BuildQuery("SELECT * FROM Test");
var f = q.ExecuteArray <object>();
Assert.IsFalse(f.Completed);
var seq = scheduler.WaitFor(f);
Assert.AreEqual(
new object[] { 0, 1, 2, 3, 4, 5, 6, 7, 8, 9 }, seq
);
}
}
public Transaction(ConnectionWrapper wrapper)
{
_Wrapper = wrapper;
_Future = _Wrapper.BeginTransaction();
_Active = true;
}
public Transaction(ConnectionWrapper wrapper, bool exclusive)
{
_Wrapper = wrapper;
_Future = _Wrapper.BeginTransaction(exclusive);
_Active = true;
}
internal Query(ConnectionWrapper manager, IDbCommand command)
{
_Manager = manager;
_Command = command;
}
