ZZZ Projects - Release Stable Version

ZZZ Projects - Release Stable Version

Author: zzzprojects

Diff for: src/Z.Expressions.SqlServer.Eval.sln

@@ -0,0 +1,24 @@
+
+Microsoft Visual Studio Solution File, Format Version 12.00
+# Visual Studio 14
+VisualStudioVersion = 14.0.23107.0
+MinimumVisualStudioVersion = 10.0.40219.1
+Project("{00D1A9C2-B5F0-4AF3-8072-F6C62B433612}") = "Z.Expressions.SqlServer.Eval", "Z.Expressions.SqlServer.Eval\Z.Expressions.SqlServer.Eval.sqlproj", "{A494B55E-94A3-4914-A03F-4D0432D16420}"
+EndProject
+Global
+	GlobalSection(SolutionConfigurationPlatforms) = preSolution
+		Debug|Any CPU = Debug|Any CPU
+		Release|Any CPU = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(ProjectConfigurationPlatforms) = postSolution
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Debug|Any CPU.ActiveCfg = Debug|Any CPU
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Debug|Any CPU.Build.0 = Debug|Any CPU
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Debug|Any CPU.Deploy.0 = Debug|Any CPU
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Release|Any CPU.ActiveCfg = Release|Any CPU
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Release|Any CPU.Build.0 = Release|Any CPU
+		{A494B55E-94A3-4914-A03F-4D0432D16420}.Release|Any CPU.Deploy.0 = Release|Any CPU
+	EndGlobalSection
+	GlobalSection(SolutionProperties) = preSolution
+		HideSolutionNode = FALSE
+	EndGlobalSection
+EndGlobal

Diff for: src/Z.Expressions.SqlServer.Eval/EvalCompiler/EvalCompiler.cs

@@ -0,0 +1,90 @@
+// Description: Evaluate C# code and expression in T-SQL stored procedure, function and trigger.
+// Website & Documentation: https://github.com/zzzprojects/Eval-SQL.NET
+// Forum: https://zzzprojects.uservoice.com/forums/328452-eval-sql-net
+// License: http://www.zzzprojects.com/license-agreement/
+// More projects: http://www.zzzprojects.com/
+// Copyright (c) 2015 ZZZ Projects. All rights reserved.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using System.Reflection;
+using Z.Expressions.CodeAnalysis.CSharp;
+using Z.Expressions.CodeCompiler.CSharp;
+
+namespace Z.Expressions
+{
+    /// <summary>An eval expression compiler used to compile the code or expression.</summary>
+    internal static partial class EvalCompiler
+    {
+        /// <summary>Property info for the IDictionary Item indexer used in ResolveParameter methods.</summary>
+        private static readonly PropertyInfo DictionaryItemPropertyInfo = typeof (IDictionary).GetProperty("Item", new[] {typeof (string)});
+
+        /// <summary>Compile the code or expression and return a TDelegate of type Func or Action to execute.</summary>
+        /// <param name="context">The eval context used to compile the code or expression.</param>
+        /// <param name="code">The code or expression to compile.</param>
+        /// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
+        /// <param name="resultType">Type of the compiled code or expression result.</param>
+        /// <returns>A TDelegate of type Func or Action that represents the compiled code or expression.</returns>
+        internal static EvalDelegate Compile(EvalContext context, string code, IDictionary<string, Type> parameterTypes, Type resultType)
+        {
+            var cacheKey = ResolveCacheKey(context, typeof (Func<IDictionary, object>), code, parameterTypes);
+
+            EvalDelegate cachedDelegate;
+            if (EvalManager.CacheDelegate.TryGetValue(cacheKey, out cachedDelegate))
+            {
+                return cachedDelegate;
+            }
+
+            // Options
+            var scope = new ExpressionScope
+            {
+                AliasExtensionMethods = context.AliasExtensionMethods,
+                AliasNames = context.AliasNames,
+                AliasStaticMembers = context.AliasStaticMembers,
+                AliasTypes = context.AliasTypes,
+                BindingFlags = context.BindingFlags,
+                UseCaretForExponent = context.UseCaretForExponent
+            };
+
+            // ADD global constants
+            if (context.AliasGlobalConstants.Count > 0)
+            {
+                scope.Constants = new Dictionary<string, ConstantExpression>(context.AliasGlobalConstants);
+            }
+
+            // ADD global variables
+            if (context.AliasGlobalVariables.Count > 0)
+            {
+                foreach (var keyValue in context.AliasGlobalVariables)
+                {
+                    scope.CreateLazyVariable(keyValue.Key, new Lazy<Expression>(() =>
+                    {
+                        var innerParameter = scope.CreateVariable(keyValue.Value.GetType(), keyValue.Key);
+                        var innerExpression = Expression.Assign(innerParameter, Expression.Constant(keyValue.Value));
+                        scope.Expressions.Add(innerExpression);
+                        return innerParameter;
+                    }));
+                }
+            }
+
+            // Resolve Parameter
+            var parameterExpressions = ResolveParameter(scope, parameterTypes);
+
+            // CodeAnalysis
+            var syntaxRoot = SyntaxParser.ParseText(code);
+
+            // CodeCompiler
+            var expression = ExpressionParser.ParseSyntax(scope, syntaxRoot, resultType);
+
+            // Compile the expression
+            var compiled = Expression.Lambda<Func<IDictionary, object>>(expression, parameterExpressions).Compile();
+
+            var evalDelegate = new EvalDelegate(cacheKey, compiled);
+            EvalManager.CacheDelegate.TryAdd(cacheKey, evalDelegate);
+
+            return evalDelegate;
+        }
+    }
+}

