From fa98af52177bb3be322ea8b4a6d3608f7dad6280 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Wed, 10 Nov 2021 12:52:23 +0500 Subject: [PATCH 01/13] Add test of filtering by enum --- .../Linq/WhereByEnumTest.cs | 313 ++++++++++++++++++ 1 file changed, 313 insertions(+) create mode 100644 Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs diff --git a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs new file mode 100644 index 0000000000..2233538756 --- /dev/null +++ b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs @@ -0,0 +1,313 @@ +// Copyright (C) 2021 Xtensive LLC. +// This code is distributed under MIT license terms. +// See the License.txt file in the project root for more information. + +using System; +using System.Collections.Generic; +using System.Linq; +using System.Text; +using NUnit.Framework; +using Xtensive.Core; +using Xtensive.Orm.Configuration; +using Xtensive.Orm.Tests.Linq.WhereByEnumTestModel; + +namespace Xtensive.Orm.Tests.Linq.WhereByEnumTestModel +{ + public enum ByteEnum : byte + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = byte.MaxValue + } + + public enum SByteEnum : sbyte + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = sbyte.MaxValue + } + + public enum ShortEnum : short + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = short.MaxValue + } + + public enum UShortEnum : ushort + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = ushort.MaxValue + } + + public enum IntEnum : int + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = int.MaxValue + } + + public enum UIntEnum : uint + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = uint.MaxValue + } + + public enum LongEnum : long + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = long.MaxValue + } + + public enum ULongEnum : ulong + { + Zero = 0, + One = 1, + Two = 2, + Three = 3, + Four = 4, + Max = ulong.MaxValue + } + + [HierarchyRoot] + [Index(nameof(EnumContainer.ByteEnumField))] + [Index(nameof(EnumContainer.SByteEnumField))] + [Index(nameof(EnumContainer.ShortEnumField))] + [Index(nameof(EnumContainer.UShortEnumField))] + [Index(nameof(EnumContainer.IntEnumField))] + [Index(nameof(EnumContainer.UIntEnumField))] + [Index(nameof(EnumContainer.LongEnumField))] + [Index(nameof(EnumContainer.ULongEnumField))] + public class EnumContainer : Entity + { + public const string Zero = "Zero"; + public const string One = "One"; + public const string Two = "Two"; + public const string Three = "Three"; + public const string Four = "Four"; + public const string Max = "Max"; + + [Field, Key] + public int Id { get; private set; } + + [Field] + public ByteEnum ByteEnumField { get; set; } + + [Field] + public SByteEnum SByteEnumField { get; set; } + + [Field] + public ShortEnum ShortEnumField { get; set; } + + [Field] + public UShortEnum UShortEnumField { get; set; } + + [Field] + public IntEnum IntEnumField { get; set; } + + [Field] + public UIntEnum UIntEnumField { get; set; } + + [Field] + public LongEnum LongEnumField { get; set; } + + [Field] + public ULongEnum ULongEnumField { get; set; } + + public EnumContainer(Session session, string enumValue) + : base(session) + { + ByteEnumField = (ByteEnum) Enum.Parse(typeof(ByteEnum), enumValue); + SByteEnumField = (SByteEnum) Enum.Parse(typeof(SByteEnum), enumValue); + ShortEnumField = (ShortEnum) Enum.Parse(typeof(ShortEnum), enumValue); + UShortEnumField = (UShortEnum) Enum.Parse(typeof(UShortEnum), enumValue); + IntEnumField = (IntEnum) Enum.Parse(typeof(IntEnum), enumValue); + UIntEnumField = (UIntEnum) Enum.Parse(typeof(UIntEnum), enumValue); + LongEnumField = (LongEnum) Enum.Parse(typeof(LongEnum), enumValue); + ULongEnumField = (ULongEnum) Enum.Parse(typeof(ULongEnum), enumValue); + } + } +} + +namespace Xtensive.Orm.Tests.Linq +{ + public class WhereByEnumTest : AutoBuildTest + { + private Session SharedSession; + + public override void TestFixtureSetUp() + { + base.TestFixtureSetUp(); + CreateSessionAndTransaction(); + SharedSession = Session.Current; + } + + public override void TestFixtureTearDown() + { + SharedSession = null; + base.TestFixtureTearDown(); + } + + protected override DomainConfiguration BuildConfiguration() + { + var config = base.BuildConfiguration(); + config.Types.Register(typeof(EnumContainer)); + config.UpgradeMode = DomainUpgradeMode.Recreate; + return config; + } + + protected override void PopulateData() + { + using (var session = Domain.OpenSession()) + using (var tx = session.OpenTransaction()) { + _ = new EnumContainer(session, EnumContainer.Zero); + _ = new EnumContainer(session, EnumContainer.One); + _ = new EnumContainer(session, EnumContainer.Two); + _ = new EnumContainer(session, EnumContainer.Three); + _ = new EnumContainer(session, EnumContainer.Four); + _ = new EnumContainer(session, EnumContainer.Max); + tx.Complete(); + } + } + + [Test] + public void ByteTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Max).ToArray(1); + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void SByteTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Max).ToArray(1); + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void ShortTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max).ToArray(1); + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void UShortTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max).ToArray(1); + + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void IntTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Max).ToArray(1); + + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void UIntTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Max).ToArray(1); + + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void LongTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Max).ToArray(1); + + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + [Test] + public void ULontTest() + { + SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; + + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Zero).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.One).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Two).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Three).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Four).ToArray(1); + _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Max).ToArray(1); + + SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + } + + private static void PrintCommandToConsole(object sender, DbCommandEventArgs args) => Console.WriteLine(args.Command.CommandText); + } +} From bbe8fbe115b3561e59ed95f09a8a389600b21462 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Wed, 10 Nov 2021 15:58:54 +0500 Subject: [PATCH 02/13] Test improved - non-nullable + nullable enum Fields - check for cast existance --- .../Linq/WhereByEnumTest.cs | 625 +++++++++++++++--- 1 file changed, 544 insertions(+), 81 deletions(-) diff --git a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs index 2233538756..3aea39b95c 100644 --- a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs +++ b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs @@ -9,6 +9,7 @@ using NUnit.Framework; using Xtensive.Core; using Xtensive.Orm.Configuration; +using Xtensive.Orm.Services; using Xtensive.Orm.Tests.Linq.WhereByEnumTestModel; namespace Xtensive.Orm.Tests.Linq.WhereByEnumTestModel @@ -138,6 +139,30 @@ public class EnumContainer : Entity [Field] public ULongEnum ULongEnumField { get; set; } + [Field] + public ByteEnum? NByteEnumField { get; set; } + + [Field] + public SByteEnum? NSByteEnumField { get; set; } + + [Field] + public ShortEnum? NShortEnumField { get; set; } + + [Field] + public UShortEnum? NUShortEnumField { get; set; } + + [Field] + public IntEnum? NIntEnumField { get; set; } + + [Field] + public UIntEnum? NUIntEnumField { get; set; } + + [Field] + public LongEnum? NLongEnumField { get; set; } + + [Field] + public ULongEnum? NULongEnumField { get; set; } + public EnumContainer(Session session, string enumValue) : base(session) { @@ -149,6 +174,15 @@ public EnumContainer(Session session, string enumValue) UIntEnumField = (UIntEnum) Enum.Parse(typeof(UIntEnum), enumValue); LongEnumField = (LongEnum) Enum.Parse(typeof(LongEnum), enumValue); ULongEnumField = (ULongEnum) Enum.Parse(typeof(ULongEnum), enumValue); + + NByteEnumField = (ByteEnum) Enum.Parse(typeof(ByteEnum), enumValue); + NSByteEnumField = (SByteEnum) Enum.Parse(typeof(SByteEnum), enumValue); + NShortEnumField = (ShortEnum) Enum.Parse(typeof(ShortEnum), enumValue); + NUShortEnumField = (UShortEnum) Enum.Parse(typeof(UShortEnum), enumValue); + NIntEnumField = (IntEnum) Enum.Parse(typeof(IntEnum), enumValue); + NUIntEnumField = (UIntEnum) Enum.Parse(typeof(UIntEnum), enumValue); + NLongEnumField = (LongEnum) Enum.Parse(typeof(LongEnum), enumValue); + NULongEnumField = (ULongEnum) Enum.Parse(typeof(ULongEnum), enumValue); } } } @@ -157,18 +191,23 @@ namespace Xtensive.Orm.Tests.Linq { public class WhereByEnumTest : AutoBuildTest { - private Session SharedSession; + private Session sharedSession; + + private string castSign; public override void TestFixtureSetUp() { base.TestFixtureSetUp(); CreateSessionAndTransaction(); - SharedSession = Session.Current; + sharedSession = Session.Current; + castSign = StorageProviderInfo.Instance.CheckProviderIs(StorageProvider.PostgreSql) + ? "::" + : "CAST"; } public override void TestFixtureTearDown() { - SharedSession = null; + sharedSession = null; base.TestFixtureTearDown(); } @@ -197,117 +236,541 @@ protected override void PopulateData() [Test] public void ByteTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Max).ToArray(1); - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void SByteTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Max).ToArray(1); - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void ShortTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max).ToArray(1); - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NShortEnumField == ShortEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NShortEnumField == ShortEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void UShortTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max).ToArray(1); - - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void IntTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Max).ToArray(1); - - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void UIntTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Max).ToArray(1); - - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] public void LongTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Max).ToArray(1); - - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var substractValue = StorageProviderInfo.Instance.CheckProviderIs(StorageProvider.SqlServer) + ? castSign.Length + : 0; + + var query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(1)); } [Test] - public void ULontTest() + public void ULongTest() { - SharedSession.Events.DbCommandExecuting += PrintCommandToConsole; - - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Zero).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.One).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Two).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Three).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Four).ToArray(1); - _ = SharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Max).ToArray(1); - - SharedSession.Events.DbCommandExecuting -= PrintCommandToConsole; + var queryFormatter = sharedSession.Services.Demand(); + + var query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Zero); + var queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Zero); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.One); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Three); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Four); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Max); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(1)); } - - private static void PrintCommandToConsole(object sender, DbCommandEventArgs args) => Console.WriteLine(args.Command.CommandText); } -} +} \ No newline at end of file From 1027f0a19c49361d7a5b3d763c9fb17ab7164dc5 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Thu, 11 Nov 2021 19:44:01 +0500 Subject: [PATCH 03/13] Cast to underlying type of enum in equaling/ineqality expessions --- .../Orm/Linq/Translator.Expressions.cs | 26 ++++++++++++++++++- 1 file changed, 25 insertions(+), 1 deletion(-) diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index 9abfe86672..16a1965a59 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -1,4 +1,4 @@ -// Copyright (C) 2009-2020 Xtensive LLC. +// Copyright (C) 2009-2021 Xtensive LLC. // This code is distributed under MIT license terms. // See the License.txt file in the project root for more information. // Created by: Alexis Kochetov @@ -207,6 +207,30 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) right = Visit(binaryExpression.Right); } } + // Following two checks for enums are here to improve result query + // performance because they let not to cast columns to integer. + else if (binaryExpression.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual) + && binaryExpression.Left.StripCasts().Type.StripNullable().IsEnum + && binaryExpression.Right.StripCasts().NodeType == ExpressionType.Constant) { + var rawEnum = binaryExpression.Left.StripCasts(); + + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(rawEnum, typeToCast)); + right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); + } + else if (binaryExpression.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual) + && binaryExpression.Right.StripCasts().Type.StripNullable().IsEnum + && binaryExpression.Left.StripCasts().NodeType == ExpressionType.Constant) { + var rawEnum = binaryExpression.Right.StripCasts(); + + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(rawEnum, typeToCast)); + right = Visit(Expression.Convert(binaryExpression.Left, typeToCast)); + } else { left = Visit(binaryExpression.Left); right = Visit(binaryExpression.Right); From 520a9a9faf1bbb1702eb0d181e4c78ad399a8b6d Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 12 Nov 2021 18:37:28 +0500 Subject: [PATCH 04/13] WhereTyEnumTest: less items in enum + no indexes --- .../Linq/WhereByEnumTest.cs | 188 ------------------ 1 file changed, 188 deletions(-) diff --git a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs index 3aea39b95c..dab5477129 100644 --- a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs +++ b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs @@ -19,8 +19,6 @@ public enum ByteEnum : byte Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = byte.MaxValue } @@ -29,8 +27,6 @@ public enum SByteEnum : sbyte Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = sbyte.MaxValue } @@ -39,8 +35,6 @@ public enum ShortEnum : short Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = short.MaxValue } @@ -49,8 +43,6 @@ public enum UShortEnum : ushort Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = ushort.MaxValue } @@ -59,8 +51,6 @@ public enum IntEnum : int Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = int.MaxValue } @@ -69,8 +59,6 @@ public enum UIntEnum : uint Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = uint.MaxValue } @@ -79,8 +67,6 @@ public enum LongEnum : long Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = long.MaxValue } @@ -89,27 +75,15 @@ public enum ULongEnum : ulong Zero = 0, One = 1, Two = 2, - Three = 3, - Four = 4, Max = ulong.MaxValue } [HierarchyRoot] - [Index(nameof(EnumContainer.ByteEnumField))] - [Index(nameof(EnumContainer.SByteEnumField))] - [Index(nameof(EnumContainer.ShortEnumField))] - [Index(nameof(EnumContainer.UShortEnumField))] - [Index(nameof(EnumContainer.IntEnumField))] - [Index(nameof(EnumContainer.UIntEnumField))] - [Index(nameof(EnumContainer.LongEnumField))] - [Index(nameof(EnumContainer.ULongEnumField))] public class EnumContainer : Entity { public const string Zero = "Zero"; public const string One = "One"; public const string Two = "Two"; - public const string Three = "Three"; - public const string Four = "Four"; public const string Max = "Max"; [Field, Key] @@ -226,8 +200,6 @@ protected override void PopulateData() _ = new EnumContainer(session, EnumContainer.Zero); _ = new EnumContainer(session, EnumContainer.One); _ = new EnumContainer(session, EnumContainer.Two); - _ = new EnumContainer(session, EnumContainer.Three); - _ = new EnumContainer(session, EnumContainer.Four); _ = new EnumContainer(session, EnumContainer.Max); tx.Complete(); } @@ -253,16 +225,6 @@ public void ByteTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -284,16 +246,6 @@ public void ByteTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -320,16 +272,6 @@ public void SByteTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -351,16 +293,6 @@ public void SByteTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -387,16 +319,6 @@ public void ShortTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -418,16 +340,6 @@ public void ShortTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -454,16 +366,6 @@ public void UShortTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -485,16 +387,6 @@ public void UShortTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -521,16 +413,6 @@ public void IntTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -552,16 +434,6 @@ public void IntTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -588,16 +460,6 @@ public void UIntTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -619,16 +481,6 @@ public void UIntTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -659,16 +511,6 @@ public void LongTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); @@ -690,16 +532,6 @@ public void LongTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); @@ -726,16 +558,6 @@ public void ULongTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); @@ -757,16 +579,6 @@ public void ULongTest() Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Three); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Four); - queryString = queryFormatter.ToSqlString(query); - Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Max); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); From 66d50e5cf729895c17e969cf349a9fa143c3c68c Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 12 Nov 2021 18:52:29 +0500 Subject: [PATCH 05/13] Test for partial indexes with enums + new formatting applied --- .../Storage/PartialIndexTest.cs | 475 +++++++++++------- 1 file changed, 302 insertions(+), 173 deletions(-) diff --git a/Orm/Xtensive.Orm.Tests/Storage/PartialIndexTest.cs b/Orm/Xtensive.Orm.Tests/Storage/PartialIndexTest.cs index b54b8a787b..2a8bf8cbd5 100644 --- a/Orm/Xtensive.Orm.Tests/Storage/PartialIndexTest.cs +++ b/Orm/Xtensive.Orm.Tests/Storage/PartialIndexTest.cs @@ -1,6 +1,6 @@ -// Copyright (C) 2011 Xtensive LLC. -// All rights reserved. -// For conditions of distribution and use, see license. +// Copyright (C) 2011-2021 Xtensive LLC. +// This code is distributed under MIT license terms. +// See the License.txt file in the project root for more information. // Created by: Denis Krjuchkov // Created: 2011.10.06 @@ -49,73 +49,61 @@ public interface ITestInterface : IEntity string TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class SimpleFilterWithMethod : TestBase { - public static Expression> Index() - { - return test => test.TestField.GreaterThan("hello world"); - } + public static Expression> Index() => + test => test.TestField.GreaterThan("hello world"); [Field] public string TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class SimpleFilterWithProperty : TestBase { - public static Expression> Index - { - get { return test => test.TestField.GreaterThan("hello world"); } - } + public static Expression> Index => + test => test.TestField.GreaterThan("hello world"); [Field] public string TestField { get; set; } } - [HierarchyRoot, Index("Target", Filter = "Index")] + [HierarchyRoot, Index(nameof(Target), Filter = nameof(Index))] public class FilterOnReferenceField : TestBase { - public static Expression> Index() - { - return test => test.Target!=null; - } + public static Expression> Index() => + test => test.Target != null; [Field] public TargetEntity Target { get; set; } } - [HierarchyRoot, Index("Target", Filter = "Index")] + [HierarchyRoot, Index(nameof(Target), Filter = nameof(Index))] public class FilterOnComplexReferenceField : TestBase { - public static Expression> Index() - { - return test => test.Target!=null; - } + public static Expression> Index() => + test => test.Target != null; [Field] public ComplexTargetEntity Target { get; set; } } - [HierarchyRoot, Index("Target", Filter = "Index")] + [HierarchyRoot, Index(nameof(Target), Filter = nameof(Index))] public class FilterOnReferenceIdField : TestBase { - public static Expression> Index() - { - return test => test.Target.Id > 0; - } + public static Expression> Index() => + test => test.Target.Id > 0; [Field] public TargetEntity Target { get; set; } } - [HierarchyRoot, Index("TestField1", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField1), Filter = nameof(Index))] public class FilterOnAlienField : TestBase { - public static Expression> Index - { - get { return test => test.TestField2.GreaterThan("hello world"); } - } + public static Expression> Index => + test => test.TestField2.GreaterThan("hello world"); [Field] public string TestField1 { get; set; } @@ -124,103 +112,83 @@ public static Expression> Index public string TestField2 { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class MultipleFieldUses : TestBase { - public static Expression> Index - { - get { return test => test.TestField.GreaterThan("hello") && test.TestField.LessThan("world"); } - } + public static Expression> Index => + test => test.TestField.GreaterThan("hello") && test.TestField.LessThan("world"); [Field] public string TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class InterfaceSupport : TestBase, ITestInterface { - public static Expression> Index - { - get { return test => test.TestField.LessThan("bye world"); } - } + public static Expression> Index => + test => test.TestField.LessThan("bye world"); [Field] public string TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class InOperatorSupport : TestBase { - public static Expression> Index - { - get { return test => test.TestField.In("1", "2", "3"); } - } + public static Expression> Index => + test => test.TestField.In("1", "2", "3"); [Field] public string TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class InOperatorSupport2 : TestBase { - public static Expression> Index - { - get { - return test => test.TestField.In( - new Guid("{D27F71D7-D4FC-446C-8C7E-E89DC2209863}"), - new Guid("{94ED80D9-6749-41E2-B60D-BEDE1CDCA237}")); - } - } + public static Expression> Index => + test => test.TestField.In( + new Guid("{D27F71D7-D4FC-446C-8C7E-E89DC2209863}"), + new Guid("{94ED80D9-6749-41E2-B60D-BEDE1CDCA237}")); [Field] public Guid TestField { get; set; } } - [HierarchyRoot, Index("TestField", Filter = "Index")] + [HierarchyRoot, Index(nameof(TestField), Filter = nameof(Index))] public class ContainsOperatorSupport : TestBase { - public static Expression> Index - { - get { return test => new[] {"1", "2", "3"}.Contains(test.TestField); } - } + public static Expression> Index => + test => new[] { "1", "2", "3" }.Contains(test.TestField); [Field] public string TestField { get; set; } } [HierarchyRoot, - Index("TestField", Filter = "More", Name = "MoreIndex"), - Index("TestField", Filter = "Less", Name = "LessIndex")] + Index(nameof(TestField), Filter = nameof(More), Name = "MoreIndex"), + Index(nameof(TestField), Filter = nameof(Less), Name = "LessIndex")] public class DoubleIndexWithName : TestBase { - public static Expression> More() - { - return test => test.TestField > 1000; - } + public static Expression> More() => + test => test.TestField > 1000; - public static Expression> Less() - { - return test => test.TestField < 100; - } + public static Expression> Less() => + test => test.TestField < 100; [Field] public int TestField { get; set; } } [HierarchyRoot, - Index("TestField", Filter = "More"), - Index("TestField", Filter = "Less")] + Index(nameof(TestField), Filter = nameof(More)), + Index(nameof(TestField), Filter = nameof(Less))] public class DoubleIndexWithoutName : TestBase { - public static Expression> More() - { - return test => test.TestField > 1000; - } + public static Expression> More() => + test => test.TestField > 1000; - public static Expression> Less() - { - return test => test.TestField < 100; - } + public static Expression> Less() => + test => test.TestField < 100; [Field] public int TestField { get; set; } @@ -233,13 +201,11 @@ public class InheritanceClassTableBase : TestBase public int BaseField { get; set; } } - [Index("TestField", Filter = "Index")] + [Index(nameof(TestField), Filter = nameof(Index))] public class InheritanceClassTable : InheritanceClassTableBase { - public static Expression> Index() - { - return test => test.BaseField > 0; - } + public static Expression> Index() => + test => test.BaseField > 0; [Field] public int TestField { get; set; } @@ -252,13 +218,11 @@ public class InheritanceSingleTableBase : TestBase public int BaseField { get; set; } } - [Index("TestField", Filter = "Index")] + [Index(nameof(TestField), Filter = nameof(Index))] public class InheritanceSingleTable : InheritanceSingleTableBase { - public static Expression> Index() - { - return test => test.BaseField > 0; - } + public static Expression> Index() => + test => test.BaseField > 0; [Field] public int TestField { get; set; } @@ -271,17 +235,230 @@ public class InheritanceConcreteTableBase : TestBase public int BaseField { get; set; } } - [Index("TestField", Filter = "Index")] + [Index(nameof(TestField), Filter = nameof(Index))] public class InheritanceConcreteTable : InheritanceConcreteTableBase { - public static Expression> Index() - { - return test => test.BaseField > 0; - } + public static Expression> Index() => + test => test.BaseField > 0; [Field] public int TestField { get; set; } } + + #region Enums + public enum ByteEnum : byte + { + Zero = 0, + One = 1, + Two = 2, + Max = byte.MaxValue + } + + public enum SByteEnum : sbyte + { + Zero = 0, + One = 1, + Two = 2, + Max = sbyte.MaxValue + } + + public enum ShortEnum : short + { + Zero = 0, + One = 1, + Two = 2, + Max = short.MaxValue + } + + public enum UShortEnum : ushort + { + Zero = 0, + One = 1, + Two = 2, + Max = ushort.MaxValue + } + + public enum IntEnum : int + { + Zero = 0, + One = 1, + Two = 2, + Max = int.MaxValue + } + + public enum UIntEnum : uint + { + Zero = 0, + One = 1, + Two = 2, + Max = uint.MaxValue + } + + public enum LongEnum : long + { + Zero = 0, + One = 1, + Two = 2, + Max = long.MaxValue + } + + public enum ULongEnum : ulong + { + Zero = 0, + One = 1, + Two = 2, + Max = ulong.MaxValue + } + #endregion + + [HierarchyRoot] + [Index(nameof(ByteEnumField), Filter = nameof(ByteIndex))] + [Index(nameof(NByteEnumField), Filter = nameof(NByteIndex))] + [Index(nameof(SByteEnumField), Filter = nameof(SByteIndex))] + [Index(nameof(NSByteEnumField), Filter = nameof(SNByteIndex))] + [Index(nameof(ShortEnumField), Filter = nameof(ShortIndex))] + [Index(nameof(NShortEnumField), Filter = nameof(NShortIndex))] + [Index(nameof(UShortEnumField), Filter = nameof(UShortIndex))] + [Index(nameof(NUShortEnumField), Filter = nameof(NUShortIndex))] + [Index(nameof(IntEnumField), Filter = nameof(IntIndex))] + [Index(nameof(NIntEnumField), Filter = nameof(NIntIndex))] + [Index(nameof(UIntEnumField), Filter = nameof(UIntIndex))] + [Index(nameof(NUIntEnumField), Filter = nameof(NUIntIndex))] + [Index(nameof(LongEnumField), Filter = nameof(LongIndex))] + [Index(nameof(NLongEnumField), Filter = nameof(NLongIndex))] + [Index(nameof(ULongEnumField), Filter = nameof(ULongIndex))] + [Index(nameof(NULongEnumField), Filter = nameof(NULongIndex))] + public class EnumFieldFilter : Entity + { + public const string Zero = "Zero"; + public const string One = "One"; + public const string Two = "Two"; + public const string Max = "Max"; + + #region Filters + public static Expression> ByteIndex() => + test => test.ByteEnumField > ByteEnum.Two; + + public static Expression> NByteIndex() => + test => test.NByteEnumField > ByteEnum.Two; + + public static Expression> SByteIndex() => + test => test.ByteEnumField > ByteEnum.Two; + + public static Expression> SNByteIndex() => + test => test.ByteEnumField > ByteEnum.Two; + + public static Expression> ShortIndex() => + test => test.ShortEnumField > ShortEnum.Two; + + public static Expression> NShortIndex() => + test => test.NShortEnumField > ShortEnum.Two; + + public static Expression> UShortIndex() => + test => test.UShortEnumField > UShortEnum.Two; + + public static Expression> NUShortIndex() => + test => test.NUShortEnumField > UShortEnum.Two; + + public static Expression> IntIndex() => + test => test.IntEnumField > IntEnum.Two; + + public static Expression> NIntIndex() => + test => test.NIntEnumField > IntEnum.Two; + + public static Expression> UIntIndex() => + test => test.UIntEnumField > UIntEnum.Two; + + public static Expression> NUIntIndex() => + test => test.NUIntEnumField > UIntEnum.Two; + + public static Expression> LongIndex() => + test => test.LongEnumField > LongEnum.Two; + + public static Expression> NLongIndex() => + test => test.NLongEnumField > LongEnum.Two; + + public static Expression> ULongIndex() => + test => test.ULongEnumField > ULongEnum.Two; + + public static Expression> NULongIndex() => + test => test.NULongEnumField > ULongEnum.Two; + + #endregion + + [Field, Key] + public int Id { get; private set; } + + [Field] + public ByteEnum ByteEnumField { get; set; } + + [Field] + public SByteEnum SByteEnumField { get; set; } + + [Field] + public ShortEnum ShortEnumField { get; set; } + + [Field] + public UShortEnum UShortEnumField { get; set; } + + [Field] + public IntEnum IntEnumField { get; set; } + + [Field] + public UIntEnum UIntEnumField { get; set; } + + [Field] + public LongEnum LongEnumField { get; set; } + + [Field] + public ULongEnum ULongEnumField { get; set; } + + [Field] + public ByteEnum? NByteEnumField { get; set; } + + [Field] + public SByteEnum? NSByteEnumField { get; set; } + + [Field] + public ShortEnum? NShortEnumField { get; set; } + + [Field] + public UShortEnum? NUShortEnumField { get; set; } + + [Field] + public IntEnum? NIntEnumField { get; set; } + + [Field] + public UIntEnum? NUIntEnumField { get; set; } + + [Field] + public LongEnum? NLongEnumField { get; set; } + + [Field] + public ULongEnum? NULongEnumField { get; set; } + + public EnumFieldFilter(Session session, string enumValue) + : base(session) + { + ByteEnumField = (ByteEnum) Enum.Parse(typeof(ByteEnum), enumValue); + SByteEnumField = (SByteEnum) Enum.Parse(typeof(SByteEnum), enumValue); + ShortEnumField = (ShortEnum) Enum.Parse(typeof(ShortEnum), enumValue); + UShortEnumField = (UShortEnum) Enum.Parse(typeof(UShortEnum), enumValue); + IntEnumField = (IntEnum) Enum.Parse(typeof(IntEnum), enumValue); + UIntEnumField = (UIntEnum) Enum.Parse(typeof(UIntEnum), enumValue); + LongEnumField = (LongEnum) Enum.Parse(typeof(LongEnum), enumValue); + ULongEnumField = (ULongEnum) Enum.Parse(typeof(ULongEnum), enumValue); + + NByteEnumField = (ByteEnum) Enum.Parse(typeof(ByteEnum), enumValue); + NSByteEnumField = (SByteEnum) Enum.Parse(typeof(SByteEnum), enumValue); + NShortEnumField = (ShortEnum) Enum.Parse(typeof(ShortEnum), enumValue); + NUShortEnumField = (UShortEnum) Enum.Parse(typeof(UShortEnum), enumValue); + NIntEnumField = (IntEnum) Enum.Parse(typeof(IntEnum), enumValue); + NUIntEnumField = (UIntEnum) Enum.Parse(typeof(UIntEnum), enumValue); + NLongEnumField = (LongEnum) Enum.Parse(typeof(LongEnum), enumValue); + NULongEnumField = (ULongEnum) Enum.Parse(typeof(ULongEnum), enumValue); + } + } } namespace Xtensive.Orm.Tests.Storage @@ -292,16 +469,11 @@ public class PartialIndexTest private Domain domain; [OneTimeSetUp] - public void TestFixtureSetUp() - { + public void TestFixtureSetUp() => Require.AllFeaturesSupported(ProviderFeatures.PartialIndexes); - } [TearDown] - public void TearDown() - { - CleanDomain(); - } + public void TearDown() => CleanDomain(); private void CleanDomain() { @@ -319,8 +491,10 @@ private void BuildDomain(IEnumerable entities, DomainUpgradeMode mode) { CleanDomain(); var config = DomainConfigurationFactory.Create(); - foreach (var entity in entities) + foreach (var entity in entities) { config.Types.Register(entity); + } + config.UpgradeMode = mode; domain = Domain.Build(config); } @@ -329,7 +503,7 @@ private void AssertBuildSuccess(params Type[] entities) { BuildDomain(entities, DomainUpgradeMode.Recreate); var partialIndexes = domain.Model.RealIndexes - .Where(index => index.IsPartial && index.FilterExpression!=null && index.Filter!=null) + .Where(index => index.IsPartial && index.FilterExpression != null && index.Filter != null) .ToList(); Assert.IsNotEmpty(partialIndexes); } @@ -340,107 +514,62 @@ private void AssertBuildFailure(params Type[] entities) } [Test] - public void SimpleFilterWithMethodTest() - { - AssertBuildSuccess(typeof (SimpleFilterWithMethod)); - } + public void SimpleFilterWithMethodTest() => AssertBuildSuccess(typeof(SimpleFilterWithMethod)); [Test] - public void SimpleFilterWithPropertyTest() - { - AssertBuildSuccess(typeof (SimpleFilterWithProperty)); - } + public void SimpleFilterWithPropertyTest() => AssertBuildSuccess(typeof(SimpleFilterWithProperty)); [Test] - public void FilterOnReferenceFieldTest() - { - AssertBuildSuccess(typeof (FilterOnReferenceField)); - } + public void FilterOnReferenceFieldTest() => AssertBuildSuccess(typeof(FilterOnReferenceField)); [Test] - public void FilterOnComplexReferenceFieldTest() - { - AssertBuildSuccess(typeof (FilterOnComplexReferenceField)); - } + public void FilterOnComplexReferenceFieldTest() => AssertBuildSuccess(typeof(FilterOnComplexReferenceField)); [Test] - public void FilterOnReferenceFieldIdTest() - { - AssertBuildSuccess(typeof (FilterOnReferenceIdField)); - } + public void FilterOnReferenceFieldIdTest() => AssertBuildSuccess(typeof(FilterOnReferenceIdField)); [Test] - public void FilterOnAlienFieldTest() - { - AssertBuildSuccess(typeof (FilterOnAlienField)); - } + public void FilterOnAlienFieldTest() => AssertBuildSuccess(typeof(FilterOnAlienField)); [Test] - public void MultipleFieldUsesTest() - { - AssertBuildSuccess(typeof(MultipleFieldUses)); - } + public void MultipleFieldUsesTest() => AssertBuildSuccess(typeof(MultipleFieldUses)); [Test] - public void InOperatorSupportTest() - { - AssertBuildSuccess(typeof (InOperatorSupport)); - } + public void InOperatorSupportTest() => AssertBuildSuccess(typeof(InOperatorSupport)); [Test] - public void InOperatorSupport2Test() - { - AssertBuildSuccess(typeof(InOperatorSupport2)); - } + public void InOperatorSupport2Test() => AssertBuildSuccess(typeof(InOperatorSupport2)); [Test] - public void ContainsOperatorSupportTest() - { - AssertBuildSuccess(typeof(ContainsOperatorSupport)); - } + public void ContainsOperatorSupportTest() => AssertBuildSuccess(typeof(ContainsOperatorSupport)); [Test] - public void DoubleIndexWithNameTest() - { - AssertBuildSuccess(typeof (DoubleIndexWithName)); - } - + public void DoubleIndexWithNameTest() => AssertBuildSuccess(typeof(DoubleIndexWithName)); + [Test] - public void DoubleIndexWithoutNameTest() - { - AssertBuildSuccess(typeof (DoubleIndexWithoutName)); - } + public void DoubleIndexWithoutNameTest() => AssertBuildSuccess(typeof(DoubleIndexWithoutName)); [Test] - public void InterfaceSupportTest() - { - AssertBuildSuccess(typeof(InterfaceSupport)); - } + public void InterfaceSupportTest() => AssertBuildSuccess(typeof(InterfaceSupport)); [Test] - public void InheritanceClassTableTest() - { - AssertBuildFailure(typeof (InheritanceClassTable)); - } + public void InheritanceClassTableTest() => AssertBuildFailure(typeof(InheritanceClassTable)); [Test] - public void InheritanceSingleTableTest() - { - AssertBuildSuccess(typeof(InheritanceSingleTable)); - } + public void InheritanceSingleTableTest() => AssertBuildSuccess(typeof(InheritanceSingleTable)); [Test] - public void InheritanceConcreteTableTest() - { - AssertBuildSuccess(typeof(InheritanceConcreteTable)); - } + public void InheritanceConcreteTableTest() => AssertBuildSuccess(typeof(InheritanceConcreteTable)); + + [Test] + public void EnumFieldFilterTest() => AssertBuildSuccess(typeof(EnumFieldFilter)); [Test] public void ValidateTest() { - var types = typeof (TestBase).Assembly + var types = typeof(TestBase).Assembly .GetTypes() - .Where(type => type.Namespace==typeof (TestBase).Namespace && type!=typeof (InheritanceClassTable)) + .Where(type => type.Namespace == typeof(TestBase).Namespace && type != typeof(InheritanceClassTable)) .ToList(); BuildDomain(types, DomainUpgradeMode.Recreate); BuildDomain(types, DomainUpgradeMode.Validate); From 946dba7631589bbcaf22c5771a1669a9cbcd4805 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 12 Nov 2021 19:16:46 +0500 Subject: [PATCH 06/13] PartialIndexFilterBuilder handles filters with enum constants --- .../Builders/PartialIndexFilterBuilder.cs | 33 +++++++++++++++++-- 1 file changed, 30 insertions(+), 3 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs index b34df0de81..48043f2f81 100644 --- a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs @@ -1,6 +1,6 @@ -// Copyright (C) 2011 Xtensive LLC. -// All rights reserved. -// For conditions of distribution and use, see license. +// Copyright (C) 2011-2021 Xtensive LLC. +// This code is distributed under MIT license terms. +// See the License.txt file in the project root for more information. // Created by: Denis Krjuchkov // Created: 2011.10.07 @@ -46,6 +46,33 @@ public static void BuildFilter(IndexInfo index) protected override Expression VisitBinary(BinaryExpression b) { + if (b.Left.StripCasts().Type.StripNullable().IsEnum + && b.Right.StripCasts().NodeType == ExpressionType.Constant) { + + var rawEnum = b.Left.StripCasts(); + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + + return base.VisitBinary(Expression.MakeBinary( + b.NodeType, + Expression.Convert(rawEnum, typeToCast), + Expression.Convert(b.Right, typeToCast))); + } + else if (b.Right.StripCasts().Type.StripNullable().IsEnum + && b.Left.StripCasts().NodeType == ExpressionType.Constant) { + + var rawEnum = b.Right.StripCasts(); + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + + return base.VisitBinary(Expression.MakeBinary( + b.NodeType, + Expression.Convert(rawEnum, typeToCast), + Expression.Convert(b.Left, typeToCast))); + } + // Detect f!=null and f==null for entity fields if (!b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual)) From 8200b5c9899a48389b0ed820edbabd865d8ab676 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 12 Nov 2021 19:21:54 +0500 Subject: [PATCH 07/13] All binary expressions with enums rewritten with cast to underlying type --- Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs | 6 ++---- 1 file changed, 2 insertions(+), 4 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index 16a1965a59..9c4686d58c 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -209,8 +209,7 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) } // Following two checks for enums are here to improve result query // performance because they let not to cast columns to integer. - else if (binaryExpression.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual) - && binaryExpression.Left.StripCasts().Type.StripNullable().IsEnum + else if (binaryExpression.Left.StripCasts().Type.StripNullable().IsEnum && binaryExpression.Right.StripCasts().NodeType == ExpressionType.Constant) { var rawEnum = binaryExpression.Left.StripCasts(); @@ -220,8 +219,7 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) left = Visit(Expression.Convert(rawEnum, typeToCast)); right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); } - else if (binaryExpression.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual) - && binaryExpression.Right.StripCasts().Type.StripNullable().IsEnum + else if (binaryExpression.Right.StripCasts().Type.StripNullable().IsEnum && binaryExpression.Left.StripCasts().NodeType == ExpressionType.Constant) { var rawEnum = binaryExpression.Right.StripCasts(); From 3613fc49f2d93bd9c737d2d7a792fd9a86f5ada8 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Thu, 18 Nov 2021 15:04:41 +0500 Subject: [PATCH 08/13] Improve contiditons when to rewrite binary expressions --- .../Orm/Linq/Translator.Expressions.cs | 21 +++++++++++++------ 1 file changed, 15 insertions(+), 6 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index 9c4686d58c..8ef0ddd14b 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -209,9 +209,10 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) } // Following two checks for enums are here to improve result query // performance because they let not to cast columns to integer. - else if (binaryExpression.Left.StripCasts().Type.StripNullable().IsEnum - && binaryExpression.Right.StripCasts().NodeType == ExpressionType.Constant) { - var rawEnum = binaryExpression.Left.StripCasts(); + else if (EnumRewritableOperations(binaryExpression) + && binaryExpression.Left.StripCasts() is var rawLeft1 && rawLeft1.Type.StripNullable().IsEnum + && binaryExpression.Right.StripCasts() is var rawRight1 && rawRight1.NodeType == ExpressionType.Constant) { + var rawEnum = rawLeft1; var typeToCast = (rawEnum.Type.IsNullable()) ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() @@ -219,9 +220,10 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) left = Visit(Expression.Convert(rawEnum, typeToCast)); right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); } - else if (binaryExpression.Right.StripCasts().Type.StripNullable().IsEnum - && binaryExpression.Left.StripCasts().NodeType == ExpressionType.Constant) { - var rawEnum = binaryExpression.Right.StripCasts(); + else if (EnumRewritableOperations(binaryExpression) + && binaryExpression.Right.StripCasts() is var rawRight2 && rawRight2.Type.StripNullable().IsEnum + && binaryExpression.Left.StripCasts() is var rawLeft2 && rawLeft2.NodeType == ExpressionType.Constant) { + var rawEnum = rawRight2; var typeToCast = (rawEnum.Type.IsNullable()) ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() @@ -253,6 +255,13 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) } return resultBinaryExpression; + + static bool EnumRewritableOperations(BinaryExpression b) + { + return b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual, + ExpressionType.GreaterThan, ExpressionType.GreaterThanOrEqual, + ExpressionType.LessThan, ExpressionType.LessThanOrEqual); + } } protected override Expression VisitConditional(ConditionalExpression c) From 68d0d64fb1ed4a3ab89dcbff6cb4883b4f7a936e Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 19 Nov 2021 16:52:47 +0500 Subject: [PATCH 09/13] PartialIndexFilterBuilder:Fixed operations to rewrite enums --- .../Builders/PartialIndexFilterBuilder.cs | 62 +++++++++++-------- 1 file changed, 35 insertions(+), 27 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs index 48043f2f81..0a455f3b95 100644 --- a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs @@ -46,31 +46,33 @@ public static void BuildFilter(IndexInfo index) protected override Expression VisitBinary(BinaryExpression b) { - if (b.Left.StripCasts().Type.StripNullable().IsEnum - && b.Right.StripCasts().NodeType == ExpressionType.Constant) { - - var rawEnum = b.Left.StripCasts(); - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); - - return base.VisitBinary(Expression.MakeBinary( - b.NodeType, - Expression.Convert(rawEnum, typeToCast), - Expression.Convert(b.Right, typeToCast))); - } - else if (b.Right.StripCasts().Type.StripNullable().IsEnum - && b.Left.StripCasts().NodeType == ExpressionType.Constant) { - - var rawEnum = b.Right.StripCasts(); - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); - - return base.VisitBinary(Expression.MakeBinary( - b.NodeType, - Expression.Convert(rawEnum, typeToCast), - Expression.Convert(b.Left, typeToCast))); + if (EnumRewritableOperations(b)) { + if (b.Left.StripCasts().Type.StripNullable().IsEnum + && b.Right.StripCasts().NodeType == ExpressionType.Constant) { + + var rawEnum = b.Left.StripCasts(); + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + + return base.VisitBinary(Expression.MakeBinary( + b.NodeType, + Expression.Convert(rawEnum, typeToCast), + Expression.Convert(b.Right, typeToCast))); + } + else if (b.Right.StripCasts().Type.StripNullable().IsEnum + && b.Left.StripCasts().NodeType == ExpressionType.Constant) { + + var rawEnum = b.Right.StripCasts(); + var typeToCast = (rawEnum.Type.IsNullable()) + ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() + : rawEnum.Type.GetEnumUnderlyingType(); + + return base.VisitBinary(Expression.MakeBinary( + b.NodeType, + Expression.Convert(rawEnum, typeToCast), + Expression.Convert(b.Left, typeToCast))); + } } // Detect f!=null and f==null for entity fields @@ -81,13 +83,19 @@ protected override Expression VisitBinary(BinaryExpression b) var left = Visit(b.Left); var right = Visit(b.Right); - FieldInfo field; - if (entityAccessMap.TryGetValue(left, out field) && IsNull(right)) + if (entityAccessMap.TryGetValue(left, out var field) && IsNull(right)) return BuildEntityCheck(field, b.NodeType); if (entityAccessMap.TryGetValue(right, out field) && IsNull(left)) return BuildEntityCheck(field, b.NodeType); return base.VisitBinary(b); + + static bool EnumRewritableOperations(BinaryExpression b) + { + return b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual, + ExpressionType.GreaterThan, ExpressionType.GreaterThanOrEqual, + ExpressionType.LessThan, ExpressionType.LessThanOrEqual); + } } protected override Expression VisitMemberAccess(MemberExpression originalMemberAccess) From 8ffe6fb88cf1db7363bf83fbac52472a86aca471 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Fri, 19 Nov 2021 16:53:19 +0500 Subject: [PATCH 10/13] Update test to check all allowed operations --- .../Linq/WhereByEnumTest.cs | 331 +++++++++++++----- 1 file changed, 240 insertions(+), 91 deletions(-) diff --git a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs index dab5477129..aaa8e72cf2 100644 --- a/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs +++ b/Orm/Xtensive.Orm.Tests/Linq/WhereByEnumTest.cs @@ -166,7 +166,6 @@ namespace Xtensive.Orm.Tests.Linq public class WhereByEnumTest : AutoBuildTest { private Session sharedSession; - private string castSign; public override void TestFixtureSetUp() @@ -210,20 +209,30 @@ public void ByteTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.ByteEnumField != ByteEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.One); + query = sharedSession.Query.All().Where(e => e.ByteEnumField > ByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Two); + query = sharedSession.Query.All().Where(e => e.ByteEnumField >= ByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField < ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.ByteEnumField <= ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.ByteEnumField == ByteEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -231,20 +240,30 @@ public void ByteTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NByteEnumField != ByteEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.One); + query = sharedSession.Query.All().Where(e => e.NByteEnumField > ByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Two); + query = sharedSession.Query.All().Where(e => e.NByteEnumField >= ByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField < ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NByteEnumField <= ByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NByteEnumField == ByteEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -257,20 +276,30 @@ public void SByteTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.SByteEnumField != SByteEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.One); + query = sharedSession.Query.All().Where(e => e.SByteEnumField > SByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Two); + query = sharedSession.Query.All().Where(e => e.SByteEnumField >= SByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField < SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.SByteEnumField <= SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.SByteEnumField == SByteEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -278,20 +307,30 @@ public void SByteTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NSByteEnumField != SByteEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.One); + query = sharedSession.Query.All().Where(e => e.NSByteEnumField > SByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Two); + query = sharedSession.Query.All().Where(e => e.NSByteEnumField >= SByteEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField < SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NSByteEnumField <= SByteEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NSByteEnumField == SByteEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -325,20 +364,30 @@ public void ShortTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NShortEnumField == ShortEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NShortEnumField != ShortEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NShortEnumField == ShortEnum.One); + query = sharedSession.Query.All().Where(e => e.NShortEnumField > ShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Two); + query = sharedSession.Query.All().Where(e => e.NShortEnumField >= ShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField < ShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.ShortEnumField <= ShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.ShortEnumField == ShortEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -351,20 +400,30 @@ public void UShortTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.UShortEnumField != UShortEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.One); + query = sharedSession.Query.All().Where(e => e.UShortEnumField > UShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Two); + query = sharedSession.Query.All().Where(e => e.UShortEnumField >= UShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField < UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.UShortEnumField <= UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -372,20 +431,30 @@ public void UShortTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NUShortEnumField != UShortEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.One); + query = sharedSession.Query.All().Where(e => e.NUShortEnumField > UShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NUShortEnumField == UShortEnum.Two); + query = sharedSession.Query.All().Where(e => e.NUShortEnumField >= UShortEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField < UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NUShortEnumField <= UShortEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.UShortEnumField == UShortEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -398,20 +467,30 @@ public void IntTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.IntEnumField != IntEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.One); + query = sharedSession.Query.All().Where(e => e.IntEnumField > IntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Two); + query = sharedSession.Query.All().Where(e => e.IntEnumField >= IntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField < IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.IntEnumField <= IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.IntEnumField == IntEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -419,20 +498,30 @@ public void IntTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NIntEnumField != IntEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.One); + query = sharedSession.Query.All().Where(e => e.NIntEnumField > IntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Two); + query = sharedSession.Query.All().Where(e => e.NIntEnumField >= IntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField < IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NIntEnumField <= IntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NIntEnumField == IntEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -445,20 +534,30 @@ public void UIntTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.UIntEnumField != UIntEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.One); + query = sharedSession.Query.All().Where(e => e.UIntEnumField > UIntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Two); + query = sharedSession.Query.All().Where(e => e.UIntEnumField >= UIntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField < UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.UIntEnumField <= UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.UIntEnumField == UIntEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -466,20 +565,30 @@ public void UIntTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NUIntEnumField != UIntEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.One); + query = sharedSession.Query.All().Where(e => e.NUIntEnumField > UIntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Two); + query = sharedSession.Query.All().Where(e => e.NUIntEnumField >= UIntEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField < UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NUIntEnumField <= UIntEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NUIntEnumField == UIntEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -496,20 +605,30 @@ public void LongTest() ? castSign.Length : 0; - var query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.LongEnumField != LongEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.One); + query = sharedSession.Query.All().Where(e => e.LongEnumField > LongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Two); + query = sharedSession.Query.All().Where(e => e.LongEnumField >= LongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField < LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.LongEnumField <= LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.LongEnumField == LongEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -517,20 +636,30 @@ public void LongTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NLongEnumField != LongEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.One); + query = sharedSession.Query.All().Where(e => e.NLongEnumField > LongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Two); + query = sharedSession.Query.All().Where(e => e.NLongEnumField >= LongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField < LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NLongEnumField <= LongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length - substractValue)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NLongEnumField == LongEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -543,20 +672,30 @@ public void ULongTest() { var queryFormatter = sharedSession.Services.Demand(); - var query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Zero); + var query = sharedSession.Query.All().Where(e => e.ULongEnumField != ULongEnum.Zero); var queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.One); + query = sharedSession.Query.All().Where(e => e.ULongEnumField > ULongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Two); + query = sharedSession.Query.All().Where(e => e.ULongEnumField >= ULongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField < ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.ULongEnumField <= ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.ULongEnumField == ULongEnum.Max); queryString = queryFormatter.ToSqlString(query); @@ -564,20 +703,30 @@ public void ULongTest() Assert.That(query.Count(), Is.EqualTo(1)); - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Zero); + query = sharedSession.Query.All().Where(e => e.NULongEnumField != ULongEnum.Zero); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.One); + query = sharedSession.Query.All().Where(e => e.NULongEnumField > ULongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(2)); - query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Two); + query = sharedSession.Query.All().Where(e => e.NULongEnumField >= ULongEnum.One); queryString = queryFormatter.ToSqlString(query); Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); - Assert.That(query.Count(), Is.EqualTo(1)); + Assert.That(query.Count(), Is.EqualTo(3)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField < ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(2)); + + query = sharedSession.Query.All().Where(e => e.NULongEnumField <= ULongEnum.Two); + queryString = queryFormatter.ToSqlString(query); + Assert.That(queryString.Replace(castSign, "").Length, Is.EqualTo(queryString.Length)); + Assert.That(query.Count(), Is.EqualTo(3)); query = sharedSession.Query.All().Where(e => e.NULongEnumField == ULongEnum.Max); queryString = queryFormatter.ToSqlString(query); From da2efc9f9a387456b8378cd10376c51e16164593 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Mon, 22 Nov 2021 12:25:40 +0500 Subject: [PATCH 11/13] Small performance improvements --- .../Builders/PartialIndexFilterBuilder.cs | 36 +++++++++---------- .../Orm/Linq/Translator.Expressions.cs | 7 ++-- 2 files changed, 22 insertions(+), 21 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs index 0a455f3b95..769b8d8300 100644 --- a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs @@ -47,30 +47,29 @@ public static void BuildFilter(IndexInfo index) protected override Expression VisitBinary(BinaryExpression b) { if (EnumRewritableOperations(b)) { - if (b.Left.StripCasts().Type.StripNullable().IsEnum - && b.Right.StripCasts().NodeType == ExpressionType.Constant) { + var rawLeft = b.Left.StripCasts(); + var rawLeftType = rawLeft.Type.StripNullable(); + var rawRight = b.Right.StripCasts(); + var rawRightType = rawRight.Type.StripNullable(); - var rawEnum = b.Left.StripCasts(); - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); + if (rawLeftType.IsEnum && rawRight.NodeType == ExpressionType.Constant) { + var typeToCast = rawLeft.Type.IsNullable() + ? rawLeftType.GetEnumUnderlyingType().ToNullable() + : rawLeft.Type.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(rawEnum, typeToCast), + Expression.Convert(rawLeft, typeToCast), Expression.Convert(b.Right, typeToCast))); } - else if (b.Right.StripCasts().Type.StripNullable().IsEnum - && b.Left.StripCasts().NodeType == ExpressionType.Constant) { - - var rawEnum = b.Right.StripCasts(); - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); + else if (rawRightType.IsEnum && rawLeft.NodeType == ExpressionType.Constant) { + var typeToCast = rawRight.Type.IsNullable() + ? rawRightType.GetEnumUnderlyingType().ToNullable() + : rawRight.Type.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(rawEnum, typeToCast), + Expression.Convert(rawRight, typeToCast), Expression.Convert(b.Left, typeToCast))); } } @@ -92,9 +91,10 @@ protected override Expression VisitBinary(BinaryExpression b) static bool EnumRewritableOperations(BinaryExpression b) { - return b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual, - ExpressionType.GreaterThan, ExpressionType.GreaterThanOrEqual, - ExpressionType.LessThan, ExpressionType.LessThanOrEqual); + var nt = b.NodeType; + return nt == ExpressionType.Equal || nt == ExpressionType.NotEqual + || nt == ExpressionType.GreaterThan || nt == ExpressionType.GreaterThanOrEqual + || nt == ExpressionType.LessThan || nt == ExpressionType.LessThanOrEqual; } } diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index 8ef0ddd14b..cd5deb088b 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -258,9 +258,10 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) static bool EnumRewritableOperations(BinaryExpression b) { - return b.NodeType.In(ExpressionType.Equal, ExpressionType.NotEqual, - ExpressionType.GreaterThan, ExpressionType.GreaterThanOrEqual, - ExpressionType.LessThan, ExpressionType.LessThanOrEqual); + var nt = b.NodeType; + return nt == ExpressionType.Equal || nt == ExpressionType.NotEqual + || nt == ExpressionType.GreaterThan || nt == ExpressionType.GreaterThanOrEqual + || nt == ExpressionType.LessThan || nt == ExpressionType.LessThanOrEqual; } } From 98882b29c9d3026e2d1268300cc3fb2c710f2216 Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Mon, 22 Nov 2021 20:44:41 +0500 Subject: [PATCH 12/13] Translator.Expressions: less wasted operations + renames in PartialIndexFilterBuilder --- .../Builders/PartialIndexFilterBuilder.cs | 28 +++++------ .../Orm/Linq/Translator.Expressions.cs | 50 ++++++++++--------- 2 files changed, 41 insertions(+), 37 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs index 769b8d8300..04e7c04004 100644 --- a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs @@ -47,29 +47,29 @@ public static void BuildFilter(IndexInfo index) protected override Expression VisitBinary(BinaryExpression b) { if (EnumRewritableOperations(b)) { - var rawLeft = b.Left.StripCasts(); - var rawLeftType = rawLeft.Type.StripNullable(); - var rawRight = b.Right.StripCasts(); - var rawRightType = rawRight.Type.StripNullable(); + var bareLeft = b.Left.StripCasts(); + var bareLeftType = bareLeft.Type.StripNullable(); + var bareRight = b.Right.StripCasts(); + var bareRightType = bareRight.Type.StripNullable(); - if (rawLeftType.IsEnum && rawRight.NodeType == ExpressionType.Constant) { - var typeToCast = rawLeft.Type.IsNullable() - ? rawLeftType.GetEnumUnderlyingType().ToNullable() - : rawLeft.Type.GetEnumUnderlyingType(); + if (bareLeftType.IsEnum && bareRight.NodeType == ExpressionType.Constant) { + var typeToCast = bareLeft.Type.IsNullable() + ? bareLeftType.GetEnumUnderlyingType().ToNullable() + : bareLeft.Type.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(rawLeft, typeToCast), + Expression.Convert(bareLeft, typeToCast), Expression.Convert(b.Right, typeToCast))); } - else if (rawRightType.IsEnum && rawLeft.NodeType == ExpressionType.Constant) { - var typeToCast = rawRight.Type.IsNullable() - ? rawRightType.GetEnumUnderlyingType().ToNullable() - : rawRight.Type.GetEnumUnderlyingType(); + else if (bareRightType.IsEnum && bareLeft.NodeType == ExpressionType.Constant) { + var typeToCast = bareRight.Type.IsNullable() + ? bareRightType.GetEnumUnderlyingType().ToNullable() + : bareRight.Type.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(rawRight, typeToCast), + Expression.Convert(bareRight, typeToCast), Expression.Convert(b.Left, typeToCast))); } } diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index cd5deb088b..6e816a837b 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -207,29 +207,33 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) right = Visit(binaryExpression.Right); } } - // Following two checks for enums are here to improve result query - // performance because they let not to cast columns to integer. - else if (EnumRewritableOperations(binaryExpression) - && binaryExpression.Left.StripCasts() is var rawLeft1 && rawLeft1.Type.StripNullable().IsEnum - && binaryExpression.Right.StripCasts() is var rawRight1 && rawRight1.NodeType == ExpressionType.Constant) { - var rawEnum = rawLeft1; - - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); - left = Visit(Expression.Convert(rawEnum, typeToCast)); - right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); - } - else if (EnumRewritableOperations(binaryExpression) - && binaryExpression.Right.StripCasts() is var rawRight2 && rawRight2.Type.StripNullable().IsEnum - && binaryExpression.Left.StripCasts() is var rawLeft2 && rawLeft2.NodeType == ExpressionType.Constant) { - var rawEnum = rawRight2; - - var typeToCast = (rawEnum.Type.IsNullable()) - ? rawEnum.Type.StripNullable().GetEnumUnderlyingType().ToNullable() - : rawEnum.Type.GetEnumUnderlyingType(); - left = Visit(Expression.Convert(rawEnum, typeToCast)); - right = Visit(Expression.Convert(binaryExpression.Left, typeToCast)); + else if (EnumRewritableOperations(binaryExpression)) { + // Following two checks for enums are here to improve result query + // performance because they let not to cast columns to integer. + + var bareLeft = binaryExpression.Left.StripCasts(); + var bareLeftType = bareLeft.Type.StripNullable(); + var bareRight = binaryExpression.Right.StripCasts(); + var bareRightType = bareRight.Type.StripNullable(); + + if (bareLeftType.IsEnum && bareRight.NodeType == ExpressionType.Constant) { + var typeToCast = bareLeft.Type.IsNullable() + ? bareLeftType.GetEnumUnderlyingType().ToNullable() + : bareLeft.Type.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(bareLeft, typeToCast)); + right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); + } + else if (bareRightType.IsEnum && bareLeft.NodeType == ExpressionType.Constant) { + var typeToCast = (bareRight.Type.IsNullable()) + ? bareRightType.GetEnumUnderlyingType().ToNullable() + : bareRight.Type.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(bareRight, typeToCast)); + right = Visit(Expression.Convert(binaryExpression.Left, typeToCast)); + } + else { + left = Visit(binaryExpression.Left); + right = Visit(binaryExpression.Right); + } } else { left = Visit(binaryExpression.Left); From 1ad55df3f00351b0156bdb4a89e804047c6f3e1d Mon Sep 17 00:00:00 2001 From: Alexey Kulakov Date: Tue, 23 Nov 2021 20:11:11 +0500 Subject: [PATCH 13/13] Less Expression.Type calls --- .../Builders/PartialIndexFilterBuilder.cs | 28 +++++++++--------- .../Orm/Linq/Translator.Expressions.cs | 29 ++++++++++--------- 2 files changed, 30 insertions(+), 27 deletions(-) diff --git a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs index 04e7c04004..fd08eededc 100644 --- a/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs +++ b/Orm/Xtensive.Orm/Orm/Building/Builders/PartialIndexFilterBuilder.cs @@ -47,29 +47,31 @@ public static void BuildFilter(IndexInfo index) protected override Expression VisitBinary(BinaryExpression b) { if (EnumRewritableOperations(b)) { - var bareLeft = b.Left.StripCasts(); - var bareLeftType = bareLeft.Type.StripNullable(); - var bareRight = b.Right.StripCasts(); - var bareRightType = bareRight.Type.StripNullable(); - - if (bareLeftType.IsEnum && bareRight.NodeType == ExpressionType.Constant) { - var typeToCast = bareLeft.Type.IsNullable() + var leftNoCasts = b.Left.StripCasts(); + var leftNoCastsType = leftNoCasts.Type; + var bareLeftType = leftNoCastsType.StripNullable(); + var rightNoCasts = b.Right.StripCasts(); + var rightNoCastsType = rightNoCasts.Type; + var bareRightType = rightNoCastsType.StripNullable(); + + if (bareLeftType.IsEnum && rightNoCasts.NodeType == ExpressionType.Constant) { + var typeToCast = leftNoCastsType.IsNullable() ? bareLeftType.GetEnumUnderlyingType().ToNullable() - : bareLeft.Type.GetEnumUnderlyingType(); + : leftNoCastsType.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(bareLeft, typeToCast), + Expression.Convert(leftNoCasts, typeToCast), Expression.Convert(b.Right, typeToCast))); } - else if (bareRightType.IsEnum && bareLeft.NodeType == ExpressionType.Constant) { - var typeToCast = bareRight.Type.IsNullable() + else if (bareRightType.IsEnum && leftNoCasts.NodeType == ExpressionType.Constant) { + var typeToCast = rightNoCastsType.IsNullable() ? bareRightType.GetEnumUnderlyingType().ToNullable() - : bareRight.Type.GetEnumUnderlyingType(); + : rightNoCastsType.GetEnumUnderlyingType(); return base.VisitBinary(Expression.MakeBinary( b.NodeType, - Expression.Convert(bareRight, typeToCast), + Expression.Convert(rightNoCasts, typeToCast), Expression.Convert(b.Left, typeToCast))); } } diff --git a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs index 6e816a837b..5f6f4ac0a3 100644 --- a/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs +++ b/Orm/Xtensive.Orm/Orm/Linq/Translator.Expressions.cs @@ -210,24 +210,25 @@ protected override Expression VisitBinary(BinaryExpression binaryExpression) else if (EnumRewritableOperations(binaryExpression)) { // Following two checks for enums are here to improve result query // performance because they let not to cast columns to integer. - - var bareLeft = binaryExpression.Left.StripCasts(); - var bareLeftType = bareLeft.Type.StripNullable(); - var bareRight = binaryExpression.Right.StripCasts(); - var bareRightType = bareRight.Type.StripNullable(); - - if (bareLeftType.IsEnum && bareRight.NodeType == ExpressionType.Constant) { - var typeToCast = bareLeft.Type.IsNullable() + var leftNoCasts = binaryExpression.Left.StripCasts(); + var leftNoCastsType = leftNoCasts.Type; + var bareLeftType = leftNoCastsType.StripNullable(); + var rightNoCasts = binaryExpression.Right.StripCasts(); + var rightNoCastsType = rightNoCasts.Type; + var bareRightType = rightNoCastsType.StripNullable(); + + if (bareLeftType.IsEnum && rightNoCasts.NodeType == ExpressionType.Constant) { + var typeToCast = leftNoCastsType.IsNullable() ? bareLeftType.GetEnumUnderlyingType().ToNullable() - : bareLeft.Type.GetEnumUnderlyingType(); - left = Visit(Expression.Convert(bareLeft, typeToCast)); + : leftNoCastsType.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(leftNoCasts, typeToCast)); right = Visit(Expression.Convert(binaryExpression.Right, typeToCast)); } - else if (bareRightType.IsEnum && bareLeft.NodeType == ExpressionType.Constant) { - var typeToCast = (bareRight.Type.IsNullable()) + else if (bareRightType.IsEnum && leftNoCasts.NodeType == ExpressionType.Constant) { + var typeToCast = rightNoCastsType.IsNullable() ? bareRightType.GetEnumUnderlyingType().ToNullable() - : bareRight.Type.GetEnumUnderlyingType(); - left = Visit(Expression.Convert(bareRight, typeToCast)); + : rightNoCastsType.GetEnumUnderlyingType(); + left = Visit(Expression.Convert(rightNoCasts, typeToCast)); right = Visit(Expression.Convert(binaryExpression.Left, typeToCast)); } else {