optimize

README.md

@@ -24,6 +24,8 @@ Vitorm: an simple orm by Vit.Linq
 
 
 
+Async
+TinyOrm
 
 
 

src/Vitorm.MySql/DbContext_Extensions.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Data;
 
-using Vitorm.Entity;
-using Vitorm.Entity.Dapper;
 using Vitorm.Sql;
 using Vitorm.Sql.SqlTranslate;
 
@@ -25,14 +23,12 @@ namespace Vit.Extensions
          */
         public static SqlDbContext UseMySql(this SqlDbContext dbContext, string ConnectionString)
         {
-            ISqlTranslateService sqlTranslateService =   Vitorm.MySql.SqlTranslateService.Instance;
+            ISqlTranslateService sqlTranslateService = Vitorm.MySql.SqlTranslateService.Instance;
 
             Func<IDbConnection> createDbConnection = () => new MySqlConnector.MySqlConnection(ConnectionString);
 
-            Func<Type, IEntityDescriptor> getEntityDescriptor = (type) => EntityDescriptor.GetEntityDescriptor(type);
 
-
-            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection, getEntityDescriptor: getEntityDescriptor);
+            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection);
 
             dbContext.createTransactionScope = (dbContext) => new Vitorm.MySql.SqlTransactionScope(dbContext);
             //dbContext.createTransactionScope = (dbContext) => new Vitorm.Mysql.SqlTransactionScope_Command(dbContext);

src/Vitorm.MySql/Vitorm.MySql.csproj

@@ -14,8 +14,16 @@
         <Authors>Lith</Authors>
         <Description>orm for MySql</Description>
         <PackageProjectUrl>https://github.com/VitormLib/Vitorm</PackageProjectUrl>
+        <PackageIcon>vitorm_logo_v1.png</PackageIcon>
     </PropertyGroup>
 
+    <ItemGroup>
+      <None Include="..\..\doc\vitorm_logo_v1.png">
+        <Pack>True</Pack>
+        <PackagePath>\</PackagePath>
+      </None>
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="MySqlConnector" Version="2.3.7" />
     </ItemGroup>

src/Vitorm.SqlServer/DbContext_Extensions.cs

@@ -1,11 +1,8 @@
 using System;
 using System.Data;
 
-using Vitorm.Entity;
-using Vitorm.Entity.Dapper;
 using Vitorm.Sql;
 using Vitorm.Sql.SqlTranslate;
-using Vitorm.SqlServer;
 
 namespace Vit.Extensions
 {
@@ -17,10 +14,7 @@ namespace Vit.Extensions
 
             Func<IDbConnection> createDbConnection = () => new Microsoft.Data.SqlClient.SqlConnection(ConnectionString);
 
-            Func<Type, IEntityDescriptor> getEntityDescriptor = (type) => EntityDescriptor.GetEntityDescriptor(type);
-
-
-            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection, getEntityDescriptor: getEntityDescriptor);
+            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection);
             dbContext.createTransactionScope = (dbContext) => new Vitorm.SqlServer.SqlTransactionScope(dbContext);
 
             return dbContext;

src/Vitorm.SqlServer/Vitorm.SqlServer.csproj

@@ -14,8 +14,16 @@
         <Authors>Lith</Authors>
         <Description>orm for SqlServer</Description>
         <PackageProjectUrl>https://github.com/VitormLib/Vitorm</PackageProjectUrl>
+        <PackageIcon>vitorm_logo_v1.png</PackageIcon>
     </PropertyGroup>
 
+    <ItemGroup>
+      <None Include="..\..\doc\vitorm_logo_v1.png">
+        <Pack>True</Pack>
+        <PackagePath>\</PackagePath>
+      </None>
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="Microsoft.Data.SqlClient" Version="5.2.1" />
     </ItemGroup>

src/Vitorm.Sqlite/DbContext_Extensions.cs

@@ -1,8 +1,6 @@
 using System;
 using System.Data;
 
-using Vitorm.Entity;
-using Vitorm.Entity.Dapper;
 using Vitorm.Sql;
 using Vitorm.Sql.SqlTranslate;
 
