ignite-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From sboi...@apache.org
Subject [35/50] [abbrv] ignite git commit: IGNITE-1630: .NET: Added LINQ support. This closes #482.
Date Sun, 03 Apr 2016 19:42:59 GMT
IGNITE-1630: .NET: Added LINQ support. This closes #482.


Project: http://git-wip-us.apache.org/repos/asf/ignite/repo
Commit: http://git-wip-us.apache.org/repos/asf/ignite/commit/ef642e91
Tree: http://git-wip-us.apache.org/repos/asf/ignite/tree/ef642e91
Diff: http://git-wip-us.apache.org/repos/asf/ignite/diff/ef642e91

Branch: refs/heads/ignite-2407
Commit: ef642e9180e4792bc7b22d57f7f88ec7d5805a84
Parents: 75f720f
Author: Pavel Tupitsyn <ptupitsyn@gridgain.com>
Authored: Thu Mar 31 13:35:24 2016 +0300
Committer: vozerov-gridgain <vozerov@gridgain.com>
Committed: Thu Mar 31 13:35:24 2016 +0300

----------------------------------------------------------------------
 .../Apache.Ignite.Core.Tests.NuGet.csproj       |   25 +-
 .../Apache.Ignite.Core.Tests.NuGet/CacheTest.cs |   37 +-
 .../Apache.Ignite.Core.Tests.NuGet/NuGet.config |    5 +-
 .../install-package.cmd                         |   10 -
 .../install-package.ps1                         |   25 +
 .../packages.config                             |   24 +
 .../Apache.Ignite.Core.Tests.csproj             |    5 +
 .../Cache/Query/CacheLinqTest.cs                | 1278 ++++++++++++++++++
 .../Apache.Ignite.Core.Tests/TestRunner.cs      |    2 +-
 .../Apache.Ignite.Core.csproj                   |    2 +
 .../Cache/Configuration/QueryEntity.cs          |    4 +-
 .../Cache/Configuration/QueryField.cs           |    2 +-
 .../dotnet/Apache.Ignite.Core/Ignition.cs       |    2 +-
 .../Impl/Binary/BinaryReflectiveActions.cs      |   37 +
 .../Apache.Ignite.Core/Impl/Binary/JavaTypes.cs |   29 +-
 .../Apache.Ignite.Core/Impl/Cache/CacheEntry.cs |    2 +-
 .../Apache.Ignite.Core/Impl/Cache/CacheImpl.cs  |   37 +-
 .../Impl/Cache/ICacheInternal.cs                |   40 +
 .../Impl/Cache/Query/FieldsQueryCursor.cs       |   26 +-
 .../Impl/Common/DelegateConverter.cs            |  127 +-
 .../Apache.Ignite.Core/Impl/Common/Logger.cs    |   37 +
 .../Impl/Common/TypeCaster.cs                   |   12 +
 .../Apache.Ignite.Core/Impl/IgniteManager.cs    |    2 +-
 .../Apache.Ignite.Linq.csproj                   |   93 ++
 .../Apache.Ignite.Linq.nuspec                   |   63 +
 .../Apache.Ignite.Linq/Apache.Ignite.Linq.snk   |  Bin 0 -> 596 bytes
 .../Apache.Ignite.Linq/CacheExtensions.cs       |   98 ++
 .../dotnet/Apache.Ignite.Linq/CompiledQuery.cs  |  206 +++
 .../Apache.Ignite.Linq/ICacheQueryable.cs       |   53 +
 .../Apache.Ignite.Linq/Impl/AliasDictionary.cs  |  102 ++
 .../Impl/CacheFieldsQueryExecutor.cs            |  225 +++
 .../Impl/CacheFieldsQueryProvider.cs            |  239 ++++
 .../Impl/CacheFieldsQueryable.cs                |   40 +
 .../Impl/CacheQueryExpressionVisitor.cs         |  506 +++++++
 .../Impl/CacheQueryModelVisitor.cs              |  508 +++++++
 .../Apache.Ignite.Linq/Impl/CacheQueryParser.cs |   56 +
 .../Apache.Ignite.Linq/Impl/CacheQueryable.cs   |   43 +
 .../Impl/CacheQueryableBase.cs                  |  122 ++
 .../Apache.Ignite.Linq/Impl/ExpressionWalker.cs |  172 +++
 .../Apache.Ignite.Linq/Impl/ICacheQueryProxy.cs |   40 +
 .../Impl/ICacheQueryableInternal.cs             |   54 +
 .../Apache.Ignite.Linq/Impl/MethodVisitor.cs    |  249 ++++
 .../dotnet/Apache.Ignite.Linq/Impl/QueryData.cs |   92 ++
 .../dotnet/Apache.Ignite.Linq/Impl/SqlTypes.cs  |   63 +
 .../NuGet/LINQPad/QueryExample.linq             |  111 ++
 .../Properties/AssemblyInfo.cs                  |   40 +
 .../dotnet/Apache.Ignite.Linq/packages.config   |   22 +
 modules/platforms/dotnet/Apache.Ignite.sln      |   16 +-
 .../Apache.Ignite.Examples.csproj               |    5 +
 .../Datagrid/LinqExample.cs                     |  253 ++++
 50 files changed, 5188 insertions(+), 53 deletions(-)
----------------------------------------------------------------------


http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/Apache.Ignite.Core.Tests.NuGet.csproj
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/Apache.Ignite.Core.Tests.NuGet.csproj b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/Apache.Ignite.Core.Tests.NuGet.csproj
index 4283de4..3ff1a37 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/Apache.Ignite.Core.Tests.NuGet.csproj
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/Apache.Ignite.Core.Tests.NuGet.csproj
@@ -54,7 +54,13 @@
   <ItemGroup>
     <Reference Include="Apache.Ignite.Core">
       <SpecificVersion>False</SpecificVersion>
-      <HintPath>pkg\lib\net40\Apache.Ignite.Core.dll</HintPath>
+      <HintPath>packages\Apache.Ignite.1.6.0\lib\net40\Apache.Ignite.Core.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
+    <Reference Include="Apache.Ignite.Linq">
+      <SpecificVersion>False</SpecificVersion>
+      <HintPath>packages\Apache.Ignite.Linq.1.6.0\lib\net40\Apache.Ignite.Linq.dll</HintPath>
+      <Private>True</Private>
     </Reference>
     <Reference Include="nunit-console-runner">
       <HintPath>..\libs\nunit-console-runner.dll</HintPath>
@@ -63,6 +69,10 @@
       <SpecificVersion>False</SpecificVersion>
       <HintPath>..\libs\nunit.framework.dll</HintPath>
     </Reference>
+    <Reference Include="Remotion.Linq, Version=2.0.0.0, Culture=neutral, PublicKeyToken=fee00910d6e5f53b, processorArchitecture=MSIL">
+      <HintPath>packages\Remotion.Linq.2.0.1\lib\net40\Remotion.Linq.dll</HintPath>
+      <Private>True</Private>
+    </Reference>
     <Reference Include="System" />
     <Reference Include="System.Core" />
   </ItemGroup>
@@ -81,17 +91,20 @@
   </ItemGroup>
   <ItemGroup>
     <None Include="Apache.Ignite.Core.Tests.NuGet.sln.DotSettings" />
-    <None Include="install-package.cmd" />
+    <None Include="install-package.ps1" />
     <None Include="NuGet.config" />
+    <None Include="packages.config">
+      <SubType>Designer</SubType>
+    </None>
   </ItemGroup>
   <Import Project="$(MSBuildToolsPath)\Microsoft.CSharp.targets" />
   <PropertyGroup>
-    <PostBuildEvent>if not exist $(TargetDir)Libs md $(TargetDir)Libs
-xcopy /s /y  $(ProjectDir)pkg\Libs $(TargetDir)Libs</PostBuildEvent>
+    <PostBuildEvent>if not exist "$(TargetDir)Libs" md "$(TargetDir)Libs"
+xcopy /s /y "$(SolutionDir)packages\Apache.Ignite.1.6.0\Libs\*.*" "$(TargetDir)Libs"</PostBuildEvent>
   </PropertyGroup>
   <PropertyGroup>
-    <PreBuildEvent>cd $(ProjectDir)
-if not exist pkg install-package.cmd</PreBuildEvent>
+    <PreBuildEvent>
+    </PreBuildEvent>
   </PropertyGroup>
   <!-- To modify your build process, add your task inside one of the targets below and uncomment it. 
        Other similar extension points exist, see Microsoft.Common.targets.

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/CacheTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/CacheTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/CacheTest.cs
index ba0487b..6606d1e 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/CacheTest.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/CacheTest.cs
@@ -20,8 +20,10 @@ namespace Apache.Ignite.Core.Tests.NuGet
 {
     using System.Linq;
     using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache;
     using Apache.Ignite.Core.Cache.Configuration;
     using Apache.Ignite.Core.Cache.Query;
+    using Apache.Ignite.Linq;
     using NUnit.Framework;
 
     /// <summary>
@@ -74,11 +76,7 @@ namespace Apache.Ignite.Core.Tests.NuGet
         [Test]
         public void TestSql()
         {
-            var ignite = Ignition.GetIgnite();
-
-            var cache = ignite.GetOrCreateCache<int, Person>(new CacheConfiguration("sqlCache", typeof (Person)));
-
-            cache.PutAll(Enumerable.Range(1, 100).ToDictionary(x => x, x => new Person {Name = "Name" + x, Age = x}));
+            var cache = GetPersonCache();
 
             var sqlRes = cache.Query(new SqlQuery(typeof (Person), "age < ?", 30)).GetAll();
 
@@ -87,6 +85,35 @@ namespace Apache.Ignite.Core.Tests.NuGet
         }
 
         /// <summary>
+        /// Tests the LINQ.
+        /// </summary>
+        [Test]
+        public void TestLinq()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            var res = cache.Where(x => x.Value.Age < 30).ToList();
+
+            Assert.AreEqual(29, res.Count);
+            Assert.IsTrue(res.All(x => x.Value.Age < 30));
+        }
+
+        /// <summary>
+        /// Gets the person cache.
+        /// </summary>
+        /// <returns></returns>
+        private static ICache<int, Person> GetPersonCache()
+        {
+            var ignite = Ignition.GetIgnite();
+
+            var cache = ignite.GetOrCreateCache<int, Person>(new CacheConfiguration("sqlCache", typeof(Person)));
+
+            cache.PutAll(Enumerable.Range(1, 100).ToDictionary(x => x, x => new Person { Name = "Name" + x, Age = x }));
+
+            return cache;
+        }
+
+        /// <summary>
         /// Query class.
         /// </summary>
         private class Person

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/NuGet.config
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/NuGet.config b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/NuGet.config
index 5099ff0..fc0c0b5 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/NuGet.config
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/NuGet.config
@@ -25,10 +25,11 @@
     <add key="automatic" value="True" />
   </packageRestore>
   <packageSources>
