PageRenderTime 60ms CodeModel.GetById 30ms RepoModel.GetById 1ms app.codeStats 0ms

/SubSonic.Core/Repository/SubSonicRepository.cs

https://github.com/henrylu/SubSonic-3.0
C# | 375 lines | 218 code | 52 blank | 105 comment | 18 complexity | 925d23273d084512a412cdbf9cc0db54 MD5 | raw file
  1. //
  2. // SubSonic - http://subsonicproject.com
  3. //
  4. // The contents of this file are subject to the New BSD
  5. // License (the "License"); you may not use this file
  6. // except in compliance with the License. You may obtain a copy of
  7. // the License at http://www.opensource.org/licenses/bsd-license.php
  8. //
  9. // Software distributed under the License is distributed on an
  10. // "AS IS" basis, WITHOUT WARRANTY OF ANY KIND, either express or
  11. // implied. See the License for the specific language governing
  12. // rights and limitations under the License.
  13. //
  14. using System;
  15. using System.Collections.Generic;
  16. using System.Linq;
  17. using System.Linq.Expressions;
  18. using SubSonic.Extensions;
  19. using SubSonic.DataProviders;
  20. using SubSonic.Query;
  21. using SubSonic.Schema;
  22. namespace SubSonic.Repository
  23. {
  24. /// <summary>
  25. /// A Repository class which wraps the a Database by type
  26. /// </summary>
  27. public class SubSonicRepository<T> : IRepository<T> where T : class, new()
  28. {
  29. private readonly IQuerySurface _db;
  30. public SubSonicRepository(IQuerySurface db)
  31. {
  32. _db = db;
  33. }
  34. #region IRepository<T> Members
  35. public ITable GetTable()
  36. {
  37. ITable tbl = _db.FindTable(typeof(T).Name);
  38. return tbl;
  39. }
  40. /// <summary>
  41. /// Loads a T object
  42. /// </summary>
  43. /// <typeparam name="T"></typeparam>
  44. /// <param name="item">The item.</param>
  45. /// <param name="column">The column.</param>
  46. /// <param name="value">The value.</param>
  47. /// <returns></returns>
  48. public bool Load<T>(T item, string column, object value) where T : class, new()
  49. {
  50. var qry = _db.Select.From(GetTable()).Where(column).IsEqualTo(value);
  51. bool loaded = false;
  52. using (var rdr = qry.ExecuteReader())
  53. {
  54. if (rdr.Read())
  55. {
  56. rdr.Load(item, null);//mike added null as ColumnNames not known
  57. loaded = true;
  58. }
  59. rdr.Dispose();
  60. }
  61. return loaded;
  62. }
  63. /// <summary>
  64. /// Loads a T object
  65. /// </summary>
  66. /// <typeparam name="T"></typeparam>
  67. /// <param name="item">The item.</param>
  68. /// <param name="expression">The expression.</param>
  69. /// <returns></returns>
  70. public bool Load<T>(T item, Expression<Func<T, bool>> expression) where T : class, new()
  71. {
  72. var qry = _db.Select.From(GetTable()).Where(expression);
  73. bool loaded = false;
  74. using (var rdr = qry.ExecuteReader())
  75. {
  76. if (rdr.Read())
  77. {
  78. rdr.Load(item, null);//mike added null as ColumnNames not known
  79. loaded = true;
  80. }
  81. rdr.Dispose();
  82. }
  83. return loaded;
  84. }
  85. /// <summary>
  86. /// Returns all T items
  87. /// </summary>
  88. public IQueryable<T> GetAll()
  89. {
  90. return _db.GetQuery<T>();
  91. }
  92. /// <summary>
  93. /// Returns a single record
  94. /// </summary>
  95. public T GetByKey(object key)
  96. {
  97. ITable tbl = GetTable();
  98. return _db.Select.From(tbl)
  99. .Where(tbl.PrimaryKey.Name).IsEqualTo(key)
  100. .ExecuteSingle<T>();
  101. }
  102. /// <summary>
  103. /// Returns a server-side Paged List
  104. /// </summary>
  105. public PagedList<T> GetPaged<TKey>(Func<T, TKey> orderBy, int pageIndex, int pageSize)
  106. {
  107. return new PagedList<T>(_db.GetQuery<T>().OrderBy(orderBy).AsQueryable(), pageIndex, pageSize);
  108. }
  109. /// <summary>
  110. /// Returns a server-side Paged List
  111. /// </summary>
  112. public PagedList<T> GetPaged(int pageIndex, int pageSize)
  113. {
  114. ITable tbl = GetTable();
  115. string orderBy = tbl.PrimaryKey != null ? tbl.PrimaryKey.Name : tbl.Columns[0].Name;
  116. return GetPaged(orderBy, pageIndex, pageSize);
  117. }
  118. /// <summary>
  119. /// Returns a server-side Paged List
  120. /// </summary>
  121. public PagedList<T> GetPaged(string sortBy, int pageIndex, int pageSize)
  122. {
  123. int totalCount = _db.Select.From<T>().GetRecordCount(); //this.GetAll().Count();
  124. ITable tbl = GetTable();
  125. var qry = _db.Select.From(tbl)
  126. .Paged(pageIndex, pageSize);
  127. if(!sortBy.EndsWith(" desc", StringComparison.InvariantCultureIgnoreCase))
  128. qry.OrderAsc(sortBy);
  129. else
  130. qry.OrderDesc(sortBy.FastReplace(" desc", ""));
  131. var list = qry.ExecuteTypedList<T>();
  132. PagedList<T> result = new PagedList<T>(list, totalCount, pageIndex, pageSize);
  133. //pull the page count
  134. return result;
  135. }
  136. /// <summary>
  137. /// Returns an IQueryable based on the passed-in Expression Chinook Database
  138. /// </summary>
  139. public IList<T> Search(string column, string value)
  140. {
  141. if(!value.EndsWith("%"))
  142. value += "%";
  143. var qry = _db.Select.From<T>().Where(column).Like(value).OrderAsc(column);
  144. return qry.ExecuteTypedList<T>();
  145. }
  146. /// <summary>
  147. /// Returns an IQueryable based on the passed-in Expression Chinook Database
  148. /// </summary>
  149. public IQueryable<T> Find(Expression<Func<T, bool>> expression)
  150. {
  151. return GetAll().Where(expression);
  152. }
  153. /// <summary>
  154. /// Adds a T item to the db
  155. /// </summary>
  156. public object Add(T item) {
  157. return Add(item, _db.Provider);
  158. }
  159. /// <summary>
  160. /// Adds a T item to the db
  161. /// </summary>
  162. public object Add(T item, IDataProvider provider)
  163. {
  164. var query = item.ToInsertQuery(provider).GetCommand();
  165. object result = null;
  166. if(query != null)
  167. {
  168. query.CommandSql += provider.InsertionIdentityFetchString;
  169. /* add "using" keywords to dispose IDataReader rdr object after its get out of the scope */
  170. using (var rdr = provider.ExecuteReader(query))
  171. {
  172. if (rdr.Read())
  173. result = rdr[0];
  174. // repopulate primary key column with newly generated ID
  175. if (result != null && result != DBNull.Value)
  176. {
  177. try
  178. {
  179. var tbl = provider.FindOrCreateTable(typeof(T));
  180. var prop = item.GetType().GetProperty(tbl.PrimaryKey.Name);
  181. var settable = result.ChangeTypeTo(prop.PropertyType);
  182. prop.SetValue(item, settable, null);
  183. }
  184. catch (Exception)
  185. {
  186. //swallow it - I don't like this per se but this is a convenience and we
  187. //don't want to throw the whole thing just because we can't auto-set the value
  188. }
  189. }
  190. }
  191. }
  192. return result;
  193. }
  194. /// <summary>
  195. /// Adds a bunch of T items
  196. ///</summary>
  197. public void Add(IEnumerable<T> items) {
  198. Add(items, _db.Provider);
  199. }
  200. /// <summary>
  201. /// Adds a bunch of T items
  202. ///</summary>
  203. public void Add(IEnumerable<T> items, IDataProvider provider)
  204. {
  205. BatchQuery bQuery = new BatchQuery(provider);
  206. foreach(T item in items)
  207. {
  208. var query = item.ToInsertQuery(provider);
  209. bQuery.Queue(query);
  210. }
  211. bQuery.Execute();
  212. }
  213. /// <summary>
  214. /// Updates the passed-in T
  215. /// </summary>
  216. public int Update(T item)
  217. {
  218. return Update(item, _db.Provider);
  219. }
  220. /// <summary>
  221. /// Updates the passed-in T
  222. /// </summary>
  223. public int Update(T item, IDataProvider provider)
  224. {
  225. int result = 0;
  226. var query = item.ToUpdateQuery(provider).GetCommand();
  227. if (query != null)
  228. result = provider.ExecuteQuery(query);
  229. return result;
  230. }
  231. /// <summary>
  232. /// Updates the passed-in T
  233. /// </summary>
  234. public int Update(IEnumerable<T> items){
  235. return Update(items, _db.Provider);
  236. }
  237. /// <summary>
  238. /// Updates the passed-in T
  239. /// </summary>
  240. public int Update(IEnumerable<T> items, IDataProvider provider)
  241. {
  242. BatchQuery bQuery = new BatchQuery(provider);
  243. int result = 0;
  244. foreach(T item in items)
  245. {
  246. var query = item.ToUpdateQuery(provider);
  247. bQuery.Queue(query);
  248. }
  249. result = bQuery.Execute();
  250. return result;
  251. }
  252. /// <summary>
  253. /// Deletes the passed-in T items
  254. /// </summary>
  255. public int Delete(IEnumerable<T> items) {
  256. return Delete(items, _db.Provider);
  257. }
  258. /// <summary>
  259. /// Deletes the passed-in T items
  260. /// </summary>
  261. public int Delete(IEnumerable<T> items, IDataProvider provider)
  262. {
  263. BatchQuery bQuery = new BatchQuery(provider);
  264. int result = 0;
  265. foreach(T item in items)
  266. {
  267. var query = item.ToDeleteQuery(provider);
  268. bQuery.Queue(query);
  269. }
  270. result = bQuery.Execute();
  271. return result;
  272. }
  273. /// <summary>
  274. /// Deletes the passed-in T item
  275. /// </summary>
  276. public int Delete(T item) {
  277. return Delete(item, _db.Provider);
  278. }
  279. /// <summary>
  280. /// Deletes the passed-in T item
  281. /// </summary>
  282. public int Delete(T item, IDataProvider provider)
  283. {
  284. int result = 0;
  285. var query = item.ToDeleteQuery(provider).GetCommand();
  286. if (query != null)
  287. result = provider.ExecuteQuery(query);
  288. return result;
  289. }
  290. /// <summary>
  291. /// Deletes the T item by Primary Key
  292. /// </summary>
  293. public int Delete(object key) {
  294. return Delete(key, _db.Provider);
  295. }
  296. /// <summary>
  297. /// Deletes the T item by Primary Key
  298. /// </summary>
  299. public int Delete(object key, IDataProvider provider)
  300. {
  301. ITable tbl = _db.FindTable(typeof(T).Name);
  302. int result = 0;
  303. if(tbl != null)
  304. result = new Delete<T>(provider).Where(tbl.PrimaryKey.Name).IsEqualTo(key).Execute();
  305. return result;
  306. }
  307. /// <summary>
  308. /// Deletes 0 to n T items from the Database based on the passed-in Expression
  309. /// </summary>
  310. public int DeleteMany(Expression<Func<T, bool>> expression) {
  311. return DeleteMany(expression, _db.Provider);
  312. }
  313. /// <summary>
  314. /// Deletes 0 to n T items from the Database based on the passed-in Expression
  315. /// </summary>
  316. public int DeleteMany(Expression<Func<T, bool>> expression, IDataProvider provider)
  317. {
  318. var cmd= _db.Delete(expression).GetCommand();
  319. return provider.ExecuteQuery(cmd);
  320. }
  321. #endregion
  322. }
  323. }