[API-274] SQL for Map ([API-617], [API-616], [API-431], [API-619], [API-620], [API-432], [API-659], [API-660], [API-661])

Hazelcast.Net.sln.DotSettings

@@ -1,4 +1,5 @@
 <wpf:ResourceDictionary xml:space="preserve" xmlns:x="http://schemas.microsoft.com/winfx/2006/xaml" xmlns:s="clr-namespace:System;assembly=mscorlib" xmlns:ss="urn:shemas-jetbrains-com:settings-storage-xaml" xmlns:wpf="http://schemas.microsoft.com/winfx/2006/xaml/presentation">
+	<s:String x:Key="/Default/CodeStyle/Naming/CSharpNaming/Abbreviations/=CN/@EntryIndexedValue">CN</s:String>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=438E8320080FDC46904A18FD18FF4DCD/@KeyIndexDefined">True</s:Boolean>
 	<s:String x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=438E8320080FDC46904A18FD18FF4DCD/Color/@EntryValue">207, 157, 50</s:String>
 	<s:Boolean x:Key="/Default/PatternsAndTemplates/Todo/TodoPatterns/=438E8320080FDC46904A18FD18FF4DCD/MatchComments/@EntryValue">True</s:Boolean>
@@ -13,6 +14,7 @@
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=endianness/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=expirations/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=multicast/@EntryIndexedValue">True</s:Boolean>
+	<s:Boolean x:Key="/Default/UserDictionary/Words/=nano/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=partitioner/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=retryable/@EntryIndexedValue">True</s:Boolean>
 	<s:Boolean x:Key="/Default/UserDictionary/Words/=hzconsole/@EntryIndexedValue">True</s:Boolean>

src/Hazelcast.Net.Tests/Core/ByteExtensionsTests.cs

@@ -417,6 +417,21 @@ public void ReadGuid()
             Assert.That(bytes.ReadGuidL(2), Is.EqualTo(Guid.Empty));
         }
 
+        [Test]
+        [TestCase(new byte[]{0, 0xE5, 0x07, 0x07, 0x1E}, 1, "2021-07-30")]
+        public void ReadLocalDate(byte[] bytes, int position, string expected)
+        {
+            Assert.AreEqual(expected, bytes.ReadLocalDate(position));
+        }
+
+        [Test]
+        [TestCase(new byte[]{0, 0x0C, 0x11, 0x10, 0x00, 0x00, 0x00, 0x00}, 1, "12:17:16")]
+        [TestCase(new byte[]{0, 0x15, 0x3B, 0x38, 0x4E, 0x61, 0xBC, 0x00}, 1, "21:59:56.012345678")]
+        public void ReadLocalTime(byte[] bytes, int position, string expected)
+        {
+            Assert.AreEqual(expected, bytes.ReadLocalTime(position));
+        }
+
         [Test]
         public void ValidateUtf8()
         {
@@ -431,7 +446,6 @@ public void ValidateUtf8()
             Assert.That(Encoding.UTF8.GetString(encodingBytes), Is.EqualTo(s));
         }
 