-    <add key="ParentFolder" value="..\" />
+	<add key="nuget.org" value="https://www.nuget.org/api/v2/" />
+    <add key="local" value="nupkg" />
   </packageSources>
   <!-- Used to specify which one of the sources are active -->
   <activePackageSource>
-    <add key="ParentFolder" value="..\" />
+    <add key="All" value="(Aggregate source)" />
   </activePackageSource>
 </configuration>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.cmd
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.cmd b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.cmd
deleted file mode 100644
index 5af7607..0000000
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.cmd
+++ /dev/null
@@ -1,10 +0,0 @@
-rem Install NuGet package to a 'pkg' folder no matter what version it is
-
-rmdir pkg /S /Q
-rmdir tmp1 /S /Q
-mkdir tmp1
-cd tmp1
-nuget install Apache.Ignite
-cd ..
-move tmp1\Apache.Ignite.* pkg
-rmdir tmp1 /S /Q
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.ps1
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.ps1 b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.ps1
new file mode 100644
index 0000000..01c0be4
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/install-package.ps1
@@ -0,0 +1,25 @@
+$ng = (Get-Item .).FullName + '\nuget.exe'
+
+if (!(Test-Path $ng)) {
+    $ng = 'nuget'
+}
+
+rmdir nupkg -Force -Recurse
+rmdir pkg -Force -Recurse
+
+mkdir nupkg
+mkdir pkg
+
+& $ng pack ..\Apache.Ignite.Core\Apache.Ignite.Core.csproj -Prop Configuration=Release -OutputDirectory nupkg
+& $ng pack ..\Apache.Ignite.Linq\Apache.Ignite.Linq.csproj -Prop Configuration=Release -OutputDirectory nupkg
+
+$ver = (Get-ChildItem nupkg\Apache.Ignite.Linq*)[0].Name -replace '\D+([\d.]+)\.\D+','$1'
+
+# Replace versions in project files
+(Get-Content packages.config) `
+    -replace 'id="Apache.Ignite(.*?)" version=".*?"', ('id="Apache.Ignite$1" version="' + $ver + '"') `
+    | Out-File packages.config -Encoding utf8
+
+(Get-Content Apache.Ignite.Core.Tests.NuGet.csproj) `
+    -replace '<HintPath>packages\\Apache.Ignite(.*?)\.[\d.]+\\', ('<HintPath>packages\Apache.Ignite$1.' + "$ver\") `
+    | Out-File Apache.Ignite.Core.Tests.NuGet.csproj  -Encoding utf8
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/packages.config
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/packages.config b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/packages.config
new file mode 100644
index 0000000..de80824
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests.NuGet/packages.config
@@ -0,0 +1,24 @@
+<?xml version="1.0" encoding="utf-8"?>
+
+<!--
+  Licensed to the Apache Software Foundation (ASF) under one or more
+  contributor license agreements.  See the NOTICE file distributed with
+  this work for additional information regarding copyright ownership.
+  The ASF licenses this file to You under the Apache License, Version 2.0
+  (the "License"); you may not use this file except in compliance with
+  the License.  You may obtain a copy of the License at
+
+       http://www.apache.org/licenses/LICENSE-2.0
+
+  Unless required by applicable law or agreed to in writing, software
+  distributed under the License is distributed on an "AS IS" BASIS,
+  WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+  See the License for the specific language governing permissions and
+  limitations under the License.
+-->
+
+<packages>
+  <package id="Apache.Ignite" version="1.6.0" targetFramework="net40" />
+  <package id="Apache.Ignite.Linq" version="1.6.0" targetFramework="net40" />
+  <package id="Remotion.Linq" version="2.0.1" targetFramework="net40" />
+</packages>
\ No newline at end of file

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
index 6df25d4..9b946d6 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Apache.Ignite.Core.Tests.csproj
@@ -71,6 +71,7 @@
     <Compile Include="Cache\CachePartitionedTest.cs" />
     <Compile Include="Cache\CacheReplicatedAtomicTest.cs" />
     <Compile Include="Cache\CacheReplicatedTest.cs" />
+    <Compile Include="Cache\Query\CacheLinqTest.cs" />
     <Compile Include="Cache\Query\CacheQueriesCodeConfigurationTest.cs" />
     <Compile Include="Cache\Query\Continuous\ContinuousQueryAbstractTest.cs" />
     <Compile Include="Cache\Query\Continuous\ContinuousQueryAtomicBackupTest.cs" />
@@ -159,6 +160,10 @@
       <Project>{4CD2F726-7E2B-46C4-A5BA-057BB82EECB6}</Project>
       <Name>Apache.Ignite.Core</Name>
     </ProjectReference>
