コード例 #1
0
        /// <summary>
        /// Gets the number of pages based on the specified
        /// </summary>
        /// <param name="PageSize">Page size</param>
        /// <param name="Parameters">Parameters to search by</param>
        /// <typeparam name="ObjectType">Object type to get the page count of</typeparam>
        /// <returns>The number of pages that the table contains for the specified page size</returns>
        public int PageCount <ObjectType>(int PageSize = 25, params IParameter[] Parameters)
            where ObjectType : class
        {
            Parameters = Parameters.Check(new IParameter[] { });
            string KeyName = typeof(ObjectType).GetName() + "_PageCount_" + PageSize.ToString(CultureInfo.InvariantCulture) + "_" + Parameters.ToString(x => x.ToString(), "_");

            Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
            if (Cache.ContainsKey(KeyName))
            {
                return((int)Cache[KeyName]);
            }
            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    int Count = QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType))
                                .PageCount(PageSize, Parameters)
                                .Execute()[0]
                                .FirstOrDefault()
                                .Total;
                    if (Count > 0)
                    {
                        int ReturnValue = (Count / PageSize) + (Count % PageSize > 0 ? 1 : 0);
                        Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
                        return(ReturnValue);
                    }
                }
            }
            return(0);
        }
コード例 #2
0
 private void SortMappings()
 {
     foreach (IDatabase Database in Mappings.Keys.OrderBy(x => x.Order))
     {
         var Order = 0;
         var Graph = MapperProvider.GetStructure(Database.GetType());
         foreach (var Mapping in KahnSort(Graph.Copy()).Reverse())
         {
             Mapping.Order = Order;
             ++Order;
         }
     }
 }
コード例 #3
0
        /// <summary>
        /// Returns all items that match the criteria
        /// </summary>
        /// <typeparam name="ObjectType">Type of the object</typeparam>
        /// <param name="Parameters">Parameters used in the where clause</param>
        /// <returns>All items that match the criteria</returns>
        public IEnumerable <ObjectType> All <ObjectType>(params IParameter[] Parameters)
            where ObjectType : class
        {
            Parameters = Parameters.Check(new IParameter[] { });
            var    ReturnValue = new List <Dynamo>();
            string KeyName     = typeof(ObjectType).GetName() + "_All_" + Parameters.ToString(x => x.ToString(), "_");

            Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
            if (Cache.ContainsKey(KeyName))
            {
                return(GetListCached <ObjectType>(ref ReturnValue, KeyName));
            }
            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    foreach (Dynamo Item in QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).All(Parameters).Execute()[0])
                    {
                        var IDProperty = Mapping.IDProperties.FirstOrDefault();
                        CopyOrAdd(ReturnValue, IDProperty, Item);
                    }
                }
            }
            Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
            return(ConvertValues <ObjectType>(ReturnValue));
        }
コード例 #4
0
 /// <summary>
 /// Saves an object to the database
 /// </summary>
 /// <typeparam name="ObjectType">Object type</typeparam>
 /// <typeparam name="PrimaryKeyType">Primary key type</typeparam>
 /// <param name="Object">Object to save</param>
 public void Save <ObjectType, PrimaryKeyType>(ObjectType Object)
     where ObjectType : class
 {
     Cache.RemoveByTag(typeof(ObjectType).GetName());
     foreach (ISourceInfo Source in SourceProvider.Where(x => x.Writable).OrderBy(x => x.Order))
     {
         IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
         if (Mapping != null)
         {
             var Generator = QueryProvider.Generate <ObjectType>(Source, MapperProvider[typeof(ObjectType), Source], MapperProvider.GetStructure(Mapping.DatabaseConfigType));
             var TempBatch = QueryProvider.Batch(Source);
             CascadeSave <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
             TempBatch.Execute();
             TempBatch = QueryProvider.Batch(Source);
             TempBatch.AddCommand(Generator.Save <PrimaryKeyType>(Object));
             TempBatch.Execute();
             TempBatch = QueryProvider.Batch(Source);
             JoinsDelete <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
             JoinsSave <ObjectType>(Object, Source, Mapping, TempBatch, new List <object>());
             TempBatch.RemoveDuplicateCommands().Execute();
         }
     }
 }