-
         [Test]
         public void FillSpan()
         {

src/Hazelcast.Net.Tests/Sql/SqlResultTests.cs

@@ -0,0 +1,42 @@
+using System;
+using System.Threading.Tasks;
+using Hazelcast.Sql;
+using NUnit.Framework;
+
+namespace Hazelcast.Tests.Sql
+{
+    [TestFixture]
+    public class SqlResultTests: SqlTestBase
+    {
+        [Test]
+        public async Task EnumerateThrowsAfterClose()
+        {
+            var sqlService = await Client.GetSqlServiceAsync();
+
+            var result = await sqlService.ExecuteAsync($"SELECT * FROM {MapName}");
+            await result.DisposeAsync();
+
+            Assert.Throws<ObjectDisposedException>(() => result.EnumerateOnce());
+        }
+
+        [Test]
+        [TestCase(1)]
+        [TestCase(2)]
+        [TestCase(.5)]
+        [TestCase(.33)]
+        public async Task Enumerate(double pageSizeRatio)
+        {
+            var sqlService = await Client.GetSqlServiceAsync();
+
+            var result = await sqlService.ExecuteAsync($"SELECT * FROM {MapName}",
+                options: new SqlStatementOptions { CursorBufferSize = (int)(MapValues.Count * pageSizeRatio) }
+            );
+
+            Assert.DoesNotThrowAsync(async () =>
+            {
+                await foreach (var row in result.EnumerateOnceAsync())
+                    GC.KeepAlive(row);
+            });
+        }
+    }
+}

src/Hazelcast.Net.Tests/Sql/SqlServiceTests.cs

@@ -0,0 +1,68 @@
+using System.Linq;
+using System.Threading.Tasks;
+using NUnit.Framework;
+
+namespace Hazelcast.Tests.Sql
+{
+    [TestFixture]
+    public class SqlServiceTests: SqlTestBase
+    {
+        [Test]
+        public async Task Execute()
+        {
+            var sql = await Client.GetSqlServiceAsync();
+            var result = await sql.ExecuteAsync($"SELECT * FROM {MapName}");
+
+            var expectedValues = MapValues;
+            var resultValues = result.EnumerateOnce().ToDictionary(r => r.GetKey<string>(), r => r.GetValue<int>());
+
+            CollectionAssert.AreEquivalent(expectedValues, resultValues);
+        }
+
+        [Test]
+        [TestCase(0)]
+        [TestCase(1)]
+        [TestCase(5)]
+        [TestCase(100)]
+        public async Task ExecuteWithIntParameter(int minValue)
+        {
+            var sql = await Client.GetSqlServiceAsync();
+            var result = await sql.ExecuteAsync($"SELECT * FROM {MapName} WHERE this >= ?", new object[] { minValue });
+
+            var expectedValues = MapValues.Where(p => p.Value >= minValue);
+            var resultValues = result.EnumerateOnce().ToDictionary(r => r.GetKey<string>(), r => r.GetValue<int>());
+
+            CollectionAssert.AreEquivalent(expectedValues, resultValues);
+        }
+
+        [Test]
+        [TestCase("0")]
+        [TestCase("1")]
+        [TestCase("5")]
+        [TestCase("100")]
+        public async Task ExecuteWithStringParameter(string key)
+        {
+            var sql = await Client.GetSqlServiceAsync();
+            var result = await sql.ExecuteAsync($"SELECT * FROM {MapName} WHERE __key == ?", new object[] { key });
+
+            var expectedValues = MapValues.Where(p => p.Key == key);
+            var resultValues = result.EnumerateOnce().ToDictionary(r => r.GetKey<string>(), r => r.GetValue<int>());
+
+            CollectionAssert.AreEquivalent(expectedValues, resultValues);
+        }
+
+        [OneTimeSetUp]
+        public async Task InitAll()
+        {
+            var map = await Client.GetMapAsync<string, int>(MapName);
+            await map.SetAllAsync(MapValues);
+        }
+
+        [OneTimeTearDown]
+        public async Task DisposeAll()
+        {
+            var map = await Client.GetMapAsync<string, int>(MapName);
+            await map.ClearAsync();
+        }
+    }
+}

src/Hazelcast.Net.Tests/Sql/SqlTestBase.cs

@@ -0,0 +1,30 @@
+using System.Collections.Generic;
+using System.Linq;
+using System.Threading.Tasks;
+using Hazelcast.Testing;
+using NUnit.Framework;
+
+namespace Hazelcast.Tests.Sql
+{
+    public class SqlTestBase : SingleMemberClientRemoteTestBase
+    {
+        protected const string MapName = "MyMap";
+
+        protected readonly Dictionary<string, int> MapValues = Enumerable.Range(1, 5)
+            .ToDictionary(i => $"{i}", i => i);
+
+        [OneTimeSetUp]
+        private async Task InitAll()
+        {
+            var map = await Client.GetMapAsync<string, int>(MapName);
+            await map.SetAllAsync(MapValues);
+        }
+
+        [OneTimeTearDown]
+        private async Task DisposeAll()
+        {
+            var map = await Client.GetMapAsync<string, int>(MapName);
+            await map.ClearAsync();
+        }
+    }
+}

src/Hazelcast.Net/Core/BytesExtensions.Protocol.cs

@@ -40,12 +40,21 @@ public static void WriteGuidL(this byte[] bytes, int position, Guid value)
         public static void WriteByteL(this byte[] bytes, int position, byte value)
             => bytes.WriteByte(position, value);
 
+        public static short ReadShortL(this byte[] bytes, int position)
+            => bytes.ReadShort(position, Endianness.LittleEndian);
+
         public static long ReadLongL(this byte[] bytes, int position)
             => bytes.ReadLong(position, Endianness.LittleEndian);
 
         public static int ReadIntL(this byte[] bytes, int position)
             => bytes.ReadInt(position, Endianness.LittleEndian);
 
+        public static float ReadFloatL(this byte[] bytes, int position)
+            => bytes.ReadFloat(position, Endianness.LittleEndian);
+
+        public static double ReadDoubleL(this byte[] bytes, int position)
+            => bytes.ReadDouble(position, Endianness.LittleEndian);
+
         public static bool ReadBoolL(this byte[] bytes, int position)
             => bytes.ReadBool(position);
 

src/Hazelcast.Net/Core/BytesExtensions.ReadFromByteArray.cs

@@ -129,7 +129,48 @@ public static long ReadLong(this byte[] bytes, int position, Endianness endianne
             }
         }
 