+    <ProjectReference Include="..\Apache.Ignite.Linq\Apache.Ignite.Linq.csproj">
+      <Project>{5b571661-17f4-4f29-8c7d-0edb38ca9b55}</Project>
+      <Name>Apache.Ignite.Linq</Name>
+    </ProjectReference>
     <ProjectReference Include="..\Apache.Ignite\Apache.Ignite.csproj">
       <Project>{27F7F3C6-BDDE-43A9-B565-856F8395A04B}</Project>
       <Name>Apache.Ignite</Name>

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheLinqTest.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheLinqTest.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheLinqTest.cs
new file mode 100644
index 0000000..1342256
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/Cache/Query/CacheLinqTest.cs
@@ -0,0 +1,1278 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+// ReSharper disable SuspiciousTypeConversion.Global
+// ReSharper disable MemberCanBePrivate.Global
+// ReSharper disable AutoPropertyCanBeMadeGetOnly.Global
+// ReSharper disable UnusedAutoPropertyAccessor.Global
+// ReSharper disable StringIndexOfIsCultureSpecific.1
+// ReSharper disable StringIndexOfIsCultureSpecific.2
+// ReSharper disable StringCompareToIsCultureSpecific
+// ReSharper disable StringCompareIsCultureSpecific.1
+// ReSharper disable UnusedMemberInSuper.Global
+namespace Apache.Ignite.Core.Tests.Cache.Query
+{
+    using System;
+    using System.Collections;
+    using System.Linq;
+    using System.Linq.Expressions;
+    using System.Text.RegularExpressions;
+    using System.Threading;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache;
+    using Apache.Ignite.Core.Cache.Configuration;
+    using Apache.Ignite.Core.Discovery.Tcp;
+    using Apache.Ignite.Core.Discovery.Tcp.Static;
+    using Apache.Ignite.Linq;
+    using NUnit.Framework;
+
+    /// <summary>
+    /// Tests LINQ.
+    /// </summary>
+    public class CacheLinqTest
+    {
+        /** Cache name. */
+        private const string PersonOrgCacheName = null;
+
+        /** Cache name. */
+        private const string PersonSecondCacheName = "person_cache";
+
+        /** Role cache name. */
+        private const string RoleCacheName = "role_cache";
+
+        /** */
+        private const int RoleCount = 3;
+
+        /** */
+        private const int PersonCount = 900;
+
+        /** */
+        private bool _runDbConsole;
+
+        /** */
+        private static readonly DateTime StartDateTime = new DateTime(2000, 1, 1, 0, 0, 0, DateTimeKind.Utc);
+
+        /// <summary>
+        /// Fixture set up.
+        /// </summary>
+        [TestFixtureSetUp]
+        public void FixtureSetUp()
+        {
+            _runDbConsole = false;  // set to true to open H2 console
+
+            if (_runDbConsole)
+                Environment.SetEnvironmentVariable("IGNITE_H2_DEBUG_CONSOLE", "true");
+
+            Ignition.Start(GetConfig());
+            Ignition.Start(GetConfig("grid2"));
+
+            // Populate caches
+            var cache = GetPersonCache();
+            var personCache = GetSecondPersonCache();
+
+            for (var i = 0; i < PersonCount; i++)
+            {
+                cache.Put(i, new Person(i, string.Format(" Person_{0}  ", i))
+                {
+                    Address = new Address {Zip = i, Street = "Street " + i, AliasTest = i},
+                    OrganizationId = i%2 + 1000,
+                    Birthday = StartDateTime.AddYears(i),
+                    AliasTest = -i
+                });
+
+                var i2 = i + PersonCount;
+                personCache.Put(i2, new Person(i2, "Person_" + i2)
+                {
+                    Address = new Address {Zip = i2, Street = "Street " + i2},
+                    OrganizationId = i%2 + 1000,
+                    Birthday = StartDateTime.AddYears(i)
+                });
+            }
+
+            var orgCache = GetOrgCache();
+
+            orgCache[1000] = new Organization {Id = 1000, Name = "Org_0"};
+            orgCache[1001] = new Organization {Id = 1001, Name = "Org_1"};
+
+            var roleCache = GetRoleCache();
+
+            roleCache[new RoleKey(1, 101)] = new Role {Name = "Role_1", Date = StartDateTime};
+            roleCache[new RoleKey(2, 102)] = new Role {Name = "Role_2", Date = StartDateTime.AddYears(1)};
+            roleCache[new RoleKey(3, 103)] = new Role {Name = null, Date = StartDateTime.AddYears(2)};
+        }
+
+        /// <summary>
+        /// Gets the configuration.
+        /// </summary>
+        private static IgniteConfiguration GetConfig(string gridName = null)
+        {
+            return new IgniteConfiguration
+            {
+                JvmClasspath = TestUtils.CreateTestClasspath(),
+                JvmOptions = TestUtils.TestJavaOptions(),
+                BinaryConfiguration = new BinaryConfiguration(typeof(Person),
+                    typeof(Organization), typeof(Address), typeof(Role), typeof(RoleKey), typeof(Numerics)),
+                DiscoverySpi = new TcpDiscoverySpi
+                {
+                    IpFinder = new TcpDiscoveryStaticIpFinder
+                    {
+                        Endpoints = new[] { "127.0.0.1:47500", "127.0.0.1:47501" }
+                    }
+                },
+                GridName = gridName
+            };
+        }
+
+        /// <summary>
+        /// Fixture tear down.
+        /// </summary>
+        [TestFixtureTearDown]
+        public void FixtureTearDown()
+        {
+            if (_runDbConsole)
+                Thread.Sleep(Timeout.Infinite);
+            Ignition.StopAll(true);
+        }
+
+        /// <summary>
+        /// Tests the empty query.
+        /// </summary>
+        [Test]
+        public void TestEmptyQuery()
+        {
+            // There are both persons and organizations in the same cache, but query should only return specific type
+            Assert.AreEqual(PersonCount, GetPersonCache().AsCacheQueryable().ToArray().Length);
+            Assert.AreEqual(RoleCount, GetRoleCache().AsCacheQueryable().ToArray().Length);
+        }
+
+        /// <summary>
+        /// Tests where clause.
+        /// </summary>
+        [Test]
+        public void TestWhere()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            // Test const and var parameters
+            const int age = 10;
+            var key = 15;
+
+            Assert.AreEqual(age, cache.Where(x => x.Value.Age < age).ToArray().Length);
+            Assert.AreEqual(age, cache.Where(x => x.Value.Address.Zip < age).ToArray().Length);
+            Assert.AreEqual(19, cache.Where(x => x.Value.Age > age && x.Value.Age < 30).ToArray().Length);
+            Assert.AreEqual(20, cache.Where(x => x.Value.Age > age).Count(x => x.Value.Age < 30 || x.Value.Age == 50));
+            Assert.AreEqual(key, cache.Where(x => x.Key < key).ToArray().Length);
+            Assert.AreEqual(key, cache.Where(x => -x.Key > -key).ToArray().Length);
+
+            Assert.AreEqual(1, GetRoleCache().AsCacheQueryable().Where(x => x.Key.Foo < 2).ToArray().Length);
+            Assert.AreEqual(2, GetRoleCache().AsCacheQueryable().Where(x => x.Key.Bar > 2 && x.Value.Name != "11")
+                .ToArray().Length);
+        }
+
+        /// <summary>
+        /// Tests the single field query.
+        /// </summary>
+        [Test]
+        public void TestSingleFieldQuery()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            // Multiple values
+            Assert.AreEqual(new[] {0, 1, 2},
+                cache.Where(x => x.Key < 3).Select(x => x.Value.Address.Zip).ToArray());
+
+            // Single value
+            Assert.AreEqual(0, cache.Where(x => x.Key < 0).Select(x => x.Value.Age).FirstOrDefault());
+            Assert.AreEqual(3, cache.Where(x => x.Key == 3).Select(x => x.Value.Age).FirstOrDefault());
+            Assert.AreEqual(3, cache.Where(x => x.Key == 3).Select(x => x.Value).Single().Age);
+            Assert.AreEqual(3, cache.Select(x => x.Key).Single(x => x == 3));
+            Assert.AreEqual(7,
+                cache.Select(x => x.Value)
+                    .Where(x => x.Age == 7)
+                    .Select(x => x.Address)
+                    .Where(x => x.Zip > 0)
+                    .Select(x => x.Zip)
+                    .Single());
+        }
+
+        /// <summary>
+        /// Tests the field projection.
+        /// </summary>
+        [Test]
+        public void TestFieldProjection()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            // Project whole cache entry to anonymous class
+            Assert.AreEqual(5, cache.Where(x => x.Key == 5).Select(x => new { Foo = x }).Single().Foo.Key);
+        }
+
+        /// <summary>
+        /// Tests the multi field query.
+        /// </summary>
+        [Test]
+        public void TestMultiFieldQuery()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            // Test anonymous type (ctor invoke)
+            var data = cache
+                .Select(x => new {Id = x.Key + 20, Age_ = x.Value.Age + 10, Addr = x.Value.Address})
+                .Where(x => x.Id < 25)
+                .ToArray();
+
+            Assert.AreEqual(5, data.Length);
+
+            foreach (var t in data)
+            {
+                Assert.AreEqual(t.Age_ - 10, t.Id - 20);
+                Assert.AreEqual(t.Age_ - 10, t.Addr.Zip);
+            }
+        }
+
+        /// <summary>
+        /// Tests the scalar query.
+        /// </summary>
+        [Test]
+        public void TestScalarQuery()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            Assert.AreEqual(PersonCount - 1, cache.Max(x => x.Value.Age));
+            Assert.AreEqual(0, cache.Min(x => x.Value.Age));
+
+            Assert.AreEqual(21, cache.Where(x => x.Key > 5 && x.Value.Age < 9).Select(x => x.Value.Age).Sum());
+
+            Assert.AreEqual(PersonCount, cache.Count());
+            Assert.AreEqual(PersonCount, cache.Count(x => x.Key < PersonCount));
+        }
+
+        /// <summary>
+        /// Tests strings.
+        /// </summary>
+        [Test]
+        public void TestStrings()
+        {
+            var strings = GetSecondPersonCache().AsCacheQueryable().Select(x => x.Value.Name);
+
+            CheckFunc(x => x.ToLower(), strings);
+            CheckFunc(x => x.ToUpper(), strings);
+            CheckFunc(x => x.StartsWith("Person_9"), strings);
+            CheckFunc(x => x.EndsWith("7"), strings);
+            CheckFunc(x => x.Contains("son_3"), strings);
+            CheckFunc(x => x.Length, strings);
+
+            CheckFunc(x => x.IndexOf("9"), strings);
+            CheckFunc(x => x.IndexOf("7", 4), strings);
+
+            CheckFunc(x => x.Substring(4), strings);
+            CheckFunc(x => x.Substring(4, 5), strings);
+
+            CheckFunc(x => x.Trim(), strings);
+            CheckFunc(x => x.Trim('P'), strings);
+            CheckFunc(x => x.Trim('3'), strings);
+            CheckFunc(x => x.TrimStart('P'), strings);
+            CheckFunc(x => x.TrimStart('3'), strings);
+            Assert.Throws<NotSupportedException>(() => CheckFunc(x => x.TrimStart('P', 'e'), strings));
+            CheckFunc(x => x.TrimEnd('P'), strings);
+            CheckFunc(x => x.TrimEnd('3'), strings);
+
+            CheckFunc(x => Regex.Replace(x, @"son.\d", "kele!"), strings);
+            CheckFunc(x => x.Replace("son", ""), strings);
+            CheckFunc(x => x.Replace("son", "kele"), strings);
+
+            // Concat
+            CheckFunc(x => x + x, strings);
+
+            // String + int
+            CheckFunc(x => x + 10, strings);
+        }
+
+        /// <summary>
+        /// Tests aggregates.
+        /// </summary>
+        [Test]
+        public void TestAggregates()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            Assert.AreEqual(PersonCount, cache.Count());
+            Assert.AreEqual(PersonCount, cache.Select(x => x.Key).Count());
+            Assert.AreEqual(2, cache.Select(x => x.Value.OrganizationId).Distinct().Count());
+
+            // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            Assert.Throws<NotSupportedException>(() => cache.Select(x => new {x.Key, x.Value}).Count());
+
+            // Min/max/sum/avg
+            var ints = cache.Select(x => x.Key);
+            Assert.AreEqual(0, ints.Min());
+            Assert.AreEqual(PersonCount - 1, ints.Max());
+            Assert.AreEqual(ints.ToArray().Sum(), ints.Sum());
+            Assert.AreEqual((int)ints.ToArray().Average(), (int)ints.Average());
+
+            var dupInts = ints.Select(x => x/10);  // duplicate values
+            CollectionAssert.AreEquivalent(dupInts.ToArray().Distinct().ToArray(), dupInts.Distinct().ToArray());
+            Assert.AreEqual(dupInts.ToArray().Distinct().Sum(), dupInts.Distinct().Sum());
+
+            // All/any
+            Assert.IsFalse(ints.Where(x => x > -5).Any(x => x > PersonCount && x > 0));
+            Assert.IsTrue(ints.Any(x => x < PersonCount / 2));
+
+            // Skip/take
+            var keys = cache.Select(x => x.Key).OrderBy(x => x);
+            Assert.AreEqual(new[] {0, 1}, keys.Take(2).ToArray());
+            Assert.AreEqual(new[] {1, 2}, keys.Skip(1).Take(2).ToArray());
+            Assert.AreEqual(new[] {PersonCount - 2, PersonCount - 1}, keys.Skip(PersonCount - 2).ToArray());
+        }
+
+        /// <summary>
+        /// Tests aggregates with all clause.
+        /// </summary>
+        [Test]
+        [Ignore("IGNITE-2563")]
+        public void TestAggregatesAll()
+        {
+            var ints = GetPersonCache().AsCacheQueryable().Select(x => x.Key);
+
+            Assert.IsTrue(ints.Where(x => x > -10).All(x => x < PersonCount && x >= 0));
+
+            Assert.IsFalse(ints.All(x => x < PersonCount / 2));
+        }
+
+        /// <summary>
+        /// Tests conditions.
+        /// </summary>
+        [Test]
+        public void TestConditions()
+        {
+            var persons = GetPersonCache().AsCacheQueryable();
+
+            var res = persons.Select(x => new {Foo = x.Key%2 == 0 ? "even" : "odd", x.Value}).ToArray();
+            Assert.AreEqual("even", res[0].Foo);
+            Assert.AreEqual("odd", res[1].Foo);
+
+            var roles = GetRoleCache().AsCacheQueryable();
+            CheckFunc(x => x.Value.Name ?? "def_name", roles);
+        }
+
+        /// <summary>
+        /// Tests the same cache join.
+        /// </summary>
+        [Test]
+        public void TestSameCacheJoin()
+        {
+            // Select persons in specific organization
+            var organizations = GetOrgCache().AsCacheQueryable();
+            var persons = GetPersonCache().AsCacheQueryable();
+
+            var res = persons.Join(organizations, person => person.Value.OrganizationId + 3, org => org.Value.Id + 3,
+                (person, org) => new {Person = person.Value, Org = org.Value})
+                .Where(x => x.Org.Name == "Org_1")
+                .ToList();
+
+            Assert.AreEqual(PersonCount / 2, res.Count);
+
+            Assert.IsTrue(res.All(r => r.Person.OrganizationId == r.Org.Id));
+
+            // Test full projection (selects pair of ICacheEntry)
+            var res2 = persons.Join(organizations, person => person.Value.OrganizationId - 1, org => org.Value.Id - 1,
+                (person, org) => new {Person = person, Org = org})
+                .Where(x => x.Org.Value.Name.ToLower() == "org_0")
+                .ToList();
+
+            Assert.AreEqual(PersonCount / 2, res2.Count);
+        }
+
+        /// <summary>
+        /// Tests the multi key join.
+        /// </summary>
+        [Test]
+        public void TestMultiKeyJoin()
+        {
+            var organizations = GetOrgCache().AsCacheQueryable();
+            var persons = GetPersonCache().AsCacheQueryable();
+
+            var multiKey =
+                from person in persons
+                join org in organizations on
+                    new { OrgId = person.Value.OrganizationId, person.Key } equals
+                    new { OrgId = org.Value.Id, Key = org.Key - 1000 }
+                where person.Key == 1
+                select new { PersonName = person.Value.Name, OrgName = org.Value.Name };
+
+            Assert.AreEqual(" Person_1  ", multiKey.Single().PersonName);
+        }
+
+        /// <summary>
+        /// Tests the cross cache join.
+        /// </summary>
+        [Test]
+        public void TestCrossCacheJoin()
+        {
+            var persons = GetPersonCache().AsCacheQueryable();
+            var roles = GetRoleCache().AsCacheQueryable();
+
+            var res = persons.Join(roles, person => person.Key, role => role.Key.Foo, (person, role) => role)
+                .ToArray();
+
+            Assert.AreEqual(RoleCount, res.Length);
+            Assert.AreEqual(101, res[0].Key.Bar);
+        }
+
+        /// <summary>
+        /// Tests the multi cache join.
+        /// </summary>
+        [Test]
+        public void TestMultiCacheJoin()
+        {
+            var organizations = GetOrgCache().AsCacheQueryable();
+            var persons = GetPersonCache().AsCacheQueryable();
+            var roles = GetRoleCache().AsCacheQueryable();
+
+            var res = roles.Join(persons, role => role.Key.Foo, person => person.Key,
+                (role, person) => new {person, role})
+                .Join(organizations, pr => pr.person.Value.OrganizationId, org => org.Value.Id,
+                    (pr, org) => new {org, pr.person, pr.role}).ToArray();
+
+            Assert.AreEqual(RoleCount, res.Length);
+        }
+
+        /// <summary>
+        /// Tests the multi cache join subquery.
+        /// </summary>
+        [Test]
+        public void TestMultiCacheJoinSubquery()
+        {
+            var organizations = GetOrgCache().AsCacheQueryable().Where(x => x.Key == 1001);
+            var persons = GetPersonCache().AsCacheQueryable().Where(x => x.Key < 20);
+            var roles = GetRoleCache().AsCacheQueryable().Where(x => x.Key.Foo >= 0);
+
+            var res = roles.Join(persons, role => role.Key.Foo, person => person.Key,
+                (role, person) => new {person, role})
+                .Join(organizations, pr => pr.person.Value.OrganizationId, org => org.Value.Id,
+                    (pr, org) => new {org, pr.person, pr.role}).ToArray();
+
+            Assert.AreEqual(2, res.Length);
+        }
+
+        /// <summary>
+        /// Tests the outer join.
+        /// </summary>
+        [Test]
+        public void TestOuterJoin()
+        {
+            var persons = GetPersonCache().AsCacheQueryable();
+            var roles = GetRoleCache().AsCacheQueryable();
+
+            var res = persons.Join(roles.Where(r => r.Key.Bar > 0).DefaultIfEmpty(),
+                person => person.Key, role => role.Key.Foo,
+                (person, role) => new
+                {
+                    PersonName = person.Value.Name,
+                    RoleName = role.Value.Name
+                })
+                .Where(x => x.PersonName != " ")
+                .ToArray();
+
+            Assert.AreEqual(PersonCount, res.Length);
+        }
+
+        /// <summary>
+        /// Tests the subquery join.
+        /// </summary>
+        [Test]
+        public void TestSubqueryJoin()
+        {
+            var persons = GetPersonCache().AsCacheQueryable().Where(x => x.Key >= 0);
+
+            var orgs = GetOrgCache().AsCacheQueryable().Where(x => x.Key > 10);
+
+            var res = persons.Join(orgs,
+                p => p.Value.OrganizationId,
+                o => o.Value.Id, (p, o) => p)
+                .Where(x => x.Key >= 0)
+                .ToList();
+
+            Assert.AreEqual(PersonCount, res.Count);
+        }
+
+        /// <summary>
+        /// Tests the invalid join.
+        /// </summary>
+        [Test]
+        public void TestInvalidJoin()
+        {
+            // Join on non-IQueryable
+            Assert.Throws<NotSupportedException>(() =>
+                // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+                GetPersonCache().AsCacheQueryable().Join(GetOrgCache(), p => p.Key, o => o.Key, (p, o) => p).ToList());
+        }
+
+        /// <summary>
+        /// Tests the multiple from.
+        /// </summary>
+        [Test]
+        public void TestMultipleFrom()
+        {
+            var persons = GetPersonCache().AsCacheQueryable().Where(x => x.Key < PersonCount);
+            var roles = GetRoleCache().AsCacheQueryable().Where(x => x.Value.Name != "1");
+
+            var all = persons.SelectMany(person => roles.Select(role => new { role, person }));
+            Assert.AreEqual(RoleCount * PersonCount, all.Count());
+
+            var filtered = 
+                from person in persons
+                from role in roles
+                where person.Key == role.Key.Foo
+                select new {Person = person.Value.Name, Role = role.Value.Name};
+
+            var res = filtered.ToArray();
+
+            Assert.AreEqual(RoleCount, res.Length);
+        }
+
+        /// <summary>
+        /// Tests the group by.
+        /// </summary>
+        [Test]
+        public void TestGroupBy()
+        {
+            var persons = GetPersonCache().AsCacheQueryable();
+            var orgs = GetOrgCache().AsCacheQueryable();
+
+            // Simple, unordered
+            CollectionAssert.AreEquivalent(new[] {1000, 1001},
+                persons.GroupBy(x => x.Value.OrganizationId).Select(x => x.Key).ToArray());
+
+            // Aggregate
+            Assert.AreEqual(1000,
+                persons.GroupBy(x => x.Value.OrganizationId).Select(x => x.Key).OrderBy(x => x).First());
+
+            // Ordering and count
+            var res1 =
+                from p in persons
+                orderby p.Value.Name
+                group p by p.Value.OrganizationId
+                into gs
+                orderby gs.Key
+                where gs.Count() > 10
+                select new {Count = gs.Count(), OrgId = gs.Key, AvgAge = gs.Average(x => x.Value.Age)};
+
+            var resArr = res1.ToArray();
+
+            Assert.AreEqual(new[]
+            {
+                new {Count = PersonCount/2, OrgId = 1000, AvgAge = (double) PersonCount/2 - 1},
+                new {Count = PersonCount/2, OrgId = 1001, AvgAge = (double) PersonCount/2}
+            }, resArr);
+
+            // Join and sum
+            var res2 = persons.Join(orgs.Where(o => o.Key > 10), p => p.Value.OrganizationId, o => o.Key,
+                (p, o) => new {p, o})
+                .GroupBy(x => x.o.Value.Name)
+                .Select(g => new {Org = g.Key, AgeSum = g.Select(x => x.p.Value.Age).Sum()});
+
+            var resArr2 = res2.ToArray();
+
+            Assert.AreEqual(new[]
+            {
+                new {Org = "Org_0", AgeSum = persons.Where(x => x.Value.OrganizationId == 1000).Sum(x => x.Value.Age)},
+                new {Org = "Org_1", AgeSum = persons.Where(x => x.Value.OrganizationId == 1001).Sum(x => x.Value.Age)}
+            }, resArr2);
+        }
+
+        /// <summary>
+        /// Tests the union.
+        /// </summary>
+        [Test]
+        public void TestUnion()
+        {
+            // Direct union
+            var persons = GetPersonCache().AsCacheQueryable();
+            var persons2 = GetSecondPersonCache().AsCacheQueryable();
+
+            var res = persons.Union(persons2).ToArray();
+
+            Assert.AreEqual(PersonCount * 2, res.Length);
+
+            // Subquery
+            var roles = GetRoleCache().AsCacheQueryable().Select(x => -x.Key.Foo);
+            var ids = GetPersonCache().AsCacheQueryable().Select(x => x.Key).Union(roles).ToArray();
+
+            Assert.AreEqual(RoleCount + PersonCount, ids.Length);
+        }
+
+        /// <summary>
+        /// Tests intersect.
+        /// </summary>
+        [Test]
+        public void TestIntersect()
+        {
+            // Direct intersect
+            var persons = GetPersonCache().AsCacheQueryable();
+            var persons2 = GetSecondPersonCache().AsCacheQueryable();
+
+            var res = persons.Intersect(persons2).ToArray();
+
+            Assert.AreEqual(0, res.Length);
+
+            // Subquery
+            var roles = GetRoleCache().AsCacheQueryable().Select(x => x.Key.Foo);
+            var ids = GetPersonCache().AsCacheQueryable().Select(x => x.Key).Intersect(roles).ToArray();
+
+            Assert.AreEqual(RoleCount, ids.Length);
+        }
+
+        /// <summary>
+        /// Tests except.
+        /// </summary>
+        [Test]
+        public void TestExcept()
+        {
+            // Direct except
+            var persons = GetPersonCache().AsCacheQueryable();
+            var persons2 = GetSecondPersonCache().AsCacheQueryable();
+
+            var res = persons.Except(persons2).ToArray();
+
+            Assert.AreEqual(PersonCount, res.Length);
+
+            // Subquery
+            var roles = GetRoleCache().AsCacheQueryable().Select(x => x.Key.Foo);
+            var ids = GetPersonCache().AsCacheQueryable().Select(x => x.Key).Except(roles).ToArray();
+
+            Assert.AreEqual(PersonCount - RoleCount, ids.Length);
+        }
+
+        /// <summary>
+        /// Tests ordering.
+        /// </summary>
+        [Test]
+        public void TestOrdering()
+        {
+            var persons = GetPersonCache().AsCacheQueryable()
+                .OrderByDescending(x => x.Key)
+                .ThenBy(x => x.Value.Age)
+                .ToArray();
+
+            Assert.AreEqual(Enumerable.Range(0, PersonCount).Reverse().ToArray(), persons.Select(x => x.Key).ToArray());
+
+            var personsByOrg = GetPersonCache().AsCacheQueryable()
+                .Join(GetOrgCache().AsCacheQueryable(), p => p.Value.OrganizationId, o => o.Value.Id,
+                    (p, o) => new
+                    {
+                        PersonId = p.Key,
+                        PersonName = p.Value.Name.ToUpper(),
+                        OrgName = o.Value.Name
+                    })
+                .OrderBy(x => x.OrgName.ToLower())
+                .ThenBy(x => x.PersonName)
+                .ToArray();
+
+            var expectedIds = Enumerable.Range(0, PersonCount)
+                .OrderBy(x => (x%2).ToString())
+                .ThenBy(x => x.ToString())
+                .ToArray();
+
+            var actualIds = personsByOrg.Select(x => x.PersonId).ToArray();
+
+            Assert.AreEqual(expectedIds, actualIds);
+        }
+
+        /// <summary>
+        /// Tests nulls.
+        /// </summary>
+        [Test]
+        public void TestNulls()
+        {
+            var roles = GetRoleCache().AsCacheQueryable();
+
+            var nullNameRole = roles.Single(x => x.Value.Name == null);
+            Assert.AreEqual(null, nullNameRole.Value.Name);
+
+            var nonNullNameRoles = roles.Where(x => x.Value.Name != null);
+            Assert.AreEqual(RoleCount - 1, nonNullNameRoles.Count());
+        }
+
+        /// <summary>
+        /// Tests date time.
+        /// </summary>
+        [Test]
+        public void TestDateTime()
+        {
+            var roles = GetRoleCache().AsCacheQueryable();
+            var persons = GetPersonCache().AsCacheQueryable();
+
+            // Invalid dateTime
+            var now = DateTime.Now;
+            // ReSharper disable once ReturnValueOfPureMethodIsNotUsed
+            Assert.Throws<InvalidOperationException>(() => roles.Where(x => x.Value.Date > now).ToArray());
+
+            // Test retrieval
+            var dates = roles.OrderBy(x => x.Value.Date).Select(x => x.Value.Date);
+            var expDates = new[] {StartDateTime, StartDateTime.AddYears(1), StartDateTime.AddYears(2)};
+            Assert.AreEqual(expDates, dates.ToArray());
+
+            // Filtering
+            Assert.AreEqual(1, persons.Count(x => x.Value.Birthday == StartDateTime));
+            Assert.AreEqual(PersonCount, persons.Count(x => x.Value.Birthday >= StartDateTime));
+
+            // Joins
+            var join = 
+                from role in roles
+                join person in persons on role.Value.Date equals person.Value.Birthday
+                select person;
+
+            Assert.AreEqual(RoleCount, join.Count());
+
+            // Functions
+            Assert.AreEqual("01 01 2000 03:00:00", dates.Select(x => x.ToString("DD MM YYYY HH:mm:ss")).First());
+        }
+
+        /// <summary>
+        /// Tests numerics.
+        /// </summary>
+        [Test]
+        public void TestNumerics()
+        {
+            var cache = Ignition.GetIgnite()
+                    .GetOrCreateCache<int, Numerics>(new CacheConfiguration("numerics", typeof (Numerics)));
+
+            for (var i = 0; i < 100; i++)
+                cache[i] = new Numerics(((double) i - 50)/3);
+
+            var query = cache.AsCacheQueryable().Select(x => x.Value);
+
+            var bytes = query.Select(x => x.Byte);
+            var sbytes = query.Select(x => x.Sbyte);
+            var shorts = query.Select(x => x.Short);
+            var ushorts = query.Select(x => x.Ushort);
+            var ints = query.Select(x => x.Int);
+            var uints = query.Select(x => x.Uint);
+            var longs = query.Select(x => x.Long);
+            var ulongs = query.Select(x => x.Ulong);
+            var doubles = query.Select(x => x.Double);
+            var decimals = query.Select(x => x.Decimal);
+            var floats = query.Select(x => x.Float);
+
+            CheckFunc(x => Math.Abs(x), doubles);
+            CheckFunc(x => Math.Abs((sbyte) x), bytes);
+            CheckFunc(x => Math.Abs(x), sbytes);
+            CheckFunc(x => Math.Abs(x), shorts);
+            CheckFunc(x => Math.Abs((short) x), ushorts);
+            CheckFunc(x => Math.Abs(x), ints);
+            CheckFunc(x => Math.Abs((int) x), uints);
+            CheckFunc(x => Math.Abs(x), longs);
+            CheckFunc(x => Math.Abs((long) x), ulongs);
+            CheckFunc(x => Math.Abs(x), decimals);
+            CheckFunc(x => Math.Abs(x), floats);
+
+            CheckFunc(x => Math.Acos(x), doubles);
+            CheckFunc(x => Math.Asin(x), doubles);
+            CheckFunc(x => Math.Atan(x), doubles);
+            CheckFunc(x => Math.Atan2(x, 0.5), doubles);
+
+            CheckFunc(x => Math.Ceiling(x), doubles);
+            CheckFunc(x => Math.Ceiling(x), decimals);
+
+            CheckFunc(x => Math.Cos(x), doubles);
+            CheckFunc(x => Math.Cosh(x), doubles);
+            CheckFunc(x => Math.Exp(x), doubles);
+
+            CheckFunc(x => Math.Floor(x), doubles);
+            CheckFunc(x => Math.Floor(x), decimals);
+
+            CheckFunc(x => Math.Log(x), doubles);
+            CheckFunc(x => Math.Log10(x), doubles);
+
+            CheckFunc(x => Math.Pow(x, 3.7), doubles);
+
+            CheckFunc(x => Math.Round(x), doubles);
+            CheckFunc(x => Math.Round(x, 3), doubles);
+            CheckFunc(x => Math.Round(x), decimals);
+            CheckFunc(x => Math.Round(x, 3), decimals);
+
+            CheckFunc(x => Math.Sign(x), doubles);
+            CheckFunc(x => Math.Sign(x), decimals);
+            CheckFunc(x => Math.Sign(x), floats);
+            CheckFunc(x => Math.Sign(x), ints);
+            CheckFunc(x => Math.Sign(x), longs);
+            CheckFunc(x => Math.Sign(x), shorts);
+            CheckFunc(x => Math.Sign(x), sbytes);
+
+            CheckFunc(x => Math.Sin(x), doubles);
+            CheckFunc(x => Math.Sinh(x), doubles);
+            CheckFunc(x => Math.Sqrt(x), doubles);
+            CheckFunc(x => Math.Tan(x), doubles);
+            CheckFunc(x => Math.Tanh(x), doubles);
+
+            CheckFunc(x => Math.Truncate(x), doubles);
+            CheckFunc(x => Math.Truncate(x), decimals);
+
+            // Operators
+            CheckFunc(x => x*7, doubles);
+            CheckFunc(x => x/7, doubles);
+            CheckFunc(x => x%7, doubles);
+            CheckFunc(x => x+7, doubles);
+            CheckFunc(x => x-7, doubles);
+        }
+
+        /// <summary>
+        /// Tests aliases.
+        /// </summary>
+        [Test]
+        public void TestAliases()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            var res = cache.Where(x => x.Key == 1)
+                .Select(x => new {X = x.Value.AliasTest, Y = x.Value.Address.AliasTest})
+                .Single();
+
+            Assert.AreEqual(new {X = -1, Y = 1}, res);
+        }
+
+        /// <summary>
+        /// Tests the compiled query.
+        /// </summary>
+        [Test]
+        public void TestCompiledQuery()
+        {
+            var cache = GetPersonCache().AsCacheQueryable();
+
+            // 0 arg
+            var qry0 = CompiledQuery.Compile(() => cache.Select(x => x.Value.Name));
+            Assert.AreEqual(PersonCount, qry0().ToArray().Length);
+
+            // 1 arg
+            var qry1 = CompiledQuery.Compile((int k) => cache.Where(x => x.Key < k));
+            Assert.AreEqual(3, qry1(3).ToArray().Length);
+
+            // 2 arg
+            var qry2 =
+                CompiledQuery.Compile((int i, string s) => cache.Where(x => x.Key < i && x.Value.Name.StartsWith(s)));
+            Assert.AreEqual(5, qry2(5, " Pe").ToArray().Length);
+
+            // Changed param order
+            var qry2R =
+                CompiledQuery.Compile((string s, int i) => cache.Where(x => x.Key < i && x.Value.Name.StartsWith(s)));
+            Assert.AreEqual(5, qry2R(" Pe", 5).ToArray().Length);
+
+            // 3 arg
+            var qry3 = CompiledQuery.Compile((int i, string s, double d) => 
+                cache.Where(x => x.Value.Address.Zip > d && x.Key < i && x.Value.Name.Contains(s)));
+            Assert.AreEqual(5, qry3(5, "son", -10).ToArray().Length);
+
+            // 4 arg
+            var keys = cache.Select(x => x.Key);
+            var qry4 = CompiledQuery.Compile((int a, int b, int c, int d) =>
+                keys.Where(k => k > a && k > b && k > c && k < d));
+            Assert.AreEqual(new[] {3, 4}, qry4(0, 1, 2, 5).ToArray());
+
+            // 5 arg
+            var qry5 = CompiledQuery.Compile((int a, int b, int c, int d, int e) =>
+                keys.Where(k => k > a && k > b && k > c && k < d && k < e));
+            Assert.AreEqual(new[] {3, 4}, qry5(0, 1, 2, 5, 6).ToArray());
+
+            // 6 arg
+            var qry6 = CompiledQuery.Compile((int a, int b, int c, int d, int e, int f) =>
+                keys.Where(k => k > a && k > b && k > c && k < d && k < e && k < f));
+            Assert.AreEqual(new[] {3, 4}, qry6(0, 1, 2, 5, 6, 7).ToArray());
+
+            // 7 arg
+            var qry7 = CompiledQuery.Compile((int a, int b, int c, int d, int e, int f, int g) =>
+                keys.Where(k => k > a && k > b && k > c && k < d && k < e && k < f && k < g));
+            Assert.AreEqual(new[] {3, 4}, qry7(0, 1, 2, 5, 6, 7, 8).ToArray());
+
+            // 8 arg
+            var qry8 = CompiledQuery.Compile((int a, int b, int c, int d, int e, int f, int g, int h) =>
+                keys.Where(k => k > a && k > b && k > c && k < d && k < e && k < f && k < g && k < h));
+            Assert.AreEqual(new[] {3, 4}, qry8(0, 1, 2, 5, 6, 7, 8, 9).ToArray());
+        }
+
+        /// <summary>
+        /// Tests the cache of primitive types.
+        /// </summary>
+        [Test]
+        public void TestPrimitiveCache()
+        {
+            // Create partitioned cache
+            var cache =
+                Ignition.GetIgnite()
+                    .GetOrCreateCache<int, string>(new CacheConfiguration("primitiveCache",
+                        new QueryEntity(typeof (int), typeof (string))) {CacheMode = CacheMode.Replicated});
+
+            var qry = cache.AsCacheQueryable();
+
+            // Populate
+            const int count = 100;
+            cache.PutAll(Enumerable.Range(0, count).ToDictionary(x => x, x => x.ToString()));
+
+            // Test
+            Assert.AreEqual(count, qry.ToArray().Length);
+            Assert.AreEqual(10, qry.Where(x => x.Key < 10).ToArray().Length);
+            Assert.AreEqual(1, qry.Count(x => x.Value.Contains("99")));
+        }
+
+        /// <summary>
+        /// Tests the local query.
+        /// </summary>
+        [Test]
+        public void TestLocalQuery()
+        {
+            // Create partitioned cache
+            var cache =
+                Ignition.GetIgnite().GetOrCreateCache<int, int>(new CacheConfiguration("partCache", typeof (int)));
+
+            // Populate
+            const int count = 100;
+            cache.PutAll(Enumerable.Range(0, count).ToDictionary(x => x, x => x));
+
+            // Non-local query returns all records
+            Assert.AreEqual(count, cache.AsCacheQueryable(false).ToArray().Length);
+
+            // Local query returns only some of the records
+            var localCount = cache.AsCacheQueryable(true).ToArray().Length;
+            Assert.Less(localCount, count);
+            Assert.Greater(localCount, 0);
+        }
+
+        /// <summary>
+        /// Tests the introspection.
+        /// </summary>
+        [Test]
+        public void TestIntrospection()
+        {
+            var cache = GetPersonCache();
+
+            // Check regular query
+            var query = (ICacheQueryable) cache.AsCacheQueryable(true).Where(x => x.Key > 10);
+
+            Assert.AreEqual(cache.Name, query.CacheName);
+            Assert.AreEqual(cache.Ignite, query.Ignite);
+
+            var fq = query.GetFieldsQuery();
+            Assert.AreEqual("select _T0._key, _T0._val from \"\".Person as _T0 where (_T0._key > ?)", fq.Sql);
+            Assert.AreEqual(new[] {10}, fq.Arguments);
+            Assert.IsTrue(fq.Local);
+            Assert.AreEqual(PersonCount - 11, cache.QueryFields(fq).GetAll().Count);
+
+            // Check fields query
+            var fieldsQuery = (ICacheQueryable) cache.AsCacheQueryable().Select(x => x.Value.Name);
+
+            Assert.AreEqual(cache.Name, fieldsQuery.CacheName);
+            Assert.AreEqual(cache.Ignite, fieldsQuery.Ignite);
+
+            fq = fieldsQuery.GetFieldsQuery();
+            Assert.AreEqual("select _T0.Name from \"\".Person as _T0", fq.Sql);
+            Assert.IsFalse(fq.Local);
+        }
+
+        /// <summary>
+        /// Tests the table name inference.
+        /// </summary>
+        [Test]
+        public void TestTableNameInference()
+        {
+            // Try with multi-type cache: explicit type is required
+            var cache = GetCacheOf<IPerson>();
+
+            Assert.Throws<CacheException>(() => cache.AsCacheQueryable());
+
+            var names = cache.AsCacheQueryable(false, "Person").Select(x => x.Value.Name).ToArray();
+
+            Assert.AreEqual(PersonCount, names.Length);
+
+            // With single-type cache, interface inference works
+            var roleCache = Ignition.GetIgnite().GetCache<object, IRole>(RoleCacheName).AsCacheQueryable();
+
+            var roleNames = roleCache.Select(x => x.Value.Name).OrderBy(x => x).ToArray();
+
+            CollectionAssert.AreEquivalent(new[] {"Role_1", "Role_2", null}, roleNames);
+
+            // Check non-queryable cache
+            var nonQueryableCache = Ignition.GetIgnite().GetOrCreateCache<Role, Person>("nonQueryable");
+
+            Assert.Throws<CacheException>(() => nonQueryableCache.AsCacheQueryable());
+        }
+
+        /// <summary>
+        /// Gets the person cache.
+        /// </summary>
+        /// <returns></returns>
+        private static ICache<int, Person> GetPersonCache()
+        {
+            return GetCacheOf<Person>();
+        }
+
+        /// <summary>
+        /// Gets the org cache.
+        /// </summary>
+        /// <returns></returns>
+        private static ICache<int, Organization> GetOrgCache()
+        {
+            return GetCacheOf<Organization>();
+        }
+
+        /// <summary>
+        /// Gets the cache.
+        /// </summary>
+        private static ICache<int, T> GetCacheOf<T>()
+        {
+            return Ignition.GetIgnite()
+                .GetOrCreateCache<int, T>(new CacheConfiguration(PersonOrgCacheName,
+                    new QueryEntity(typeof (int), typeof (Person))
+                    {
+                        Aliases = new[]
+                        {
+                            new QueryAlias("AliasTest", "Person_AliasTest"),
+                            new QueryAlias("Address.AliasTest", "Addr_AliasTest")
+                        }
+                    },
+                    new QueryEntity(typeof (int), typeof (Organization))) {CacheMode = CacheMode.Replicated});
+        }
+
+        /// <summary>
+        /// Gets the role cache.
+        /// </summary>
+        private static ICache<RoleKey, Role> GetRoleCache()
+        {
+            return Ignition.GetIgnite()
+                .GetOrCreateCache<RoleKey, Role>(new CacheConfiguration(RoleCacheName,
+                    new QueryEntity(typeof (RoleKey), typeof (Role))) {CacheMode = CacheMode.Replicated});
+        }
+
+        /// <summary>
+        /// Gets the second person cache.
+        /// </summary>
+        private static ICache<int, Person> GetSecondPersonCache()
+        {
+            return Ignition.GetIgnite()
+                .GetOrCreateCache<int, Person>(new CacheConfiguration(PersonSecondCacheName,
+                    new QueryEntity(typeof (int), typeof (Person))) {CacheMode = CacheMode.Replicated});
+        }
+
+        /// <summary>
+        /// Checks that function maps to SQL function properly.
+        /// </summary>
+        private static void CheckFunc<T, TR>(Expression<Func<T, TR>> exp, IQueryable<T> query, 
+            Func<TR, TR> localResultFunc = null)
+        {
+            localResultFunc = localResultFunc ?? (x => x);
+
+            // Calculate result locally, using real method invocation
+            var expected = query.ToArray().AsQueryable().Select(exp).Select(localResultFunc).OrderBy(x => x).ToArray();
+
+            // Perform SQL query
+            var actual = query.Select(exp).ToArray().OrderBy(x => x).ToArray();
+
+            // Compare results
+            CollectionAssert.AreEqual(expected, actual, new NumericComparer());
+
+            // Perform intermediate anonymous type conversion to check type projection
+            actual = query.Select(exp).Select(x => new {Foo = x}).ToArray().Select(x => x.Foo)
+                .OrderBy(x => x).ToArray();
+
+            // Compare results
+            CollectionAssert.AreEqual(expected, actual, new NumericComparer());
+        }
+
+        public interface IPerson
+        {
+            int Age { get; set; }
+            string Name { get; set; }
+        }
+
+        public class Person : IBinarizable, IPerson
+        {
+            public Person(int age, string name)
+            {
+                Age = age;
+                Name = name;
+            }
+
+            [QuerySqlField(Name = "age1")] public int Age { get; set; }
+
+            [QuerySqlField] public string Name { get; set; }
+
+            [QuerySqlField] public Address Address { get; set; }
+
+            [QuerySqlField] public int OrganizationId { get; set; }
+
+            [QuerySqlField] public DateTime? Birthday { get; set; }
+
+            [QuerySqlField] public int AliasTest { get; set; }
+
+            public void WriteBinary(IBinaryWriter writer)
+            {
+                writer.WriteInt("age1", Age);
+                writer.WriteString("name", Name);
+                writer.WriteInt("OrganizationId", OrganizationId);
+                writer.WriteObject("Address", Address);
+                writer.WriteTimestamp("Birthday", Birthday);
+                writer.WriteInt("AliasTest", AliasTest);
+            }
+
+            public void ReadBinary(IBinaryReader reader)
+            {
+                Age = reader.ReadInt("age1");
+                Name = reader.ReadString("name");
+                OrganizationId = reader.ReadInt("OrganizationId");
+                Address = reader.ReadObject<Address>("Address");
+                Birthday = reader.ReadTimestamp("Birthday");
+                AliasTest = reader.ReadInt("AliasTest");
+            }
+        }
+
+        public class Address
+        {
+            [QuerySqlField] public int Zip { get; set; }
+            [QuerySqlField] public string Street { get; set; }
+            [QuerySqlField] public int AliasTest { get; set; }
+        }
+
+        public class Organization
+        {
+            [QuerySqlField] public int Id { get; set; }
+            [QuerySqlField] public string Name { get; set; }
+        }
+
+        public interface IRole
+        {
+            string Name { get; }
+            DateTime Date { get; }
+        }
+
+        public class Role : IRole
+        {
+            [QuerySqlField] public string Name { get; set; }
+            [QuerySqlField] public DateTime Date { get; set; }
+        }
+
+        public class Numerics
+        {
+            public Numerics(double val)
+            {
+                Double = val;
+                Float = (float) val;
+                Decimal = (decimal) val;
+                Int = (int) val;
+                Uint = (uint) val;
+                Long = (long) val;
+                Ulong = (ulong) val;
+                Short = (short) val;
+                Ushort = (ushort) val;
+                Byte = (byte) val;
+                Sbyte =  (sbyte) val;
+            }
+
+            [QuerySqlField] public double Double { get; set; }
+            [QuerySqlField] public float Float { get; set; }
+            [QuerySqlField] public decimal Decimal { get; set; }
+            [QuerySqlField] public int Int { get; set; }
+            [QuerySqlField] public uint Uint { get; set; }
+            [QuerySqlField] public long Long { get; set; }
+            [QuerySqlField] public ulong Ulong { get; set; }
+            [QuerySqlField] public short Short { get; set; }
+            [QuerySqlField] public ushort Ushort { get; set; }
+            [QuerySqlField] public byte Byte { get; set; }
+            [QuerySqlField] public sbyte Sbyte { get; set; }
+        }
+
+        public struct RoleKey : IEquatable<RoleKey>
+        {
+            private readonly int _foo;
+            private readonly long _bar;
+
+            public RoleKey(int foo, long bar)
+            {
+                _foo = foo;
+                _bar = bar;
+            }
+
+            [QuerySqlField(Name = "_foo")]
+            public int Foo
+            {
+                get { return _foo; }
+            }
+
+            [QuerySqlField(Name = "_bar")]
+            public long Bar
+            {
+                get { return _bar; }
+            }
+
+            public bool Equals(RoleKey other)
+            {
+                return _foo == other._foo && _bar == other._bar;
+            }
+
+            public override bool Equals(object obj)
+            {
+                if (ReferenceEquals(null, obj)) return false;
+                return obj is RoleKey && Equals((RoleKey) obj);
+            }
+
+            public override int GetHashCode()
+            {
+                unchecked
+                {
+                    return (_foo*397) ^ _bar.GetHashCode();
+                }
+            }
+
+            public static bool operator ==(RoleKey left, RoleKey right)
+            {
+                return left.Equals(right);
+            }
+
+            public static bool operator !=(RoleKey left, RoleKey right)
+            {
+                return !left.Equals(right);
+            }
+        }
+
+        /// <summary>
+        /// Epsilon comparer.
+        /// </summary>
+        private class NumericComparer : IComparer
+        {
+            /** <inheritdoc /> */
+            public int Compare(object x, object y)
+            {
+                if (Equals(x, y))
+                    return 0;
+
+                if (x is double)
+                {
+                    var dx = (double) x;
+                    var dy = (double) y;
+
+                    // Epsilon is proportional to the min value, but not too small.
+                    const double epsilon = 2E-10d;
+                    var min = Math.Min(Math.Abs(dx), Math.Abs(dy));
+                    var relEpsilon = Math.Max(min*epsilon, epsilon);
+
+                    // Compare with epsilon because some funcs return slightly different results.
+                    return Math.Abs((double) x - (double) y) < relEpsilon ? 0 : 1;
+                }
+
+                return ((IComparable) x).CompareTo(y);
+            }
+        }
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
index a1083b6..74ea846 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core.Tests/TestRunner.cs
@@ -32,7 +32,7 @@ namespace Apache.Ignite.Core.Tests
             Debug.Listeners.Add(new TextWriterTraceListener(Console.Out));
             Debug.AutoFlush = true;
 
