public void ReadOnlyMode()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
for (int i = 0; i < 100; i++)
{
DataPoint dp = new DataPoint();
dp.X = i * 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
}
t.Commit();
s.Close();
AssertInsertCount(100);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
// NH-specific: Replace use of Scroll with List
IList<DataPoint> sr = s.CreateQuery("from DataPoint dp order by dp.X asc")
.SetReadOnly(true)
.List<DataPoint>();
int index = 0;
foreach (DataPoint dp in sr)
{
if (++index == 50)
{
s.SetReadOnly(dp, false);
}
dp.Description = "done!";
}
t.Commit();
AssertUpdateCount(1);
ClearCounts();
s.Clear();
t = s.BeginTransaction();
IList single = s.CreateQuery("from DataPoint where description='done!'").List();
Assert.That(single.Count, Is.EqualTo(1));
Assert.That(s.CreateQuery("delete from DataPoint").ExecuteUpdate(), Is.EqualTo(100));
t.Commit();
s.Close();
AssertUpdateCount(0);
//deletes from Query.executeUpdate() are not tracked
//AssertDeleteCount(100);
}
public void ReadOnlyOnProxies()
{
DataPoint dp = null;
long dpId = -1;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
s.BeginTransaction();
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
dp.Description = "original";
s.Save(dp);
dpId = dp.Id;
s.Transaction.Commit();
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
s.BeginTransaction();
s.DefaultReadOnly = true;
Assert.That(s.DefaultReadOnly, Is.True);
dp = (DataPoint)s.Load<DataPoint>(dpId);
s.DefaultReadOnly = false;
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False, "was initialized");
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False, "was initialized during isReadOnly");
dp.Description = "changed";
Assert.That(NHibernateUtil.IsInitialized(dp), Is.True, "was not initialized during mod");
Assert.That(dp.Description, Is.StringMatching("changed"), "desc not changed in memory");
s.Flush();
s.Transaction.Commit();
}
using (ISession s = OpenSession())
{
s.BeginTransaction();
IList list = s.CreateQuery("from DataPoint where description = 'changed'").List();
Assert.That(list.Count, Is.EqualTo(0), "change written to database");
s.CreateQuery("delete from DataPoint").ExecuteUpdate();
s.Transaction.Commit();
}
}
public void ReadOnlyOnProxies()
{
ClearCounts();
ISession s = OpenSession();
s.BeginTransaction();
DataPoint dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
dp.Description = "original";
s.Save(dp);
long dpId = dp.Id;
s.Transaction.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
s.BeginTransaction();
dp = s.Load<DataPoint>(dpId);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False, "was initialized");
s.SetReadOnly(dp, true);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False, "was initialized during SetReadOnly");
dp.Description = "changed";
Assert.That(NHibernateUtil.IsInitialized(dp), Is.True, "was not initialized during mod");
Assert.That(dp.Description, Is.EqualTo("changed"), "desc not changed in memory");
s.Flush();
s.Transaction.Commit();
s.Close();
AssertUpdateCount(0);
s = OpenSession();
s.BeginTransaction();
IList list = s.CreateQuery("from DataPoint where Description = 'changed'").List();
Assert.That(list.Count, Is.EqualTo(0), "change written to database");
Assert.That(s.CreateQuery("delete from DataPoint").ExecuteUpdate(), Is.EqualTo(1));
s.Transaction.Commit();
s.Close();
AssertUpdateCount(0);
//deletes from Query.executeUpdate() are not tracked
//AssertDeleteCount(1);
}
public void MergeWithReadOnlyProxy()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
}
}
dp.Description = "description";
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
DataPoint dpProxy = s.Load<DataPoint>(dp.Id);
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.False);
s.Evict(dpProxy);
dpProxy = (DataPoint)s.Merge(dpProxy);
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.False);
dpProxy = (DataPoint)s.Merge(dp);
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
s.Evict(dpProxy);
dpProxy = (DataPoint)s.Merge(dpProxy);
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
dpProxy.Description = null;
dpProxy = (DataPoint)s.Merge(dp);
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
t.Commit();
}
}
using (ISession s = OpenSession())
{
using (ITransaction t = s.BeginTransaction())
{
dp = s.Get<DataPoint>(dp.Id);
Assert.That(dp.Description, Is.Null);
s.Delete(dp);
t.Commit();
}
}
}
public void MergeWithReadOnlyEntity()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
}
}
dp.Description = "description";
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
DataPoint dpManaged = s.Get<DataPoint>(dp.Id);
DataPoint dpMerged = (DataPoint)s.Merge(dp);
Assert.That(dpManaged, Is.SameAs(dpMerged));
t.Commit();
}
}
using (ISession s = OpenSession())
{
using (ITransaction t = s.BeginTransaction())
{
DataPoint dpManaged = s.Get<DataPoint>(dp.Id);
Assert.That(dpManaged.Description, Is.Null);
s.Delete(dpManaged);
t.Commit();
}
}
}
public void MergeWithReadOnlyEntity()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
DataPoint dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
dp.Description = "description";
s = OpenSession();
t = s.BeginTransaction();
DataPoint dpManaged = s.Get<DataPoint>(dp.Id);
s.SetReadOnly(dpManaged, true);
DataPoint dpMerged = (DataPoint)s.Merge(dp);
Assert.That(dpManaged, Is.SameAs(dpMerged));
t.Commit();
s.Close();
AssertUpdateCount(0);
s = OpenSession();
t = s.BeginTransaction();
dpManaged = s.Get<DataPoint>(dp.Id);
Assert.That(dpManaged.Description, Is.Null);
s.Delete(dpManaged);
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
}
public async Task MergeWithReadOnlyProxyAsync()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
await(t.CommitAsync());
}
}
dp.Description = "description";
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
DataPoint dpProxy = await(s.LoadAsync <DataPoint>(dp.Id));
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.False);
await(s.EvictAsync(dpProxy));
dpProxy = (DataPoint)await(s.MergeAsync(dpProxy));
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.False);
dpProxy = (DataPoint)await(s.MergeAsync(dp));
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
await(s.EvictAsync(dpProxy));
dpProxy = (DataPoint)await(s.MergeAsync(dpProxy));
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
dpProxy.Description = null;
dpProxy = (DataPoint)await(s.MergeAsync(dp));
Assert.That(s.IsReadOnly(dpProxy), Is.True);
Assert.That(NHibernateUtil.IsInitialized(dpProxy), Is.True);
Assert.That(dpProxy.Description, Is.EqualTo("description"));
await(t.CommitAsync());
}
}
using (ISession s = OpenSession())
{
using (ITransaction t = s.BeginTransaction())
{
dp = await(s.GetAsync <DataPoint>(dp.Id));
Assert.That(dp.Description, Is.Null);
await(s.DeleteAsync(dp));
await(t.CommitAsync());
}
}
}
public void ReadOnlyProxyRefreshDetached()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.Description = "original";
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
dp = s.Load<DataPoint>(dp.Id);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
Assert.That(s.IsReadOnly(dp), Is.True);
s.Evict(dp);
s.Refresh(dp);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
s.DefaultReadOnly = false;
Assert.That(s.IsReadOnly(dp), Is.True);
s.Evict(dp);
s.Refresh(dp);
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
Assert.That(s.IsReadOnly(dp), Is.False);
Assert.That(s.IsReadOnly(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementation()), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
Assert.That(NHibernateUtil.IsInitialized(dp), Is.True);
s.Evict(dp);
s.Refresh(dp);
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
Assert.That(s.IsReadOnly(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementation()), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.DefaultReadOnly = true;
s.Evict(dp);
s.Refresh(dp);
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(s.IsReadOnly(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementation()), Is.True);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
t.Commit();
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
dp = s.Get<DataPoint>(dp.Id);
Assert.That(dp.Description, Is.EqualTo("original"));
s.Delete(dp);
t.Commit();
}
}
}
public void QueryModifiableIterate()
{
long lastDataPointId = 0;
int nExpectedChanges = 0;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
DataPoint dp = null;
for (int i = 0; i < 100; i++)
{
dp = new DataPoint();
dp.X = 0.1M * i;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
}
t.Commit();
lastDataPointId = dp.Id;
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
IQuery query = s.CreateQuery("from DataPoint dp order by dp.X asc");
Assert.That(query.IsReadOnly, Is.True);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(query.IsReadOnly, Is.True);
query.SetReadOnly(false);
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(query.IsReadOnly, Is.False);
query.SetReadOnly(true);
Assert.That(query.IsReadOnly, Is.True);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.True);
query.SetReadOnly(false);
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(s.DefaultReadOnly, Is.True);
IEnumerator<DataPoint> it = query.Enumerable<DataPoint>().GetEnumerator();
Assert.That(query.IsReadOnly, Is.False);
DataPoint dpLast = s.Get<DataPoint>(lastDataPointId);
Assert.That(s.IsReadOnly(dpLast), Is.True);
query.SetReadOnly(true);
Assert.That(query.IsReadOnly, Is.True);
Assert.That(s.DefaultReadOnly, Is.True);
int i = 0;
while (it.MoveNext())
{
Assert.That(s.DefaultReadOnly, Is.True);
DataPoint dp = it.Current;
Assert.That(s.DefaultReadOnly, Is.True);
if (dp.Id == dpLast.Id)
{
//dpLast existed in the session before executing the read-only query
Assert.That(s.IsReadOnly(dp), Is.True);
}
else
{
Assert.That(s.IsReadOnly(dp), Is.False);
}
if (++i == 50)
{
s.SetReadOnly(dp, true);
nExpectedChanges = (dp == dpLast ? 99 : 98);
}
dp.Description = "done!";
}
Assert.That(s.DefaultReadOnly, Is.True);
t.Commit();
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
try
{
IList list = s.CreateQuery("from DataPoint where Description = 'done!'").List();
Assert.That(list.Count, Is.EqualTo(nExpectedChanges));
}
finally
{
// cleanup
s.CreateQuery("delete from DataPoint").ExecuteUpdate();
}
t.Commit();
}
}
}
public void ReadOnlyModeAutoFlushOnQuery()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
for (int i = 0; i < 100; i++)
{
DataPoint dp = new DataPoint();
dp.X = i * 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
}
AssertInsertCount(0);
AssertUpdateCount(0);
// NH-specific: Replace use of Scroll with List
IList<DataPoint> sr = s.CreateQuery("from DataPoint dp order by dp.X asc")
.SetReadOnly(true)
.List<DataPoint>();
AssertInsertCount(100);
AssertUpdateCount(0);
ClearCounts();
foreach(DataPoint dp in sr)
{
Assert.That(s.IsReadOnly(dp), Is.False);
s.Delete(dp);
}
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(100);
}
private DataPoint CreateDataPoint(CacheMode mode)
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
dp.Description = "original";
s.Save(dp);
t.Commit();
}
}
return dp;
}
public async Task ReadOnlyProxyRefreshDetachedAsync()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.Description = "original";
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
await(t.CommitAsync());
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
dp = await(s.LoadAsync <DataPoint>(dp.Id));
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
Assert.That(s.IsReadOnly(dp), Is.True);
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
s.DefaultReadOnly = false;
Assert.That(s.IsReadOnly(dp), Is.True);
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(NHibernateUtil.IsInitialized(dp), Is.False);
Assert.That(s.IsReadOnly(dp), Is.False);
Assert.That(s.IsReadOnly(await(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementationAsync(CancellationToken.None))), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
Assert.That(NHibernateUtil.IsInitialized(dp), Is.True);
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
Assert.That(s.IsReadOnly(await(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementationAsync(CancellationToken.None))), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.DefaultReadOnly = true;
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(s.IsReadOnly(await(((INHibernateProxy)dp).HibernateLazyInitializer.GetImplementationAsync(CancellationToken.None))), Is.True);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
await(t.CommitAsync());
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
dp = await(s.GetAsync <DataPoint>(dp.Id));
Assert.That(dp.Description, Is.EqualTo("original"));
await(s.DeleteAsync(dp));
await(t.CommitAsync());
}
}
}
public async Task ReadOnlyRefreshDetachedAsync()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.Description = "original";
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
await(t.CommitAsync());
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = false;
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
await(s.RefreshAsync(dp));
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.DefaultReadOnly = true;
await(s.EvictAsync(dp));
await(s.RefreshAsync(dp));
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.True);
dp.Description = "changed";
await(t.CommitAsync());
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
dp = await(s.GetAsync <DataPoint>(dp.Id));
Assert.That(dp.Description, Is.EqualTo("original"));
await(s.DeleteAsync(dp));
await(t.CommitAsync());
}
}
}
public async Task QueryModifiableIterateAsync()
{
long lastDataPointId = 0;
int nExpectedChanges = 0;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
DataPoint dp = null;
for (int i = 0; i < 100; i++)
{
dp = new DataPoint();
dp.X = 0.1M * i;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
}
await(t.CommitAsync());
lastDataPointId = dp.Id;
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = true;
IQuery query = s.CreateQuery("from DataPoint dp order by dp.X asc");
Assert.That(query.IsReadOnly, Is.True);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(query.IsReadOnly, Is.True);
query.SetReadOnly(false);
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(query.IsReadOnly, Is.False);
query.SetReadOnly(true);
Assert.That(query.IsReadOnly, Is.True);
s.DefaultReadOnly = false;
Assert.That(query.IsReadOnly, Is.True);
query.SetReadOnly(false);
Assert.That(query.IsReadOnly, Is.False);
s.DefaultReadOnly = true;
Assert.That(s.DefaultReadOnly, Is.True);
IEnumerator <DataPoint> it = (await(query.EnumerableAsync <DataPoint>())).GetEnumerator();
Assert.That(query.IsReadOnly, Is.False);
DataPoint dpLast = await(s.GetAsync <DataPoint>(lastDataPointId));
Assert.That(s.IsReadOnly(dpLast), Is.True);
query.SetReadOnly(true);
Assert.That(query.IsReadOnly, Is.True);
Assert.That(s.DefaultReadOnly, Is.True);
int i = 0;
while (it.MoveNext())
{
Assert.That(s.DefaultReadOnly, Is.True);
DataPoint dp = it.Current;
Assert.That(s.DefaultReadOnly, Is.True);
if (dp.Id == dpLast.Id)
{
//dpLast existed in the session before executing the read-only query
Assert.That(s.IsReadOnly(dp), Is.True);
}
else
{
Assert.That(s.IsReadOnly(dp), Is.False);
}
if (++i == 50)
{
s.SetReadOnly(dp, true);
nExpectedChanges = (dp == dpLast ? 99 : 98);
}
dp.Description = "done!";
}
Assert.That(s.DefaultReadOnly, Is.True);
await(t.CommitAsync());
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
try
{
IList list = await(s.CreateQuery("from DataPoint where Description = 'done!'").ListAsync());
Assert.That(list.Count, Is.EqualTo(nExpectedChanges));
}
finally
{
// cleanup
await(s.CreateQuery("delete from DataPoint").ExecuteUpdateAsync());
}
await(t.CommitAsync());
}
}
}
public async Task ModifiableSessionDefaultQueryReadOnlySessionIterateAsync()
{
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
for (int i = 0; i < 100; i++)
{
DataPoint dp = new DataPoint();
dp.X = 0.1M * i;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
}
await(t.CommitAsync());
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = false;
IQuery query = s.CreateQuery("from DataPoint dp order by dp.X asc");
s.DefaultReadOnly = true;
IEnumerable enumerable = await(query.EnumerableAsync());
s.DefaultReadOnly = false;
int i = 0;
foreach (DataPoint dp in enumerable)
{
if (++i == 50)
{
s.SetReadOnly(dp, false);
}
dp.Description = "done!";
}
await(t.CommitAsync());
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
try
{
IList single = await(s.CreateQuery("from DataPoint where Description = 'done!'").ListAsync());
Assert.That(single.Count, Is.EqualTo(1));
}
finally
{
// cleanup
await(s.CreateQuery("delete from DataPoint").ExecuteUpdateAsync());
}
await(t.CommitAsync());
}
}
}
public void ModifiableSessionDefaultQueryReadOnlySessionIterate()
{
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
for (int i = 0; i < 100; i++)
{
DataPoint dp = new DataPoint();
dp.X = 0.1M * i;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
}
t.Commit();
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
s.DefaultReadOnly = false;
IQuery query = s.CreateQuery("from DataPoint dp order by dp.X asc");
s.DefaultReadOnly = true;
IEnumerable enumerable = query.Enumerable();
s.DefaultReadOnly = false;
int i = 0;
foreach (DataPoint dp in enumerable)
{
if (++i == 50)
{
s.SetReadOnly(dp, false);
}
dp.Description = "done!";
}
t.Commit();
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
try
{
IList single = s.CreateQuery("from DataPoint where Description = 'done!'").List();
Assert.That(single.Count, Is.EqualTo(1));
}
finally
{
// cleanup
s.CreateQuery("delete from DataPoint").ExecuteUpdate();
}
t.Commit();
}
}
}
public void ReadOnlyRefreshDetached()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
DataPoint dp = new DataPoint();
dp.Description = "original";
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.Refresh(dp);
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
s.SetReadOnly(dp, true);
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.Evict(dp);
s.Refresh(dp);
Assert.That(dp.Description, Is.EqualTo("original"));
Assert.That(s.IsReadOnly(dp), Is.False);
t.Commit();
AssertInsertCount(0);
AssertUpdateCount(0);
s.Clear();
t = s.BeginTransaction();
dp = s.Get<DataPoint>(dp.Id);
Assert.That(dp.Description, Is.EqualTo("original"));
s.Delete(dp);;
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
}
public void ReadOnlyGetModifyAndDelete()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
DataPoint dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
s.Close();
AssertInsertCount(1);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
dp = s.Get<DataPoint>(dp.Id);
s.SetReadOnly(dp, true);
dp.Description = "a DataPoint";
s.Delete(dp);
t.Commit();
s.Close();
AssertUpdateCount(0);
AssertDeleteCount(1);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
IList list = s.CreateQuery("from DataPoint where Description='done!'").List();
Assert.That(list.Count, Is.EqualTo(0));
t.Commit();
s.Close();
}
public void ReadOnlyRefresh()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.Description = "original";
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
}
}
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
s.DefaultReadOnly = true;
using (ITransaction t = s.BeginTransaction())
{
dp = s.Get<DataPoint>(dp.Id);
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(dp.Description, Is.EqualTo("original"));
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.Refresh(dp);
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(dp.Description, Is.EqualTo("original"));
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
s.DefaultReadOnly = false;
s.Refresh(dp);
Assert.That(s.IsReadOnly(dp), Is.True);
Assert.That(dp.Description, Is.EqualTo("original"));
dp.Description = "changed";
Assert.That(dp.Description, Is.EqualTo("changed"));
t.Commit();
}
s.Clear();
using (ITransaction t = s.BeginTransaction())
{
dp = s.Get<DataPoint>(dp.Id);
Assert.That(dp.Description, Is.EqualTo("original"));
s.Delete(dp);
t.Commit();
}
}
}
public void ModifiableModeWithExistingReadOnlyEntity()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
DataPoint dp = null;
for (int i = 0; i < 100; i++)
{
dp = new DataPoint();
dp.X = i * 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
}
t.Commit();
s.Close();
AssertInsertCount(100);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
DataPoint dpLast = s.Get<DataPoint>(dp.Id);
Assert.That(s.IsReadOnly(dpLast), Is.False);
s.SetReadOnly(dpLast, true);
Assert.That(s.IsReadOnly(dpLast), Is.True);
dpLast.Description = "oy";
AssertUpdateCount(0);
// NH-specific: Replace use of Scroll with List
IList<DataPoint> sr = s.CreateQuery("from DataPoint dp order by dp.X asc")
.SetReadOnly(false)
.List<DataPoint>();
int nExpectedChanges = 0;
int index = 0;
foreach(DataPoint nextDp in sr)
{
if (nextDp.Id == dpLast.Id )
{
//dpLast existed in the session before executing the read-only query
Assert.That(s.IsReadOnly(nextDp), Is.True);
}
else
{
Assert.That(s.IsReadOnly(nextDp), Is.False);
}
if (++index == 50)
{
s.SetReadOnly(nextDp, true);
nExpectedChanges = (nextDp == dpLast ? 99 : 98);
}
nextDp.Description = "done!";
}
t.Commit();
s.Clear();
AssertUpdateCount(nExpectedChanges);
ClearCounts();
t = s.BeginTransaction();
IList list = s.CreateQuery("from DataPoint where Description='done!'").List();
Assert.That(list.Count, Is.EqualTo(nExpectedChanges));
Assert.That(s.CreateQuery("delete from DataPoint").ExecuteUpdate(), Is.EqualTo(100));
t.Commit();
s.Close();
AssertUpdateCount(0);
}
public void ReadOnlyGetModifyAndDelete()
{
DataPoint dp = null;
using (ISession s = OpenSession())
{
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = new DataPoint();
dp.X = 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
s.Save(dp);
t.Commit();
}
}
using (ISession s = OpenSession())
{
s.DefaultReadOnly = true;
s.CacheMode = CacheMode.Ignore;
using (ITransaction t = s.BeginTransaction())
{
dp = s.Get<DataPoint>(dp.Id);
s.DefaultReadOnly = true;
dp.Description = "a DataPoint";
s.Delete(dp);
t.Commit();
}
}
using (ISession s = OpenSession())
{
using (ITransaction t = s.BeginTransaction())
{
IList list = s.CreateQuery("from DataPoint where id=" + dp.Id ).List();
Assert.That(list.Count, Is.EqualTo(0));
t.Commit();
}
}
}
public async Task ModifiableModeWithExistingReadOnlyEntityAsync()
{
ClearCounts();
ISession s = OpenSession();
ITransaction t = s.BeginTransaction();
DataPoint dp = null;
for (int i = 0; i < 100; i++)
{
dp = new DataPoint();
dp.X = i * 0.1M;
dp.Y = (decimal)System.Math.Cos((double)dp.X);
await(s.SaveAsync(dp));
}
await(t.CommitAsync());
s.Close();
AssertInsertCount(100);
AssertUpdateCount(0);
ClearCounts();
s = OpenSession();
t = s.BeginTransaction();
DataPoint dpLast = await(s.GetAsync <DataPoint>(dp.Id));
Assert.That(s.IsReadOnly(dpLast), Is.False);
s.SetReadOnly(dpLast, true);
Assert.That(s.IsReadOnly(dpLast), Is.True);
dpLast.Description = "oy";
AssertUpdateCount(0);
// NH-specific: Replace use of Scroll with List
IList <DataPoint> sr = await(s.CreateQuery("from DataPoint dp order by dp.X asc")
.SetReadOnly(false)
.ListAsync <DataPoint>());
int nExpectedChanges = 0;
int index = 0;
foreach (DataPoint nextDp in sr)
{
if (nextDp.Id == dpLast.Id)
{
//dpLast existed in the session before executing the read-only query
Assert.That(s.IsReadOnly(nextDp), Is.True);
}
else
{
Assert.That(s.IsReadOnly(nextDp), Is.False);
}
if (++index == 50)
{
s.SetReadOnly(nextDp, true);
nExpectedChanges = (nextDp == dpLast ? 99 : 98);
}
nextDp.Description = "done!";
}
await(t.CommitAsync());
s.Clear();
AssertUpdateCount(nExpectedChanges);
ClearCounts();
t = s.BeginTransaction();
IList list = await(s.CreateQuery("from DataPoint where Description='done!'").ListAsync());
Assert.That(list.Count, Is.EqualTo(nExpectedChanges));
Assert.That(await(s.CreateQuery("delete from DataPoint").ExecuteUpdateAsync()), Is.EqualTo(100));
await(t.CommitAsync());
s.Close();
AssertUpdateCount(0);
}