+        public static string ReadLocalDate(this byte[] bytes, int position)
+        {
+            var year = bytes.ReadShortL(position);
+            var month = bytes.ReadByte(position + SizeOfShort);
+            var date = bytes.ReadByte(position + SizeOfShort + SizeOfByte);
+
+            return $"{year:D4}-{month:D2}-{date:D2}";
+        }
 
+        public static string ReadLocalTime(this byte[] bytes, int position)
+        {
+            var hour = bytes.ReadByte(position);
+            var minute = bytes.ReadByte(position + SizeOfByte);
+            var second = bytes.ReadByte(position + SizeOfByte * 2);
+            var nano = bytes.ReadIntL(position + SizeOfByte * 3);
+
+            return nano == 0
+                ? $"{hour:D2}:{minute:D2}:{second:D2}"
+                : $"{hour:D2}:{minute:D2}:{second:D2}.{nano:D9}";
+        }
+
+        public static string ReadLocalDateTime(this byte[] bytes, int position)
+        {
+            var date = ReadLocalDate(bytes, position);
+            var time = ReadLocalTime(bytes, position + SizeOfLocalDate);
+            return $"{date}T{time}";
+        }
+
+        public static string ReadOffsetDateTime(this byte[] bytes, int position)
+        {
+            var localDateTime = ReadLocalDate(bytes, position);
+            var offsetSeconds = ReadIntL(bytes, position + SizeOfLocalDateTime);
+
+            var offsetMinutes = Math.Abs(offsetSeconds / 60);
+            if (offsetMinutes == 0)
+                return localDateTime + 'Z';
+
+            var offsetModifier = offsetSeconds < 0 ? '-' : '+';
+            var offsetHours = offsetMinutes / 60;
+            offsetMinutes %= 60;
+            return $"{localDateTime}{offsetModifier}{offsetHours}:{offsetMinutes}";
+        }
 
         /// <summary>
         /// Reads a <see cref="float"/> value from an array of bytes.

src/Hazelcast.Net/Core/BytesExtensions.cs

@@ -99,6 +99,26 @@ internal static partial class BytesExtensions
         /// </summary>
         public const int SizeOfGuid = (1 + 16) * SizeOfByte;
 
+        /// <summary>
+        /// Gets the size of a Java LocalDate value in arrays or sequences of bytes.
+        /// </summary>
+        public const int SizeOfLocalDate = SizeOfShort + SizeOfByte * 2;
+
+        /// <summary>
+        /// Gets the size of a Java LocalTime value in arrays or sequences of bytes.
+        /// </summary>
+        public const int SizeOfLocalTime = SizeOfInt + SizeOfByte * 3;
+
+        /// <summary>
+        /// Gets the size of a Java LocalDateTime value in arrays or sequences of bytes.
+        /// </summary>
+        public const int SizeOfLocalDateTime = SizeOfLocalDate + SizeOfLocalTime;
+
+        /// <summary>
+        /// Gets the size of a Java OffsetDateTime value in arrays or sequences of bytes.
+        /// </summary>
+        public const int SizeOfOffsetDateTime = SizeOfLocalDateTime + SizeOfInt;
+
         /// <summary>
         /// Copies a sequence of <typeparamref name="T"/> to a span of <typeparamref name="T"/>.
         /// </summary>

src/Hazelcast.Net/Core/CollectionExtensions.cs

@@ -14,6 +14,8 @@
 
 using System;
 using System.Collections.Generic;
