/// <summary>
/// 지정한 문화권의 모든 리소스 정보를 Hashtable로 반환한다.
/// </summary>
public Hashtable GetResources(CultureInfo culture)
{
if (IsDebugEnabled)
{
log.Debug("Get resources map... resourceType=[{0}], culture=[{1}]", ResourceName, culture);
}
var resourceMap = new Hashtable();
try {
culture = culture.GetOrCurrentCulture();
using (var cmd = GetResourcesCommand(culture.Name))
using (var reader = Ado.ExecuteReader(cmd)) {
while (reader.Read())
{
var key = reader.AsString("ResourceKey");
var value = reader.AsString("ResourceValue");
resourceMap.Add(key, value);
}
}
}
catch (Exception ex) {
if (log.IsErrorEnabled)
{
log.Error("리소스를 얻는데 실패했습니다. culture=[{0}]", culture);
log.Error(ex);
}
throw;
}
return(resourceMap);
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,INameMapper,System.Data.Common.DbCommand,IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="targetFactory">대상 객체 생성 함수</param>
/// <param name="firstResult">첫번째 레코드 인덱스 (0부터 시작)</param>
/// <param name="maxResults">최대 레코드 갯수(0이면 끝까지)</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Func <T> targetFactory,
int firstResult,
int maxResults,
Action <AdoResultRow, T> additionalMapping,
string query,
params IAdoParameter[] parameters)
{
nameMapper.ShouldNotBeNull("nameMapper");
targetFactory.ShouldNotBeNull("targetFactory");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader()을 수행하고, 병렬로 매핑하여 결과를 IList<{0}>으로 매핑합니다... " +
"query=[{1}], firstResult=[{2}], maxResults=[{3}]", typeof(T).Name, query, firstResult, maxResults);
}
return
(Task.Factory
.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapAsParallel <T>(targetFactory, nameMapper, firstResult, maxResults,
additionalMapping);
}));
}
/// <summary>
/// 비동기적으로 ExecuteReader()을 수행하고, 병렬 방식으로 매핑하여 결과를 IPageList{T} 으로 반환하는 Task를 빌드합니다
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="rowMapFunc">DataReader로부터 {T} 수형의 인스턴스로 변환하는 메소드</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IPagingList <T> > ExecuteInstanceAsParallelAsync <T>(this IAdoRepository repository,
Func <AdoResultRow, T> rowMapFunc,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
rowMapFunc.ShouldNotBeNull("converter");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader()을 수행하고, 병렬 방식으로 매핑하여 결과를 IPageList<{0}>으로 반환하는 Task를 빌드합니다... " +
@"query=[{1}]", typeof(T).Name, query);
}
var itemsTask = Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return(reader.MapAsParallel <T>(rowMapFunc, pageIndex * pageSize, pageSize));
});
var totalItemCountTask = repository.CountAsync(query, parameters);
var result = new PagingList <T>(itemsTask.Result, pageIndex, pageSize, totalItemCountTask.Result);
return(Task.Factory.FromResult((IPagingList <T>)result));
}
/// <summary>
/// Command를 수행하고, 결과를 XML 문자열로 반환합니다.
/// </summary>
/// <param name="repository">Repository</param>
/// <param name="requestItem">요청 정보</param>
/// <returns>Data 처리 결과의 XML 문자열</returns>
public override string Execute(IAdoRepository repository, RequestItem requestItem) {
Repository = repository;
var method = requestItem.Method;
var requestParameters = requestItem.Parameters;
if(IsDebugEnabled)
log.Debug("{0}를 수행합니다. method=[{1}], parameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
var query = repository.QueryProvider.GetQuery(method).AsText(method);
string result;
using(var cmd = repository.GetCommand(query, GetParameters(requestParameters))) {
var reader = repository.ExecuteReader(cmd);
var records = BuildResponse(reader);
result = JsonTool.SerializeAsText(records);
}
if(IsDebugEnabled)
log.Debug("{0}를 완료했습니다. method=[{1}], requestParameters=[{2}]", GetType().FullName, method,
requestParameters.CollectionToString());
return result;
}
/// <summary>
/// Command를 수행하고, 결과를 XML 문자열로 반환합니다.
/// </summary>
/// <param name="repository">Repository</param>
/// <param name="requestItem">요청 정보</param>
/// <returns>Data 처리 결과의 XML 문자열</returns>
public override string Execute(IAdoRepository repository, RequestItem requestItem)
{
Repository = repository;
var method = requestItem.Method;
var requestParameters = requestItem.Parameters;
if (IsDebugEnabled)
{
log.Debug("{0}를 수행합니다. method=[{1}], parameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
}
var query = repository.QueryProvider.GetQuery(method).AsText(method);
string result;
using (var cmd = repository.GetCommand(query, GetParameters(requestParameters))) {
var reader = repository.ExecuteReader(cmd);
var records = BuildResponse(reader);
result = JsonTool.SerializeAsText(records);
}
if (IsDebugEnabled)
{
log.Debug("{0}를 완료했습니다. method=[{1}], requestParameters=[{2}]", GetType().FullName, method,
requestParameters.CollectionToString());
}
return(result);
}
//! ===============================================================================================
/// <summary>
/// 지정한 Command의 실행 결과 셋이 존재하는지 검사한다 (결과 셋의 레코드가 하나 이상이다)
/// </summary>
public static bool Exists(this IAdoRepository repository, DbCommand cmd, params IAdoParameter[] parameters)
{
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("결과 셋이 존재하는지 검사합니다... commandText=[{0}], parameters=[{1}]", cmd.CommandText, parameters.CollectionToString());
}
using (var dr = repository.ExecuteReader(cmd, parameters))
return(dr.Read());
}
//! ===============================================================================================
/// <summary>
/// 지정된 Command를 실행한 결과 셋의 레코드 갯수를 구한다.
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="cmd">실행할 Command 객체</param>
/// <param name="parameters">Command 인자 정보</param>
/// <returns>결과 셋의 레코드 수</returns>
/// <remarks>
/// 실제 SQL의 count(*) 함수를 생성하는 것이 아니라, IDataReader를 이용하여 결과 셋을 가져와서 갯수만 센다.
/// 장점은 DataSet을 이용하여 Paging하는 것보다 빠르고, Count 용 Query문을 따로 만들 필요가 없다.
/// 단점은 SQL의 count(*) 함수보다는 당연히 느리다.
/// </remarks>
public static int Count(this IAdoRepository repository, DbCommand cmd, params IAdoParameter[] parameters)
{
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("결과 셋의 갯수를 계산합니다. commandText=[{0}], parameters=[{1}]", cmd.CommandText, parameters.CollectionToString());
}
using (var dr = repository.ExecuteReader(cmd, parameters)) {
return(dr.Count());
}
}
//! ======================================================================================
/// <summary>
/// 비동기 방식으로 작업을 <paramref name="query"/>를 수행하여, <see cref="IDataReader"/>를 결과값으로 제공하는 Task를 반환합니다.
/// </summary>
/// <param name="repository">Repository</param>
/// <param name="query">실행할 쿼리문 또는 Procedure Name</param>
/// <param name="parameters">Parameters</param>
/// <returns>결과셋을 IDataReader 로 결과를 제공하는 Task</returns>
public static Task <IDataReader> ExecuteReaderAsync(this IAdoRepository repository, string query,
params IAdoParameter[] parameters)
{
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기 방식으로 쿼리를 수행하여 IDataReader를 얻습니다... query=[{0}], parameters=[{1}]",
query, parameters.CollectionToString());
}
return(Task.Factory.StartNew(() => repository.ExecuteReader(query, parameters)));
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 <paramref name="filter"/> 에 만족하는 레코드만 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="persister">대상 객체를 빌드하는 Persister</param>
/// <param name="filter">매핑할 Row를 선별할 필터 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecuteInstanceIfAsync <T>(this IAdoRepository repository,
IReaderPersister <T> persister,
Func <IDataReader, bool> filter,
string query,
params IAdoParameter[] parameters) where T : class
{
persister.ShouldNotBeNull("persister");
filter.ShouldNotBeNull("filter");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapIf <T>(persister, filter, null);
}));
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// <paramref name="continuationCondition"/> 조건이 만족할 동안만, DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="mapFunc">매핑 함수</param>
/// <param name="continuationCondition">매핑을 계속할 조건인지 판단하는 델리게이트</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecuteInstanceWhileAsync <T>(this IAdoRepository repository,
Func <IDataReader, T> mapFunc,
Func <IDataReader, bool> continuationCondition,
string query,
params IAdoParameter[] parameters) where T : class
{
mapFunc.ShouldNotBeNull("mapFunc");
continuationCondition.ShouldNotBeNull("continuationCondition");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapWhile <T>(mapFunc, continuationCondition);
}));
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// DataReader로부터 <paramref name="filter"/> 에 만족하는 레코드만 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="mapFunc">매핑 함수</param>
/// <param name="filter">매핑할 Row를 선별할 필터 함수</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecutInstanceIfTask <T>(this IAdoRepository repository,
Func <IDataReader, T> mapFunc,
Func <IDataReader, bool> filter,
string query,
params IAdoParameter[] parameters) where T : class
{
mapFunc.ShouldNotBeNull("mapFunc");
filter.ShouldNotBeNull("filter");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapIf <T>(mapFunc, filter);
}));
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteInstance{T}(System.Func{System.Data.IDataReader,T},System.Data.Common.DbCommand,NFramework.Data.IAdoParameter[])"/> 를 비동기적으로 수행하여,
/// <paramref name="continuationCondition"/> 조건이 만족할 동안만, DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="targetFactory">대상 객체 생성용 Factory</param>
/// <param name="nameMap">DB 컬럼명- 클래스 속성명 매핑 정보</param>
/// <param name="continuationCondition">매핑을 계속할 조건인지 판단하는 델리게이트</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IEnumerable <T> > ExecuteInstanceWhileAsync <T>(this IAdoRepository repository,
Func <T> targetFactory,
INameMap nameMap,
Func <IDataReader, bool> continuationCondition,
string query,
params IAdoParameter[] parameters) where T : class
{
nameMap.ShouldNotBeNull("nameMap");
continuationCondition.ShouldNotBeNull("continuationCondition");
return(Task.Factory.StartNew(() => {
using (var reader = repository.ExecuteReader(query, parameters))
return reader.MapWhile <T>(ActivatorTool.CreateInstance <T>,
nameMap,
continuationCondition,
null);
}));
}
/// <summary>
/// Execute DbCommand, Build instance of specified type by mapping DataReader Column Value to Instance Property Value
/// </summary>
/// <typeparam name="T">Type of Persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMap">Key = ColumnName of DataReader, Value = Property Name of Specifieid Type</param>
/// <param name="cmd">Instance of DbCommand to executed</param>
/// <param name="parameters">Command parameters</param>
/// <returns>Collection of Persistent object</returns>
public static IList <T> ExecuteInstance <T>(this IAdoRepository repository,
INameMap nameMap,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
nameMap.ShouldNotBeNull("nameMap");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("DataReader를 INameMap를 통해 지정된 Class의 인스턴스들을 생성합니다. " +
"persistent=[{0}], nameMap=[{1}], commandText=[{2}], parameters=[{3}]",
typeof(T).FullName, nameMap.DictionaryToString(), cmd.CommandText, parameters.CollectionToString());
}
using (var reader = repository.ExecuteReader(cmd, parameters))
return(reader.Map <T>(ActivatorTool.CreateInstance <T>, nameMap));
}
/// <summary>
/// DbCommand를 실행해 얻은 DataReader를 Converter를 통해 지정된 형식의 인스턴스를 만든다.
/// </summary>
/// <typeparam name="T">Type of persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="mapFunc">IDataReader의 한 레코드인 IDataRecord 정보를 가지고, Persistent Object를 만들 Converter</param>
/// <param name="cmd">Instance of DbCommand to executed</param>
/// <param name="parameters">Parameters for DbCommand to execute</param>
/// <returns>Collection of Persistent Object</returns>
public static IList <T> ExecuteInstance <T>(this IAdoRepository repository,
Func <IDataReader, T> mapFunc,
DbCommand cmd,
params IAdoParameter[] parameters)
{
mapFunc.ShouldNotBeNull("mapFunc");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("DataReader를 Mapping function 를 통해 지정된 Class의 인스턴스들을 생성합니다. " +
"persistent=[{0}], mapFunc=[{1}], commandText=[{2}], parameters=[{3}]",
typeof(T).FullName, mapFunc, cmd.CommandText, parameters.CollectionToString());
}
using (var reader = repository.ExecuteReader(cmd, parameters))
return(reader.Map <T>(mapFunc));
}
/// <summary>
/// Execute DbCommand, Build instance of specified type from IDataReader using Persister
/// </summary>
/// <typeparam name="T">Type of persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="persister">Persister from IDataReader</param>
/// <param name="cmd">Instance of DbCommand</param>
/// <param name="parameters">Parameters for DbCommand to execute</param>
/// <returns>List of Persistent Object</returns>
public static IList <T> ExecuteInstance <T>(this IAdoRepository repository,
IReaderPersister <T> persister,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
persister.ShouldNotBeNull("persister");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("DataReader를 IReaderPersister를 통해 지정된 Class의 인스턴스들을 생성합니다. " +
"persistent=[{0}], persister=[{1}], commandText=[{2}], parameters=[{3}]",
typeof(T).FullName, persister, cmd.CommandText, parameters.CollectionToString());
}
using (var reader = repository.ExecuteReader(cmd, parameters))
return(reader.Map <T>(persister));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="mapFunc">IDataReader로부터 Persistent Object를 빌드하는 Mapping function</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">DbCommand 실행시의 Parameter 정보</param>
/// <returns>Paging된 Persistent Object의 List</returns>
public static IPagingList <T> ExecuteInstance <T>(this IAdoRepository repository,
Func <IDataReader, T> @mapFunc,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
@mapFunc.ShouldNotBeNull("@mapFunc");
cmd.ShouldNotBeNull("cmd");
pageIndex.ShouldBePositiveOrZero("pageIndex");
pageSize.ShouldBePositive("pageSize");
if (IsDebugEnabled)
{
log.Debug("ExecuteReader를 수행해 엔티티로 매핑합니다... " +
"CommandText=[{0}], @mapFunc=[{1}], pageIndex=[{2}], pageSize=[{3}], parameters=[{4}]",
cmd.CommandText, @mapFunc, pageIndex, pageSize, parameters.CollectionToString());
}
var query = cmd.CommandText;
var firstResult = pageIndex * pageSize;
var maxResults = pageSize;
var totalItemCountTask = repository.CountAsync(query, parameters);
IList <T> instances;
using (var dr = repository.ExecuteReader(cmd, parameters))
instances = dr.Map <T>(@mapFunc, firstResult, maxResults);
var pagingList = new PagingList <T>(instances, pageIndex, pageSize, totalItemCountTask.Result);
if (IsDebugEnabled)
{
log.Debug("ExecuteReader를 수행해 엔티티로 매핑했습니다!!! pageIndex=[{0}], pageSize=[{1}], totalItemCount=[{2}]",
pageIndex, pageSize, totalItemCountTask.Result);
}
return(pagingList);
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMap">컬럼명:속성명의 매핑정보</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="pageIndex">결과셋의 Page Index (0부터 시작)</param>
/// <param name="pageSize">결과셋 Paging 시의 Page Size</param>
/// <param name="parameters">DbCommand 실행시의 Parameter 정보</param>
/// <returns>Paging된 Persistent Object의 List</returns>
public static IPagingList <T> ExecuteInstance <T>(this IAdoRepository repository,
INameMap nameMap,
Action <IDataReader, T> additionalMapping,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
nameMap.ShouldNotBeNull("nameMap");
cmd.ShouldNotBeNull("cmd");
if (IsDebugEnabled)
{
log.Debug("ExecuteReader를 수행해 PersistentObject로 매핑합니다... " +
"CommandText=[{0}], NameMapping=[{1}], pageIndex=[{2}], pageSize=[{3}], parameters=[{4}]",
cmd.CommandText, nameMap, pageIndex, pageSize, parameters.CollectionToString());
}
var query = cmd.CommandText;
var firstResult = pageIndex * pageSize;
var maxResults = pageSize;
var totalItemCountTask = repository.CountAsync(query, parameters);
IList <T> instances;
using (var dr = repository.ExecuteReader(cmd, parameters))
instances = dr.Map <T>(ActivatorTool.CreateInstance <T>, nameMap, firstResult, maxResults, additionalMapping);
var pagingList = new PagingList <T>(instances, pageIndex, pageSize, totalItemCountTask.Result);
if (IsDebugEnabled)
{
log.Debug("ExecuteReader를 수행해 PersistentObject로 매핑했습니다!!! pageIndex=[{0}], pageSize=[{1}], totalItemCount=[{2}]",
pageIndex, pageSize, totalItemCountTask.Result);
}
return(pagingList);
}