/// <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 Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
IReaderPersister <T> persister,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(persister, cmd, parameters)));
}
/// <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>
/// ExecuteInstance() 를 비동기적으로 수행하여,
/// DataReader로부터 T 수형의 인스턴스를 매핑한다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMapper">DataReader 컬럼과 엔티티의 속성명의 Name 매퍼</param>
/// <param name="query">실행할 SQL문 또는 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>매핑한 엔티티 컬렉션을 결과값으로 가지는 Task</returns>
public static Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
string query,
params IAdoParameter[] parameters) where T : class
{
return(ExecuteInstanceAsync(repository, nameMapper, (Action <IDataReader, T>)null, query, parameters));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,System.Func{System.Data.IDataReader,T},DbCommand,int,int,IAdoParameter[])"/>을 비동기적으로 수행합니다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMap">DataReader 컬럼명 - Class 속성명의 매핑 정보</param>
/// <param name="additionalMapping">추가적인 매핑 함수</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> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMap nameMap,
Action <IDataReader, T> additionalMapping,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
nameMap.ShouldNotBeNull("nameMap");
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기적으로 ExecuteReader<{0}>()을 수행하고, 결과를 IList<{0}>으로 매핑합니다... query=[{1}]", typeof(T).FullName, query);
}
return(Task.Factory.StartNew(() => {
using (var cmd = repository.GetCommand(query))
return repository.ExecuteInstance <T>(nameMap,
additionalMapping,
cmd,
pageIndex,
pageSize,
parameters);
}));
}
/// <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>
/// 지정된 쿼리 문을 실행한 결과 셋의 레코드 갯수를 구한다. (SQL 문장이 SQL Count() 함수 문장으로 변환이 가능하다면 속도가 가장 빠르다.)
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="sqlString">실행할 Command 객체</param>
/// <param name="parameters">Command 인자 정보</param>
/// <returns>결과 셋의 레코드 수</returns>
/// <remarks>
/// 실제 SQL의 count(*) 함수로 변환할 수 있는 SQL문장이라면, 변환하여 Count 값을 가져오고,
/// 불가능하다면 IDataReader를 이용하여 결과 셋을 가져와서 갯수만 센다.
/// </remarks>
/// <seealso cref="AdoTool.GetCountingSqlString"/>
public static int CountBySqlString(this IAdoRepository repository, string sqlString, params IAdoParameter[] parameters)
{
sqlString.ShouldNotBeWhiteSpace("sqlString");
// 1. SELECT Count(*) FROM 구문으로 변환이 가능하다면, 변환된 SQL 문장을 수행한다.
try {
var countSql = AdoTool.GetCountingSqlString(sqlString);
var count = repository.ExecuteScalarBySqlString(countSql, parameters).AsInt(-1);
if (count > -1)
{
return(count);
}
}
catch (Exception ex) {
if (log.IsInfoEnabled)
{
log.Info("Count() SQL로 변환 작업이 지원되지 않는 문장입니다. DataReader를 이용하여, 결과 셋의 레코드 수를 알아봅니다.");
log.Info("sqlString=[{0}]", sqlString);
log.Info(ex);
}
}
// 2. SQL Count() 함수를 이용하지 못할 경우라면, 그냥 DataReader를 이용하여 Count를 계산한다.
//
using (var cmd = repository.GetSqlStringCommand(sqlString))
return(repository.Count(cmd, parameters));
}
/// <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 Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
Func <IDataReader, T> mapFunc,
DbCommand cmd,
params IAdoParameter[] parameters)
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(mapFunc, cmd, parameters)));
}
/// <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}], requestParameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
}
var query = repository.QueryProvider.GetQuery(method).AsText(method);
string result;
using (var cmd = repository.GetCommand(query, true)) {
var scalar = repository.ExecuteScalar(cmd, GetParameters(requestParameters));
result = JsonTool.SerializeAsText(scalar);
}
if (IsDebugEnabled)
{
log.Debug("{0}를 완료했습니다. method=[{1}], requestParameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
}
return(result);
}
public DataServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper) {
adoRepository.ShouldNotBeNull("adoRepository");
nameMapper.ShouldNotBeNull("nameMapper");
AdoRepository = adoRepository;
NameMapper = nameMapper;
}
/// <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>
/// 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}], requestParameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
var query = repository.QueryProvider.GetQuery(method).AsText(method);
string result;
using(var cmd = repository.GetCommand(query, true)) {
repository.ExecuteNonQuery(cmd, GetParameters(requestParameters));
var outputs = AdoTool.GetOutputParameters(repository.Db, cmd);
result = JsonTool.SerializeAsText(outputs);
}
if(IsDebugEnabled)
log.Debug("{0}를 완료했습니다. method=[{1}], requestParameters=[{2}]",
GetType().FullName, method, requestParameters.CollectionToString());
return result;
}
/// <summary>
/// 지정된 Entity의 속성 값을 이용하여 Procedure의 Parameter 값을 설정하고, 실행시키는 작업을 비동기적으로 수행합니다.
/// 일반적으로 Save / Update시에 활용하면 좋다.
/// 단, 비동기적인 작업이므로, Transaction 에 문제가 발생할 소지가 있습니다.
/// </summary>
/// <typeparam name="T">Persistent object 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="spName">실행할 Procedure Name</param>
/// <param name="entity">실행할 Entity</param>
/// <param name="nameMapper">Name Mapping Class</param>
/// <returns>Command 인자 중에 ParameterDirection이 ReturnValue인 인자의 값</returns>
public static Task <object> ExecuteEntityTask <T>(this IAdoRepository repository, string spName, T entity, INameMapper nameMapper)
{
spName.ShouldNotBeWhiteSpace("spName");
entity.ShouldNotBeNull("entity");
nameMapper.ShouldNotBeNull("nameMapper");
return(Task.Factory.StartNew(() => repository.ExecuteEntity <T>(spName, entity, nameMapper)));
}
public DataServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper)
{
adoRepository.ShouldNotBeNull("adoRepository");
nameMapper.ShouldNotBeNull("nameMapper");
AdoRepository = adoRepository;
NameMapper = nameMapper;
}
//! ===============================================================================================
/// <summary>
/// 지정된 Command를 수행하고, RETURN_VALUE를 반환합니다.
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="parameters">인자</param>
/// <returns>Procedure인 경우 return value를 반환한다. 반환값이 없으면 0을 반환한다.</returns>
public static object ExecuteCommand(this IAdoRepository repository, DbCommand cmd, params IAdoParameter[] parameters)
{
cmd.ShouldNotBeNull("cmd");
repository.ExecuteNonQuery(cmd, parameters);
return(AdoTool.GetReturnValue(repository.Db, cmd, 0));
}
///<summary>
/// DbCommand를 실행해 얻은 DataReader를 통해 지정된 형식의 인스턴스를 만든다.
///</summary>
/// <typeparam name="T">Type of Persistent object</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMapper">컬럼명과 속성명 Mapper</param>
/// <param name="additionalMapping">추가적인 매핑 함수</param>
/// <param name="cmd">실행할 DbCommand</param>
/// <param name="parameters">Procedure 인자</param>
/// <returns>Collection of Persistet object</returns>
public static Task <IList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMapper nameMapper,
Action <IDataReader, T> additionalMapping,
DbCommand cmd,
params IAdoParameter[] parameters) where T : class
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(nameMapper, additionalMapping, cmd, parameters)));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="persister">IDataReader로부터 Persistent Object를 빌드하는 Persister</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,
IReaderPersister <T> persister,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
return(repository.ExecuteInstance <T>(persister.Persist, cmd, pageIndex, pageSize, parameters));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,System.Func{System.Data.IDataReader,T},DbCommand,int,int,IAdoParameter[])"/>을 비동기적으로 수행합니다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMap">DataReader 컬럼명 - Class 속성명의 매핑 정보</param>
/// <param name="targetFactory">대상 객체 생성 함수</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,
INameMap nameMap,
Func <T> targetFactory,
string query,
params IAdoParameter[] parameters)
{
return(ExecuteInstanceAsParallelAsync(repository, nameMap, targetFactory, 0, 0, (Action <AdoResultRow, T>)null, query,
parameters));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="nameMap">컬럼명:속성명의 매핑정보</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 Task <IPagingList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMap nameMap,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(nameMap, cmd, pageIndex, pageSize, parameters)));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,System.Func{IDataReader,T},DbCommand,int,int,IAdoParameter[])"/>을 비동기적으로 수행합니다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMap">DataReader 컬럼명 - Class 속성명의 매핑 정보</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> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
INameMap nameMap,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters) where T : class
{
return(ExecuteInstanceAsync(repository, nameMap, (Action <IDataReader, T>)null, query, pageIndex, pageSize, parameters));
}
/// <summary>
/// 지정된 Command를 실행하여, 결과 셋을 Paging하여, 지정된 Page에 해당하는 정보만 Persistent Object로 빌드하여 반환한다.
/// </summary>
/// <typeparam name="T">Persistent Object의 수형</typeparam>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="persister">IDataReader로부터 Persistent Object를 빌드하는 Persister</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 Task <IPagingList <T> > ExecuteInstanceAsync <T>(this IAdoRepository repository,
IReaderPersister <T> persister,
DbCommand cmd,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
return(Task.Factory.StartNew(() => repository.ExecuteInstance <T>(persister, cmd, pageIndex, pageSize, parameters)));
}
/// <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="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,
Action <AdoResultRow, T> additionalMapping,
string query,
params IAdoParameter[] parameters)
{
return(ExecuteInstanceAsParallelAsync(repository, nameMapper, targetFactory, 0, 0, additionalMapping, query, parameters));
}
/// <summary>
/// 비동기적으로 ExecuteReader()을 수행하고, 병렬 방식으로 매핑하여 결과를 IPageList{T} 으로 반환하는 Task를 빌드합니다
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="nameMap">DataReader 컬럼명 - Class 속성명의 매핑 정보</param>
/// <param name="targetFactory">대상 객체 생성 Factory</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,
INameMap nameMap,
Func <T> targetFactory,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
return(ExecuteInstanceAsParallelAsync(repository, nameMap, targetFactory, null, query, pageIndex, pageSize, parameters));
}
/// <summary>
/// QueryProvider에서 제공하는 Query로 <see cref="DbCommand"/> 인스턴스를 생성합니다.
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="queryKey">[Section,] QueryName 형태의 쿼리 키</param>
/// <param name="parameters">parameter collection</param>
/// <returns>DbCommand instance</returns>
/// <exception cref="InvalidOperationException">QueryProvider 속성이 null일때</exception>
public static DbCommand GetNamedQueryCommand(this IAdoRepository repository, string queryKey, params IAdoParameter[] parameters)
{
var query = repository.QueryProvider.GetQuery(queryKey);
Guard.Assert(query.IsNotWhiteSpace(), "QueryKey=[{0}] 에 해당하는 쿼리 문을 찾지 못했습니다.", queryKey);
return((AdoTool.IsSqlString(query))
? repository.GetSqlStringCommand(query, parameters)
: repository.GetProcedureCommand(query, AdoTool.DEFAULT_DISCOVER_PARAMETER, parameters));
}
/// <summary>
/// 요청정보 중에 RequestType이 <see cref="XmlDataRequestKind.Method"/> 인 경우에는 Method를 실제 실행할 Query 문장으로 변경한다.
/// </summary>
/// <param name="repository"><see cref="IIniQueryProvider"/>를 가진 기본 <see cref="IAdoRepository"/></param>
/// <param name="request">요청 정보</param>
public static void ConvertToQuery(IAdoRepository repository, XdsRequestItem request)
{
repository.ShouldNotBeNull("repository");
request.ShouldNotBeNull("request");
if (IsDebugEnabled)
{
log.Debug("요청정보의 Method에 해당하는 실제 Query String을 읽어옵니다.");
}
if (repository.QueryProvider == null)
{
if (IsDebugEnabled)
{
log.Debug("AdoRepository.QueryProvider가 제공되지 않아, 조회 작업이 취소되었습니다.");
}
return;
}
foreach (XdsQuery query in request.PreQueries)
{
if (query.RequestKind == XmlDataRequestKind.Method)
{
query.Query = repository.QueryProvider.GetQuery(query.Query);
query.RequestKind = AdoTool.IsSqlString(query.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
}
if (request.RequestKind == XmlDataRequestKind.Method)
{
request.Query = repository.QueryProvider.GetQuery(request.Query);
request.RequestKind = AdoTool.IsSqlString(request.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
foreach (XdsQuery query in request.PostQueries)
{
if (query.RequestKind == XmlDataRequestKind.Method)
{
query.Query = repository.QueryProvider.GetQuery(query.Query);
query.RequestKind = AdoTool.IsSqlString(query.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
}
if (IsDebugEnabled)
{
log.Debug("요청 정보의 Method에 해당하는 실제 Query String을 모두 읽었습니다.");
}
}
//! ======================================================================================
/// <summary>
/// <see cref="IAdoRepository.ExecuteNonQuery(string, IAdoParameter[])"/>를 비동기 방식으로 수행합니다.
/// </summary>
/// <param name="repository">Repository</param>
/// <param name="query">실행할 쿼리문 또는 Procedure Name</param>
/// <param name="parameters">Parameters</param>
/// <returns>영향받는 레코드수를 결과값으로 제공하는 Task</returns>
public static Task <int> ExecuteNonQueryAsync(this IAdoRepository repository, string query, params IAdoParameter[] parameters)
{
query.ShouldNotBeWhiteSpace("query");
if (IsDebugEnabled)
{
log.Debug("비동기 방식으로 쿼리를 수행합니다... query=[{0}], parameters=[{1}]", query, parameters.CollectionToString());
}
return(Task.Factory.StartNew(() => repository.ExecuteNonQuery(query, parameters)));
}
/// <summary>
/// <see cref="ExecuteInstance{T}(IAdoRepository,Mappers.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">대상 객체 생성 Factory</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,
INameMapper nameMapper,
Func <T> targetFactory,
string query,
int pageIndex,
int pageSize,
params IAdoParameter[] parameters)
{
return(repository.ExecuteInstanceAsParallelAsync(nameMapper, targetFactory, (Action <AdoResultRow, T>)null, query, pageIndex,
pageSize, parameters));
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="repository">Ado Repository</param>
/// <param name="sqlStatements">실행할 쿼리문의 컬렉션</param>
public AdoPreCacheService(IAdoRepository repository, IEnumerable<string> sqlStatements)
{
repository.ShouldNotBeNull("repository");
sqlStatements.ShouldNotBeEmpty<string>("sqlStatements");
_adoRepository = repository;
SqlStatements = sqlStatements.ToArray();
if(log.IsInfoEnabled)
log.Debug(@"AdoPreCacheService 의 인스턴스가 생성되었습니다.");
}
/// <summary>
/// 쿼리를 수행하여, 결과 셋을 대상 객체 컬렉션으로 병렬로 매핑을 수행하여 반환하는 Task를 빌드합니다.
/// </summary>
/// <typeparam name="T">결과 셋으로 표현할 엔티티의 수형</typeparam>
/// <param name="repository"><see cref="IAdoRepository"/></param>
/// <param name="rowMapFunc">AdoResultRow로부터 {T} 수형의 인스턴스로 변환하는 메소드</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,
Func <AdoResultRow, T> rowMapFunc,
string query,
params IAdoParameter[] parameters)
{
return(ExecuteInstanceAsParallelAsync(repository,
rowMapFunc,
0,
0,
query,
parameters));
}
/// <summary>
/// <see cref="ExistsByProcedure"/>를 비동기 방식으로 수행합니다.
/// </summary>
/// <param name="repository"><see cref="IAdoRepository"/>의 인스턴스</param>
/// <param name="spName">실행할 Procedure Name</param>
/// <param name="parameters">패러미터</param>
/// <returns>Exists 결과를 가지는 Task</returns>
public static Task <bool> ExistsByProdedureAsync(this IAdoRepository repository, string spName, params IAdoParameter[] parameters)
{
spName.ShouldNotBeWhiteSpace("spName");
if (IsDebugEnabled)
{
log.Debug("비동기 방식으로 IAdoRepository.ExistsByProcedure()을 수행합니다... spName=[{0}], parameters=[{1}]",
spName, parameters.CollectionToString());
}
return(Task.Factory.StartNew(() => repository.ExistsByProcedure(spName, parameters)));
}
/// <summary>
/// <see cref="IAdoRepository.ExecuteNonQueryByProcedure"/> 를 비동기 방식으로 수행합니다.
/// </summary>
/// <param name="repository"><see cref="IAdoRepository"/> 인스턴스</param>
/// <param name="spName">실행할 Procedure Name</param>
/// <param name="parameters">Procedure의 Parameters</param>
/// <returns>영향받는 레코드수를 결과값으로 제공하는 Task</returns>
public static Task <int> ExecuteNonQueryByProcedureTask(this IAdoRepository repository, string spName,
params IAdoParameter[] parameters)
{
spName.ShouldNotBeWhiteSpace("spName");
if (IsDebugEnabled)
{
log.Debug("비동기 방식으로 Procedure를 실행합니다... spName=[{0}], parameters=[{1}]", spName, parameters.CollectionToString());
}
return(Task.Factory.StartNew(() => repository.ExecuteNonQueryByProcedure(spName, parameters)));
}
/// <summary>
/// 지정된 쿼리 문을 실행한 결과 셋의 레코드 갯수를 구한다.
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="query">실행할 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, string query, params IAdoParameter[] parameters)
{
query.ShouldNotBeWhiteSpace("query");
if (AdoTool.IsSqlString(query))
{
return(repository.CountBySqlString(query, parameters));
}
using (var cmd = repository.GetCommand(query))
return(repository.Count(cmd, parameters));
}
//! ===============================================================================================
/// <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>
/// PREQUERIES, POSTQUERIES에 있는 결과를 반환할 필요없는 단순 Query문을 실행합니다.
/// </summary>
/// <param name="ado">AdoRepository</param>
/// <param name="queries">queries to execute</param>
private static void ExecuteSimpleQuery(IAdoRepository ado, IEnumerable <XdsQuery> queries)
{
foreach (var query in queries.Where(q => q.Query.IsNotWhiteSpace()).Select(q => q.Query))
{
if (IsDebugEnabled)
{
log.Debug("요청 처리 사전/사후 설정용 쿼리문을 수행합니다... query=[{0}]", query);
}
ado.ExecuteNonQuery(query);
}
}
//! ===============================================================================================
/// <summary>
/// 지정된 쿼리문을 CommendText로 가지는 <see cref="DbCommand"/> 인스턴스를 생성합니다.
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="query">simple query string or procedure name or queryKey of QueryProvider ([Section,] QueryName)</param>
/// <param name="parameters">파라미터 컬렉션</param>
/// <returns>instance of <see cref="DbCommand"/></returns>
public static DbCommand GetCommand(this IAdoRepository repository, string query, params IAdoParameter[] parameters)
{
query.ShouldNotBeWhiteSpace("query");
var cmd = repository.GetCommand(query, AdoTool.DEFAULT_DISCOVER_PARAMETER);
if (parameters.IsNotEmptySequence())
{
AdoTool.SetParameterValues(repository.Db, cmd, parameters);
}
return(cmd);
}
private void InitializeComponents() {
_dbName = Request[XmlDataServiceFacade.PARAM_PRODUCT].AsText(AdoTool.DefaultDatabaseName);
var repositoryId = @"AdoRepository";
if(_dbName.IsNotWhiteSpace())
repositoryId = string.Concat(repositoryId, ".", _dbName);
if(IsDebugEnabled)
log.Debug(@"기본 AdoRepository를 Resolve합니다. repositoryId=[{0}]", repositoryId);
_repository = IoC.Resolve<IAdoRepository>(repositoryId);
}
/// <summary>
/// 생성자
/// </summary>
/// <param name="repository">IAdoRepository 인스턴스</param>
/// <param name="tableName">String Resources 정보를 담은 Table 명</param>
/// <param name="assemblyName">대분류</param>
/// <param name="resourceName">String Resources의 중분류</param>
public AdoResourceRepository(IAdoRepository repository, string resourceName = null, string assemblyName = null,
string tableName = null) {
repository.ShouldNotBeNull("repository");
if(IsDebugEnabled)
log.Debug("AdoResourceRepository 인스턴스 생성. databaseName=[{0}], tableName=[{1}], assemblyName=[{2}], resourceName=[{3}]",
repository.DbName, tableName, assemblyName, resourceName);
DatabaseName = repository.DbName ?? AdoTool.DefaultDatabaseName;
TableName = tableName ?? AdoResourceProvider.DefaultStringResourceTableName;
AssemblyName = assemblyName ?? AdoResourceProvider.DefaultAssemblyName;
ResourceName = resourceName ?? string.Empty;
Ado = repository;
}
public XmlDataManager(IAdoRepository ado) {
ado.ShouldNotBeNull("ado");
Ado = ado;
}
/// <summary> /// Command를 수행하고, 결과를 XML 문자열로 반환합니다. /// </summary> /// <param name="repository">Repository</param> /// <param name="requestItem">요청 정보</param> /// <returns>Data 처리 결과의 XML 문자열</returns> public abstract string Execute(IAdoRepository repository, RequestItem requestItem);
public DataServiceImpl(IAdoRepository adoRepository) {
adoRepository.ShouldNotBeNull("adoRepository");
AdoRepository = adoRepository;
}
public DataCommandServiceImpl(IAdoRepository adoRepository, INameMapper nameMapper) : base(adoRepository, nameMapper) {}
/// <summary>
/// 요청정보 중에 RequestType이 <see cref="XmlDataRequestKind.Method"/> 인 경우에는 Method를 실제 실행할 Query 문장으로 변경한다.
/// </summary>
/// <param name="repository"><see cref="IIniQueryProvider"/>를 가진 기본 <see cref="IAdoRepository"/></param>
/// <param name="request">요청 정보</param>
public static void ConvertToQuery(IAdoRepository repository, XdsRequestItem request) {
repository.ShouldNotBeNull("repository");
request.ShouldNotBeNull("request");
if(IsDebugEnabled)
log.Debug("요청정보의 Method에 해당하는 실제 Query String을 읽어옵니다.");
if(repository.QueryProvider == null) {
if(IsDebugEnabled)
log.Debug("AdoRepository.QueryProvider가 제공되지 않아, 조회 작업이 취소되었습니다.");
return;
}
foreach(XdsQuery query in request.PreQueries) {
if(query.RequestKind == XmlDataRequestKind.Method) {
query.Query = repository.QueryProvider.GetQuery(query.Query);
query.RequestKind = AdoTool.IsSqlString(query.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
}
if(request.RequestKind == XmlDataRequestKind.Method) {
request.Query = repository.QueryProvider.GetQuery(request.Query);
request.RequestKind = AdoTool.IsSqlString(request.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
foreach(XdsQuery query in request.PostQueries) {
if(query.RequestKind == XmlDataRequestKind.Method) {
query.Query = repository.QueryProvider.GetQuery(query.Query);
query.RequestKind = AdoTool.IsSqlString(query.Query)
? XmlDataRequestKind.Query
: XmlDataRequestKind.StoredProc;
}
}
if(IsDebugEnabled)
log.Debug("요청 정보의 Method에 해당하는 실제 Query String을 모두 읽었습니다.");
}
public AsyncDataServiceImpl(IAdoRepository repository) : base(repository) {}
public DataCommandServiceImpl(IAdoRepository adoRepository) : base(adoRepository) {}
public XmlDataAsyncManager(IAdoRepository ado) : base(ado) {}
public AsyncDataCommandServiceImpl(IAdoRepository repository, INameMapper nameMapper) : base(repository, nameMapper) {}
/// <summary>
/// PREQUERIES, POSTQUERIES에 있는 결과를 반환할 필요없는 단순 Query문을 실행합니다.
/// </summary>
/// <param name="ado">AdoRepository</param>
/// <param name="queries">queries to execute</param>
private static void ExecuteSimpleQuery(IAdoRepository ado, IEnumerable<XdsQuery> queries) {
foreach(var query in queries.Where(q => q.Query.IsNotWhiteSpace()).Select(q => q.Query)) {
if(IsDebugEnabled)
log.Debug("요청 처리 사전/사후 설정용 쿼리문을 수행합니다... query=[{0}]", query);
ado.ExecuteNonQuery(query);
}
}