+using System.Collections.ObjectModel;
+using Hazelcast.Serialization.Collections;
 
 namespace Hazelcast.Core
 {
@@ -33,5 +35,34 @@ internal static class CollectionExtensions
             if (source == null) throw new ArgumentNullException(nameof(source));
             return source.Remove(new KeyValuePair<TKey, TValue>(key, value));
         }
+
+        /// <summary>
+        /// Creates a new array and copies all data from <paramref name="array"/> starting from <paramref name="startIncl"/> and up to <paramref name="endExcl"/> indices.
+        /// </summary>
+        /// <remarks>
+        /// Similar to Array.prototype.slice method in JavaScript.
+        /// </remarks>
+        public static T[] Slice<T>(this T[] array, long startIncl, long endExcl)
+        {
+            var res = new T[endExcl - startIncl];
+            Array.Copy(
+                sourceArray: array, sourceIndex: startIncl,
+                destinationArray: res, destinationIndex: 0, length: res.Length
+            );
+
+            return res;
+        }
+
+        /// <summary>
+        /// Returns read-only wrapper for <paramref name="list"/>
+        /// or <paramref name="list"/> itself if it already implements <see cref="IReadOnlyList{T}"/>.
+        /// </summary>
+        public static IReadOnlyList<T> AsReadOnly<T>(this IList<T> list) => list as IReadOnlyList<T> ?? new ReadOnlyCollection<T>(list);
+
+        /// <summary>
+        /// Returns read-only wrapper for <paramref name="list"/> where each element is returned as <see cref="object"/> with boxing performed if needed
+        /// or <paramref name="list"/> itself if it already implements <see cref="IReadOnlyList{T}"/> (T is <see cref="object"/>).
+        /// </summary>
+        public static IReadOnlyList<object> AsReadOnlyObjectList<T>(this IList<T> list) => list as IReadOnlyList<object> ?? new ReadOnlyObjectList<T>(list);
     }
 }

src/Hazelcast.Net/Core/EnumerableExtensions.cs

@@ -117,5 +117,16 @@ public static IEnumerable<(T1, T2, T3, T4)> Combine<T1, T2, T3, T4>(this (IEnume
         /// <returns>A <see cref="Dictionary{TKey,TValue}"/> that contains values provided by <paramref name="source"/>.</returns>
         public static IDictionary<TKey, TValue> ToDictionary<TKey, TValue>(this IEnumerable<(TKey Key, TValue Value)> source)
             => source.ToDictionary(x => x.Key, x => x.Value);
+
+        /// <summary>
+        /// Enumerates <paramref name="source"/> to a new <see cref="List{T}"/> starting from <paramref name="initialCapacity"/> size.
+        /// This allows to avoid or minimize list resizing if number of elements if known fully or approximately.
+        /// </summary>
+        public static List<T> ToList<T>(this IEnumerable<T> source, int initialCapacity)
+        {
+            var list = new List<T>(initialCapacity);
+            list.AddRange(source);
+            return list;
+        }
     }
 }

src/Hazelcast.Net/HazelcastClient.Objects.cs

@@ -12,13 +12,15 @@
 // See the License for the specific language governing permissions and
 // limitations under the License.
 
+using System;
 using System.Threading.Tasks;
 using Hazelcast.Clustering;
 using Hazelcast.Core;
 using Hazelcast.CP;
 using Hazelcast.DistributedObjects;
 using Hazelcast.DistributedObjects.Impl;
 using Hazelcast.Serialization;
+using Hazelcast.Sql;
 using Microsoft.Extensions.Logging;
 
 namespace Hazelcast
@@ -28,6 +30,9 @@ internal partial class HazelcastClient // Distributed Objects
         private readonly ISequence<long> _lockReferenceIdSequence = new Int64Sequence();
         private ICPSubsystem _cpSubsystem;
 
+        // FIXME [Oleksii] discuss if lazy is needed
+        private readonly Lazy<ISqlService> _sqlServiceLazy;
+
         /// <summary>
         /// Gets the CP subsystem.
         /// </summary>
@@ -189,5 +194,11 @@ Task<IHRingBuffer<T>> GetRingBufferAsync<T>(string name)
             return await task.CfAwait();
 #endif
         }
+
+        /// <inheritdoc />
+        public Task<ISqlService> GetSqlServiceAsync()
+        {
+            return Task.FromResult(_sqlServiceLazy.Value);
+        }
     }
 }