diff --git a/OrmTest/UnitTest/ExpressionTest/Method.cs b/OrmTest/UnitTest/ExpressionTest/Method.cs
index ca0de130d..d944776af 100644
--- a/OrmTest/UnitTest/ExpressionTest/Method.cs
+++ b/OrmTest/UnitTest/ExpressionTest/Method.cs
@@ -30,11 +30,118 @@ namespace OrmTest.UnitTest
                 ToLower();
                 Trim();
                 Contains();
+                Between();
+                Equals();
+                Equals_2();
+                DateIsSameByDay();
+                DateIsSameByType();
+                DateAddDay();
+                DateAddByType();
                 #endregion
             }
             base.End("Method Test");
         }
 
+        private void Between()
+        {
+            //throw new NotImplementedException();
+        }
+
+        private void DateAddByType()
+        {
+            var x2 = DateTime.Now;
+            Expression<Func<Student, bool>> exp = it => NBORM.DateAdd(x2, 11, DateType.Millisecond);
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, " (DATEADD(@MethodConst2,@MethodConst1,@MethodConst0)) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",11),
+                new SugarParameter("@MethodConst2",DateType.Millisecond)
+            }, "DateAddByType");
+        }
+        private void DateAddDay()
+        {
+            var x2 = DateTime.Now;
+            Expression<Func<Student, bool>> exp = it => NBORM.DateAdd(x2, 1);
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, " (DATEADD(day,@MethodConst1,@MethodConst0)) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",1)
+            }, "DateIsSameByType");
+        }
+
+        private void DateIsSameByType()
+        {
+            var x2 = DateTime.Now;
+            Expression<Func<Student, bool>> exp = it => NBORM.DateIsSame(x2,x2, DateType.Millisecond);
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, " (DATEDIFF(@MethodConst2,@MethodConst0,@MethodConst1)=0) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2),
+                new SugarParameter("@MethodConst2",DateType.Millisecond)
+            }, "DateIsSameByType");
+        }
+        private void DateIsSameByDay()
+        {
+            var x2 = DateTime.Now;
+            Expression<Func<Student, bool>> exp = it => NBORM.DateIsSame(x2,x2);
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, "(DATEDIFF(day,@MethodConst0,@MethodConst1)=0) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0",x2),new SugarParameter("@MethodConst1",x2)
+            }, "DateIsSameDay");
+        }
+
+        private void Equals()
+        {
+            Expression<Func<Student, bool>> exp = it => NBORM.Equals(it.Name, "a");
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, " ([Name] = @MethodConst0) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0","a")
+            }, "Equals1");
+
+
+            Expression<Func<Student, bool>> exp2 = it => NBORM.Equals("a",it.Name);
+            SqlServerExpressionContext expContext2 = new SqlServerExpressionContext();
+            expContext2.Resolve(exp2, ResolveExpressType.WhereSingle);
+            var value2 = expContext2.Result.GetString();
+            var pars2 = expContext2.Parameters;
+            base.Check(value2, pars2, " (@MethodConst0 = [Name]) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0","a")
+            }, "Equals2");
+        }
+        private void Equals_2()
+        {
+            Expression<Func<Student, bool>> exp = it => NBORM.Equals(it.Name, it.Name);
+            SqlServerExpressionContext expContext = new SqlServerExpressionContext();
+            expContext.Resolve(exp, ResolveExpressType.WhereSingle);
+            var value = expContext.Result.GetString();
+            var pars = expContext.Parameters;
+            base.Check(value, pars, " ([Name] = [Name]) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0","a")
+            }, "Equals1");
+
+
+            Expression<Func<Student, bool>> exp2 = it => NBORM.Equals("a", "a2");
+            SqlServerExpressionContext expContext2 = new SqlServerExpressionContext();
+            expContext2.Resolve(exp2, ResolveExpressType.WhereSingle);
+            var value2 = expContext2.Result.GetString();
+            var pars2 = expContext2.Parameters;
+            base.Check(value2, pars2, " (@MethodConst0 = @MethodConst1) ", new List<SugarParameter>() {
+                new SugarParameter("@MethodConst0","a"),new SugarParameter("@MethodConst1","a2")
+            }, "Equals2");
+        }
+
         private void Contains()
         {
             Expression<Func<Student, bool>> exp = it => NBORM.Contains(it.Name,"a");
diff --git a/SqlSugar/ExpressionsToSql/Common/DeteType.cs b/SqlSugar/ExpressionsToSql/Common/DeteType.cs
new file mode 100644
index 000000000..6de1122b4
--- /dev/null
+++ b/SqlSugar/ExpressionsToSql/Common/DeteType.cs
@@ -0,0 +1,19 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+using System.Text;
+using System.Threading.Tasks;
+
+namespace SqlSugar
+{
+    public enum DateType
+    {
+        Year = 1,
+        Month = 2,
+        Day =3,
+        Hour = 4,
+        Second=5,
+        Minute=6,
+        Millisecond=7
+    }
+}
diff --git a/SqlSugar/ExpressionsToSql/Method/DefaultDbMethod.cs b/SqlSugar/ExpressionsToSql/Method/DefaultDbMethod.cs
index cbcd0176c..64e4178e6 100644
--- a/SqlSugar/ExpressionsToSql/Method/DefaultDbMethod.cs
+++ b/SqlSugar/ExpressionsToSql/Method/DefaultDbMethod.cs
@@ -37,5 +37,42 @@ namespace SqlSugar
             var parameter2 = model.Args[1];
             return string.Format(" ({0} like '%'+{1}+'%') ", parameter.Value, parameter2.Value);
         }