-            TestOne(typeof(IgniteConfigurationTest), "TestStaticIpFinder");
+            TestOne(typeof(CacheLinqTest), "TestExcept");
 
             //TestAll(typeof (CacheQueriesCodeConfigurationTest));
             //TestAllInAssembly();

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj b/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
index 5ae7851..1be10b4 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Apache.Ignite.Core.csproj
@@ -230,6 +230,7 @@
     <Compile Include="Impl\Cache\Event\CacheEntryCreateEvent.cs" />
     <Compile Include="Impl\Cache\Event\CacheEntryRemoveEvent.cs" />
     <Compile Include="Impl\Cache\Event\CacheEntryUpdateEvent.cs" />
+    <Compile Include="Impl\Cache\ICacheInternal.cs" />
     <Compile Include="Impl\Cache\MutableCacheEntry.cs" />
     <Compile Include="Impl\Cache\Query\AbstractQueryCursor.cs" />
     <Compile Include="Impl\Cache\Query\Continuous\ContinuousQueryFilter.cs" />
@@ -266,6 +267,7 @@
     <Compile Include="Impl\Common\IgniteConfigurationXmlSerializer.cs" />
     <Compile Include="Impl\Common\IgniteHome.cs" />
     <Compile Include="Impl\Common\LoadedAssembliesResolver.cs" />