Diff for: src/Z.Expressions.SqlServer.Eval/EvalCompiler/Parameter/ResolveCacheKey.cs

@@ -0,0 +1,38 @@
+// Description: Evaluate C# code and expression in T-SQL stored procedure, function and trigger.
+// Website & Documentation: https://github.com/zzzprojects/Eval-SQL.NET
+// Forum: https://zzzprojects.uservoice.com/forums/328452-eval-sql-net
+// License: http://www.zzzprojects.com/license-agreement/
+// More projects: http://www.zzzprojects.com/
+// Copyright (c) 2015 ZZZ Projects. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace Z.Expressions
+{
+    internal static partial class EvalCompiler
+    {
+        /// <summary>Resolve and return the cache key used in the EvalManager cache.</summary>
+        /// <param name="context">The eval context used to compile the code or expression.</param>
+        /// <param name="tdelegate">Type of the delegate (Func or Action) to use to compile the code or expression.</param>
+        /// <param name="code">The code or expression to compile.</param>
+        /// <param name="parameterTypes">List of parameter types used to compile the code or expression.</param>
+        /// <returns>A string representing a unique key for the combinaison delegate/code/parameter types.</returns>
+        private static string ResolveCacheKey(EvalContext context, Type tdelegate, string code, IDictionary<string, Type> parameterTypes)
+        {
+            // Concatenate:
+            // - CacheKey Prefix
+            // - Code or expression
+            // - Delegate
+            // - Parameter Types
+            return string.Concat(context.CacheKeyPrefix,
+                ";",
+                code,
+                ";",
+                tdelegate.FullName,
+                ";",
+                parameterTypes == null ? "" : string.Join(";", parameterTypes.Values.Select(x => x.FullName)));
+        }
+    }
+}

Diff for: src/Z.Expressions.SqlServer.Eval/EvalCompiler/Parameter/ResolveParameter.cs