+
+        public object Equals(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter2 = model.Args[1];
+            return string.Format(" ({0} = {1}) ", parameter.Value, parameter2.Value); ;
+        }
+
+        public object DateIsSameDay(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter2 = model.Args[1];
+            return string.Format(" (DATEDIFF(day,{0},{1})=0) ", parameter.Value, parameter2.Value); ;
+        }
+
+        public object DateIsSameByType(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter2 = model.Args[1];
+            var parameter3 = model.Args[2];
+            return string.Format(" (DATEDIFF({2},{0},{1})=0) ", parameter.Value, parameter2.Value, parameter3.Value); 
+        }
+
+        public object DateAddByType(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter2 = model.Args[1];
+            var parameter3 = model.Args[2];
+            return string.Format(" (DATEADD({2},{1},{0})) ", parameter.Value, parameter2.Value, parameter3.Value);
+        }
+
+        public object DateAddDay(MethodCallExpressionModel model)
+        {
+            var parameter = model.Args[0];
+            var parameter2 = model.Args[1];
+            return string.Format(" (DATEADD(day,{1},{0})) ", parameter.Value, parameter2.Value); 
+        }
     }
 }
diff --git a/SqlSugar/ExpressionsToSql/Method/IDbMethods.cs b/SqlSugar/ExpressionsToSql/Method/IDbMethods.cs
index 1e4154a07..a50c2a342 100644
--- a/SqlSugar/ExpressionsToSql/Method/IDbMethods.cs
+++ b/SqlSugar/ExpressionsToSql/Method/IDbMethods.cs
@@ -16,5 +16,10 @@ namespace SqlSugar
         object ToUpper(MethodCallExpressionModel model);
         object Trim(MethodCallExpressionModel model);
         object Contains(MethodCallExpressionModel model);
+        object Equals(MethodCallExpressionModel model);
+        object DateIsSameDay(MethodCallExpressionModel model);
+        object DateIsSameByType(MethodCallExpressionModel model);
+        object DateAddByType(MethodCallExpressionModel model);
+        object DateAddDay(MethodCallExpressionModel model);
     }
 }
diff --git a/SqlSugar/ExpressionsToSql/Method/NBORM.cs b/SqlSugar/ExpressionsToSql/Method/NBORM.cs
index 66f4db4b1..2456d3a8a 100644
--- a/SqlSugar/ExpressionsToSql/Method/NBORM.cs
+++ b/SqlSugar/ExpressionsToSql/Method/NBORM.cs
@@ -13,5 +13,10 @@ namespace SqlSugar
         public static string ToUpper(object thisValue) { throw new NotImplementedException(); }
         public static string Trim(object thisValue) { throw new NotImplementedException(); }
         public static bool Contains(string thisValue, string parameterValue) {  throw new NotImplementedException();}
+        public new static bool Equals(object thisValue, object parameterValue) { throw new NotImplementedException(); }
+        public static bool DateIsSame(DateTime date1, DateTime date2) {  throw new NotImplementedException();}
+        public static bool DateIsSame(DateTime date1, DateTime date2, DateType dataType)  { throw new NotImplementedException(); }
+        public static bool DateAdd(DateTime date1, int addValue, DateType millisecond){ throw new NotImplementedException(); }
+        public static bool DateAdd(DateTime date1, int addValue) { throw new NotImplementedException(); }
     }
 }
diff --git a/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs b/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs
index d1fc68c9b..f9363ddf7 100644
--- a/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs
+++ b/SqlSugar/ExpressionsToSql/ResolveItems/MethodCallExpressionResolve.cs
@@ -78,6 +78,18 @@ namespace SqlSugar
                     return this.Context.DbMehtods.Trim(model);
                 case "Contains":
                     return this.Context.DbMehtods.Contains(model);
+                case "Equals":
+                    return this.Context.DbMehtods.Equals(model);
+                case "DateIsSame":
+                    if (model.Args.Count == 2)
+                        return this.Context.DbMehtods.DateIsSameDay(model);
+                    else
+                        return this.Context.DbMehtods.DateIsSameByType(model);
+                case "DateAdd":
+                    if (model.Args.Count == 2)
+                        return this.Context.DbMehtods.DateAddDay(model);
+                    else
+                        return this.Context.DbMehtods.DateAddByType(model);
                 default:
                     break;
             }
diff --git a/SqlSugar/SqlSugar.csproj b/SqlSugar/SqlSugar.csproj
index 78eea858b..468d21453 100644
--- a/SqlSugar/SqlSugar.csproj
+++ b/SqlSugar/SqlSugar.csproj
@@ -91,6 +91,7 @@
     <Compile Include="Entities\Mapping\IgnoreComumn.cs" />
     <Compile Include="Entities\SqlWith.cs" />
     <Compile Include="ExpressionsToSql\Common\CommonTempDataType.cs" />
+    <Compile Include="ExpressionsToSql\Common\DeteType.cs" />
     <Compile Include="ExpressionsToSql\Common\MethodCallExpressionModel.cs" />
     <Compile Include="ExpressionsToSql\Method\DefaultDbMethod.cs" />
     <Compile Include="Databases\SqlServer\Db\SqlBuilder\SqlServerExpressionContext.cs" />