public EntityRecord ReadRecord(IDataRecord dataRecord, EntitySession session)
{
// Some outer join queries may produce entities that are null; so we first try to read Primary key values - if they're all null, we return null.
if (_primaryKeyColumns.Count > 0 && PrimaryKeyIsNull(dataRecord))
{
return(null);
}
var entRec = new EntityRecord(_tableInfo.Entity, EntityStatus.Loading);
object dbValue = null;
OutColumnMapping colMap = null;
//for-i loop is more efficient than foreach
for (int i = 0; i < _columns.Count; i++)
{
try {
colMap = _columns[i];
dbValue = dataRecord[colMap.ReaderColumnIndex];
//System.Diagnostics.Debug.WriteLine(colMap.DbColumn.ColumnName + " " + dbValue + "(" + dbValue.GetType() + ")");
var conv = colMap.DbColumn.TypeInfo.ColumnToPropertyConverter;
if (dbValue != null && conv != null)
{
dbValue = conv(dbValue);
}
entRec.SetValue(colMap.DbColumn.Member, dbValue);
} catch (Exception ex) {
ex.AddValue("DataRecord", dataRecord);
ex.AddValue("ColumnName", colMap.DbColumn.ColumnName);
ex.AddValue("DbValue", dbValue);
throw;
}
}
var sessionRec = session.Attach(entRec); //might return different, previously loaded record
return(sessionRec);
}
public CacheDisableToken(EntitySession session)
{
_session = session;
_wasEnabled = session.CacheEnabled;
if (_wasEnabled)
{
session.EnableCache(false);
}
}
// Used for efficient reading entities in linq queries
public object ReadEntity(IDataRecord dataRecord, EntitySession session)
{
var entRec = ReadRecord(dataRecord, session);
if (entRec == null)
{
return(null);
}
return(entRec.EntityInstance);
}
public static SearchResults <TEntity> ExecuteSearchImpl <TEntity>(
EntitySession session,
Expression <Func <TEntity, bool> > where,
SearchParams searchParams,
Expression <Func <TEntity, object> > include = null,
QueryOptions options = QueryOptions.ForceIgnoreCase,
Dictionary <string, string> nameMapping = null) where TEntity : class
{
try {
var baseQuery = session.EntitySet <TEntity>().Where(where).WithOptions(options); //this will be reused by Count query
//add include, order by, skip, take
var incQuery = include == null ? baseQuery : baseQuery.Include <TEntity>(include);
var orderedQuery = string.IsNullOrEmpty(searchParams.OrderBy) ? incQuery : incQuery.OrderBy(searchParams.OrderBy, nameMapping);
// Add Skip, Take; we return '+1' rows, to check if there are any more; if not, we do not need to query total
var takePlusOne = searchParams.Take + 1;
var pageQuery = orderedQuery.Skip(searchParams.Skip).Take(takePlusOne);
var rows = pageQuery.ToList();
if (rows.Count > 0 && rows.Count < takePlusOne)
{
// important (bug #74) - we must check rows.Count > 0, that any rows returned
//We see the last row, we do not need to run total query
return new SearchResults <TEntity>()
{
Results = rows, TotalCount = searchParams.Skip + rows.Count
}
}
;
// we received more than Take number of rows (or zero); it means we need to run TotalCount
//save main query command, and restore it after total query; in debugging main query is more interesting than total query
var queryCmd = session.GetLastCommand();
var totalCount = baseQuery.Count(); //use baseQuery here, without OrderBy, Skip, Take
session.SetLastCommand(queryCmd); //restore main query command
//remove last extra row if it is there - we queried for 1 extra
if (rows.Count > searchParams.Take && rows.Count > 0)
{
rows.RemoveAt(rows.Count - 1);
}
var results = new SearchResults <TEntity>()
{
Results = rows, TotalCount = totalCount
};
return(results);
} catch (Exception ex) {
session.Context.App.AppEvents.OnError(session.Context, ex);
throw;
}
}
public static SearchResults <TResult> ExecuteSearchImpl <TEntity, TResult>(
EntitySession session,
Expression <Func <TEntity, bool> > where,
SearchParams searchParams,
Func <TEntity, TResult> converter,
Expression <Func <TEntity, object> > include = null,
QueryOptions options = QueryOptions.ForceIgnoreCase,
Dictionary <string, string> nameMapping = null)
where TEntity : class
{
var tempResults = ExecuteSearchImpl <TEntity>(session, where, searchParams, include, options, nameMapping);
if (converter == null)
{
Util.Check(typeof(TEntity) == typeof(TResult), "ExecuteSearch - if result type is different from entity type, converter method must be provided.");
return((SearchResults <TResult>)(object) tempResults);
}
var results = tempResults.Convert(converter);
return(results);
}
public CacheDisableToken(EntitySession session)
{
_session = session;
_wasDisabled = session.CacheDisabled;
session.CacheDisabled = true;
}
private IncludeProcessor(EntitySession session, IList <LambdaExpression> includes)
{
_session = session;
_includes = includes;
}
