/// <summary>
        ///
        /// </summary>
        /// <param name="entityType"></param>
        /// <param name="connection"></param>
        /// <param name="tableName"></param>
        /// <param name="dbFields"></param>
        /// <param name="fields"></param>
        /// <param name="commandText"></param>
        /// <returns></returns>
        private static UpdateExecutionContext CreateInternal(Type entityType,
                                                             IDbConnection connection,
                                                             string tableName,
                                                             IEnumerable <DbField> dbFields,
                                                             IEnumerable <Field> fields,
                                                             string commandText)
        {
            var dbSetting   = connection.GetDbSetting();
            var inputFields = new List <DbField>();

            // Filter the actual properties for input fields
            inputFields = dbFields?
                          .Where(dbField => dbField.IsIdentity == false)
                          .Where(dbField =>
                                 fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
                          .AsList();

            // Return the value
            return(new UpdateExecutionContext
            {
                CommandText = commandText,
                InputFields = inputFields,
                ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction(entityType,
                                                                                                    string.Concat(entityType.FullName, StringConstant.Period, tableName, ".Update"),
                                                                                                    inputFields?.AsList(),
                                                                                                    null,
                                                                                                    dbSetting)
            });
        }
Exemplo n.º 2
0
        public SourceView(string text)
            : base("SourceView")
        {
            TextBox = new Scintilla
            {
                Lexer = ScintillaNET.Lexer.Container,
                VirtualSpaceOptions = VirtualSpace.UserAccessible
            };

            foreach (var id in TextStyle.All)
                StyleConfig(id);

            TextBox.StyleNeeded += (s, args) => SignalStyleNeeded(args.Position);
            TextBox.TextChanged += (s, args) => OnTextChanged();

            TextBox.ContextMenu = new ContextMenu();
            TextBox.ContextMenu.Popup += (s, args) => OnContextMenuPopup();

            CompilerCache = new ValueCache<CompilerBrowser>(CreateCompilerBrowser);

            ResultCachesViews = new FunctionCache<Value, ResultCachesView>
                (item => new ResultCachesView(item, this));
            ChildViews = new FunctionCache<object, ChildView>(CreateView);

            Client = TextBox;

            TextBox.Text = text;

            TraceLog = new BrowseTraceCollector(this);
            LogView = new TraceLogView(this);
        }
Exemplo n.º 3
0
        Proxy CreateProxy(FunctionCache <Version, ModDescription> modVersions)
        {
            var value        = modVersions.OrderByDescending(mod => mod.Key).First().Value;
            var moreVersions = modVersions.Select(v => v.Key).Where(v => v != value.Version);

            return(new Proxy(value, moreVersions, RefreshTitle));
        }
Exemplo n.º 4
0
 internal T4Context(StringBuilder text, ITextTemplatingEngineHost host)
 {
     _text = text;
     _host = host;
     _fileItems = new FunctionCache<string, Box<string>>(fileName => new Box<string>(""));
     _dte = new ValueCache<DTE>(ObtainDTE);
 }
Exemplo n.º 5
0
        public CalculatorEngine()
        {
            TrigonometryMode = TrigonometryMode.DEG;
            ConstantDB       = new ConstantDB();
            _linebuffer      = new StringBuilder();
            _functioncache   = new Dictionary <string, FunctionInformation>();
            _preprocessor    = new Preprocessor(_functioncache, ConstantDB);
            var options = new Dictionary <string, object>();

            options["DivisionOptions"] = PythonDivisionOptions.New;
            _history = new ZeroStream();
            _output  = new EventRedirectedStreamWriter(_history);
            _output.StreamWasWritten += _output_StreamWasWritten;
            _engine = Python.CreateEngine(options);
            _engine.Runtime.IO.SetOutput(_history, _output);
            _engine.Runtime.IO.SetErrorOutput(_history, _output);
            _scope = _engine.CreateScope();

            _functionTypes = new Type[]
            {
                typeof(Trigonometry),
                typeof(Engineering),
                typeof(GeneralFunctions),
                typeof(Variations),
                typeof(TypeFunctions),
                typeof(Statistics)
            };

            FunctionCache.Fill(ref _functioncache, ref _scope, _functionTypes);
        }
Exemplo n.º 6
0
        /// <summary>
        ///     Gets the value of this curry cache according to the parameter association
        /// </summary>
        /// <param name="association"></param>
        /// <returns></returns>
        public ExplainedValue GetValue(Dictionary <Actual, IValue> association)
        {
            ExplainedValue retVal = null;

            FunctionCache current = Curry;

            foreach (IValue val in OrderedParameters(association))
            {
                FunctionCache next;
                if (current.TryGetValue(val, out next))
                {
                    current = next;
                }
                else
                {
                    current = null;
                    break;
                }
            }

            if (current != null)
            {
                retVal = current.Value;
            }

            return(retVal);
        }
Exemplo n.º 7
0
 public static Qualifier Put <T1, R>(Qualifier named, Func <T1, R> f1)
 {
     FunctionCache.AddOrUpdate(named, f1, (q, f) =>
     {
         Log.LogWarning("{0}: Key '{1}' already present. Using new function reference.", typeof(DynamicDelegation), named.ToLabel());
         return(f1);
     });
     return(named);
 }
Exemplo n.º 8
0
 public TypeLibrary(IEnumerable<Type> types)
 {
     _types = types.ToArray();
     ByNamePart = new FunctionCache<string, Type>(GetTypeByNamePart);
     ByNamePartMulti = new FunctionCache<string, Type[]>(GetTypesByNamePart);
     _byName = _types.GroupBy(t => t.Name, t => t).ToDictionary(t => t.Key, t => t);
     PrettyName = new FunctionCache<Type, string>(type => ObtainTypeName(type, true));
     CompleteName = new FunctionCache<Type, string>(type => ObtainTypeName(type, false));
 }
Exemplo n.º 9
0
 public TypeLibrary(IEnumerable <Type> types)
 {
     Types           = types.ToArray();
     ByNamePart      = new(GetTypeByNamePart);
     ByNamePartMulti = new(GetTypesByNamePart);
     ByName          = Types.GroupBy(t => t.Name, t => t).ToDictionary(t => t.Key, t => t);
     PrettyName      = new(type => ObtainTypeName(type, true));
     CompleteName    = new(type => ObtainTypeName(type, false));
 }
Exemplo n.º 10
0
        public static Symbol Execute(FunctionSymbol symbol, Stack <Symbol> arguments)
        {
            if (cached_functions == null)
            {
                LoadFunctionCache();
            }

            if (!cached_functions.ContainsKey(symbol.Name))
            {
                throw new InvalidFunctionException(symbol.Name);
            }

            FunctionCache function = cached_functions[symbol.Name];

            if (arguments.Count != function.ArgumentCount && function.ArgumentCount >= 0)
            {
                throw new ArgumentException(symbol.Name);
            }

            if (function.RawSymbols)
            {
                if (function.ArgumentCount == -1)
                {
                    return((Symbol)function.Method.Invoke(null, new object [] { arguments.ToArray() }));
                }
                else
                {
                    return((Symbol)function.Method.Invoke(null, arguments.ToArray()));
                }
            }

            ArrayList resolved_arguments = new ArrayList();

            while (arguments.Count > 0)
            {
                Symbol argument = arguments.Pop();
                if (!(argument is ValueSymbol))
                {
                    throw new ArgumentException("argument must be ValueSymbol");
                }
                resolved_arguments.Add((argument as ValueSymbol).Value);
            }

            double retval;

            if (function.ArgumentCount == -1)
            {
                retval = (double)function.Method.Invoke(null, new object [] { resolved_arguments.ToArray(typeof(double)) });
            }
            else
            {
                retval = (double)function.Method.Invoke(null, resolved_arguments.ToArray());
            }

            return(new NumberSymbol(retval));
        }
Exemplo n.º 11
0
 internal CodeContainer
     (string moduleName, Root root, Syntax syntax, string description)
 {
     ModuleName = moduleName;
     Root = root;
     MainCache = new ValueCache<Container>
         (() => root.MainContainer(syntax, description));
     CSharpStringCache = new ValueCache<string>(GetCSharpStringForCache);
     _functions = new FunctionCache<int, FunctionContainer>(Root.FunctionContainer);
 }
Exemplo n.º 12
0
 public FunctionList()
 {
     _dictionary = new FunctionCache
         <FunctionSyntax, FunctionCache<CompoundView, FunctionCache<TypeBase, int>>>
         (
         syntax => new FunctionCache<CompoundView, FunctionCache<TypeBase, int>>
             (
             structure => new FunctionCache<TypeBase, int>
                 (-1, args => CreateFunctionInstance(args, syntax, structure))));
 }
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="connection"></param>
        /// <param name="dbFields"></param>
        /// <param name="tableName"></param>
        /// <param name="fields"></param>
        /// <param name="commandText"></param>
        /// <returns></returns>
        private static InsertExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
                                                                                 IEnumerable <DbField> dbFields,
                                                                                 string tableName,
                                                                                 IEnumerable <Field> fields,
                                                                                 string commandText)
            where TEntity : class
        {
            var typeOfEntity    = typeof(TEntity);
            var dbSetting       = connection.GetDbSetting();
            var identity        = (Field)null;
            var inputFields     = (IEnumerable <DbField>)null;
            var identityDbField = dbFields?.FirstOrDefault(f => f.IsIdentity);

            // Set the identity field
            if (typeOfEntity.IsClassType())
            {
                identity = IdentityCache.Get <TEntity>()?.AsField() ??
                           FieldCache
                           .Get <TEntity>()?
                           .FirstOrDefault(field =>
                                           string.Equals(field.Name.AsUnquoted(true, dbSetting), identityDbField?.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) ??
                           identityDbField?.AsField();
            }

            // Filter the actual properties for input fields
            inputFields = dbFields?
                          .Where(dbField => dbField.IsIdentity == false)
                          .Where(dbField =>
                                 fields.FirstOrDefault(field =>
                                                       string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
                          .AsList();

            // Variables for the entity action
            var identityPropertySetter = (Action <TEntity, object>)null;

            // Get the identity setter
            if (typeOfEntity.IsClassType() == true && identity != null)
            {
                identityPropertySetter = FunctionCache.GetDataEntityPropertySetterCompiledFunction <TEntity>(identity);
            }

            // Return the value
            return(new InsertExecutionContext <TEntity>
            {
                CommandText = commandText,
                InputFields = inputFields,
                ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
                    string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".Insert"),
                    inputFields?.AsList(),
                    null,
                    dbSetting),
                IdentityPropertySetterFunc = identityPropertySetter
            });
        }
Exemplo n.º 14
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of <see cref="ExpandoObject"/> object.
 /// </summary>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="basedOnFields">Check whether to create a delegate based on the data reader fields.</param>
 /// <returns>An array of <see cref="ExpandoObject"/> objects.</returns>
 internal static IEnumerable <dynamic> ToEnumerable(DbDataReader reader, bool basedOnFields = false)
 {
     if (reader != null && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToExpandoObjectFunction(reader, basedOnFields);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
        /// <summary>
        /// Returns the first element of a sequence, or a default value if no element is found.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to return.</param>
        /// <param name="value">
        /// The <see cref="IEnumerable"/> to return the item from.
        /// </param>
        /// <returns>
        /// The <see cref="object"/> representing the item.
        /// </returns>
        public static object FirstOrDefault(Type type, IEnumerable value)
        {
            var key = GetMethodCacheKey(type);

            if (FunctionCache.TryGetValue(key, out Func <object, object> f) == false)
            {
                f = StaticMethodSingleParameter <object>(FirstOrDefaultMethod.MakeGenericMethod(type));
                FunctionCache[key] = f;
            }

            return(f(Cast(type, value)));
        }
Exemplo n.º 16
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity object.
 /// </summary>
 /// <typeparam name="TEntity">The data entity type to convert.</typeparam>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="basedOnFields">Check whether to create a delegate based on the data reader fields.</param>
 /// <returns>An array of data entity objects.</returns>
 internal static IEnumerable <TEntity> ToEnumerable <TEntity>(DbDataReader reader, bool basedOnFields = false)
     where TEntity : class
 {
     if (reader != null && reader.IsClosed == false && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToDataEntityFunction <TEntity>(reader, basedOnFields);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
        /// <summary>
        /// Returns an empty <see cref="IEnumerable{T}"/> that has the specified type argument.
        /// </summary>
        /// <param name="type">
        /// The <see cref="Type"/> to assign to the type parameter of the returned
        /// generic <see cref="IEnumerable{T}"/>.
        /// </param>
        /// <returns>
        /// The <see cref="object"/> representing the empty enumerable.
        /// </returns>
        public static object Empty(Type type)
        {
            var key = GetMethodCacheKey(type);

            if (FunctionCache.TryGetValue(key, out Func <object, object> f) == false)
            {
                f = StaticMethod <object>(EmptyMethod.MakeGenericMethod(type));
                FunctionCache[key] = f;
            }

            return(f(type));
        }
Exemplo n.º 18
0
        public static object GetValue(PropertyInfo property, object instance)
        {
            var key = GetMethodCacheKey(property);

            if (FunctionCache.TryGetValue(key, out Func <object, object> a) == false)
            {
                a = MakeGetMethod(property.GetGetMethod(), property.PropertyType);
                FunctionCache[key] = a;
            }

            return(a(instance));
        }
Exemplo n.º 19
0
        /// <summary>
        /// Casts the elements of the given <see cref="IEnumerable"/> to the specified type.
        /// </summary>
        /// <param name="type">The <see cref="Type"/> to cast to.</param>
        /// <param name="value">
        /// The <see cref="IEnumerable"/> to cast the items of.
        /// </param>
        /// <returns>
        /// The <see cref="object"/> representing the cast enumerable.
        /// </returns>
        public static object Cast(Type type, IEnumerable value)
        {
            var key = GetMethodCacheKey(type);

            Func <object, object> f;

            if (!FunctionCache.TryGetValue(key, out f))
            {
                f = StaticMethodSingleParameter <object>(CastMethod.MakeGenericMethod(type));
                FunctionCache[key] = f;
            }

            return(f(value));
        }
        /// <summary>
        /// Gets the value of the property on the given instance.
        /// </summary>
        /// <param name="property">The property to set.</param>
        /// <param name="instance">The current instance to return the property from.</param>
        /// <returns>The <see cref="object"/> value.</returns>
        public static object GetValue(PropertyInfo property, object instance)
        {
            var key = GetMethodCacheKey(property);

            Func <object, object> a;

            if (!FunctionCache.TryGetValue(key, out a))
            {
                a = BuildGetAccessor(property.GetGetMethod());
                FunctionCache[key] = a;
            }

            return(a(instance));
        }
Exemplo n.º 21
0
        private FunctionSymbol?TryGetFunctionSymbol(string name)
        {
            // symbol comparison relies on object equality; use of this cache ensures that different symbols with the same name are not returned.
            // we also cache negative lookups (null) so that we don't slow down when looking up references to a missing symbol
            if (FunctionCache.TryGetValue(name, out var symbol))
            {
                return(symbol);
            }

            // wildcard match (e.g. list*)
            var wildcardOverloads = FunctionWildcardOverloads.Where(fo => fo.WildcardRegex.IsMatch(name));

            // create a new symbol for each unique name that matches the wildcard
            return(wildcardOverloads.Any() ? new FunctionSymbol(name, wildcardOverloads) : null);
        }
Exemplo n.º 22
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of dynamic objects.
 /// </summary>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="dbFields">The list of the <see cref="DbField"/> objects to be used.</param>
 /// <param name="dbSetting">The instance of <see cref="IDbSetting"/> object to be used.</param>
 /// <returns>An array of dynamic objects.</returns>
 public static IEnumerable <dynamic> ToEnumerable(DbDataReader reader,
                                                  IEnumerable <DbField> dbFields = null,
                                                  IDbSetting dbSetting           = null)
 {
     if (reader?.IsClosed == false && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToExpandoObjectCompileFunction(reader,
                                                                              dbFields,
                                                                              dbSetting);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
Exemplo n.º 23
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity objects.
 /// </summary>
 /// <typeparam name="TResult">The type of the result.</typeparam>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="dbFields">The list of the <see cref="DbField"/> objects to be used.</param>
 /// <param name="dbSetting">The instance of <see cref="IDbSetting"/> object to be used.</param>
 /// <returns>A list of the target result type.</returns>
 public static IEnumerable <TResult> ToEnumerable <TResult>(DbDataReader reader,
                                                            IEnumerable <DbField> dbFields = null,
                                                            IDbSetting dbSetting           = null)
 {
     if (reader?.IsClosed == false && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToTypeCompiledFunction <TResult>(reader,
                                                                                dbFields,
                                                                                dbSetting);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
Exemplo n.º 24
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of <see cref="ExpandoObject"/> object.
 /// </summary>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="tableName">The name of the target table.</param>
 /// <param name="connection">The used <see cref="IDbConnection"/> object.</param>
 /// <returns>An array of <see cref="ExpandoObject"/> objects.</returns>
 internal static IEnumerable <dynamic> ToEnumerable(DbDataReader reader,
                                                    string tableName,
                                                    IDbConnection connection)
 {
     if (reader != null && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToExpandoObjectConverterFunction(reader,
                                                                                tableName,
                                                                                connection);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
        /// <summary>
        ///
        /// </summary>
        /// <param name="entityType"></param>
        /// <param name="connection"></param>
        /// <param name="dbFields"></param>
        /// <param name="tableName"></param>
        /// <param name="fields"></param>
        /// <param name="commandText"></param>
        /// <returns></returns>
        private static MergeExecutionContext CreateInternal(Type entityType,
                                                            IDbConnection connection,
                                                            IEnumerable <DbField> dbFields,
                                                            string tableName,
                                                            IEnumerable <Field> fields,
                                                            string commandText)
        {
            var dbSetting       = connection.GetDbSetting();
            var identity        = (Field)null;
            var inputFields     = new List <DbField>();
            var identityDbField = dbFields?.FirstOrDefault(f => f.IsIdentity);

            // Set the identity field
            identity = IdentityCache.Get(entityType)?.AsField() ??
                       FieldCache
                       .Get(entityType)?
                       .FirstOrDefault(field =>
                                       string.Equals(field.Name.AsUnquoted(true, dbSetting), identityDbField?.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) ??
                       identityDbField?.AsField();

            // Filter the actual properties for input fields
            inputFields = dbFields?
                          .Where(dbField =>
                                 fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
                          .AsList();

            // Variables for the entity action
            var identityPropertySetter = (Action <object, object>)null;

            // Get the identity setter
            if (identity != null)
            {
                identityPropertySetter = FunctionCache.GetDataEntityPropertySetterCompiledFunction(entityType, identity);
            }

            // Return the value
            return(new MergeExecutionContext
            {
                CommandText = commandText,
                InputFields = inputFields,
                ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction(entityType,
                                                                                                    string.Concat(entityType.FullName, StringConstant.Period, tableName, ".Merge"),
                                                                                                    inputFields?.AsList(),
                                                                                                    null,
                                                                                                    dbSetting),
                IdentityPropertySetterFunc = identityPropertySetter
            });
        }
Exemplo n.º 26
0
        /// <summary>
        /// Set the parameters (and/or values) of the <see cref="DbCommand"/> object based on the passed data entity object.
        /// </summary>
        /// <typeparam name="TEntity">The type of the data entity object.</typeparam>
        /// <param name="command">The <see cref="DbCommand"/> object where to set the parameters.</param>
        /// <param name="tableName">The name of the target table.</param>
        /// <param name="entities">The list of the data entity objects.</param>
        /// <param name="inputFields">The list of the input <see cref="DbField"/> objects to be used.</param>
        /// <param name="outputFields">The list of the output <see cref="DbField"/> objects to be used.</param>
        public static void SetParameters <TEntity>(DbCommand command,
                                                   string tableName,
                                                   IEnumerable <TEntity> entities,
                                                   IEnumerable <DbField> inputFields,
                                                   IEnumerable <DbField> outputFields)
            where TEntity : class
        {
            // Get the actual function
            var func = FunctionCache.GetDataEntitiesDbCommandParameterSetterFunction <TEntity>(tableName,
                                                                                               inputFields,
                                                                                               outputFields,
                                                                                               entities.Count());

            // Execute the function
            func(command, entities.AsList());
        }
Exemplo n.º 27
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity object.
 /// </summary>
 /// <typeparam name="TEntity">The data entity type to convert.</typeparam>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="connection">The used <see cref="IDbConnection"/> object.</param>
 /// <param name="transaction">The transaction object that is currently in used.</param>
 /// <returns>An array of data entity objects.</returns>
 public static IEnumerable <TEntity> ToEnumerable <TEntity>(DbDataReader reader,
                                                            IDbConnection connection   = null,
                                                            IDbTransaction transaction = null)
     where TEntity : class
 {
     if (reader != null && reader.IsClosed == false && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToDataEntityFunction <TEntity>(reader,
                                                                              connection,
                                                                              transaction);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
Exemplo n.º 28
0
        /// <summary>
        ///     Sets the value according to the parameter association
        /// </summary>
        /// <param name="association"></param>
        /// <param name="value"></param>
        public void SetValue(Dictionary <Actual, IValue> association, IValue value, ExplanationPart explanation)
        {
            FunctionCache current = Curry;

            foreach (IValue val in OrderedParameters(association))
            {
                FunctionCache next;
                if (!current.TryGetValue(val, out next))
                {
                    next = new FunctionCache();
                    current.Add(val, next);
                }
                current = next;
            }

            current.Value = new ExplainedValue(value, explanation);
        }
Exemplo n.º 29
0
        /// <summary>
        /// Converts the <see cref="DbDataReader"/> into an enumerable of <see cref="ExpandoObject"/> object in an asynchronous way.
        /// </summary>
        /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
        /// <param name="tableName">The name of the target table.</param>
        /// <param name="connection">The used <see cref="IDbConnection"/> object.</param>
        /// <returns>An array of <see cref="ExpandoObject"/> objects.</returns>
        internal static async Task <IEnumerable <dynamic> > ToEnumerableAsync(DbDataReader reader,
                                                                              string tableName,
                                                                              IDbConnection connection)
        {
            var list = new List <dynamic>();

            if (reader != null && reader.HasRows)
            {
                var func = FunctionCache.GetDataReaderToExpandoObjectConverterFunction(reader,
                                                                                       tableName,
                                                                                       connection);
                while (await reader.ReadAsync())
                {
                    list.Add(func(reader));
                }
            }
            return(list);
        }
Exemplo n.º 30
0
        public FunctionAnalysis2ndPass(FunctionCache functionCache, MethodInfo method)
        {
            FunctionCache = functionCache;
            Data          = null;
            _IsPure       = method.Metadata.HasAttribute("JSIL.Meta.JSIsPure");

            var parms = method.Metadata.GetAttributeParameters("JSIL.Meta.JSMutatedArguments");

            if (parms != null)
            {
                ModifiedVariables = new HashSet <string>(GetAttributeArguments <string>(parms));
            }
            else if (!_IsPure)
            {
                ModifiedVariables = new HashSet <string>(from p in method.Parameters select p.Name);
            }
            else
            {
                ModifiedVariables = new HashSet <string>();
            }

            parms = method.Metadata.GetAttributeParameters("JSIL.Meta.JSEscapingArguments");
            if (parms != null)
            {
                EscapingVariables = new HashSet <string>(GetAttributeArguments <string>(parms));
            }
            else if (!_IsPure)
            {
                EscapingVariables = new HashSet <string>(from p in method.Parameters select p.Name);
            }
            else
            {
                EscapingVariables = new HashSet <string>();
            }

            VariableAliases = new Dictionary <string, HashSet <string> >();

            ResultVariable = null;
            ResultIsNew    = method.Metadata.HasAttribute("JSIL.Meta.JSResultIsNew");

            MutatedFields = null;

            Trace(method.Member.FullName);
        }
Exemplo n.º 31
0
        /// <summary>
        /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity objects in asynchronous way.
        /// </summary>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
        /// <param name="dbFields">The list of the <see cref="DbField"/> objects to be used.</param>
        /// <param name="dbSetting">The instance of <see cref="IDbSetting"/> object to be used.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> object to be used during the asynchronous operation.</param>
        /// <returns>A list of the target result type.</returns>
        public static async IAsyncEnumerable <TResult> ToEnumerableAsync <TResult>(DbDataReader reader,
                                                                                   IEnumerable <DbField> dbFields = null,
                                                                                   IDbSetting dbSetting           = null,
                                                                                   [EnumeratorCancellation] CancellationToken cancellationToken = default)
        {
            if (reader?.IsClosed != false || !reader.HasRows)
            {
                yield break;
            }

            var func = FunctionCache.GetDataReaderToTypeCompiledFunction <TResult>(reader,
                                                                                   dbFields,
                                                                                   dbSetting);

            while (await reader.ReadAsync(cancellationToken))
            {
                yield return(func(reader));
            }
        }
Exemplo n.º 32
0
        /// <summary>
        /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity objects in asynchronous way.
        /// </summary>
        /// <typeparam name="TResult">The type of the result.</typeparam>
        /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
        /// <param name="dbFields">The list of the <see cref="DbField"/> objects to be used.</param>
        /// <param name="dbSetting">The instance of <see cref="IDbSetting"/> object to be used.</param>
        /// <param name="cancellationToken">The <see cref="CancellationToken"/> object to be used during the asynchronous operation.</param>
        /// <returns>A list of the target result type.</returns>
        public static async Task <IEnumerable <TResult> > ToEnumerableAsync <TResult>(DbDataReader reader,
                                                                                      IEnumerable <DbField> dbFields      = null,
                                                                                      IDbSetting dbSetting                = null,
                                                                                      CancellationToken cancellationToken = default)
        {
            var list = new List <TResult>();

            if (reader != null && reader.IsClosed == false && reader.HasRows)
            {
                var func = FunctionCache.GetDataReaderToTypeCompiledFunction <TResult>(reader,
                                                                                       dbFields,
                                                                                       dbSetting);
                while (await reader.ReadAsync(cancellationToken))
                {
                    list.Add(func(reader));
                }
            }
            return(list);
        }
Exemplo n.º 33
0
        /// <summary>
        /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity object in an asynchronous way.
        /// </summary>
        /// <typeparam name="TEntity">The data entity type to convert.</typeparam>
        /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
        /// <param name="connection">The used <see cref="IDbConnection"/> object.</param>
        /// <param name="basedOnFields">Check whether to create a delegate based on the data reader fields.</param>
        /// <returns>An array of data entity objects.</returns>
        internal static async Task <IEnumerable <TEntity> > ToEnumerableAsync <TEntity>(DbDataReader reader,
                                                                                        IDbConnection connection,
                                                                                        bool basedOnFields)
            where TEntity : class
        {
            var list = new List <TEntity>();

            if (reader != null && reader.IsClosed == false && reader.HasRows)
            {
                var func = FunctionCache.GetDataReaderToDataEntityFunction <TEntity>(reader,
                                                                                     connection,
                                                                                     basedOnFields);
                while (await reader.ReadAsync())
                {
                    list.Add(func(reader));
                }
            }
            return(list);
        }
Exemplo n.º 34
0
 /// <summary>
 /// Converts the <see cref="DbDataReader"/> into an enumerable of data entity objects.
 /// </summary>
 /// <typeparam name="TEntity">The data entity type to convert.</typeparam>
 /// <param name="reader">The <see cref="DbDataReader"/> to be converted.</param>
 /// <param name="connection">The used <see cref="IDbConnection"/> object.</param>
 /// <param name="connectionString">The raw connection string.</param>
 /// <param name="transaction">The transaction object that is currently in used.</param>
 /// <param name="enableValidation">Enables the validation after retrieving the database fields.</param>
 /// <returns>An array of data entity objects.</returns>
 internal static IEnumerable <TEntity> ToEnumerableInternal <TEntity>(DbDataReader reader,
                                                                      IDbConnection connection   = null,
                                                                      string connectionString    = null,
                                                                      IDbTransaction transaction = null,
                                                                      bool enableValidation      = true)
     where TEntity : class
 {
     if (reader != null && reader.IsClosed == false && reader.HasRows)
     {
         var func = FunctionCache.GetDataReaderToDataEntityCompiledFunction <TEntity>(reader,
                                                                                      connection,
                                                                                      connectionString,
                                                                                      transaction,
                                                                                      enableValidation);
         while (reader.Read())
         {
             yield return(func(reader));
         }
     }
 }
Exemplo n.º 35
0
        /// <summary>
        ///
        /// </summary>
        /// <typeparam name="TEntity"></typeparam>
        /// <param name="connection"></param>
        /// <param name="tableName"></param>
        /// <param name="where"></param>
        /// <param name="dbFields"></param>
        /// <param name="fields"></param>
        /// <param name="hints"></param>
        /// <param name="transaction"></param>
        /// <param name="statementBuilder"></param>
        /// <returns></returns>
        private static UpdateExecutionContext <TEntity> CreateInternal <TEntity>(IDbConnection connection,
                                                                                 string tableName,
                                                                                 QueryGroup where,
                                                                                 IEnumerable <DbField> dbFields,
                                                                                 IEnumerable <Field> fields,
                                                                                 string hints = null,
                                                                                 IDbTransaction transaction         = null,
                                                                                 IStatementBuilder statementBuilder = null)
            where TEntity : class
        {
            var dbSetting   = connection.GetDbSetting();
            var inputFields = new List <DbField>();

            // Filter the actual properties for input fields
            inputFields = dbFields?
                          .Where(dbField => dbField.IsIdentity == false)
                          .Where(dbField =>
                                 fields.FirstOrDefault(field => string.Equals(field.Name.AsUnquoted(true, dbSetting), dbField.Name.AsUnquoted(true, dbSetting), StringComparison.OrdinalIgnoreCase)) != null)
                          .AsList();

            // Identify the requests
            var updateRequest = new UpdateRequest(tableName,
                                                  connection,
                                                  transaction,
                                                  where,
                                                  fields,
                                                  hints,
                                                  statementBuilder);

            // Return the value
            return(new UpdateExecutionContext <TEntity>
            {
                CommandText = CommandTextCache.GetUpdateText(updateRequest),
                InputFields = inputFields,
                ParametersSetterFunc = FunctionCache.GetDataEntityDbParameterSetterCompiledFunction <TEntity>(
                    string.Concat(typeof(TEntity).FullName, StringConstant.Period, tableName, ".Update"),
                    inputFields?.AsList(),
                    null,
                    dbSetting)
            });
        }
Exemplo n.º 36
0
        Syntax
        (
            Syntax left,
            ITokenClass tokenClass,
            IToken token,
            Syntax right)
            : base(NextObjectId++)
        {
            Left = left;
            TokenClass = tokenClass;
            Token = token;
            Right = right;
            Option = new SyntaxOption(this);
            LocatePositionCache = new FunctionCache<int, Syntax>(LocatePositionForCache);

            if(Left != null)
                Left.Parent = this;

            if(Right != null)
                Right.Parent = this;
        }
Exemplo n.º 37
0
        internal CompoundView(Compound compound, int viewPosition)
            : base(_nextObjectId++)
        {
            Compound = compound;
            ViewPosition = viewPosition;
            CompoundContextCache = new ValueCache<CompoundContext>
                (() => new CompoundContext(this));

            _typeCache = new ValueCache<CompoundType>(() => new CompoundType(this));

            _accessFeaturesCache
                = new FunctionCache<int, AccessFeature>
                    (position => new AccessFeature(this, position));

            _fieldAccessTypeCache
                = new FunctionCache<int, FieldAccessType>
                    (position => new FieldAccessType(this, position));

            _functionBodyTypeCache
                = new FunctionCache<FunctionSyntax, FunctionBodyType>
                    (syntax => new FunctionBodyType(this, syntax));

            StopByObjectIds();
        }
Exemplo n.º 38
0
 SQLSysViews()
 {
     _compountTypesCache = new ValueCache<all_objectsClass[]>(GetCompountTypes);
     _objectsCache = new ValueCache<Dictionary<string, all_objectsClass>>(CreateObjects);
     Columns = new FunctionCache<all_objectsClass, all_columnsClass[]>(CreateColumns);
 }
Exemplo n.º 39
0
 internal Externalizer()
 {
     _map = new FunctionCache<Internalizer.IItem, Item>(Create);
     _ids = new FunctionCache<Item, int>(Id);
 }
Exemplo n.º 40
0
 public Reducer(LocalReference[] references, CodeBase body)
 {
     _references = references;
     _map = new FunctionCache<LocalReference, LocalReference>(GetReplacementsForCache);
     NewBody = GetNewBody(body);
 }
Exemplo n.º 41
0
 public Information(IDataProvider provider)
 {
     _sqlSysViews = Profiler.Measure(() => new SQLSysViews(provider));
     _compountTypeCache = new FunctionCache<string, CompountType>(GetCompountType);
 }
Exemplo n.º 42
0
 public LocalStackReference(FunctionCache<string, StackData> locals, string holder)
 {
     _locals = locals;
     _holder = holder;
 }