diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs index 9aff73e4e83..0cff9650e6a 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { using System.Threading.Tasks; - [TestFixture] - public class HiLoForcedTableSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoForcedTableSequenceTestAsync : TestCaseWithMultiTenancy { + public HiLoForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.HiLo.hbm.xml" }; } @@ -54,9 +58,15 @@ public async Task TestNormalBoundaryAsync() long expectedId = i + 1; Assert.That(entities[i].Id, Is.EqualTo(expectedId)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" @@ -64,9 +74,15 @@ public async Task TestNormalBoundaryAsync() await (session.SaveAsync(entities[increment])); Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); await (transaction.CommitAsync()); } @@ -85,4 +101,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs index f792da88124..03924789aaa 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { using System.Threading.Tasks; - [TestFixture] - public class PooledForcedTableSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledForcedTableSequenceTestAsync : TestCaseWithMultiTenancy { + public PooledForcedTableSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.Pooled.hbm.xml" }; } @@ -55,8 +59,13 @@ public async Task TestNormalBoundaryAsync() Assert.That(entities[i].Id, Is.EqualTo(expectedId)); // NOTE : initialization calls table twice Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" @@ -66,8 +75,14 @@ public async Task TestNormalBoundaryAsync() Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); // initialization (2) + clock over Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment*2 + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + await (transaction.CommitAsync()); } @@ -86,4 +101,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs index e7e5c23fad0..a047e3aec35 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/OptimizerTests.cs @@ -8,8 +8,8 @@ //------------------------------------------------------------------------------ -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced { diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs index cb185e72c6f..9942b263e6a 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs @@ -11,13 +11,18 @@ using System.Collections; using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test.IdGen.Enhanced.Sequence { using System.Threading.Tasks; - [TestFixture] - public class HiLoSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoSequenceTestAsync : TestCaseWithMultiTenancy { + public HiLoSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.HiLo.hbm.xml" }; } @@ -51,18 +56,30 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (session.SaveAsync(entities[i])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (session.SaveAsync(entities[increment])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); await (transaction.CommitAsync()); } @@ -80,4 +97,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs index 7d0d4d11763..47c2ca1a82d 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Sequence/PooledSequenceTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using System.Collections; -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Sequence { using System.Threading.Tasks; - [TestFixture] - public class PooledSequenceTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledSequenceTestAsync : TestCaseWithMultiTenancy { + public PooledSequenceTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.Pooled.hbm.xml" }; } @@ -51,16 +55,26 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (session.SaveAsync(entities[i])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (session.SaveAsync(entities[increment])); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } @@ -79,4 +93,4 @@ public async Task TestNormalBoundaryAsync() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs index 0f9615a2ccd..85fc9520c87 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/SourceMock.cs @@ -46,4 +46,4 @@ public Task GetNextValueAsync(CancellationToken cancellationToken) } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs index 962460f90e0..9938d691506 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/HiLoTableTest.cs @@ -10,14 +10,19 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class HiLoTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoTableTestAsync : TestCaseWithMultiTenancy { + public HiLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.HiLo.hbm.xml" }; } @@ -50,18 +55,30 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs index d721443bdd6..a5afc87bb50 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledLoTableTest.cs @@ -10,14 +10,19 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class PooledLoTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledLoTableTestAsync : TestCaseWithMultiTenancy { + public PooledLoTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.PooledLo.hbm.xml" }; } @@ -50,16 +55,26 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs index 00c921da834..439de62e4cd 100644 --- a/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs +++ b/src/NHibernate.Test/Async/IdGen/Enhanced/Table/PooledTableTest.cs @@ -8,16 +8,20 @@ //------------------------------------------------------------------------------ -using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { using System.Threading.Tasks; - [TestFixture] - public class PooledTableTestAsync : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledTableTestAsync : TestCaseWithMultiTenancy { + public PooledTableTestAsync(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.Pooled.hbm.xml" }; } @@ -50,16 +54,26 @@ public async Task TestNormalBoundaryAsync() entities[i] = new Entity("" + (i + 1)); await (s.SaveAsync(entities[i])); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); await (s.SaveAsync(entities[increment])); Assert.That(generator.TableAccessCount, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); await (transaction.CommitAsync()); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs index c2ba2b1f589..2411dfada16 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/HiLoForcedTableSequenceTest.cs @@ -1,12 +1,16 @@ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { - [TestFixture] - public class HiLoForcedTableSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoForcedTableSequenceTest : TestCaseWithMultiTenancy { + public HiLoForcedTableSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.HiLo.hbm.xml" }; } @@ -43,9 +47,15 @@ public void TestNormalBoundary() long expectedId = i + 1; Assert.That(entities[i].Id, Is.EqualTo(expectedId)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" @@ -53,9 +63,15 @@ public void TestNormalBoundary() session.Save(entities[increment]); Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); // initialization + clock-over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); transaction.Commit(); } @@ -74,4 +90,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs index 91839abf07f..4add7229bba 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Forcedtable/PooledForcedTableSequenceTest.cs @@ -1,12 +1,16 @@ -using NUnit.Framework; using NHibernate.Id.Enhanced; -using System.Collections; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Forcedtable { - [TestFixture] - public class PooledForcedTableSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledForcedTableSequenceTest : TestCaseWithMultiTenancy { + public PooledForcedTableSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Forcedtable.Pooled.hbm.xml" }; } @@ -44,8 +48,13 @@ public void TestNormalBoundary() Assert.That(entities[i].Id, Is.EqualTo(expectedId)); // NOTE : initialization calls table twice Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" @@ -55,8 +64,14 @@ public void TestNormalBoundary() Assert.That(entities[optimizer.IncrementSize].Id, Is.EqualTo(optimizer.IncrementSize + 1)); // initialization (2) + clock over Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment*2 + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + transaction.Commit(); } @@ -75,4 +90,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs b/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs index 8f0fd01986f..90842a1048e 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/OptimizerTests.cs @@ -1,5 +1,5 @@ -using NUnit.Framework; -using NHibernate.Id.Enhanced; +using NHibernate.Id.Enhanced; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced { diff --git a/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs index 3cac164ec72..10db766ed8b 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Sequence/HiLoSequenceTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test.IdGen.Enhanced.Sequence { - [TestFixture] - public class HiLoSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoSequenceTest : TestCaseWithMultiTenancy { + public HiLoSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.HiLo.hbm.xml" }; } @@ -40,18 +45,30 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); session.Save(entities[i]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); session.Save(entities[increment]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment * 2 + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); transaction.Commit(); } @@ -69,4 +86,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs index 3e73cc21a9d..669c03376db 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Sequence/PooledSequenceTest.cs @@ -1,12 +1,16 @@ -using System.Collections; -using NUnit.Framework; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; +using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Sequence { - [TestFixture] - public class PooledSequenceTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledSequenceTest : TestCaseWithMultiTenancy { + public PooledSequenceTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Sequence.Pooled.hbm.xml" }; } @@ -40,16 +44,26 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); session.Save(entities[i]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); session.Save(entities[increment]); Assert.That(generator.DatabaseStructure.TimesAccessed, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment * 2 + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } @@ -68,4 +82,4 @@ public void TestNormalBoundary() } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs b/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs index d7fcce2f9ec..3097d3f3814 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/SourceMock.cs @@ -6,15 +6,20 @@ public partial class SourceMock : IAccessCallback { private long _val; private readonly long _initialValue; + private readonly string _tenantId; private readonly int _increment; private int _timesCalled; public SourceMock(long initialValue) : this(initialValue, 1) { } - public SourceMock(long initialValue, int increment) : this(initialValue, increment, 0) { } + public SourceMock(long initialValue, int increment) : this(null, initialValue, increment, 0) { } - public SourceMock(long initialValue, int increment, int timesCalled) + public SourceMock(long initialValue, int increment, int timesCalled): this(null, initialValue, increment, timesCalled) { + } + public SourceMock(string tenantId, long initialValue, int increment, int timesCalled) + { + _tenantId = tenantId; _increment = increment; _timesCalled = timesCalled; @@ -57,6 +62,8 @@ private void InitValue() _val = _initialValue; } + public string GetTenantIdentifier() => _tenantId; + public int TimesCalled { get { return _timesCalled; } @@ -71,4 +78,4 @@ public long CurrentValue } } } -} \ No newline at end of file +} diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs index 878252ce3dd..d25c772661c 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/HiLoTableTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class HiLoTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class HiLoTableTest : TestCaseWithMultiTenancy { + public HiLoTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.HiLo.hbm.xml" }; } @@ -39,18 +44,30 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo(increment + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(2)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.HiValue, Is.EqualTo((increment * 2) + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(2)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetHiValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs index bd5245dbe9a..4181a25372e 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledLoTableTest.cs @@ -1,12 +1,17 @@ using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class PooledLoTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledLoTableTest : TestCaseWithMultiTenancy { + public PooledLoTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.PooledLo.hbm.xml" }; } @@ -39,16 +44,26 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(1)); // initialization + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(1)); // initialization + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs index 3a7ca042514..383b2925b03 100644 --- a/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs +++ b/src/NHibernate.Test/IdGen/Enhanced/Table/PooledTableTest.cs @@ -1,12 +1,16 @@ -using System.Collections; using NHibernate.Id.Enhanced; +using NHibernate.Test.MultiTenancy; using NUnit.Framework; namespace NHibernate.Test.IdGen.Enhanced.Table { - [TestFixture] - public class PooledTableTest : TestCase + [TestFixture(null)] + [TestFixture("test")] + public class PooledTableTest : TestCaseWithMultiTenancy { + public PooledTableTest(string tenantIdentifier) : base(tenantIdentifier) + { + } protected override string[] Mappings { get { return new[] { "IdGen.Enhanced.Table.Pooled.hbm.xml" }; } @@ -39,16 +43,26 @@ public void TestNormalBoundary() entities[i] = new Entity("" + (i + 1)); s.Save(entities[i]); Assert.That(generator.TableAccessCount, Is.EqualTo(2)); // initialization calls seq twice - Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice - Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.LastValue, Is.EqualTo(i + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo(increment + 1)); // initialization calls seq twice + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(i + 1)); } // now force a "clock over" entities[increment] = new Entity("" + increment); s.Save(entities[increment]); Assert.That(generator.TableAccessCount, Is.EqualTo(3)); // initialization (2) + clock over - Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over - Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + if (TenantIdentifier == null) + { + Assert.That(optimizer.LastSourceValue, Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.LastValue, Is.EqualTo(increment + 1)); + } + Assert.That(optimizer.GetLastSourceValue(TenantIdentifier), Is.EqualTo((increment * 2) + 1)); // initialization (2) + clock over + Assert.That(optimizer.GetLastValue(TenantIdentifier), Is.EqualTo(increment + 1)); transaction.Commit(); } diff --git a/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs b/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs new file mode 100644 index 00000000000..5ce6ae74477 --- /dev/null +++ b/src/NHibernate.Test/MultiTenancy/TestCaseWithMultiTenancy.cs @@ -0,0 +1,60 @@ +using System.Data.Common; +using NHibernate.Cfg; +using NHibernate.Dialect; +using NHibernate.Driver; +using NHibernate.MultiTenancy; + +namespace NHibernate.Test.MultiTenancy +{ + public abstract class TestCaseWithMultiTenancy : TestCase + { + protected TestCaseWithMultiTenancy(string tenantIdentifier) + { + TenantIdentifier = tenantIdentifier; + } + + public string TenantIdentifier { get; } + + protected override void Configure(Configuration configuration) + { + if (TenantIdentifier != null) + { + configuration.DataBaseIntegration( + x => + { + x.MultiTenancy = MultiTenancyStrategy.Database; + x.MultiTenancyConnectionProvider(); + }); + } + base.Configure(configuration); + } + + protected override DbConnection OpenConnectionForSchemaExport() + { + if (TenantIdentifier != null) + { + return Sfi.Settings.MultiTenancyConnectionProvider + .GetConnectionAccess(GetTenantConfig("defaultTenant"), Sfi).GetConnection(); + } + return base.OpenConnectionForSchemaExport(); + } + + private TenantConfiguration GetTenantConfig(string tenantId) + { + return new TestTenantConfiguration(tenantId, IsSqlServerDialect); + } + + protected override ISession OpenSession() + { + if (TenantIdentifier != null) + { + return Sfi.WithOptions().Tenant(new TestTenantConfiguration(TenantIdentifier, IsSqlServerDialect)).OpenSession(); + } + return base.OpenSession(); + } + + //Create extension method for this? + private bool IsSqlServerDialect => Sfi.Dialect is MsSql2000Dialect && !(Sfi.ConnectionProvider.Driver is OdbcDriver); + + } +} diff --git a/src/NHibernate.Test/TestCase.cs b/src/NHibernate.Test/TestCase.cs index 1335b6a722a..5db87e14a72 100644 --- a/src/NHibernate.Test/TestCase.cs +++ b/src/NHibernate.Test/TestCase.cs @@ -21,6 +21,8 @@ using NHibernate.SqlTypes; using NHibernate.Util; using NSubstitute; +using NHibernate.MultiTenancy; +using NHibernate.Test.MultiTenancy; namespace NHibernate.Test { diff --git a/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs b/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs index b52c3e524b5..8fbb5c27826 100644 --- a/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs +++ b/src/NHibernate/Async/Id/Enhanced/IAccessCallback.cs @@ -20,4 +20,4 @@ public partial interface IAccessCallback /// A cancellation token that can be used to cancel the work Task GetNextValueAsync(CancellationToken cancellationToken); } -} \ No newline at end of file +} diff --git a/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs b/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs index 5ba08f4a31e..1e9350f3e94 100644 --- a/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs +++ b/src/NHibernate/Async/Id/Enhanced/OptimizerFactory.cs @@ -10,7 +10,6 @@ using System; using System.Reflection; -using System.Runtime.CompilerServices; using NHibernate.Util; namespace NHibernate.Id.Enhanced @@ -28,29 +27,32 @@ public partial class HiLoOptimizer : OptimizerSupport public override async Task GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + cancellationToken.ThrowIfCancellationRequested(); + + using (await (generationState.AsyncLock.LockAsync()).ConfigureAwait(false)) { - if (_lastSourceValue < 0) + if (generationState.LastSourceValue < 0) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - while (_lastSourceValue <= 0) + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + while (generationState.LastSourceValue <= 0) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); } // upperLimit defines the upper end of the bucket values - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; // initialize value to the low end of the bucket - _value = _upperLimit - IncrementSize; + generationState.Value = generationState.UpperLimit - IncrementSize; } - else if (_upperLimit <= _value) + else if (generationState.UpperLimit <= generationState.Value) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; } - return Make(_value++); + return Make(generationState.Value++); } } } @@ -104,39 +106,41 @@ public partial class PooledOptimizer : OptimizerSupport, IInitialValueAwareOptim public override async Task GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + cancellationToken.ThrowIfCancellationRequested(); + + using (await (generationState.AsyncLock.LockAsync()).ConfigureAwait(false)) { - if (_hiValue < 0) + if (generationState.HiValue < 0) { - _value = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - if (_value < 1) + generationState.Value = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + if (generationState.Value < 1) { // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... - Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", _value); + Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", generationState.Value); } - if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue) - _hiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + if ((_initialValue == -1 && generationState.Value < IncrementSize) || generationState.Value == _initialValue) + generationState.HiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); else { - _hiValue = _value; - _value = _hiValue - IncrementSize; + generationState.HiValue = generationState.Value; + generationState.Value = generationState.HiValue - IncrementSize; } } - else if (_value >= _hiValue) + else if (generationState.Value >= generationState.HiValue) { - _hiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _value = _hiValue - IncrementSize; + generationState.HiValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.Value = generationState.HiValue - IncrementSize; } - return Make(_value++); + return Make(generationState.Value++); } } } - #endregion #region Nested type: PooledLoOptimizer @@ -147,18 +151,23 @@ public partial class PooledLoOptimizer : OptimizerSupport public override async Task GenerateAsync(IAccessCallback callback, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + cancellationToken.ThrowIfCancellationRequested(); + + using (await (generationState.AsyncLock.LockAsync()).ConfigureAwait(false)) { - if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize)) + if (generationState.LastSourceValue < 0 || generationState.Value >= (generationState.LastSourceValue + IncrementSize)) { - _lastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); - _value = _lastSourceValue; + generationState.LastSourceValue = await (callback.GetNextValueAsync(cancellationToken)).ConfigureAwait(false); + generationState.Value = generationState.LastSourceValue; // handle cases where initial-value is less than one (hsqldb for instance). - while (_value < 1) - _value++; + if (generationState.Value < 1) + { + generationState.Value = 1; + } } - return Make(_value++); + return Make(generationState.Value++); } } } diff --git a/src/NHibernate/Async/Id/Enhanced/SequenceStructure.cs b/src/NHibernate/Async/Id/Enhanced/SequenceStructure.cs index a3a7fd57d54..dd5d5b1ffdb 100644 --- a/src/NHibernate/Async/Id/Enhanced/SequenceStructure.cs +++ b/src/NHibernate/Async/Id/Enhanced/SequenceStructure.cs @@ -26,7 +26,7 @@ public partial class SequenceStructure : IDatabaseStructure #region Nested type: SequenceAccessCallback - private partial class SequenceAccessCallback : IAccessCallback + private partial class SequenceAccessCallback : IMultiTenantAccessCallback { #region IAccessCallback Members diff --git a/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs b/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs index 0ca2de00611..3c56cf5dfaa 100644 --- a/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs +++ b/src/NHibernate/Async/Id/Enhanced/TableGenerator.cs @@ -9,16 +9,14 @@ using System; -using System.Data.Common; using System.Collections.Generic; using System.Data; -using System.Runtime.CompilerServices; +using System.Data.Common; +using NHibernate.AdoNet.Util; using NHibernate.Engine; -using NHibernate.Mapping; +using NHibernate.SqlCommand; using NHibernate.Type; using NHibernate.Util; -using NHibernate.SqlCommand; -using NHibernate.AdoNet.Util; namespace NHibernate.Id.Enhanced { @@ -36,7 +34,7 @@ public virtual async Task GenerateAsync(ISessionImplementor session, obj } } - private partial class TableAccessCallback : IAccessCallback + private partial class TableAccessCallback : IMultiTenantAccessCallback { #region IAccessCallback Members @@ -44,7 +42,7 @@ private partial class TableAccessCallback : IAccessCallback public async Task GetNextValueAsync(CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - return Convert.ToInt64(await (owner.DoWorkInNewTransactionAsync(session, cancellationToken)).ConfigureAwait(false)); + return Convert.ToInt64(await (_owner.DoWorkInNewTransactionAsync(_session, cancellationToken)).ConfigureAwait(false)); } #endregion diff --git a/src/NHibernate/Async/Id/Enhanced/TableStructure.cs b/src/NHibernate/Async/Id/Enhanced/TableStructure.cs index 0ffa27d6c30..557781ca809 100644 --- a/src/NHibernate/Async/Id/Enhanced/TableStructure.cs +++ b/src/NHibernate/Async/Id/Enhanced/TableStructure.cs @@ -95,7 +95,7 @@ public override async Task DoWorkInCurrentTransactionAsync(ISessionImple #region Nested type: TableAccessCallback - private partial class TableAccessCallback : IAccessCallback + private partial class TableAccessCallback : IMultiTenantAccessCallback { #region IAccessCallback Members diff --git a/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs b/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs index 75992f456ed..ddf62bb98f6 100644 --- a/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs +++ b/src/NHibernate/Async/Id/SequenceHiLoGenerator.cs @@ -10,6 +10,7 @@ using System; using System.Collections; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.CompilerServices; @@ -37,7 +38,10 @@ public partial class SequenceHiLoGenerator : SequenceGenerator public override async Task GenerateAsync(ISessionImplementor session, object obj, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + cancellationToken.ThrowIfCancellationRequested(); + + using (await (generationState.AsyncLock.LockAsync()).ConfigureAwait(false)) { if (maxLo < 1) { @@ -48,15 +52,15 @@ public override async Task GenerateAsync(ISessionImplementor session, ob return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); if (log.IsDebugEnabled()) log.Debug("new hi value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Async/Id/TableGenerator.cs b/src/NHibernate/Async/Id/TableGenerator.cs index 3ad468a09be..bc579a777db 100644 --- a/src/NHibernate/Async/Id/TableGenerator.cs +++ b/src/NHibernate/Async/Id/TableGenerator.cs @@ -46,7 +46,7 @@ public virtual async Task GenerateAsync(ISessionImplementor session, obj using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) { // This has to be done using a different connection to the containing - // transaction becase the new hi value must remain valid even if the + // transaction because the new hi value must remain valid even if the // containing transaction rolls back. return await (DoWorkInNewTransactionAsync(session, cancellationToken)).ConfigureAwait(false); } @@ -62,7 +62,7 @@ public override async Task DoWorkInCurrentTransactionAsync(ISessionImple int rows; do { - //the loop ensure atomicitiy of the + //the loop ensures atomicity of the //select + update even for no transaction //or read committed isolation level (needed for .net?) diff --git a/src/NHibernate/Async/Id/TableHiLoGenerator.cs b/src/NHibernate/Async/Id/TableHiLoGenerator.cs index 663733f6b39..8ee8ab67c50 100644 --- a/src/NHibernate/Async/Id/TableHiLoGenerator.cs +++ b/src/NHibernate/Async/Id/TableHiLoGenerator.cs @@ -16,6 +16,7 @@ using NHibernate.Type; using NHibernate.Util; using System.Collections.Generic; +using System.Collections.Concurrent; namespace NHibernate.Id { @@ -36,7 +37,10 @@ public partial class TableHiLoGenerator : TableGenerator public override async Task GenerateAsync(ISessionImplementor session, object obj, CancellationToken cancellationToken) { cancellationToken.ThrowIfCancellationRequested(); - using (await (_asyncLock.LockAsync()).ConfigureAwait(false)) + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + cancellationToken.ThrowIfCancellationRequested(); + + using (await (generationState.AsyncLock.LockAsync()).ConfigureAwait(false)) { if (maxLo < 1) { @@ -46,15 +50,15 @@ public override async Task GenerateAsync(ISessionImplementor session, ob val = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(await (base.GenerateAsync(session, obj, cancellationToken)).ConfigureAwait(false)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); log.Debug("New high value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Id/Enhanced/IAccessCallback.cs b/src/NHibernate/Id/Enhanced/IAccessCallback.cs index f072ab68fb8..8e1a1da0718 100644 --- a/src/NHibernate/Id/Enhanced/IAccessCallback.cs +++ b/src/NHibernate/Id/Enhanced/IAccessCallback.cs @@ -11,4 +11,17 @@ public partial interface IAccessCallback /// long GetNextValue(); } -} \ No newline at end of file + + internal interface IMultiTenantAccessCallback : IAccessCallback + { + /// + /// Obtain the tenant identifier (multi-tenancy), if one, associated with this callback. + /// + string GetTenantIdentifier(); + } + + internal static class AccessCallbackExtensions + { + internal static string GetTenantIdentifier(this IAccessCallback accessCallback) => (accessCallback as IMultiTenantAccessCallback)?.GetTenantIdentifier(); + } +} diff --git a/src/NHibernate/Id/Enhanced/OptimizerFactory.cs b/src/NHibernate/Id/Enhanced/OptimizerFactory.cs index 0adf3695551..fc239a27145 100644 --- a/src/NHibernate/Id/Enhanced/OptimizerFactory.cs +++ b/src/NHibernate/Id/Enhanced/OptimizerFactory.cs @@ -1,6 +1,5 @@ using System; using System.Reflection; -using System.Runtime.CompilerServices; using NHibernate.Util; namespace NHibernate.Id.Enhanced @@ -70,9 +69,9 @@ private static IOptimizer BuildOptimizer(string type, System.Type returnClass, i ConstructorInfo ctor = optimizerClass.GetConstructor(CtorSignature); if (ctor == null) - throw new HibernateException("Optimizer does not have expected contructor"); + throw new HibernateException("Optimizer does not have expected constructor"); - return (IOptimizer)ctor.Invoke(new object[] { returnClass, incrementSize }); + return (IOptimizer) ctor.Invoke(new object[] { returnClass, incrementSize }); } catch (Exception ex) { @@ -89,7 +88,7 @@ public static IOptimizer BuildOptimizer(string type, System.Type returnClass, in IOptimizer optimizer = BuildOptimizer(type, returnClass, incrementSize); if (optimizer is IInitialValueAwareOptimizer) - ((IInitialValueAwareOptimizer)optimizer).InjectInitialValue(explicitInitialValue); + ((IInitialValueAwareOptimizer) optimizer).InjectInitialValue(explicitInitialValue); return optimizer; } @@ -98,10 +97,7 @@ public static IOptimizer BuildOptimizer(string type, System.Type returnClass, in public partial class HiLoOptimizer : OptimizerSupport { - private long _upperLimit; - private long _lastSourceValue = -1; - private long _value; - private readonly AsyncLock _asyncLock = new AsyncLock(); + private readonly TenantStateStore _stateStore = new TenantStateStore(); public HiLoOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { @@ -115,17 +111,25 @@ public HiLoOptimizer(System.Type returnClass, int incrementSize) : base(returnCl } } + public class GenerationState + { + public AsyncLock AsyncLock { get; } = new AsyncLock(); + public long LastSourceValue { get; internal set; } = -1; + public long Value { get; internal set; } + public long UpperLimit { get; internal set; } + } + /// /// Exposure intended for testing purposes. /// public override long LastSourceValue { - get { return _lastSourceValue; } + get { return _stateStore.NoTenantGenerationState.LastSourceValue; } } public long LastValue { - get { return _value - 1; } + get { return _stateStore.NoTenantGenerationState.Value - 1; } } /// @@ -133,7 +137,21 @@ public long LastValue /// public long HiValue { - get { return _upperLimit; } + get { return _stateStore.NoTenantGenerationState.UpperLimit; } + } + + public long GetHiValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).UpperLimit; + } + + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).LastSourceValue; + } + public long GetLastValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } public override bool ApplyIncrementSizeToSourceValues @@ -143,29 +161,31 @@ public override bool ApplyIncrementSizeToSourceValues public override object Generate(IAccessCallback callback) { - using (_asyncLock.Lock()) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + using (generationState.AsyncLock.Lock()) { - if (_lastSourceValue < 0) + if (generationState.LastSourceValue < 0) { - _lastSourceValue = callback.GetNextValue(); - while (_lastSourceValue <= 0) + generationState.LastSourceValue = callback.GetNextValue(); + while (generationState.LastSourceValue <= 0) { - _lastSourceValue = callback.GetNextValue(); + generationState.LastSourceValue = callback.GetNextValue(); } // upperLimit defines the upper end of the bucket values - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; // initialize value to the low end of the bucket - _value = _upperLimit - IncrementSize; + generationState.Value = generationState.UpperLimit - IncrementSize; } - else if (_upperLimit <= _value) + else if (generationState.UpperLimit <= generationState.Value) { - _lastSourceValue = callback.GetNextValue(); - _upperLimit = (_lastSourceValue * IncrementSize) + 1; + generationState.LastSourceValue = callback.GetNextValue(); + generationState.UpperLimit = (generationState.LastSourceValue * IncrementSize) + 1; } - return Make(_value++); + return Make(generationState.Value++); } } } @@ -268,11 +288,8 @@ protected virtual object Make(long value) /// public partial class PooledOptimizer : OptimizerSupport, IInitialValueAwareOptimizer { - private long _hiValue = -1; - private long _value; private long _initialValue; - private readonly AsyncLock _asyncLock = new AsyncLock(); - + private readonly TenantStateStore _stateStore = new TenantStateStore(); public PooledOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { if (incrementSize < 1) @@ -285,17 +302,34 @@ public PooledOptimizer(System.Type returnClass, int incrementSize) : base(return } } + public class GenerationState + { + public AsyncLock AsyncLock { get; } = new AsyncLock(); + public long Value { get; internal set; } + public long HiValue { get; internal set; } = -1; + } + public override long LastSourceValue { - get { return _hiValue; } + get { return _stateStore.NoTenantGenerationState.HiValue; } } /// /// Exposure intended for testing purposes. /// + /// + public long LastValue { - get { return _value - 1; } + get { return _stateStore.NoTenantGenerationState.Value - 1; } + } + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).HiValue; + } + public long GetLastValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } public override bool ApplyIncrementSizeToSourceValues @@ -310,48 +344,47 @@ public void InjectInitialValue(long initialValue) public override object Generate(IAccessCallback callback) { - using (_asyncLock.Lock()) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + using (generationState.AsyncLock.Lock()) { - if (_hiValue < 0) + if (generationState.HiValue < 0) { - _value = callback.GetNextValue(); - if (_value < 1) + generationState.Value = callback.GetNextValue(); + if (generationState.Value < 1) { // unfortunately not really safe to normalize this // to 1 as an initial value like we do the others // because we would not be able to control this if // we are using a sequence... - Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", _value); + Log.Info("pooled optimizer source reported [{0}] as the initial value; use of 1 or greater highly recommended", generationState.Value); } - if ((_initialValue == -1 && _value < IncrementSize) || _value == _initialValue) - _hiValue = callback.GetNextValue(); + if ((_initialValue == -1 && generationState.Value < IncrementSize) || generationState.Value == _initialValue) + generationState.HiValue = callback.GetNextValue(); else { - _hiValue = _value; - _value = _hiValue - IncrementSize; + generationState.HiValue = generationState.Value; + generationState.Value = generationState.HiValue - IncrementSize; } } - else if (_value >= _hiValue) + else if (generationState.Value >= generationState.HiValue) { - _hiValue = callback.GetNextValue(); - _value = _hiValue - IncrementSize; + generationState.HiValue = callback.GetNextValue(); + generationState.Value = generationState.HiValue - IncrementSize; } - return Make(_value++); + return Make(generationState.Value++); } } } - #endregion #region Nested type: PooledLoOptimizer public partial class PooledLoOptimizer : OptimizerSupport { - private long _lastSourceValue = -1; // last value read from db source - private long _value; // the current generator value - private readonly AsyncLock _asyncLock = new AsyncLock(); + private readonly TenantStateStore _stateStore = new TenantStateStore(); public PooledLoOptimizer(System.Type returnClass, int incrementSize) : base(returnClass, incrementSize) { @@ -365,26 +398,38 @@ public PooledLoOptimizer(System.Type returnClass, int incrementSize) : base(retu } } + public class GenerationState + { + public AsyncLock AsyncLock { get; } = new AsyncLock(); + public long LastSourceValue { get; internal set; } = -1; + public long Value { get; internal set; } + } + public override object Generate(IAccessCallback callback) { - using (_asyncLock.Lock()) + var generationState = _stateStore.LocateGenerationState(callback.GetTenantIdentifier()); + + using (generationState.AsyncLock.Lock()) { - if (_lastSourceValue < 0 || _value >= (_lastSourceValue + IncrementSize)) + if (generationState.LastSourceValue < 0 || generationState.Value >= (generationState.LastSourceValue + IncrementSize)) { - _lastSourceValue = callback.GetNextValue(); - _value = _lastSourceValue; + generationState.LastSourceValue = callback.GetNextValue(); + generationState.Value = generationState.LastSourceValue; // handle cases where initial-value is less than one (hsqldb for instance). - while (_value < 1) - _value++; + if (generationState.Value < 1) + { + generationState.Value = 1; + } } - return Make(_value++); + return Make(generationState.Value++); } } + public override long LastSourceValue { - get { return _lastSourceValue; } + get { return _stateStore.NoTenantGenerationState.LastSourceValue; } } public override bool ApplyIncrementSizeToSourceValues @@ -397,7 +442,17 @@ public override bool ApplyIncrementSizeToSourceValues /// public long LastValue { - get { return _value - 1; } + get { return _stateStore.NoTenantGenerationState.Value - 1; } + } + + public long GetLastSourceValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).LastSourceValue; + } + + public long GetLastValue(string tenantIdentifier) + { + return _stateStore.LocateGenerationState(tenantIdentifier).Value - 1; } } diff --git a/src/NHibernate/Id/Enhanced/SequenceStructure.cs b/src/NHibernate/Id/Enhanced/SequenceStructure.cs index 50d70e54964..0b7fe16694f 100644 --- a/src/NHibernate/Id/Enhanced/SequenceStructure.cs +++ b/src/NHibernate/Id/Enhanced/SequenceStructure.cs @@ -80,7 +80,7 @@ public int TimesAccessed #region Nested type: SequenceAccessCallback - private partial class SequenceAccessCallback : IAccessCallback + private partial class SequenceAccessCallback : IMultiTenantAccessCallback { private readonly SequenceStructure _owner; private readonly ISessionImplementor _session; @@ -136,6 +136,8 @@ public virtual long GetNextValue() } } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/Enhanced/TableGenerator.cs b/src/NHibernate/Id/Enhanced/TableGenerator.cs index 60a287db13f..61d7fefcbb6 100644 --- a/src/NHibernate/Id/Enhanced/TableGenerator.cs +++ b/src/NHibernate/Id/Enhanced/TableGenerator.cs @@ -1,14 +1,12 @@ -using System; -using System.Data.Common; +using System; using System.Collections.Generic; using System.Data; -using System.Runtime.CompilerServices; +using System.Data.Common; +using NHibernate.AdoNet.Util; using NHibernate.Engine; -using NHibernate.Mapping; +using NHibernate.SqlCommand; using NHibernate.Type; using NHibernate.Util; -using NHibernate.SqlCommand; -using NHibernate.AdoNet.Util; namespace NHibernate.Id.Enhanced { @@ -387,24 +385,26 @@ public virtual object Generate(ISessionImplementor session, object obj) } } - private partial class TableAccessCallback : IAccessCallback + private partial class TableAccessCallback : IMultiTenantAccessCallback { - private TableGenerator owner; - private readonly ISessionImplementor session; + private TableGenerator _owner; + private readonly ISessionImplementor _session; public TableAccessCallback(ISessionImplementor session, TableGenerator owner) { - this.session = session; - this.owner = owner; + _session = session; + _owner = owner; } #region IAccessCallback Members public long GetNextValue() { - return Convert.ToInt64(owner.DoWorkInNewTransaction(session)); + return Convert.ToInt64(_owner.DoWorkInNewTransaction(_session)); } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/Enhanced/TableStructure.cs b/src/NHibernate/Id/Enhanced/TableStructure.cs index 82c36b43a65..c59b613196f 100644 --- a/src/NHibernate/Id/Enhanced/TableStructure.cs +++ b/src/NHibernate/Id/Enhanced/TableStructure.cs @@ -163,7 +163,7 @@ public override object DoWorkInCurrentTransaction(ISessionImplementor session, D #region Nested type: TableAccessCallback - private partial class TableAccessCallback : IAccessCallback + private partial class TableAccessCallback : IMultiTenantAccessCallback { private readonly TableStructure _owner; private readonly ISessionImplementor _session; @@ -181,6 +181,8 @@ public virtual long GetNextValue() return Convert.ToInt64(_owner.DoWorkInNewTransaction(_session)); } + public string GetTenantIdentifier() => _session.GetTenantIdentifier(); + #endregion } diff --git a/src/NHibernate/Id/SequenceHiLoGenerator.cs b/src/NHibernate/Id/SequenceHiLoGenerator.cs index 2d9fca0b85b..ec20886f66f 100644 --- a/src/NHibernate/Id/SequenceHiLoGenerator.cs +++ b/src/NHibernate/Id/SequenceHiLoGenerator.cs @@ -1,5 +1,6 @@ using System; using System.Collections; +using System.Collections.Concurrent; using System.Collections.Generic; using System.Runtime.CompilerServices; @@ -29,7 +30,7 @@ namespace NHibernate.Id ///

///

/// The user may specify a max_lo value to determine how often new hi values are - /// fetched. If sequences are not avaliable, TableHiLoGenerator might be an + /// fetched. If sequences are not available, TableHiLoGenerator might be an /// alternative. ///

/// @@ -43,10 +44,15 @@ public partial class SequenceHiLoGenerator : SequenceGenerator public const string MaxLo = "max_lo"; private int maxLo; - private int lo; - private long hi; private System.Type returnClass; - private readonly AsyncLock _asyncLock = new AsyncLock(); + private TenantStateStore _stateStore; + + private class GenerationState + { + public AsyncLock AsyncLock { get; } = new AsyncLock(); + public long Lo { get; internal set; } + public long Hi { get; internal set; } + } #region IConfigurable Members @@ -61,8 +67,8 @@ public override void Configure(IType type, IDictionary parms, Di { base.Configure(type, parms, dialect); maxLo = PropertiesHelper.GetInt32(MaxLo, parms, 9); - lo = maxLo + 1; // so we "clock over" on the first invocation returnClass = type.ReturnedClass; + _stateStore = new TenantStateStore(state => state.Lo = maxLo + 1);// so we "clock over" on the first invocation } #endregion @@ -78,7 +84,9 @@ public override void Configure(IType type, IDictionary parms, Di /// The new identifier as a , , or . public override object Generate(ISessionImplementor session, object obj) { - using (_asyncLock.Lock()) + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + + using (generationState.AsyncLock.Lock()) { if (maxLo < 1) { @@ -89,15 +97,15 @@ public override object Generate(ISessionImplementor session, object obj) return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(base.Generate(session, obj)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); if (log.IsDebugEnabled()) log.Debug("new hi value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Id/TableGenerator.cs b/src/NHibernate/Id/TableGenerator.cs index 09180687efc..3fbd16e4015 100644 --- a/src/NHibernate/Id/TableGenerator.cs +++ b/src/NHibernate/Id/TableGenerator.cs @@ -157,7 +157,7 @@ public virtual object Generate(ISessionImplementor session, object obj) using (_asyncLock.Lock()) { // This has to be done using a different connection to the containing - // transaction becase the new hi value must remain valid even if the + // transaction because the new hi value must remain valid even if the // containing transaction rolls back. return DoWorkInNewTransaction(session); } @@ -220,7 +220,7 @@ public override object DoWorkInCurrentTransaction(ISessionImplementor session, D int rows; do { - //the loop ensure atomicitiy of the + //the loop ensures atomicity of the //select + update even for no transaction //or read committed isolation level (needed for .net?) diff --git a/src/NHibernate/Id/TableHiLoGenerator.cs b/src/NHibernate/Id/TableHiLoGenerator.cs index c64de1d3323..9cf03db31ac 100644 --- a/src/NHibernate/Id/TableHiLoGenerator.cs +++ b/src/NHibernate/Id/TableHiLoGenerator.cs @@ -6,6 +6,7 @@ using NHibernate.Type; using NHibernate.Util; using System.Collections.Generic; +using System.Collections.Concurrent; namespace NHibernate.Id { @@ -48,11 +49,16 @@ public partial class TableHiLoGenerator : TableGenerator /// public const string MaxLo = "max_lo"; - private long hi; - private long lo; private long maxLo; private System.Type returnClass; - private readonly AsyncLock _asyncLock = new AsyncLock(); + private TenantStateStore _stateStore; + + private class GenerationState + { + public AsyncLock AsyncLock { get; } = new AsyncLock(); + public long Lo { get; internal set; } + public long Hi { get; internal set; } + } #region IConfigurable Members @@ -67,8 +73,8 @@ public override void Configure(IType type, IDictionary parms, Di { base.Configure(type, parms, dialect); maxLo = PropertiesHelper.GetInt64(MaxLo, parms, Int16.MaxValue); - lo = maxLo + 1; // so we "clock over" on the first invocation returnClass = type.ReturnedClass; + _stateStore = new TenantStateStore(state => state.Lo = maxLo + 1);// so we "clock over" on the first invocation } #endregion @@ -83,7 +89,9 @@ public override void Configure(IType type, IDictionary parms, Di /// The new identifier as a . public override object Generate(ISessionImplementor session, object obj) { - using (_asyncLock.Lock()) + var generationState = _stateStore.LocateGenerationState(session.GetTenantIdentifier()); + + using (generationState.AsyncLock.Lock()) { if (maxLo < 1) { @@ -93,15 +101,15 @@ public override object Generate(ISessionImplementor session, object obj) val = Convert.ToInt64(base.Generate(session, obj)); return IdentifierGeneratorFactory.CreateNumber(val, returnClass); } - if (lo > maxLo) + if (generationState.Lo > maxLo) { long hival = Convert.ToInt64(base.Generate(session, obj)); - lo = (hival == 0) ? 1 : 0; - hi = hival * (maxLo + 1); + generationState.Lo = (hival == 0) ? 1 : 0; + generationState.Hi = hival * (maxLo + 1); log.Debug("New high value: {0}", hival); } - return IdentifierGeneratorFactory.CreateNumber(hi + lo++, returnClass); + return IdentifierGeneratorFactory.CreateNumber(generationState.Hi + generationState.Lo++, returnClass); } } diff --git a/src/NHibernate/Id/TenantStateStore.cs b/src/NHibernate/Id/TenantStateStore.cs new file mode 100644 index 00000000000..276df6a3e81 --- /dev/null +++ b/src/NHibernate/Id/TenantStateStore.cs @@ -0,0 +1,46 @@ +using System; +using System.Collections.Concurrent; + +namespace NHibernate.Id +{ + internal class TenantStateStore where TState : new() + { + private Lazy _noTenantState; + private Action _initializer; + private ConcurrentDictionary _tenantSpecificState = new ConcurrentDictionary(); + + public TenantStateStore(Action initializer) : this() + { + _initializer = initializer; + } + + public TenantStateStore() + { + _noTenantState = new Lazy(() => CreateNewState()); + } + + internal TState LocateGenerationState(string tenantIdentifier) + { + if (tenantIdentifier == null) + { + return _noTenantState.Value; + } + else + { + return _tenantSpecificState.GetOrAdd(tenantIdentifier, _ => CreateNewState()); + } + } + + internal TState NoTenantGenerationState => _noTenantState.IsValueCreated ? + _noTenantState.Value : + throw new HibernateException("Could not locate previous generation state for no-tenant"); + + + private TState CreateNewState() + { + var state = new TState(); + _initializer?.Invoke(state); + return state; + } + } +}