@@ -12,14 +10,12 @@ namespace Vit.Extensions
     {
         public static SqlDbContext UseSqlite(this SqlDbContext dbContext, string ConnectionString)
         {
-            ISqlTranslateService sqlTranslateService =   Vitorm.Sqlite.SqlTranslateService.Instance;
+            ISqlTranslateService sqlTranslateService = Vitorm.Sqlite.SqlTranslateService.Instance;
 
             Func<IDbConnection> createDbConnection = () => new Microsoft.Data.Sqlite.SqliteConnection(ConnectionString);
 
-            Func<Type, IEntityDescriptor> getEntityDescriptor = (type) => EntityDescriptor.GetEntityDescriptor(type);
 
-
-            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection, getEntityDescriptor: getEntityDescriptor);
+            dbContext.Init(sqlTranslateService: sqlTranslateService, createDbConnection: createDbConnection);
 
             dbContext.createTransactionScope = (dbContext) => new Vitorm.Sqlite.SqlTransactionScope(dbContext);
 

src/Vitorm.Sqlite/Vitorm.Sqlite.csproj

@@ -14,8 +14,16 @@
         <Authors>Lith</Authors>
         <Description>orm for Sqlite</Description>
         <PackageProjectUrl>https://github.com/VitormLib/Vitorm</PackageProjectUrl>
+        <PackageIcon>vitorm_logo_v1.png</PackageIcon>
     </PropertyGroup>
 
+    <ItemGroup>
+      <None Include="..\..\doc\vitorm_logo_v1.png">
+        <Pack>True</Pack>
+        <PackagePath>\</PackagePath>
+      </None>
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="Microsoft.Data.Sqlite" Version="8.0.6" />
     </ItemGroup>

src/Vitorm/DbContext.cs

@@ -5,37 +5,53 @@ using System.Linq;
 using Vit.Linq.ExpressionTree;
 
 using Vitorm.Entity;
+using Vitorm.Entity.Dapper;
 
 namespace Vitorm
 {
     public class DbContext : IDisposable
     {
-        public DbContext() { }
+        public DbContext()
+        {
+            dbSetCreator = DefaultDbSetCreator;
+        }
 
-        public virtual ExpressionConvertService convertService => Environment.convertService;
 
-        public Func<Type, IDbSet> dbSetCreator { set; protected get; }
+        #region DbSet
+
+        public IDbSet DefaultDbSetCreator(Type entityType)
+        {
+            var entityDescriptor = GetEntityDescriptor(entityType);
+            return DbSetConstructor.CreateDbSet(this, entityType, entityDescriptor);
+        }
+
+        protected virtual Func<Type, IDbSet> dbSetCreator { set; get; }
 
-        Dictionary<Type, IDbSet> dbSetMap = new();
+        Dictionary<Type, IDbSet> dbSetMap = null;
 
         public virtual IDbSet DbSet(Type entityType)
         {
-            if (dbSetMap.TryGetValue(entityType, out var dbSet)) return dbSet;
+            if (dbSetMap?.TryGetValue(entityType, out var dbSet) == true) return dbSet;
 
             dbSet = dbSetCreator(entityType);
             if (dbSet == null) return null;
+
+            dbSetMap ??= new();
             dbSetMap[entityType] = dbSet;
             return dbSet;
-
-            //return dbSetMap.GetOrAdd(entityType, dbSetCreator);
         }
         public virtual DbSet<Entity> DbSet<Entity>()
         {
             return DbSet(typeof(Entity)) as DbSet<Entity>;
         }
+        #endregion
+
 
+        public virtual IEntityDescriptor GetEntityDescriptor(Type entityType) => EntityDescriptor.GetEntityDescriptor(entityType);
+
+
+        public virtual ExpressionConvertService convertService => Environment.convertService;
 
-        public virtual IEntityDescriptor GetEntityDescriptor(Type entityType) => DbSet(entityType)?.entityDescriptor;
 
 
         // #1 Schema :  Create

src/Vitorm/DbSet.cs

@@ -1,5 +1,7 @@
-using System.Collections.Generic;
+using System;
+using System.Collections.Generic;
 using System.Linq;
+using System.Reflection;
 
 using Vitorm.Entity;
 
@@ -10,32 +12,62 @@ namespace Vitorm
         IEntityDescriptor entityDescriptor { get; }
     }
 
-    public abstract class DbSet<Entity> : IDbSet
+    public class DbSetConstructor
     {
-        public abstract IEntityDescriptor entityDescriptor { get; }
+        public static IDbSet CreateDbSet(DbContext dbContext, Type entityType, IEntityDescriptor entityDescriptor)
+        {
+            return _CreateDbSet.MakeGenericMethod(entityType)
+                     .Invoke(null, new object[] { dbContext, entityDescriptor }) as IDbSet;
+        }
+
+        static MethodInfo _CreateDbSet = new Func<DbContext, IEntityDescriptor, IDbSet>(CreateDbSet<object>)
+                   .Method.GetGenericMethodDefinition();
+        public static IDbSet CreateDbSet<Entity>(DbContext dbContext, IEntityDescriptor entityDescriptor)
+        {
+            return new DbSet<Entity>(dbContext, entityDescriptor);
+        }
+
+    }
+
+
+    public class DbSet<Entity> : IDbSet
+    {
+        protected DbContext dbContext;
+
+        protected IEntityDescriptor _entityDescriptor;
+        public virtual IEntityDescriptor entityDescriptor => _entityDescriptor;
+
+
+        public DbSet(DbContext dbContext, IEntityDescriptor entityDescriptor)
+        {
+            this.dbContext = dbContext;
+            this._entityDescriptor = entityDescriptor;
+        }
+
+        public virtual void Create() => dbContext.Create<Entity>();
+
 
 
-        public abstract void Create();
+        public virtual Entity Add(Entity entity) => dbContext.Add(entity);
+        public virtual void AddRange(IEnumerable<Entity> entitys) => dbContext.AddRange(entitys);
 
 
-        public abstract Entity Add(Entity entity);
-        public abstract void AddRange(IEnumerable<Entity> entitys);
 
 
-        public abstract Entity Get(object keyValue);
-        public abstract IQueryable<Entity> Query();
+        public virtual Entity Get(object keyValue) => dbContext.Get<Entity>(keyValue);
+        public virtual IQueryable<Entity> Query() => dbContext.Query<Entity>();
 
 
 
-        public abstract int Update(Entity entity);
-        public abstract int UpdateRange(IEnumerable<Entity> entitys);
+        public virtual int Update(Entity entity) => dbContext.Update<Entity>(entity);
+        public virtual int UpdateRange(IEnumerable<Entity> entitys) => dbContext.UpdateRange<Entity>(entitys);
 
 
-        public abstract int Delete(Entity entity);
-        public abstract int DeleteRange(IEnumerable<Entity> entitys);
 
-        public abstract int DeleteByKey(object keyValue);
-        public abstract int DeleteByKeys<Key>(IEnumerable<Key> keys);
+        public virtual int Delete(Entity entity) => dbContext.Delete<Entity>(entity);
+        public virtual int DeleteRange(IEnumerable<Entity> entitys) => dbContext.DeleteRange<Entity>(entitys);
+        public virtual int DeleteByKey(object keyValue) => dbContext.DeleteByKey<Entity>(keyValue);
+        public virtual int DeleteByKeys<Key>(IEnumerable<Key> keys) => dbContext.DeleteByKeys<Entity, Key>(keys);
 
 
 

src/Vitorm/Entity/DataAnnotations/EntityDescriptor.cs

@@ -10,7 +10,7 @@ namespace Vitorm.Entity.Dapper
         static ConcurrentDictionary<Type, EntityDescriptor> descMap = new();
 
 
-        public static EntityDescriptor GetEntityDescriptor(Type entityType)
+        public static IEntityDescriptor GetEntityDescriptor(Type entityType)
         {
             if (descMap.TryGetValue(entityType, out var entityDescriptor)) return entityDescriptor;
 
@@ -20,7 +20,7 @@ namespace Vitorm.Entity.Dapper
             return entityDescriptor;
         }
 
-        public static EntityDescriptor GetEntityDescriptor<Entity>()
+        public static IEntityDescriptor GetEntityDescriptor<Entity>()
         {
             return GetEntityDescriptor(typeof(Entity));
         }

src/Vitorm/Sql/SqlDbContext.cs

@@ -5,7 +5,6 @@ using System.Linq;
 using System.Linq.Expressions;
 using Vit.Linq.ExpressionTree.ComponentModel;
 using Vit.Linq;
-using Vitorm.Entity;
 using Vitorm.Sql.Transaction;
 using Vitorm.Sql.SqlTranslate;
 using Vitorm.StreamQuery;
@@ -22,7 +21,6 @@ namespace Vitorm.Sql
         {
             base.Dispose();
 
-
             transactionScope?.Dispose();
             transactionScope = null;
 
@@ -34,25 +32,12 @@ namespace Vitorm.Sql
 
         public virtual ISqlTranslateService sqlTranslateService { get; private set; }
 
-
-        public virtual void Init(ISqlTranslateService sqlTranslateService, Func<IDbConnection> createDbConnection, Func<Type, IEntityDescriptor> getEntityDescriptor)
+        public virtual void Init(ISqlTranslateService sqlTranslateService, Func<IDbConnection> createDbConnection)
         {
             this.sqlTranslateService = sqlTranslateService;
             this.createDbConnection = createDbConnection;
-
-            this.dbSetCreator = (entityType) =>
-            {
-                var entityDescriptor = getEntityDescriptor(entityType);
-                return SqlDbSetConstructor.CreateDbSet(this, entityType, entityDescriptor);
-            };
         }
-        public virtual void Init(ISqlTranslateService sqlTranslator, Func<IDbConnection> createDbConnection, Func<Type, IDbSet> dbSetCreator)
-        {
-            this.sqlTranslateService = sqlTranslator;
-            this.createDbConnection = createDbConnection;
 
-            this.dbSetCreator = dbSetCreator;
-        }
 
         #region #0 Schema :  Create
 
@@ -110,7 +95,7 @@ namespace Vitorm.Sql
             (string sql, Func<object, Dictionary<string, object>> GetSqlParams) = sqlTranslateService.PrepareAdd(arg);
 
             // #2 execute
-            var affectedRowCount = 0; 
+            var affectedRowCount = 0;
 
             if (entityDescriptor.key.databaseGenerated == System.ComponentModel.DataAnnotations.Schema.DatabaseGeneratedOption.Identity)
             {
@@ -184,18 +169,12 @@ namespace Vitorm.Sql
             Func<Expression, Type, object> QueryExecutor = (expression, type) =>
             {
                 // #1 convert to ExpressionNode
-                // (query) => query.Where().OrderBy().Skip().Take().Select().ToList();
-                // (users) => users.SelectMany(
-                //      user => users.Where(father => (father.id == user.fatherId)).DefaultIfEmpty(),
-                //      (user, father) => new <>f__AnonymousType4`2(user = user, father = father)
-                //  ).Where().Select();
                 var isArgument = QueryableBuilder.QueryTypeNameCompare(dbContextId);
                 ExpressionNode node = convertService.ConvertToData(expression, autoReduce: true, isArgument: isArgument);
                 //var strNode = Json.Serialize(node);
 
 
-                // #2 convert to Streams
-                // {select,left,joins,where,order,skip,take}
+                // #2 convert to Stream
                 var stream = StreamReader.ReadNode(node);
                 //var strStream = Json.Serialize(stream);
 

src/Vitorm/Sql/SqlDbSet.cs

@@ -1,69 +0,0 @@
-using System;
-using System.Collections.Generic;
-using System.Linq;
-using Vitorm.Entity;
-using System.Reflection;
-using Vitorm.Sql.SqlTranslate;
-
-namespace Vitorm.Sql
-{
-    public class SqlDbSetConstructor
-    {
-        public static IDbSet CreateDbSet( SqlDbContext dbContext, Type entityType, IEntityDescriptor entityDescriptor)
-        {
-            return _CreateDbSet.MakeGenericMethod(entityType)
-                     .Invoke(null, new object[] { dbContext, entityDescriptor }) as IDbSet;
-        }
-       
-        static MethodInfo _CreateDbSet = new Func<SqlDbContext, IEntityDescriptor,IDbSet>(CreateDbSet<object>)
-                   .Method.GetGenericMethodDefinition();
-        public static IDbSet CreateDbSet<Entity>(SqlDbContext dbContext, IEntityDescriptor entityDescriptor)
-        {
-            return new SqlDbSet<Entity>(dbContext, entityDescriptor);
-        }
-
-    }
-
-    public class SqlDbSet<Entity> : Vitorm.DbSet<Entity>
-    {
-        protected SqlDbContext dbContext;
-
-        protected IEntityDescriptor _entityDescriptor;
-        public override IEntityDescriptor entityDescriptor => _entityDescriptor;
-
-
-        public virtual ISqlTranslateService sqlTranslator => dbContext.sqlTranslateService;
-
-        public SqlDbSet(SqlDbContext dbContext, IEntityDescriptor entityDescriptor)
-        {
-            this.dbContext = dbContext;
-            this._entityDescriptor = entityDescriptor;
-        }
-
-        public override void Create() => dbContext.Create<Entity>();
-
-
-
-        public override Entity Add(Entity entity) => dbContext.Add(entity);
-        public override void AddRange(IEnumerable<Entity> entitys) => dbContext.AddRange(entitys);
-
-
-
-
-        public override Entity Get(object keyValue) => dbContext.Get<Entity>(keyValue);
-        public override IQueryable<Entity> Query() => dbContext.Query<Entity>();
-
-
-
-        public override int Update(Entity entity) => dbContext.Update<Entity>(entity);
-        public override int UpdateRange(IEnumerable<Entity> entitys) => dbContext.UpdateRange<Entity>(entitys);
-
-
-
-        public override int Delete(Entity entity) => dbContext.Delete<Entity>(entity);
-        public override int DeleteRange(IEnumerable<Entity> entitys) => dbContext.DeleteRange<Entity>(entitys);
-        public override int DeleteByKey(object keyValue) => dbContext.DeleteByKey<Entity>(keyValue);
-        public override int DeleteByKeys<Key>(IEnumerable<Key> keys) => dbContext.DeleteByKeys<Entity, Key>(keys);
-
-    }
-}

src/Vitorm/Sql/SqlTranslate/BaseQueryTranslateService.cs

@@ -161,7 +161,7 @@ namespace Vitorm.Sql.SqlTranslate
         protected virtual string BuildReader(QueryTranslateArgument arg, CombinedStream stream, EntityReader reader)
         {
             var resultEntityType = arg.resultEntityType;
-            ExpressionNode selectedFields = stream.select?.fields as ExpressionNode;
+            ExpressionNode selectedFields = stream.select?.fields;
             if (selectedFields == null)
             {
                 if (stream.joins?.Any() != true && resultEntityType != null)

src/Vitorm/StreamQuery/CombinedStream.cs

@@ -58,7 +58,7 @@ value(Vit.Linq.Converter.OrderedQueryable`1[Vit.Linq.MsTest.Converter.Join_Test+
         public List<StreamToJoin> joins { get; set; }
         public ExpressionNode GetSelectedFields(Type entityType)
         {
-            var parameterValue = select?.fields as ExpressionNode;
+            var parameterValue = select?.fields;
             if (parameterValue == null && joins?.Any() != true)
             {
                 parameterValue = ExpressionNode_RenameableMember.Member(stream: source, entityType);

src/Vitorm/StreamQuery/SelectedFields.cs

@@ -1,29 +1,12 @@
-using System.Linq;
-
-using Vit.Linq.ExpressionTree.ComponentModel;
+using Vit.Linq.ExpressionTree.ComponentModel;
 
 namespace Vitorm.StreamQuery
 {
     public class SelectedFields
     {
         // root value of ExpressionNode_Member is IStream
-        public ExpressionNode_New fields;
+        public ExpressionNode fields { get; set; }
 
         public bool? isDefaultSelect { get; set; }
-        internal bool TryGetField(string fieldName, out ExpressionNode field)
-        {
-            field = null;
-
-            var fieldInfo = fields?.memberArgs?.FirstOrDefault(m => m.name == fieldName);
-
-            fieldInfo ??= fields?.constructorArgs?.FirstOrDefault(m => m.name == fieldName);
-
-            if (fieldInfo != null)
-            {
-                field = fieldInfo.value;
-                return true;
-            }
-            return false;
-        }
     }
 }

src/Vitorm/StreamQuery/StreamReader.DeepClone.cs

@@ -1,7 +1,5 @@
 using System;
-using System.Collections.Generic;
 using System.Linq;
-using System.Text;
 
 using Vit.Linq.ExpressionTree.ComponentModel;
 

src/Vitorm/StreamQuery/StreamReader.GroupBy.cs

@@ -44,7 +44,7 @@ namespace Vitorm.StreamQuery
                         else
                         {
                             var parameterName = resultSelector.parameterNames[0];
-                            var parameterValue = (ExpressionNode)combinedStream.select.fields;
+                            var parameterValue = combinedStream.select.fields;
 
                             var newArg = arg.WithParameter(parameterName, parameterValue);
                             var groupByFields = ReadFields(newArg, resultSelector);

src/Vitorm/StreamQuery/StreamReader.Join.cs

@@ -40,7 +40,7 @@ namespace Vitorm.StreamQuery
                         {
                             // merge multiple join
                             finalStream = combinedStream;
-                            parameterValueForLeftStream = combinedStream.select.fields as ExpressionNode;
+                            parameterValueForLeftStream = combinedStream.select.fields;
                             break;
                         }
                         throw new NotSupportedException($"[StreamReader] not support inner select in join sentence");

src/Vitorm/StreamQuery/StreamReader.SelectMany.cs

@@ -37,7 +37,7 @@ namespace Vitorm.StreamQuery
                         {
                             // merge multiple join
                             finalStream = combinedStream;
-                            parameterValueForLeftStream = combinedStream.select.fields as ExpressionNode;
+                            parameterValueForLeftStream = combinedStream.select.fields;
                             break;
                         }
                         throw new NotSupportedException($"[StreamReader] not support inner select in join sentence");

src/Vitorm/StreamQuery/StreamReader.cs

@@ -104,7 +104,7 @@ namespace Vitorm.StreamQuery
 
             return StreamReader.DeepClone(node, GetParameter);
         }
-   
+
     }
 
     public partial class StreamReader
@@ -289,7 +289,7 @@ namespace Vitorm.StreamQuery
                                         case CombinedStream combinedStream:
                                             {
                                                 var parameterName = resultSelector.parameterNames[0];
-                                                var parameterValue = (ExpressionNode)combinedStream.select.fields;
+                                                var parameterValue = combinedStream.select.fields;
                                                 var newArg = arg.WithParameter(parameterName, parameterValue);
                                                 var select = ReadFieldSelect(newArg, resultSelector);
 
@@ -315,7 +315,7 @@ namespace Vitorm.StreamQuery
                                         case CombinedStream combinedStream:
                                             {
                                                 var parameterName = resultSelector.parameterNames[0];
-                                                var parameterValue = combinedStream.select.fields as ExpressionNode;
+                                                var parameterValue = combinedStream.select.fields;
                                                 var select = ReadFieldSelect(arg.WithParameter(parameterName, parameterValue), resultSelector);
 
                                                 return new StreamToUpdate(source) { fieldsToUpdate = select.fields };
@@ -432,17 +432,26 @@ namespace Vitorm.StreamQuery
             if (node?.nodeType != NodeType.New && node?.nodeType != NodeType.Member)
                 throw new NotSupportedException($"[StreamReader] unexpected expression nodeType : {node.nodeType}");
 
+            bool isDefaultSelect = false;
+            var fields = arg.DeepClone(node);
 
-            bool? existCalculatedField = null;
-
-            var fields = arg.DeepClone(node) as ExpressionNode_New;
+            if (fields?.nodeType == NodeType.Member)
+            {
+                ExpressionNode_Member member = fields;
+                if (member.parameterName == resultSelector.parameterNames[0] && member.memberName == null) 
+                    isDefaultSelect = true;
+            }
+            else if (fields?.nodeType == NodeType.New)
+            {
+                bool? existCalculatedField = null;
+                if (existCalculatedField != true)
+                    existCalculatedField = fields.constructorArgs?.Exists(m => m?.value?.nodeType != NodeType.Member && m?.value?.nodeType != NodeType.New);
 
-            if (existCalculatedField != true)
-                existCalculatedField = fields.constructorArgs?.Exists(m => m?.value?.nodeType != NodeType.Member && m?.value?.nodeType != NodeType.New);
+                if (existCalculatedField != true)
+                    existCalculatedField = fields.memberArgs?.Exists(m => m?.value?.nodeType != NodeType.Member && m?.value?.nodeType != NodeType.New);
 
-            if (existCalculatedField != true)
-                existCalculatedField = fields.memberArgs?.Exists(m => m?.value?.nodeType != NodeType.Member && m?.value?.nodeType != NodeType.New);
-            var isDefaultSelect = !(existCalculatedField ?? false);
+                isDefaultSelect = !(existCalculatedField ?? false);
+            }
 
             return new() { fields = fields, isDefaultSelect = isDefaultSelect };
         }

src/Vitorm/Vitorm.csproj

@@ -14,14 +14,22 @@
         <Authors>Lith</Authors>
         <Description>Vitorm : simple orm</Description>
         <PackageProjectUrl>https://github.com/VitormLib/Vitorm</PackageProjectUrl>
+        <PackageIcon>vitorm_logo_v1.png</PackageIcon>
     </PropertyGroup>
 
+    <ItemGroup>
+      <None Include="..\..\doc\vitorm_logo_v1.png">
+        <Pack>True</Pack>
+        <PackagePath>\</PackagePath>
+      </None>
+    </ItemGroup>
+
     <ItemGroup>
         <PackageReference Include="System.ComponentModel.Annotations" Version="5.0.0" />
     </ItemGroup>
 
     <ItemGroup>
-        <PackageReference Include="Vit.Linq" Version="2.2.22-temp-ki9" />
+        <ProjectReference Include="..\..\..\Vit.Linq\src\Vit.Linq\Vit.Linq.csproj" />
     </ItemGroup>
 
 </Project>

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

@@ -61,6 +61,10 @@ namespace Vitorm.MsTest.CommonTest
                 Assert.AreEqual(1, userList.Count);
                 Assert.AreEqual(3, userList.First().id);
             }
+            {
+                var userList = userQuery.Where(u => u.id == 3).Where(m => m.fatherId == 5).ToList();
+                Assert.AreEqual(3, userList.First().id);
+            }
             {
                 var userList = userQuery.Where(u => u.id + 1 == 4).Where(m => m.fatherId == 5).ToList();
                 Assert.AreEqual(3, userList.First().id);
@@ -237,6 +241,10 @@ namespace Vitorm.MsTest.CommonTest
             using var dbContext = DataSource.CreateDbContext();
             var userQuery = dbContext.Query<User>();
 
+            {
+                var id = userQuery.Select(u => u.id).FirstOrDefault();
+                Assert.AreEqual(1, id);
+            }
             {
                 var user = userQuery.LastOrDefault();
                 Assert.AreEqual(6, user?.id);
@@ -322,6 +330,22 @@ namespace Vitorm.MsTest.CommonTest
             using var dbContext = DataSource.CreateDbContext();
             var userQuery = dbContext.Query<User>();
 
+            // string in
+            {
+                var userList = userQuery.Where(u => new[] { "u3", "u5" }.Contains(u.name)).ToList();
+                Assert.AreEqual(2, userList.Count);
+                Assert.AreEqual(3, userList.First().id);
+                Assert.AreEqual(5, userList.Last().id);
+            }
+            // string not in
+            {
+                var userList = userQuery.Where(u => !new[] { "u3", "u5" }.Contains(u.name)).ToList();
+                Assert.AreEqual(4, userList.Count);
+                Assert.AreEqual(1, userList.First().id);
+                Assert.AreEqual(4, userList[2].id);
+            }
+
+            // numeric in
             {
                 var userList = userQuery.Where(u => new[] { 3, 5 }.Contains(u.id)).ToList();
                 Assert.AreEqual(2, userList.Count);