ExpressionInfo <T> GetInfo(DbManager db)
{
DataProviderBase lastDataProvider;
MappingSchema lastMappingSchema;
ExpressionInfo <T> info;
lock (_sync)
{
lastDataProvider = _lastDataProvider;
lastMappingSchema = _lastMappingSchema;
info = _lastInfo;
}
var dataProvider = db != null ? db.DataProvider : DbManager.GetDataProvider(DbManager.DefaultConfiguration);
var mappingSchema = db != null ? db.MappingSchema : Map.DefaultSchema;
if (lastDataProvider != dataProvider || lastMappingSchema != mappingSchema)
{
info = null;
}
if (info == null)
{
var key = new { dataProvider, mappingSchema };
lock (_sync)
_infos.TryGetValue(key, out info);
if (info == null)
{
lock (_sync)
{
_infos.TryGetValue(key, out info);
if (info == null)
{
info = new ExpressionParser <T>().Parse(dataProvider, mappingSchema, _expression, _lambda.Parameters.ToArray());
_infos.Add(key, info);
_lastDataProvider = dataProvider;
_lastMappingSchema = mappingSchema;
_lastInfo = info;
}
}
}
}
return(info);
}
private ExpressionInfo <T> GetExpressionInfo(Expression expression, bool cache)
{
if (cache && Info != null)
{
return(Info);
}
var dataProvider = DbManager != null ? DbManager.DataProvider : DbManager.GetDataProvider(DbManager.DefaultConfiguration);
var mappingSchema = DbManager != null ? DbManager.MappingSchema : Map.DefaultSchema;
var info = ExpressionInfo <T> .GetExpressionInfo(dataProvider, mappingSchema, expression);
if (cache)
{
Info = info;
}
return(info);
}
public static ExpressionInfo <T> GetExpressionInfo(DataProviderBase dataProvider, MappingSchema mappingSchema, Expression expr)
{
var info = FindInfo(dataProvider, mappingSchema, expr);
if (info == null)
{
lock (_sync)
{
info = FindInfo(dataProvider, mappingSchema, expr);
if (info == null)
{
info = new ExpressionParser <T>().Parse(dataProvider, mappingSchema, expr, null);
info.Next = _first;
_first = info;
}
}
}
return(info);
}
static ExpressionInfo <TR> .Parameter GetParameter <TR>(DbManager dataContext, SqlField field)
{
var exprParam = Expression.Parameter(typeof(Expression), "expr");
var mapper = Expression.Lambda <Func <ExpressionInfo <TR>, Expression, object[], object> >(
Expression.Convert(
Expression.PropertyOrField(
Expression.Convert(
Expression.Property(
Expression.Convert(exprParam, typeof(ConstantExpression)),
Constant.Value),
typeof(T)),
field.Name),
typeof(object)),
new []
{
Expression.Parameter(typeof(ExpressionInfo <TR>), "info"),
exprParam,
Expression.Parameter(typeof(object[]), "ps")
});
var param = new ExpressionInfo <TR> .Parameter
{
Expression = null,
Accessor = mapper.Compile(),
SqlParameter = new SqlParameter(field.SystemType, field.Name, null)
};
if (field.SystemType.IsEnum)
{
var ms = dataContext.MappingSchema;
var tp = field.SystemType;
param.SqlParameter.ValueConverter = o => ms.MapEnumToValue(o, tp);
}
return(param);
}
public static int Delete <T>(this DbManager dataContext, T obj)
{
return(ExpressionInfo <T> .Delete(dataContext, obj));
}
public static object InsertWithIdentity <T>(this DbManager dataContext, T obj)
{
return(ExpressionInfo <T> .InsertWithIdentity(dataContext, obj));
}
public static int Insert <T>(this DbManager dataContext, T obj)
{
return(ExpressionInfo <T> .Insert(dataContext, obj));
}
public static int Update(DbManager dataContext, T obj)
{
if (Equals(default(T), obj))
{
return(0);
}
ExpressionInfo <int> ei;
var key = new { dataContext.MappingSchema, dataContext.DataProvider };
if (!ObjectOperation <T> .Update.TryGetValue(key, out ei))
{
lock (_sync)
if (!ObjectOperation <T> .Update.TryGetValue(key, out ei))
{
var sqlTable = new SqlTable <T>(dataContext.MappingSchema);
var sqlQuery = new SqlQuery {
QueryType = QueryType.Update
};
sqlQuery.From.Table(sqlTable);
ei = new ExpressionInfo <int>
{
MappingSchema = dataContext.MappingSchema,
DataProvider = dataContext.DataProvider,
Queries = { new ExpressionInfo <int> .QueryInfo {
SqlQuery = sqlQuery,
} }
};
var keys = sqlTable.GetKeys(true).Cast <SqlField>();
var fields = sqlTable.Fields.Values.Where(f => f.IsUpdatable).Except(keys).ToList();
if (fields.Count == 0)
{
throw new LinqException(
string.Format("There are no fields to update in the type '{0}'.", sqlTable.Name));
}
foreach (var field in fields)
{
var param = GetParameter <int>(dataContext, field);
ei.Queries[0].Parameters.Add(param);
sqlQuery.Set.Items.Add(new SqlQuery.SetExpression(field, param.SqlParameter));
}
foreach (var field in keys)
{
var param = GetParameter <int>(dataContext, field);
ei.Queries[0].Parameters.Add(param);
sqlQuery.Where.Field(field).Equal.Expr(param.SqlParameter);
}
ei.SetNonQueryQuery();
ObjectOperation <T> .Update.Add(key, ei);
}
}
return((int)ei.GetElement(null, dataContext, Expression.Constant(obj), null));
}
