/// <summary>
/// Gets a persistence handler for a given type
/// </summary>
/// <param name="type"></param>
/// <returns></returns>
public IPersistenceHandler GetPersistenceHandler(Type type)
{
if (type.IsGenericType)
{
type = type.GetGenericTypeDefinition();
}
IPersistenceHandler handler = persistenceHandlerPool.GetHandler(type, (t) =>
{
// 1. If a handler type is registered, use an instance of this handler
var newHandler = this.configContainer.Resolve <IPersistenceHandler>();
// 2. try to use an NDOPersistenceHandler
if (newHandler == null)
{
newHandler = new SqlPersistenceHandler(this.configContainer);
}
return(newHandler);
});
Mappings mappings = configContainer.Resolve <Mappings>();
// The dataSet will be used as template to create a DataTable for the query results.
handler.Initialize(mappings, type, ReleaseHandler);
return(handler);
}
private IList ExecuteSubQuery(Type t, QueryContextsEntry queryContextsEntry)
{
IQueryGenerator queryGenerator = ConfigContainer.Resolve <IQueryGenerator>();
bool hasBeenPrepared = PrepareParameters();
string generatedQuery;
if (this.queryLanguage == QueryLanguage.NDOql)
{
generatedQuery = queryGenerator.GenerateQueryString(queryContextsEntry, this.expressionTree, this.hollowResults, this.queryContextsForTypes.Count > 1, this.orderings, this.skip, this.take);
}
else
{
generatedQuery = (string)this.expressionTree.Value;
}
if (hasBeenPrepared)
{
WriteBackParameters();
}
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(t))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
this.pm.CheckTransaction(persistenceHandler, t);
DataTable table = persistenceHandler.PerformQuery(generatedQuery, this.parameters, this.pm.DataSet);
return(pm.DataTableToIList(t, table.Rows, this.hollowResults));
}
}
void ReleaseHandler(Type t, IPersistenceHandler handler)
{
// Don't close the connection or transaction here
// because it might be used with other handlers.
handler.Connection = null;
this.persistenceHandlerPool.ReleaseHandler(t, handler);
}
private object ExecuteAggregateQuery(QueryContextsEntry queryContextsEntry, string field, AggregateType aggregateType)
{
Type t = queryContextsEntry.Type;
IQueryGenerator queryGenerator = ConfigContainer.Resolve <IQueryGenerator>();
string generatedQuery = queryGenerator.GenerateAggregateQueryString(field, queryContextsEntry, this.expressionTree, this.queryContextsForTypes.Count > 1, aggregateType);
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(t))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
this.pm.CheckTransaction(persistenceHandler, t);
// Note, that we can't execute all subQueries in one batch, because
// the subqueries could be executed against different connections.
// TODO: This could be optimized, if we made clear whether the involved tables
// can be reached with the same connection.
var l = persistenceHandler.ExecuteBatch(new string[] { generatedQuery }, this.parameters);
if (l.Count == 0)
{
return(null);
}
return((l[0])["AggrResult"]);
}
}
/// <summary>
/// Returns a handler to the pool.
/// </summary>
/// <param name="type"></param>
/// <param name="handler"></param>
public void ReleaseHandler(Type type, IPersistenceHandler handler)
{
var list = handlerPools.GetOrAdd(type, (t) => new Stack <IPersistenceHandler>());
lock (list)
{
list.Push(handler);
}
}
private List <T> ExecuteSqlQuery()
{
Type t = this.resultType;
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(t))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
this.pm.CheckTransaction(persistenceHandler, t);
DataTable table = persistenceHandler.PerformQuery(this.queryExpression, this.parameters, this.pm.DataSet);
return((List <T>)pm.DataTableToIList(t, table.Rows, this.hollowResults));
}
}
/// <summary>
/// Deletes records directly without caring for composite relations.
/// </summary>
/// <remarks>Only use this method if your class does not use composite relations and you are sure that this will not be the case in the future either. If you are unsure about this, you better use PersistenceManager.Delete().</remarks>
public void DeleteDirectly()
{
string sql = GetDirectDeleteQuery();
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(this.resultType))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
this.pm.CheckTransaction(persistenceHandler, this.resultType);
persistenceHandler.ExecuteBatch(new string[] { sql }, this.parameters);
}
//using (var handler = this.pm.GetSqlPassThroughHandler())
//{
// handler.Execute( sql, false, this.parameters.ToArray() );
// pm.Save(); // Commit
//}
}
public ProductController(IUnityContainer container)
{
var repository = container.Resolve <IRepository>();
var target = repository.GetRepository();
persistanceObject = container.Resolve <IPersistenceHandler <Product> >(
target == RepositoryStrategyEnum.Database ? "Database" :
target == RepositoryStrategyEnum.XML ? "Xml" :
target == RepositoryStrategyEnum.CSV ? "Csv" : "Memory"
);
AutoMapper.Mapper.Initialize(
cfg =>
{
cfg.CreateMap <Product, ProductModel>();
cfg.CreateMap <ProductModel, Product>();
}
);
}
/// <summary>
/// Sets the persistence handler.
/// </summary>
/// <param name="handler">The persistence handler.</param>
public static void SetPersistenceHandler(IPersistenceHandler handler)
{
persistenceHandler = handler;
}
private List <ObjectRowPair <T> > ExecuteOrderedSubQuery(QueryContextsEntry queryContextsEntry)
{
Type t = queryContextsEntry.Type;
Class resultSubClass = this.pm.GetClass(t);
DataTable comparismTable = new DataTable("ComparismTable");
foreach (QueryOrder order in this.orderings)
{
DataColumn col = comparismTable.Columns.Add(order.FieldName);
if (order.IsAscending)
{
col.AutoIncrementStep = 1;
}
else
{
col.AutoIncrementStep = -1;
}
}
DataTable table = null;
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(t))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
this.pm.CheckTransaction(persistenceHandler, t);
bool hasBeenPrepared = PrepareParameters();
IQueryGenerator queryGenerator = ConfigContainer.Resolve <IQueryGenerator>();
string generatedQuery = queryGenerator.GenerateQueryString(queryContextsEntry, this.expressionTree, this.hollowResults, this.queryContextsForTypes.Count > 1, this.orderings, this.skip, this.take);
if (hasBeenPrepared)
{
WriteBackParameters();
}
table = persistenceHandler.PerformQuery(generatedQuery, this.parameters, this.pm.DataSet);
}
DataRow[] rows = table.Select();
var objects = pm.DataTableToIList(t, rows, this.hollowResults);
List <ObjectRowPair <T> > result = new List <ObjectRowPair <T> >(objects.Count);
int i = 0;
IProvider provider = mappings.GetProvider(t);
foreach (T obj in objects)
{
DataRow row = rows[i++];
DataRow newRow = comparismTable.NewRow();
foreach (QueryOrder order in this.orderings)
{
string newColumnName = order.FieldName;
if (!comparismTable.Columns.Contains(newColumnName))
{
throw new InternalException(558, "Query.cs - Column not found.");
}
string oldColumnName = resultSubClass.FindField(order.FieldName).Column.Name;
if (!table.Columns.Contains(oldColumnName))
{
throw new InternalException(561, "Query.cs - Column not found.");
}
newRow[newColumnName] = row[oldColumnName];
}
result.Add(new ObjectRowPair <T>(obj, newRow));
}
return(result);
}
void GetPrefetches(List <T> parents)
{
var queryGenerator = this.ConfigContainer.Resolve <IQueryGenerator>();
if (parents.Count == 0)
{
return;
}
var mustUseInClause = false;
if (this.expressionTree != null)
{
mustUseInClause = this.expressionTree.GetAll(n => n.Operator == "IN").Any();
}
foreach (string prefetch in this.Prefetches)
{
Type t = GetPrefetchResultType(this.resultType, prefetch);
using (IPersistenceHandler persistenceHandler = this.pm.PersistenceHandlerManager.GetPersistenceHandler(t))
{
persistenceHandler.VerboseMode = this.pm.VerboseMode;
persistenceHandler.LogAdapter = this.pm.LogAdapter;
DataTable table = null;
foreach (var queryContextsEntry in this.queryContextsForTypes)
{
Type parentType = queryContextsEntry.Type;
var parentCls = mappings.FindClass(parentType);
var isMultiple = parentCls.Oid.OidColumns.Count > 1;
var selectedParents = parents.Where(p => p.GetType() == parentType).Select(p => (IPersistenceCapable)p).ToList();
if (selectedParents.Count == 0)
{
continue;
}
string generatedQuery;
if (!mustUseInClause && (parents.Count > 100 || isMultiple) && this.skip == 0 && this.take == 0)
{
generatedQuery = queryGenerator.GenerateQueryString(queryContextsEntry, this.expressionTree, false, true, new List <QueryOrder>(), 0, 0, prefetch);
}
else
{
if (isMultiple)
{
throw new QueryException(10050, "Can't process a prefetch with skip, take & multiple oid columns");
}
generatedQuery = queryGenerator.GeneratePrefetchQuery(parentType, selectedParents, prefetch);
}
#warning Prefetches: Überprüfen, ob das in der normalen Transaktion mitläuft
// this.pm.CheckTransaction( persistenceHandler, t );
this.pm.CheckTransaction(persistenceHandler, t);
table = persistenceHandler.PerformQuery(generatedQuery, this.parameters, this.pm.DataSet);
var result = pm.DataTableToIList(t, table.Rows, false);
MatchRelations(parents, result, prefetch);
}
}
}
}
/// <summary>
/// Set the Persistence Handler for all objects of the same type as the parameter object
/// </summary>
/// <param name="pc">Persistence capable object</param>
/// <param name="ph">The handler object</param>
public static void SetNDOHandler(object pc, IPersistenceHandler ph)
{
pc.GetType().InvokeMember("NDOSetPersistenceHandler", BindingFlags.InvokeMethod | BindingFlags.Static, null, null, new object[] { ph });
}