+    <Compile Include="Impl\Common\Logger.cs" />
     <Compile Include="Impl\Common\ResizeableArray.cs" />
     <Compile Include="Impl\Common\TypeCaster.cs" />
     <Compile Include="Impl\Common\TypeStringConverter.cs" />

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs
index f4c12f6..e6eceb8 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryEntity.cs
@@ -104,7 +104,7 @@ namespace Apache.Ignite.Core.Cache.Configuration
 
                 KeyTypeName = value == null
                     ? null
-                    : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value));
+                    : (JavaTypes.GetJavaTypeNameAndLogWarning(value) ?? BinaryUtils.GetTypeName(value));
 
                 _keyType = value;
             }
@@ -140,7 +140,7 @@ namespace Apache.Ignite.Core.Cache.Configuration
 
                 ValueTypeName = value == null
                     ? null
-                    : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value));
+                    : (JavaTypes.GetJavaTypeNameAndLogWarning(value) ?? BinaryUtils.GetTypeName(value));
 
                 _valueType = value;
             }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs
index 8c70a29..b11e53d 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Cache/Configuration/QueryField.cs
@@ -87,7 +87,7 @@ namespace Apache.Ignite.Core.Cache.Configuration
             {
                 FieldTypeName = value == null
                     ? null
-                    : (JavaTypes.GetJavaTypeName(value) ?? BinaryUtils.GetTypeName(value));
+                    : (JavaTypes.GetJavaTypeNameAndLogWarning(value) ?? BinaryUtils.GetTypeName(value));
 
                 _type = value;
             }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Ignition.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Ignition.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Ignition.cs