@@ -0,0 +1,50 @@
+// Description: Evaluate C# code and expression in T-SQL stored procedure, function and trigger.
+// Website & Documentation: https://github.com/zzzprojects/Eval-SQL.NET
+// Forum: https://zzzprojects.uservoice.com/forums/328452-eval-sql-net
+// License: http://www.zzzprojects.com/license-agreement/
+// More projects: http://www.zzzprojects.com/
+// Copyright (c) 2015 ZZZ Projects. All rights reserved.
+
+using System;
+using System.Collections;
+using System.Collections.Generic;
+using System.Linq.Expressions;
+using Z.Expressions.CodeCompiler.CSharp;
+
+namespace Z.Expressions
+{
+    internal static partial class EvalCompiler
+    {
+        /// <summary>Resolve parameters used for the code or expression.</summary>
+        /// <param name="scope">The expression scope for the code or expression to compile.</param>
+        /// <param name="parameterTypes">The dictionary of parameter (name / type) used in the code or expression to compile.</param>
+        /// <returns>A ParameterExpression list used in code or expression to compile.</returns>
+        private static List<ParameterExpression> ResolveParameter(ExpressionScope scope, IDictionary<string, Type> parameterTypes)
+        {
+            var parameters = new List<ParameterExpression>();
+
+            var parameterDictionary = scope.CreateParameter(typeof (IDictionary));
+            parameters.Add(parameterDictionary);
+
+            foreach (var parameter in parameterTypes)
+            {
+                scope.CreateLazyVariable(parameter.Key, new Lazy<Expression>(() =>
+                {
+                    var innerParameter = scope.CreateVariable(parameter.Value, parameter.Key);
+
+                    Expression innerExpression = Expression.Property(parameterDictionary, DictionaryItemPropertyInfo, Expression.Constant(parameter.Key));
+
+                    innerExpression = innerExpression.Type != parameter.Value ?
+                        Expression.Assign(innerParameter, Expression.Convert(innerExpression, parameter.Value)) :
+                        Expression.Assign(innerParameter, innerExpression);
+
+                    scope.Expressions.Add(Expression.Assign(innerParameter, innerExpression));
+
+                    return innerParameter;
+                }));
+            }
+
+            return parameters;
+        }
+    }
+}

Diff for: src/Z.Expressions.SqlServer.Eval/EvalCompilerParameterKind.cs

@@ -0,0 +1,21 @@
+// Description: Evaluate C# code and expression in T-SQL stored procedure, function and trigger.
+// Website & Documentation: https://github.com/zzzprojects/Eval-SQL.NET
+// Forum: https://zzzprojects.uservoice.com/forums/328452-eval-sql-net
+// License: http://www.zzzprojects.com/license-agreement/
+// More projects: http://www.zzzprojects.com/
+// Copyright (c) 2015 ZZZ Projects. All rights reserved.
+
+namespace Z.Expressions
+{
+    /// <summary>Values that represent the ParameterKind for the EvalCompiler.</summary>
+    public enum EvalCompilerParameterKind
+    {
+        None,
+        Dictionary,
+        Enumerable,
+        SingleDictionary,
+        SingleObject,
+        Typed,
+        Untyped
+    }
+}

Diff for: src/Z.Expressions.SqlServer.Eval/EvalContext/Compile/EvalContext.Compile.cs

@@ -0,0 +1,24 @@
+// Description: Evaluate C# code and expression in T-SQL stored procedure, function and trigger.
+// Website & Documentation: https://github.com/zzzprojects/Eval-SQL.NET
+// Forum: https://zzzprojects.uservoice.com/forums/328452-eval-sql-net
+// License: http://www.zzzprojects.com/license-agreement/
+// More projects: http://www.zzzprojects.com/
+// Copyright (c) 2015 ZZZ Projects. All rights reserved.
+
+using System;
+using System.Collections.Generic;
+
+namespace Z.Expressions
+{
+    public partial class EvalContext
+    {
+        /// <summary>Compile the code or expression and return a delegate of type Func to execute.</summary>
+        /// <param name="code">The code or expression to compile.</param>
+        /// <param name="parameterTypes">Parameter types used to compile the code or expression.</param>
+        /// <returns>A delegate of type Func that represents the compiled code or expression.</returns>
+        public EvalDelegate Compile(string code, IDictionary<string, Type> parameterTypes)
+        {
+            return EvalCompiler.Compile(this, code, parameterTypes, typeof (object));
+        }
+    }
+}