SqlServerFunctionsTests.cs

/Tests/Linq/DataProvider/SqlServerFunctionsTests.cs

https://github.com/linq2db/linq2db
C# | 1452 lines | 1273 code | 178 blank | 1 comment | 6 complexity | 1816bfbfd80be1081ba191617739bcee MD5 | raw file

using System;

using System.Linq;



using LinqToDB;

using LinqToDB.Data;

using LinqToDB.DataProvider.SqlServer;

using LinqToDB.Tools;

using LinqToDB.Tools.DataProvider.SqlServer.Schemas;



using NUnit.Framework;



namespace Tests.DataProvider

{

	[TestFixture]

	public class SqlServerFunctionsTests : TestBase

	{

		#region Configuration



		[Test]

		public void DbTSTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DbTS);

			Console.WriteLine(result.ToDiagnosticString());

			Assert.That(result.Length, Is.EqualTo(8));

		}



		[Test]

		public void LangIDTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.LangID);

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThanOrEqualTo(0));

		}



		[Test]

		public void LanguageTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Language);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		[Test]

		public void LockTimeoutTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			db.Execute("SET LOCK_TIMEOUT 1000");

			var result = db.Select(() => SqlFn.LockTimeout);

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1000));

		}



		[Test]

		public void MaxConnectionsTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.MaxConnections);

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(32767));

		}



		[Test]

		public void MaxPrecisionTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.MaxPrecision);

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(38));

		}



		[Test]

		public void NestLevelTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.NestLevel);

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(0));

		}



		[Test]

		public void OptionsTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Options);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.EqualTo(0));

		}



		[Test]

		public void RemServerTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.RemServer);

			Console.WriteLine(result);

			Assert.That(result, Is.Null);

		}



		[Test]

		public void ServerNameTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.ServerName);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		[Test]

		public void ServiceNameTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			if (context == "SqlAzure")

				return;



			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.ServiceName);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		[Test]

		public void SpIDTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SpID);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.EqualTo(0));

		}



		[Test]

		public void TextSizeTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			db.Execute("SET TEXTSIZE 2048");

			var result = db.Select(() => SqlFn.TextSize);

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2048));

		}



		[Test]

		public void VersionTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Version);

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		#endregion



		#region Conversion



		[Test]

		public void CastTest1([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Cast("10:10:10", SqlType.Time));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(10, 10, 10)));

		}



		[Test]

		public void CastTest2([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Cast("10:10:10", SqlType.Time(3)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(10, 10, 10)));

		}



		[Test]

		public void CastTest3([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Cast<string>(123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.VarChar(4), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.Decimal, 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void ConvertTest3([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.NVarChar(10), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertTest4([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.VarCharMax, 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertTest5([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.Decimal(30, 0), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void ConvertTest6([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert<string>(123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertWithStyleTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.VarChar(4), 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertWithStyleTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.Decimal, 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void ConvertWithStyleTest3([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.NVarChar(10), new DateTime(2022, 02, 22), 105));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("22-02-2022"));

		}



		[Test]

		public void ConvertWithStyleTest4([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.VarCharMax, 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void ConvertWithStyleTest5([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert(SqlType.Decimal(30, 0), 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void ConvertWithStyleTest6([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Convert<string>(new DateTime(2022, 02, 22), 5));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("22-02-22"));

		}



		[Test]

		public void ParseTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse("Monday, 13 December 2010", SqlType.Date));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2010, 12, 13)));

		}



		[Test]

		public void ParseTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse("123", SqlType.Decimal(30)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void ParseTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse<int>("123"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123));

		}



		[Test]

		public void ParseWithCultureTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse("€345,98", SqlType.Money, "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		[Test]

		public void ParseWithCultureTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse("345,98", SqlType.Decimal(30,2), "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		[Test]

		public void ParseWithCultureTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Parse<decimal>("345,98", "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		[Test]

		public void TryCastTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db     = new SystemDB(context);

			var       result = db.Select(() => SqlFn.TryCast("10:10:10", SqlType.Time));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(10, 10, 10)));

		}



		[Test]

		public void TryCastTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db     = new SystemDB(context);

			var       result = db.Select(() => SqlFn.TryCast("10:10:10", SqlType.Time(3)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(10, 10, 10)));

		}



		[Test]

		public void TryCastTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db     = new SystemDB(context);

			var       result = db.Select(() => SqlFn.TryCast<string>(123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.VarChar(4), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.Decimal, 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void TryConvertTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.NVarChar(10), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertTest4([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.VarCharMax, 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertTest5([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.Decimal(30, 0), 123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void TryConvertTest6([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert<string>(123));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertWithStyleTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.VarChar(4), 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertWithStyleTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.Decimal, 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void TryConvertWithStyleTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.NVarChar(10), new DateTime(2022, 02, 22), 105));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("22-02-2022"));

		}



		[Test]

		public void TryConvertWithStyleTest4([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.VarCharMax, 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("123"));

		}



		[Test]

		public void TryConvertWithStyleTest5([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert(SqlType.Decimal(30, 0), 123, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void TryConvertWithStyleTest6([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryConvert<string>(new DateTime(2022, 02, 22), 5));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("22-02-22"));

		}



		[Test]

		public void TryParseTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse("Monday, 13 December 2010", SqlType.Date));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2010, 12, 13)));

		}



		[Test]

		public void TryParseTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse("123", SqlType.Decimal(30)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123m));

		}



		[Test]

		public void TryParseTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse<int>("123"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(123));

		}



		[Test]

		public void TryParseWithCultureTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse("€345,98", SqlType.Money, "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		[Test]

		public void TryParseWithCultureTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse("345,98", SqlType.Decimal(30,2), "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		[Test]

		public void TryParseWithCultureTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TryParse<decimal>("345,98", "de-DE"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(345.98m));

		}



		#endregion



		#region Data type



		[Test]

		public void DataLengthTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DataLength("123"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(6));

		}



		[Test]

		public void DataLengthLTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DataLengthBig("123"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(6));

		}



		[Test]

		public void IdentityCurrentTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.IdentityCurrent("Person"));

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThanOrEqualTo(0m));

		}



		[Test]

		public void IdentityIncrementTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.IdentityIncrement("Person"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1m));

		}



		[Test]

		public void IdentitySeedTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.IdentitySeed("Person"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1m));

		}



		#endregion



		#region Date and Time



		[Test]

		public void DateFirstTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateFirst);

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThan(0));

		}



		[Test]

		public void CurrentTimestampTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.CurrentTimestamp);

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.Today.Year));

		}



		[Test]

		public void CurrentTimezoneTest([IncludeDataSources(TestProvName.AllSqlServer2019Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.CurrentTimezone());

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		[Test]

		public void CurrentTimezoneIDTest([IncludeDataSources(TestProvName.SqlAzure)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.CurrentTimezoneID());

			Console.WriteLine(result);

			Assert.That(result, Is.Not.Null);

		}



		[Test]

		public void DateAddTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateAdd(SqlFn.DateParts.Month, -1, "2022-02-22"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 01, 22)));

		}



		[Test]

		public void DateAddTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateAdd(SqlFn.DateParts.Day, 1, TestData.Date));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(TestData.Date.AddDays(1)));

		}



		[Test]

		public void DateAddTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateAdd(SqlFn.DateParts.Year, 1, TestData.DateTimeOffset));

			Console.WriteLine(result);

			Assert.That(result?.Date, Is.EqualTo(TestData.DateTimeOffset.Date.AddYears(1)));

		}



		[Test]

		public void DateAddTest4([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateAdd(SqlFn.DateParts.Hour, 1, TimeSpan.FromHours(2)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(3, 0, 0)));

		}



		[Test]

		public void DateDiffTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiff(SqlFn.DateParts.Day, "2022-02-22", "2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void DateDiffTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiff(SqlFn.DateParts.Month, TestData.Date, TestData.Date.AddYears(1)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(12));

		}



		[Test]

		public void DateDiffTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiff(SqlFn.DateParts.Month, TestData.DateTimeOffset, TestData.DateTimeOffset.AddYears(1)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(12));

		}



		[Test]

		public void DateDiffTest4([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiff(SqlFn.DateParts.Hour, TimeSpan.FromHours(2), TimeSpan.FromHours(3)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1));

		}



		[Test]

		public void DateDiffBigTest1([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiffBig(SqlFn.DateParts.Day, "2022-02-22", "2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void DateDiffBigTest2([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiffBig(SqlFn.DateParts.Month, TestData.Date, TestData.Date.AddYears(1)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(12));

		}



		[Test]

		public void DateDiffBigTest3([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiffBig(SqlFn.DateParts.Month, TestData.DateTimeOffset, TestData.DateTimeOffset.AddYears(1)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(12));

		}



		[Test]

		public void DateDiffBigTest4([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateDiffBig(SqlFn.DateParts.Hour, TimeSpan.FromHours(2), TimeSpan.FromHours(3)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1));

		}



		[Test]

		public void TimeFromPartsTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TimeFromParts(1, 1, 1, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(1, 1, 1)));

		}



		[Test]

		public void TimeFromPartsTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.TimeFromParts(1, 1, 1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new TimeSpan(1, 1, 1)));

		}



		[Test]

		public void DateFromPartsTest([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateFromParts(2022, 2, 22));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void SmallDateTimeFromPartsTest([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SmallDateTimeFromParts(2022, 2, 22, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTimeFromPartsTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeFromParts(2022, 2, 22, 0, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTimeFromPartsTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeFromParts(2022, 2, 22, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTimeFromPartsTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeFromParts(2022, 2, 22));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTime2FromPartsTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTime2FromParts(2022, 2, 22, 0, 0, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTime2FromPartsTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTime2FromParts(2022, 2, 22, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTime2FromPartsTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTime2FromParts(2022, 2, 22));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTime(2022, 2, 22)));

		}



		[Test]

		public void DateTimeOffsetFromPartsTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeOffsetFromParts(2022, 2, 22, 0, 0, 0, 0, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTimeOffset(new DateTime(2022, 2, 22), TimeSpan.Zero)));

		}



		[Test]

		public void DateTimeOffsetFromPartsTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeOffsetFromParts(2022, 2, 22, 0, 0, 0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTimeOffset(new DateTime(2022, 2, 22), TimeSpan.Zero)));

		}



		[Test]

		public void DateTimeOffsetFromPartsTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateTimeOffsetFromParts(2022, 2, 22));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(new DateTimeOffset(new DateTime(2022, 2, 22), TimeSpan.Zero)));

		}



		[Test]

		public void DateNameTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateName(SqlFn.DateParts.Day, "2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("24"));

		}



		[Test]

		public void DateNameTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateName(SqlFn.DateParts.Month, new DateTime(2022, 03, 22)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("March"));

		}



		[Test]

		public void DateNameTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateName(SqlFn.DateParts.Month, new DateTimeOffset(new DateTime(2022, 03, 22), TimeSpan.Zero)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("March"));

		}



		[Test]

		public void DateNameTest4([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DateName(SqlFn.DateParts.Hour, TimeSpan.FromHours(2)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("2"));

		}



		[Test]

		public void DatePartTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DatePart(SqlFn.DateParts.Day, "2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(24));

		}



		[Test]

		public void DatePartTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DatePart(SqlFn.DateParts.Month, new DateTime(2022, 02, 22)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void DatePartTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DatePart(SqlFn.DateParts.Month, new DateTimeOffset(new DateTime(2022, 02, 22), TimeSpan.Zero)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void DatePartTest4([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.DatePart(SqlFn.DateParts.Hour, TimeSpan.FromHours(2)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void DayTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Day("2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(24));

		}



		[Test]

		public void DayTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Day(new DateTime(2022, 02, 22)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(22));

		}



		[Test]

		public void DayTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Day(new DateTimeOffset(new DateTime(2022, 02, 22), TimeSpan.Zero)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(22));

		}



		[Test]

		public void EndOfMonthTest1([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.EndOfMonth("2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result?.Day, Is.EqualTo(28));

		}



		[Test]

		public void EndOfMonthTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.EndOfMonth("2022-02-24", 1));

			Console.WriteLine(result);

			Assert.That(result?.Day, Is.EqualTo(31));

		}



		[Test]

		public void EndOfMonthTest21([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var date   = "2022-02-24";

			var result = db.Select(() =>  SqlFn.EndOfMonth(date, 1));

			Console.WriteLine(result);

			Assert.That(result?.Day, Is.EqualTo(31));

		}



		[Test]

		public void EndOfMonthTest3([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.EndOfMonth(new DateTime(2022, 02, 22)));

			Console.WriteLine(result);

			Assert.That(result?.Day, Is.EqualTo(28));

		}



		[Test]

		public void EndOfMonthTest4([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.EndOfMonth(new DateTime(2022, 02, 22), 1));

			Console.WriteLine(result);

			Assert.That(result?.Day, Is.EqualTo(31));

		}



		[Test]

		public void GetDateTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.GetDate());

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.Today.Year));

		}



		[Test]

		public void GetUtcDateTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.GetUtcDate());

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.UtcNow.Year));

		}



		[Test]

		public void SysDatetimeTest([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SysDatetime());

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.Now.Year));

		}



		[Test]

		public void SysDatetimeOffsetTest([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SysDatetimeOffset());

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.Now.Year));

		}



		[Test]

		public void SysUtcDatetimeTest([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SysUtcDatetime());

			Console.WriteLine(result);

			Assert.That(result.Year, Is.EqualTo(DateTime.Now.Year));

		}



		[Test]

		public void IsDateTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.IsDate("2022-02-22"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(1));

		}



		[Test]

		public void MonthTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);



			var date   = "2022-02-24";

			var result = db.Select(() => SqlFn.Month(date));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void MonthTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Month(new DateTime(2022, 02, 22)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void MonthTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Month(new DateTimeOffset(new DateTime(2022, 02, 22), TimeSpan.Zero)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2));

		}



		[Test]

		public void SwitchOffsetTest([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.SwitchOffset(new DateTimeOffset(new DateTime(2022, 02, 22), TimeSpan.Zero), "-04:00"));

			Console.WriteLine(result);

			Assert.That(result?.Year, Is.EqualTo(2022));

		}



		[Test]

		public void ToDatetimeOffsetTest([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.ToDatetimeOffset(new DateTime(2022, 02, 22), "-04:00"));

			Console.WriteLine(result);

			Assert.That(result?.Year, Is.EqualTo(2022));

		}



		[Test]

		public void YearTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Year("2022-02-24"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2022));

		}



		[Test]

		public void YearTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db     = new SystemDB(context);

			var       result = db.Select(() => SqlFn.Year(new DateTime(2022, 02, 22)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2022));

		}



		[Test]

		public void YearTest3([IncludeDataSources(TestProvName.AllSqlServer2008Plus)] string context)

		{

			using var db     = new SystemDB(context);

			var       result = db.Select(() => SqlFn.Year(new DateTimeOffset(new DateTime(2022, 02, 22), TimeSpan.Zero)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(2022));

		}



		#endregion



		#region Json



		[Test]

		public void IsJson([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.IsJson("{ \"test\" : 1 }"));

			Console.WriteLine(result);

			Assert.That(result, Is.True);

		}



		[Test]

		public void JsonValue([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.JsonValue("{ \"test\" : 1 }", "$.test"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("1"));

		}



		[Test]

		public void JsonQuery([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.JsonQuery("{ \"test\" : 1 }", "$"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("{ \"test\" : 1 }"));

		}



		[Test]

		public void JsonModify([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.JsonModify("{ \"test\" : 1 }", "$.test", "2"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("{ \"test\" : \"2\" }"));

		}



		[Test]

		public void OpenJson1([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.GetTable<SqlFn.JsonData>(null, LinqToDB.Linq.MethodHelper.GetMethodInfo(SqlFn.OpenJson, string.Empty), "{ \"test\" : 1 }").ToArray();

			Console.WriteLine(result);



			var expected = new[]

			{

				new SqlFn.JsonData { Key = "test", Value = "1", Type = 2, },

			};



			AreEqual(expected, result);

		}



		[Test]

		public void OpenJson2([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.GetTable<SqlFn.JsonData>(null, LinqToDB.Linq.MethodHelper.GetMethodInfo(SqlFn.OpenJson, string.Empty, string.Empty), "{ \"test\" : [ 10, 20 ] }", "$.test").ToArray();

			Console.WriteLine(result);



			var expected = new[]

			{

				new SqlFn.JsonData { Key = "0", Value = "10", Type = 2, },

				new SqlFn.JsonData { Key = "1", Value = "20", Type = 2, },

			};



			AreEqual(expected, result);

		}



		[Test]

		public void OpenJson3([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.GetTable<SqlFn.JsonData>(null, LinqToDB.Linq.MethodHelper.GetMethodInfo(SqlFn.OpenJson, string.Empty), "[ 10, 20, 30, 40, 50, 60, 70 ]")

				.Where(jd => jd.Key != "2")

				.Where(jd => jd.Value != "60")

				.Select(jd => jd.Value)

				.ToArray();

			Console.WriteLine(result);



			var expected = new[] { "10", "20", "40", "50", "70" };



			AreEqual(expected, result);

		}



#if !NET45

		[Test]

		public void OpenJson4([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.OpenJson("{ \"test\" : 1 }").ToArray();

			Console.WriteLine(result);



			var expected = new[]

			{

				new SqlFn.JsonData { Key = "test", Value = "1", Type = 2, },

			};



			AreEqual(expected, result);

		}



		// SQL Server 2016 doesn't support @var for path

		[Test]

		public void OpenJson5([IncludeDataSources(TestProvName.AllSqlServer2017Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.OpenJson("{ \"test\" : [ 10, 20 ] }", "$.test").ToArray();

			Console.WriteLine(result);



			var expected = new[]

			{

				new SqlFn.JsonData { Key = "0", Value = "10", Type = 2, },

				new SqlFn.JsonData { Key = "1", Value = "20", Type = 2, },

			};



			AreEqual(expected, result);

		}



		[Test]

		public void OpenJson6([IncludeDataSources(TestProvName.AllSqlServer2016Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.OpenJson("[ 10, 20, 30, 40, 50, 60, 70 ]")

				.Where(jd => jd.Key != "2")

				.Where(jd => jd.Value != "60")

				.Select(jd => jd.Value)

				.ToArray();

			Console.WriteLine(result);



			var expected = new[] { "10", "20", "40", "50", "70" };



			AreEqual(expected, result);

		}

#endif

		#endregion



		#region Mathematical



		[Test]

		public void AbsTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Abs("-10"));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo("10"));

		}



		[Test]

		public void AbsTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Abs(-10.01m));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(10.01m));

		}



		[Test]

		public void AcosTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Acos(0.5));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Acos(0.5)));

		}



		[Test]

		public void AsinTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Asin(0.5));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Asin(0.5)));

		}



		[Test]

		public void AtanTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Atan(0.5));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Atan(0.5)));

		}



		[Test]

		public void Atn2Test([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Atn2(10, 100));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(0));

		}



		[Test]

		public void CeilingTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Ceiling(123.45));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(124));

		}



		[Test]

		public void CosTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Cos(0));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Cos(0)));

		}



		[Test]

		public void CotTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Cot(1));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(0));

		}



		[Test]

		public void DegreesTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Degrees(1.5));

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThan(0));

		}



		[Test]

		public void ExpTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Exp(10));

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThan(0));

		}



		[Test]

		public void FloorTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Floor(10.11));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(10));

		}



		[Test]

		public void LogTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Log(SqlFn.Exp(10)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(10));

		}



		[Test]

		public void LogTest2([IncludeDataSources(TestProvName.AllSqlServer2012Plus)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Log(10.0, 2));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Log(10, 2)));

		}



		[Test]

		public void Log10Test([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Log10(SqlFn.Exp(10)));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(10));

		}



		[Test]

		public void PITest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.PI());

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.PI));

		}



		[Test]

		public void PowerTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Power(2m, 2));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(Math.Pow(2, 2)));

		}



		[Test]

		public void RadiansTest([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Round(SqlFn.Radians(-45.01m), 4));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(-0.7856m));

		}



		[Test]

		public void RandTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Random());

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThanOrEqualTo(0).And.LessThanOrEqualTo(1));

		}



		[Test]

		public void RandTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Random(10));

			Console.WriteLine(result);

			Assert.That(result, Is.GreaterThanOrEqualTo(0).And.LessThanOrEqualTo(1));

		}



		[Test]

		public void RoundTest1([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlFn.Round(12345, -3));

			Console.WriteLine(result);

			Assert.That(result, Is.EqualTo(12000));

		}



		[Test]

		public void RoundTest2([IncludeDataSources(TestProvName.AllSqlServer)] string context)

		{

			using var db = new SystemDB(context);

			var result = db.Select(() => SqlF