index b1693e7..94dab88 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Ignition.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Ignition.cs
@@ -241,7 +241,7 @@ namespace Apache.Ignite.Core
         private static void CheckServerGc(IgniteConfiguration cfg)
         {
             if (!cfg.SuppressWarnings && !GCSettings.IsServerGC && Interlocked.CompareExchange(ref _gcWarn, 1, 0) == 0)
-                Console.WriteLine("GC server mode is not enabled, this could lead to less " +
+                Logger.LogWarning("GC server mode is not enabled, this could lead to less " +
                     "than optimal performance on multi-core machines (to enable see " +
                     "http://msdn.microsoft.com/en-us/library/ms229357(v=vs.110).aspx).");
         }

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryReflectiveActions.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryReflectiveActions.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryReflectiveActions.cs
index 8b5e2a1..07cf08f 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryReflectiveActions.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/BinaryReflectiveActions.cs
@@ -20,9 +20,11 @@ namespace Apache.Ignite.Core.Impl.Binary
     using System;
     using System.Collections;
     using System.Diagnostics;
+    using System.Linq;
     using System.Linq.Expressions;
     using System.Reflection;
     using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache.Configuration;
     using Apache.Ignite.Core.Common;
     using Apache.Ignite.Core.Impl.Common;
 
@@ -398,6 +400,31 @@ namespace Apache.Ignite.Core.Impl.Binary
         }
 
         /// <summary>
