block query from different datasource

doc/ReleaseLog.md

@@ -1,5 +1,9 @@
 # Vitorm ReleaseLog
 
+-----------------------
+# 2.1.0
+- block query from different datasource
+
 -----------------------
 # 2.0.6
 

src/Vitorm/Sql/SqlDbContext.Query.cs

@@ -118,9 +118,14 @@ namespace Vitorm.Sql
 
         public bool query_ToListAndTotalCount_InvokeInOneExecute = true;
 
-        protected virtual bool QueryIsFromSameDb(object query, Type elementType)
+        protected virtual bool QueryIsFromSameDb(object obj, Type elementType)
         {
-            return dbGroupName == QueryableBuilder.GetQueryConfig(query as IQueryable) as string;
+            if (obj is not IQueryable query) return false;
+
+            if (dbGroupName == QueryableBuilder.GetQueryConfig(query) as string) return true;
+
+            throw new InvalidOperationException("do not allow to use queryable from different datasource , queryable type: " + obj?.GetType().FullName);
+            //return false;
         }
         protected virtual object ExecuteQuery(Expression expression, Type expressionResultType, Action dispose)
         {

src/Vitorm/Sql/SqlTranslate/SqlTranslateService.cs

@@ -201,7 +201,13 @@ namespace Vitorm.Sql.SqlTranslate
                         switch (methodCall.methodName)
                         {
                             // ##1 in
-                            case nameof(Enumerable.Contains):
+                            case nameof(List<string>.Contains) when methodCall.@object is not null && methodCall.arguments.Length == 1:
+                                {
+                                    var values = methodCall.@object;
+                                    var member = methodCall.arguments[0];
+                                    return $"{EvalExpression(arg, member)} in {EvalExpression(arg, values)}";
+                                }
+                            case nameof(Enumerable.Contains) when methodCall.arguments.Length == 2:
                                 {
                                     var values = methodCall.arguments[0];
                                     var member = methodCall.arguments[1];

test/Vitorm.Data.MsTest/CustomTest/Query_JoinFromDifferenceDataSource_Test.cs

@@ -0,0 +1,61 @@
+using System.Data;
+
+using Microsoft.VisualStudio.TestTools.UnitTesting;
+
+namespace Vitorm.MsTest.CommonTest
+{
+    [TestClass]
+    public class Query_JoinFromDifferenceDataSource_Test
+    {
+
+        [TestMethod]
+        public void Test()
+        {
+            new Sqlite_Test().Init();
+            new SqliteReadOnly_Test().Init("SqliteReadOnly_Test.db");
+            new SqliteReadOnly_Test().Init("SqliteReadOnly_Test.readonly.db");
+
+            var userQuery = Data.Query<Sqlite.User>();
+
+            var userQuery2 = Data.Query<Sqlite2.User>();
+
+            var userQuery3 = Data.Query<MySql.User>();
+
+
+            {
+                try
+                {
+                    var list = (from user in userQuery
+                                from father in userQuery2.Where(father => user.fatherId == father.id)
+                                select new { user, father })
+                            .ToList();
+                    Assert.Fail("should not able to join table from different datasource");
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+
+
+            {
+                try
+                {
+                    var list = (from user in userQuery
+                                from father in userQuery3.Where(father => user.fatherId == father.id)
+                                select new { user, father })
+                            .ToList();
+
+                    Assert.Fail("should not able to join table from different datasource");
+                }
+                catch (Exception ex)
+                {
+                }
+            }
+
+
+        }
+
+
+
+    }
+}

test/Vitorm.Sqlite.MsTest/CommonTest/Property_Numeric_Test.cs

@@ -9,7 +9,6 @@ namespace Vitorm.MsTest.CommonTest
     public class Property_Numeric_Test
     {
         // Enumerable.Contains
-        // Queryable.Contains
         [TestMethod]
         public void Test_In()
         {
@@ -31,9 +30,9 @@ namespace Vitorm.MsTest.CommonTest
                 Assert.AreEqual(0, userList.Select(m => m.id).Except(new[] { 3, 5 }).Count());
             }
 
-            // Queryable.Contains
+            // List.Contains
             {
-                var ids = new[] { 3, 5 }.AsQueryable();
+                var ids = new[] { 3, 5 }.ToList();
                 var userList = userQuery.Where(u => ids.Contains(u.id)).ToList();
                 Assert.AreEqual(2, userList.Count);
                 Assert.AreEqual(0, userList.Select(m => m.id).Except(new[] { 3, 5 }).Count());

test/Vitorm.Sqlite.MsTest/CommonTest/Property_String_Test.cs

@@ -10,7 +10,6 @@ namespace Vitorm.MsTest.CommonTest
     {
 
         // Enumerable.Contains
-        // Queryable.Contains
         [TestMethod]
         public void Test_In()
         {
@@ -32,9 +31,9 @@ namespace Vitorm.MsTest.CommonTest
                 Assert.AreEqual(0, userList.Select(m => m.name).Except(new[] { "u356", "u500" }).Count());
             }
 
-            // Queryable.Contains
+            // List.Contains
             {
-                var ids = new[] { "u356", "u500" }.AsQueryable();
+                var ids = new[] { "u356", "u500" }.ToList();
                 var userList = userQuery.Where(u => ids.Contains(u.name)).ToList();
                 Assert.AreEqual(2, userList.Count);
                 Assert.AreEqual(0, userList.Select(m => m.name).Except(new[] { "u356", "u500" }).Count());