added limited stored proc support

Luticate2.Utils/DataAccess/LuEfCrudDataAccess.cs

             return Execute(() =>
             {
                 var queryable = GetFilterQuery(filter);
-                var v = new ExpressionVisitorDebugger();
-                v.Visit(queryable.Expression);
                 var count = queryable.Count();
                 IOrderedQueryable<TModel> ordered = null;
                 foreach (var field in orderBy.Fields)

Luticate2.Utils/DataAccess/Npgsql/ExpressionVisitorDebugger.cs

-using System.Linq.Expressions;
-
-namespace Luticate2.Utils.DataAccess.Npgsql
-{
-    public class ExpressionVisitorDebugger : ExpressionVisitor
-    {
-        protected override Expression VisitUnary(UnaryExpression node)
-        {
-            return base.VisitUnary(node);
-        }
-
-        protected override Expression VisitBinary(BinaryExpression node)
-        {
-            return base.VisitBinary(node);
-        }
-    }
-}

Luticate2.Utils/DataAccess/Npgsql/NpgsqlCompositeMethodCallTranslatorLuticate.cs

     {
         private static readonly IMethodCallTranslator[] _methodCallTranslators2 =
         {
-            new NpgsqlIntToStringTranslator()
+            new NpgsqlIntToStringTranslator(),
+            new NpgsqlStoredProcTranslator()
         };
 
         public NpgsqlCompositeMethodCallTranslatorLuticate(ILogger<NpgsqlCompositeMethodCallTranslator> logger) : base(logger)

Luticate2.Utils/DataAccess/Npgsql/NpgsqlIntToStringTranslator.cs

     {
         private readonly Type[] _declaringTypes = {typeof(int), typeof(int?)};
 
-        private readonly string _clrMethodName = "ToString";
+        private readonly string _clrMethodName = nameof(ToString);
 
         public Expression Translate(MethodCallExpression methodCallExpression)
         {
             {
                 var methodInfo = declaringType.GetTypeInfo()
                     .GetDeclaredMethods(_clrMethodName).SingleOrDefault(m => !m.GetParameters().Any());
-                if (methodInfo != null && declaringType.IsAssignableFrom(methodCallExpression.Object.Type))
+                if (methodInfo != null && methodCallExpression.Method.Name == _clrMethodName
+                    && declaringType.IsAssignableFrom(methodCallExpression.Object.Type))
                 {
                     return new ExplicitCastExpression(methodCallExpression.Object, typeof(string));
                 }

Luticate2.Utils/DataAccess/Npgsql/NpgsqlStoredProcTranslator.cs

+using System;
+using System.Linq.Expressions;
+using System.Reflection;
+using Microsoft.EntityFrameworkCore;
+using Microsoft.EntityFrameworkCore.Query.Expressions;
+using Microsoft.EntityFrameworkCore.Query.ExpressionTranslators;
+
+namespace Luticate2.Utils.DataAccess.Npgsql
+{
+    public class NpgsqlStoredProcTranslator : IMethodCallTranslator
+    {
+        private readonly Type _declaringType = typeof(DbContext);
+
+        public Expression Translate(MethodCallExpression methodCallExpression)
+        {
+            if (_declaringType.IsAssignableFrom(methodCallExpression.Method.DeclaringType))
+            {
+                return new SqlFunctionExpression(methodCallExpression.Method.Name, methodCallExpression.Type, methodCallExpression.Arguments);
+            }
+            return null;
+        }
+    }
+}

Test/Utils/DataAccess/LuUtilsPartialContext.cs

 using System;
-using Microsoft.EntityFrameworkCore;
-using Luticate2.Auth.DataAccess.Models;
-using Test.Utils.DataAccess.Models;
+using System.Linq;
 
 namespace Test.Utils.DataAccess
 {
     public partial class LuUtilsDbContext
     {
+        public static string unaccent(string str)
+        {
+            throw new NotImplementedException();
+        }
+
+        public static bool lu_texts_match(string query, string data)
+        {
+            throw new NotImplementedException();
+        }
     }
 }

Test/Utils/DataAccess/LuUtilsPkGuidDataAccess.cs

 using System.Linq.Expressions;
 using Luticate2.Utils.DataAccess;
 using Luticate2.Utils.Dbo.Filter;
+using Luticate2.Utils.Utils;
 using Test.Utils.DataAccess.Models;
 using Test.Utils.Dbo.PkGuid;
 
 
         protected override Expression<Func<pk_guid, bool>> GetFilterExpression(LuFilterDbo filter)
         {
-            var query = filter.Query.ToLower();
-            return model => model.some_text.ToLower().Contains(query) || model.some_int.ToString().Contains(query);
+            return model => LuUtilsDbContext.lu_texts_match(filter.Query, model.some_text + " " + model.some_int.ToString());
         }
     }
 }