+        /// Determines whether specified field is a query field (has QueryFieldAttribute).
+        /// </summary>
+        private static bool IsQueryField(FieldInfo fieldInfo)
+        {
+            Debug.Assert(fieldInfo != null && fieldInfo.DeclaringType != null);
+
+            var fieldName = BinaryUtils.CleanFieldName(fieldInfo.Name);
+
+            object[] attrs = null;
+
+            if (fieldName != fieldInfo.Name)
+            {
+                // Backing field, check corresponding property
+                var prop = fieldInfo.DeclaringType.GetProperty(fieldName, fieldInfo.FieldType);
+
+                if (prop != null)
+                    attrs = prop.GetCustomAttributes(true);
+            }
+
+            attrs = attrs ?? fieldInfo.GetCustomAttributes(true);
+
+            return attrs.OfType<QuerySqlFieldAttribute>().Any();
+        }
+
+        /// <summary>
         /// Handle other type.
         /// </summary>
         /// <param name="field">The field.</param>
@@ -476,6 +503,16 @@ namespace Apache.Ignite.Core.Impl.Binary
                     ? GetRawReader(field, r => r.ReadCollection())
                     : GetReader(field, (f, r) => r.ReadCollection(f));
             }
+            else if (type == typeof (DateTime) && IsQueryField(field))
+            {
+                writeAction = GetWriter<DateTime>(field, (f, w, o) => w.WriteTimestamp(f, o));
+                readAction = GetReader(field, (f, r) => r.ReadObject<DateTime>(f));
+            }
+            else if (nullableType == typeof (DateTime) && IsQueryField(field))
+            {
+                writeAction = GetWriter<DateTime?>(field, (f, w, o) => w.WriteTimestamp(f, o));
+                readAction = GetReader(field, (f, r) => r.ReadTimestamp(f));
+            }
             else
             {
                 writeAction = raw ? GetRawWriter(field, MthdWriteObjRaw) : GetWriter(field, MthdWriteObj);

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/JavaTypes.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/JavaTypes.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/JavaTypes.cs
index fccbfae..f30264d 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/JavaTypes.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Binary/JavaTypes.cs
@@ -20,6 +20,7 @@ namespace Apache.Ignite.Core.Impl.Binary
     using System;
     using System.Collections.Generic;
     using System.Linq;
+    using Apache.Ignite.Core.Impl.Common;
 
     /// <summary>
     /// Provides mapping between Java and .NET basic types.
@@ -43,7 +44,18 @@ namespace Apache.Ignite.Core.Impl.Binary
             {typeof (double), "java.lang.Double"},
             {typeof (string), "java.lang.String"},
             {typeof (decimal), "java.math.BigDecimal"},
-            {typeof (Guid), "java.util.UUID"}
+            {typeof (Guid), "java.util.UUID"},
+            {typeof (DateTime), "java.sql.Timestamp"},
+            {typeof (DateTime?), "java.sql.Timestamp"},
+        };
+
+        /** */
+        private static readonly Dictionary<Type, Type> IndirectMappingTypes = new Dictionary<Type, Type>
+        {
+            {typeof (sbyte), typeof (byte)},
+            {typeof (ushort), typeof (short)},
+            {typeof (uint), typeof (int)},
+            {typeof (ulong), typeof (long)}
         };
 
         /** */
