///
        /// LOAD BY ID
        ///

        internal static string ContructLoadByID <T>(this DirectQueryLoader <T> loader, long id) where T : DirectModel
        {
            return(string.Format("SELECT {0} FROM [].{1} WHERE {2}={3};",
                                 loader.SelectQuery,
                                 loader.Instance.GetTableName(),
                                 loader.Instance.GetIdNameValue(), id));
        }
        ///
        /// LOAD BY WHERE
        ///

        internal static string ContructLoad <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            return(string.Format("SELECT {0} FROM [].{1} {2} {3}",
                                 loader.SelectQuery,
                                 loader.Instance.TableName,
                                 loader.WhereQuery,
                                 loader.Additional));
        }
    public static DirectQueryLoader<T> Where<T>(this DirectQueryLoader<T> loader, string input) where T : DirectModel
    {
      if(input.Contains("[id]"))
        using (var tempValue = (T)Activator.CreateInstance(typeof(T), (DirectDatabaseBase)null))
          input = input.Replace("[id]", tempValue.IdName);

      loader.Where = input;
      return loader;
    }
        public static List <T> Load <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            List <T> result = new List <T>();

            foreach (var entry in LoadEnumerable <T>(loader))
            {
                result.Add(entry);
            }
            return(result);
        }
        public static T LoadLater <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            using (var tempValue = (T)Activator.CreateInstance(typeof(T), (DirectDatabaseBase)null))
                loader.Select = tempValue.IdName;

            T temp = (T)Activator.CreateInstance(typeof(T), loader.Database);

            loader.Database.TransactionalManager.Load(temp, loader.ContructLoad());
            return(temp);
        }
        public static IEnumerable <T> LoadEnumerable <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            var dc = loader.Database.LoadContainer(loader.ContructLoad());

            if (!dc.HasValue)
            {
                return(null);
            }

            return(loader.CastEnumerable(dc));
        }
        public static T Load <T>(this DirectQueryLoader <T> loader, long id) where T : DirectModel
        {
            var dc = loader.Database.LoadContainer(loader.ContructLoadByID(id));

            if (!dc.HasValue)
            {
                return(null);
            }
            T result = loader.Cast(dc);

            return(result);
        }
 public static DirectQueryLoader<T> Select<T>(this DirectQueryLoader<T> loader, string input) where T : DirectModel
 {
   using (var tempValue = (T)Activator.CreateInstance(typeof(T), (DirectDatabaseBase)null))
   {
     if (loader.Select.Equals("id"))
       loader.Select = tempValue.IdName;
     else if (!string.IsNullOrEmpty(input))
       loader.Select = tempValue.IdName + "," + input;
     else
       loader.Select = "*";
   }
   return loader;
 }
        public static async Task <T> LoadSingleAsync <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            string command = string.Format("SELECT {0} FROM [].{1} {2} LIMIT 1",
                                           loader.SelectQuery,
                                           loader.Instance.TableName,
                                           loader.WhereQuery);

            var dc = await loader.Database.LoadContainerAsync(command);

            if (!dc.HasValue)
            {
                return(null);
            }
            return(loader.Cast(dc));
        }
        public static async Task <T> LoadAsync <T>(this DirectQueryLoader <T> loader, int id) where T : DirectModel
        {
            string command = string.Format("SELECT {0} FROM [].{1} WHERE {2}={3};",
                                           loader.SelectQuery,
                                           loader.Instance.GetTableName(),
                                           loader.Instance.GetIdNameValue(), id);

            var dc = await loader.Database.LoadContainerAsync(command);

            if (!dc.HasValue)
            {
                return(null);
            }
            return(loader.Cast(dc));
        }
        public static async Task <List <T> > LoadAsync <T>(this DirectQueryLoader <T> loader) where T : DirectModel
        {
            string command = string.Format("SELECT {0} FROM [].{1} {2} {3}",
                                           loader.SelectQuery,
                                           loader.Instance.TableName,
                                           loader.WhereQuery,
                                           loader.Additional);

            List <T> result = new List <T>();

            var dc = await loader.Database.LoadContainerAsync(command);

            if (!dc.HasValue)
            {
                return(result);
            }

            foreach (var entry in loader.CastEnumerable(dc))
            {
                result.Add(entry);
            }

            return(result);
        }
 public static DirectQueryLoader <T> Where <T>(this DirectQueryLoader <T> loader, string input) where T : DirectModel
 {
     loader.Where = input;
     return(loader);
 }
 public static async Task <T> LoadAsync <T>(this DirectQueryLoader <T> loader, string query) where T : DirectModel
 => loader.Cast(await loader.Database.LoadContainerAsync(query));
 public static DirectQueryLoader<T> Additional<T>(this DirectQueryLoader<T> loader, string input) where T : DirectModel
 {
   loader.Additional = input;
   return loader;
 }
 public static T Load <T>(this DirectQueryLoader <T> loader, int id) where T : DirectModel
 => Load(loader, (long)id);
 public static DirectQueryLoader<T> Where<T>(this DirectQueryLoader<T> loader, string input, params object[] parameters) where T : DirectModel
 {
   loader.SetWhere(input, parameters);
   return loader;
 }
 public static T Load <T>(this DirectQueryLoader <T> loader, string query) where T : DirectModel
 => loader.Cast(loader.Database.LoadContainer(query));