using System;

using System.Collections.Generic;

using System.Linq;

using System.Reflection;

using Microsoft.EntityFrameworkCore.Query.SqlExpressions;

​

public class Program

{

    public static void Main()

    {

        List<Parent> temp = new List<Parent>();

        DateTime lastUpdateDate = DateTime.Now;

        temp.Add(new Parent()

                 {

                     ID = 0,

                     Description = "Test",

                     UpdateDate = DateTime.Now

        });

        var t = temp.Where(x => x.UpdateDate != null && TruncateMillisecondFromDateTime(x.UpdateDate) > lastUpdateDate).AsQueryable();

        Console.WriteLine(ToSql(t));

        foreach(var r in temp){

            Console.WriteLine(r.Description);

        }

    }

        private static DateTime TruncateMillisecondFromDateTime(DateTime dateTime)

        {

            return dateTime.AddMilliseconds(-(dateTime.Millisecond));

        }

    public static string ToSql<TEntity>(IQueryable<TEntity> query) where TEntity : class

        {

​

            var enumerator = query.Provider.Execute<IEnumerable<TEntity>>(query.Expression).GetEnumerator();

            var relationalCommandCache = Private(enumerator, "_relationalCommandCache");

            var selectExpression = Private<SelectExpression>(relationalCommandCache, "_selectExpression");

            var factory = Private<IQuerySqlGeneratorFactory>(relationalCommandCache, "_querySqlGeneratorFactory");

            var relationalQueryContext = Private<RelationalQueryContext>(enumerator, "_relationalQueryContext");

​

            var sqlGenerator = factory.Create();

            var command = sqlGenerator.GetCommand(selectExpression);

​

            var parametersDict = relationalQueryContext.ParameterValues;

​

            return SubstituteVariables(command.CommandText, parametersDict);

        }

​

    private static object Private(object obj, string privateField) => obj?.GetType().GetField(privateField, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj);

        private static T Private<T>(object obj, string privateField) => (T)obj?.GetType().GetField(privateField, BindingFlags.Instance | BindingFlags.NonPublic)?.GetValue(obj);

​

        private static string SubstituteVariables(string commandText, IReadOnlyDictionary<string, object> parametersDictionary)

        {

            var sql = commandText;

            foreach (var parameter in parametersDictionary)

            {

                var placeHolder = "@" + parameter.Key;

                var actualValue = GetActualValue(parameter.Value);

                sql = sql.Replace(placeHolder, actualValue);

            }

​

            return sql;

        }

​

        private static string GetActualValue(object value)

        {

            var type = value.GetType();

​

            if (type.IsNumeric())

                return value.ToString();

​

            if (type == typeof(DateTime) || type == typeof(DateTimeOffset))

            {

                switch (type.Name)

                {

                    case nameof(DateTime):

                        return $"'{(DateTime)value:u}'";

​

                    case nameof(DateTimeOffset):

                        return $"'{(DateTimeOffset)value:u}'";

                }

            }

​

            return $"'{value}'";

        }

​

}

​

public class Parent

    {

        public int ID { get; set; }

        public string Description { get; set; }

        public DateTime UpdateDate { get; set; }

    }

​

public class Child

    {

        public int ID { get; set; }

        public int ParentID { get; set; }

        public string Description { get; set; }

        public string Condition { get; set; }

    }