@@ -55,15 +67,26 @@ namespace Apache.Ignite.Core.Impl.Binary
 
         /// <summary>
         /// Gets the corresponding Java type name.
+        /// Logs a warning for indirectly mapped types.
         /// </summary>
-        public static string GetJavaTypeName(Type type)
+        public static string GetJavaTypeNameAndLogWarning(Type type)
         {
             if (type == null)
                 return null;
 
             string res;
 
-            return NetToJava.TryGetValue(type, out res) ? res : null;
+            if (!NetToJava.TryGetValue(type, out res))
+                return null;
+
+            Type directType;
+
+            if (IndirectMappingTypes.TryGetValue(type, out directType))
+                Logger.LogWarning("Type '{0}' maps to Java type '{1}' using unchecked conversion. " +
+                                  "This may cause issues in SQL queries. " +
+                                  "You can use '{2}' instead to achieve direct mapping.", type, res, directType);
+
+            return res;
         }
 
         /// <summary>

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheEntry.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheEntry.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheEntry.cs
index 5537489..31bb2ed 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheEntry.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheEntry.cs
@@ -24,7 +24,7 @@ namespace Apache.Ignite.Core.Impl.Cache
     /// <summary>
     /// Represents a cache entry.
     /// </summary>
-    internal struct CacheEntry<TK, TV> : ICacheEntry<TK, TV>
+    public struct CacheEntry<TK, TV> : ICacheEntry<TK, TV>
     {
         /** Key. */
         private readonly TK _key;

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheImpl.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheImpl.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheImpl.cs
index 266012f..8a25a2c 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheImpl.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/CacheImpl.cs
@@ -41,7 +41,7 @@ namespace Apache.Ignite.Core.Impl.Cache
     /// Native cache wrapper.
     /// </summary>
     [SuppressMessage("Microsoft.Design", "CA1001:TypesThatOwnDisposableFieldsShouldBeDisposable")]
-    internal class CacheImpl<TK, TV> : PlatformTarget, ICache<TK, TV>
+    internal class CacheImpl<TK, TV> : PlatformTarget, ICache<TK, TV>, ICacheInternal
     {
         /** Duration: unchanged. */
         private const long DurUnchanged = -2;
@@ -940,7 +940,27 @@ namespace Apache.Ignite.Core.Impl.Cache
         /** <inheritDoc /> */
         public IQueryCursor<IList> QueryFields(SqlFieldsQuery qry)
         {
+            return QueryFields(qry, ReadFieldsArrayList);
+        }
+
+        /// <summary>
+        /// Reads the fields array list.
+        /// </summary>
+        private static IList ReadFieldsArrayList(IBinaryRawReader reader, int count)
+        {
+            IList res = new ArrayList(count);
+
+            for (var i = 0; i < count; i++)
+                res.Add(reader.ReadObject<object>());
+
+            return res;
+        }
+
+        /** <inheritDoc /> */
+        public IQueryCursor<T> QueryFields<T>(SqlFieldsQuery qry, Func<IBinaryRawReader, int, T> readerFunc)
+        {
             IgniteArgumentCheck.NotNull(qry, "qry");
+            IgniteArgumentCheck.NotNull(readerFunc, "readerFunc");
 
             if (string.IsNullOrEmpty(qry.Sql))
                 throw new ArgumentException("Sql cannot be null or empty");
@@ -962,7 +982,7 @@ namespace Apache.Ignite.Core.Impl.Cache
                 cursor = UU.CacheOutOpQueryCursor(Target, (int) CacheOp.QrySqlFields, stream.SynchronizeOutput());
             }
         
-            return new FieldsQueryCursor(cursor, Marshaller, _flagKeepBinary);
+            return new FieldsQueryCursor<T>(cursor, Marshaller, _flagKeepBinary, readerFunc);
         }
 
         /** <inheritDoc /> */
@@ -998,9 +1018,18 @@ namespace Apache.Ignite.Core.Impl.Cache
             else
             {
                 writer.WriteInt(args.Length);
-        
+
                 foreach (var arg in args)
-                    writer.WriteObject(arg);
+                {
+                    // Write DateTime as TimeStamp always, otherwise it does not make sense
+                    // Wrapped DateTime comparison does not work in SQL
+                    var dt = arg as DateTime?;  // Works with DateTime also
+
+                    if (dt != null)
+                        writer.WriteTimestamp(dt);
+                    else
+                        writer.WriteObject(arg);
+                }
             }
         }
 

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/ICacheInternal.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/ICacheInternal.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/ICacheInternal.cs
new file mode 100644
index 0000000..a23cf08
--- /dev/null
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/ICacheInternal.cs
@@ -0,0 +1,40 @@
+/*
+ * Licensed to the Apache Software Foundation (ASF) under one or more
+ * contributor license agreements.  See the NOTICE file distributed with
+ * this work for additional information regarding copyright ownership.
+ * The ASF licenses this file to You under the Apache License, Version 2.0
+ * (the "License"); you may not use this file except in compliance with
+ * the License.  You may obtain a copy of the License at
+ *
+ *      http://www.apache.org/licenses/LICENSE-2.0
+ *
+ * Unless required by applicable law or agreed to in writing, software
+ * distributed under the License is distributed on an "AS IS" BASIS,
+ * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
+ * See the License for the specific language governing permissions and
+ * limitations under the License.
+ */
+
+namespace Apache.Ignite.Core.Impl.Cache
+{
+    using System;
+    using Apache.Ignite.Core.Binary;
+    using Apache.Ignite.Core.Cache.Query;
+
+    /// <summary>
+    /// Extended Cache interface for internal needs.
+    /// </summary>
+    public interface ICacheInternal
+    {
+        /// <summary>
+        /// Queries separate entry fields.
+        /// </summary>
+        /// <typeparam name="T">Type of the result.</typeparam>
+        /// <param name="qry">SQL fields query.</param>
+        /// <param name="readerFunc">Reader function, takes raw reader and field count, returns typed result.</param>
+        /// <returns>
+        /// Cursor.
+        /// </returns>
+        IQueryCursor<T> QueryFields<T>(SqlFieldsQuery qry, Func<IBinaryRawReader, int, T> readerFunc);
+    }
+}

http://git-wip-us.apache.org/repos/asf/ignite/blob/ef642e91/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/Query/FieldsQueryCursor.cs
----------------------------------------------------------------------
diff --git a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/Query/FieldsQueryCursor.cs b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/Query/FieldsQueryCursor.cs
index 42fa1b9..d33fdce 100644
--- a/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/Query/FieldsQueryCursor.cs
+++ b/modules/platforms/dotnet/Apache.Ignite.Core/Impl/Cache/Query/FieldsQueryCursor.cs
@@ -17,40 +17,44 @@
 
 namespace Apache.Ignite.Core.Impl.Cache.Query
 {
-    using System.Collections;
+    using System;
+    using System.Diagnostics;
     using System.Diagnostics.CodeAnalysis;
+    using Apache.Ignite.Core.Binary;
     using Apache.Ignite.Core.Impl.Binary;
     using Apache.Ignite.Core.Impl.Unmanaged;
 
     /// <summary>
     /// Cursor for entry-based queries.
     /// </summary>
-    internal class FieldsQueryCursor : AbstractQueryCursor<IList>
+    internal class FieldsQueryCursor<T> : AbstractQueryCursor<T>
     {
+        /** */
+        private readonly Func<IBinaryRawReader, int, T> _readerFunc;
+
         /// <summary>
         /// Constructor.
         /// </summary>
         /// <param name="target">Target.</param>
         /// <param name="marsh">Marshaler.</param>
         /// <param name="keepBinary">Keep poratble flag.</param>
-        public FieldsQueryCursor(IUnmanagedTarget target, Marshaller marsh, bool keepBinary)
+        /// <param name="readerFunc">The reader function.</param>
+        public FieldsQueryCursor(IUnmanagedTarget target, Marshaller marsh, bool keepBinary, 
+            Func<IBinaryRawReader, int, T> readerFunc)
             : base(target, marsh, keepBinary)
         {
-            // No-op.
+            Debug.Assert(readerFunc != null);
+
+            _readerFunc = readerFunc;
         }
 
         /** <inheritdoc /> */
         [SuppressMessage("Microsoft.Design", "CA1062:Validate arguments of public methods")]
-        protected override IList Read(BinaryReader reader)
+        protected override T Read(BinaryReader reader)
         {
             int cnt = reader.ReadInt();
 
-            var res = new ArrayList(cnt);
-
-            for (int i = 0; i < cnt; i++)
-                res.Add(reader.ReadObject<object>());
-
-            return res;
+            return _readerFunc(reader, cnt);
         }
     }
 }


Mime
View raw message