コード例 #5
0
        /// <summary>
        /// Returns a paged list of items
        /// </summary>
        /// <typeparam name="ObjectType">Object type</typeparam>
        /// <param name="PageSize">Page size</param>
        /// <param name="CurrentPage">Current page (starting with 0)</param>
        /// <param name="OrderBy">The order by portion of the query</param>
        /// <param name="Parameters">Parameters used in the where clause</param>
        /// <returns>A paged list of items that match the criteria</returns>
        public IEnumerable <ObjectType> Paged <ObjectType>(int PageSize = 25, int CurrentPage = 0, string OrderBy = "", params IParameter[] Parameters)
            where ObjectType : class
        {
            Parameters = Parameters.Check(new IParameter[] { });
            string KeyName = typeof(ObjectType).GetName() + "_Paged_" + PageSize.ToString(CultureInfo.InvariantCulture) + "_" + CurrentPage.ToString(CultureInfo.InvariantCulture) + "_" + Parameters.ToString(x => x.ToString(), "_");

            Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
            var ReturnValue = new System.Collections.Generic.List <Dynamo>();

            if (Cache.ContainsKey(KeyName))
            {
                return(GetListCached <ObjectType>(ref ReturnValue, KeyName));
            }
            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    var IDProperty = Mapping.IDProperties.FirstOrDefault();
                    if (IDProperty != null)
                    {
                        foreach (Dynamo Item in QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType))
                                 .Paged(PageSize, CurrentPage, OrderBy, Parameters)
                                 .Execute()[0])
                        {
                            CopyOrAdd(ReturnValue, IDProperty, Item);
                        }
                    }
                }
            }
            Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
            return(ConvertValues <ObjectType>(ReturnValue));
        }
コード例 #6
0
        /// <summary>
        /// Loads a property (primarily used internally for lazy loading)
        /// </summary>
        /// <typeparam name="ObjectType">Object type</typeparam>
        /// <typeparam name="DataType">Data type</typeparam>
        /// <param name="Object">Object</param>
        /// <param name="PropertyName">Property name</param>
        /// <returns>The appropriate property value</returns>
        public IList <DataType> LoadProperties <ObjectType, DataType>(ObjectType Object, string PropertyName)
            where ObjectType : class
            where DataType : class
        {
            var ReturnValue = new System.Collections.Generic.List <Dynamo>();

            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    var Property = Mapping.Properties.FirstOrDefault(x => x.Name == PropertyName);
                    if (Property != null)
                    {
                        foreach (Dynamo Item in QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType))
                                 .LoadProperty <DataType>(Object, Property)
                                 .Execute()[0])
                        {
                            var IDProperty = Property.ForeignMapping.IDProperties.FirstOrDefault();
                            CopyOrAdd(ReturnValue, IDProperty, Item);
                        }
                    }
                }
            }
            if (ReturnValue.Count == 0)
            {
                return(new ObservableList <DataType>());
            }
            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping ObjectMapping = MapperProvider[typeof(ObjectType), Source];
                IMapping Mapping       = MapperProvider[typeof(DataType), Source];
                if (Mapping != null)
                {
                    IProperty ObjectProperty = ObjectMapping == null ? null : ObjectMapping.Properties.FirstOrDefault(x => x.Name == PropertyName);
                    if (ObjectProperty == null)
                    {
                        var        IDProperty = Mapping.IDProperties.FirstOrDefault();
                        IParameter Parameter  = null;
                        int        Counter    = 0;
                        foreach (Dynamo Item in ReturnValue)
                        {
                            if (IDProperty.GetParameter(Item) != null)
                            {
                                Parameter = Parameter == null ? (IParameter) new EqualParameter <object>(IDProperty.GetParameter(Item), Counter.ToString(CultureInfo.InvariantCulture), IDProperty.FieldName, Source.ParameterPrefix) : (IParameter) new OrParameter(Parameter, new EqualParameter <object>(IDProperty.GetParameter(Item), Counter.ToString(CultureInfo.InvariantCulture), IDProperty.FieldName, Source.ParameterPrefix));
                                ++Counter;
                            }
                        }
                        if (Parameter != null)
                        {
                            foreach (Dynamo Item in QueryProvider.Generate <DataType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).All(Parameter).Execute()[0])
                            {
                                CopyOrAdd(ReturnValue, IDProperty, Item);
                            }
                        }
                    }
                }
            }
            return(ConvertValues <DataType>(ReturnValue).ToObservableList(x => x));
        }
コード例 #7
0
        /// <summary>
        /// Returns a single item matching the criteria specified
        /// </summary>
        /// <typeparam name="ObjectType">Type of the object</typeparam>
        /// <typeparam name="IDType">ID type for the object</typeparam>
        /// <param name="ID">ID of the object to load</param>
        /// <returns>A single object matching the ID</returns>
        public ObjectType Any <ObjectType, IDType>(IDType ID)
            where ObjectType : class
            where IDType : IComparable
        {
            Dynamo ReturnValue = null;
            string KeyName     = typeof(ObjectType).GetName() + "_Any_" + ID.ToString();

            if (Cache.ContainsKey(KeyName))
            {
                return(GetCached <ObjectType>(ref ReturnValue, KeyName));
            }
            var StringID = ID.ToString();

            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    var IDProperty = Mapping.IDProperties.FirstOrDefault();
                    if (IDProperty != null)
                    {
                        Dynamo Value = typeof(IDType) == typeof(string) ?
                                       QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).Any(new StringEqualParameter(StringID, IDProperty.FieldName, StringID.Length, IDProperty.FieldName, Source.ParameterPrefix)).Execute()[0].FirstOrDefault() :
                                       QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).Any(new EqualParameter <IDType>(ID, IDProperty.FieldName, IDProperty.FieldName, Source.ParameterPrefix)).Execute()[0].FirstOrDefault();
                        ReturnValue = CopyOrAssign(ReturnValue, Value);
                    }
                }
            }
            Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
            return(ConvertValue <ObjectType>(ReturnValue));
        }
コード例 #8
0
        /// <summary>
        /// Returns a single item matching the criteria
        /// </summary>
        /// <typeparam name="ObjectType">Type of the object</typeparam>
        /// <param name="Parameters">Parameters used in the where clause</param>
        /// <returns>A single object matching the criteria</returns>
        public ObjectType Any <ObjectType>(params IParameter[] Parameters)
            where ObjectType : class
        {
            Parameters = Parameters.Check(new IParameter[] { });
            Dynamo ReturnValue = null;
            string KeyName     = typeof(ObjectType).GetName() + "_Any_" + Parameters.ToString(x => x.ToString(), "_");

            Parameters.ForEach(x => { KeyName = x.AddParameter(KeyName); });
            if (Cache.ContainsKey(KeyName))
            {
                return(GetCached <ObjectType>(ref ReturnValue, KeyName));
            }
            foreach (ISourceInfo Source in SourceProvider.Where(x => x.Readable).OrderBy(x => x.Order))
            {
                IMapping Mapping = MapperProvider[typeof(ObjectType), Source];
                if (Mapping != null)
                {
                    Dynamo Value = QueryProvider.Generate <ObjectType>(Source, Mapping, MapperProvider.GetStructure(Mapping.DatabaseConfigType)).Any(Parameters).Execute()[0].FirstOrDefault();
                    ReturnValue = CopyOrAssign(ReturnValue, Value);
                }
            }
            Cache.Add(KeyName, ReturnValue, new string[] { typeof(ObjectType).GetName() });
            return(ConvertValue <ObjectType>(ReturnValue));
        }