/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when a ResultClass is specified on the statement and
/// the ResultClass is a SimpleType.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object outObject = resultObject;
AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap;
if (outObject == null)
{
outObject = resultMap.CreateInstanceOfResultClass();
}
if (!resultMap.IsInitalized)
{
lock (resultMap)
{
if (!resultMap.IsInitalized)
{
// Create a ResultProperty
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = 0;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(outObject.GetType());
property.PropertyStrategy = PropertyStrategyFactory.Get(property);
resultMap.Properties.Add(property);
resultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));// set the PrimitiveDataExchange
resultMap.IsInitalized = true;
}
}
}
resultMap.Properties[0].PropertyStrategy.Set(request, resultMap, resultMap.Properties[0], ref outObject, reader, null);
return(outObject);
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// a an auto result map is used.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object outObject = resultObject;
if (outObject == null)
{
outObject = request.CurrentResultMap.CreateInstanceOfResult(null);
}
AutoResultMap resultMap = InitializeAutoResultMap(request, reader, ref outObject);
// En configuration initialiser des AutoResultMap (IResultMap) avec uniquement leur class name et class et les mettres
// ds Statement.ResultsMap puis ds AutoMapStrategy faire comme AutoResultMap ds Java
// tester si la request.CurrentResultMap [AutoResultMap (IResultMap)] est initialisée
// [if (allowRemapping || getResultMappings() == null) {initialize(rs);] java
// si ( request.Statement.AllowRemapping || (request.CurrentResultMap as AutoResultMap).IsInitalized) ....
for (int index = 0; index < resultMap.Properties.Count; index++)
{
ResultProperty property = resultMap.Properties[index];
resultMap.SetValueOfProperty(ref outObject, property,
property.GetDataBaseValue(reader));
}
return(outObject);
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when a 'resultClass' attribute is specified on the statement and
/// the 'resultClass' attribute is a <see cref="IDictionary"/>.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object outObject = resultObject;
AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap;
if (outObject == null)
{
outObject = resultMap.CreateInstanceOfResultClass();
}
int count = reader.FieldCount;
IDictionary dictionary = (IDictionary)outObject;
for (int i = 0; i < count; i++)
{
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = i;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i));
dictionary.Add(
reader.GetName(i),
property.GetDataBaseValue(reader));
}
return(outObject);
}
private AutoResultMap InitializeAutoResultMap(RequestScope request, ref IDataReader reader, ref object resultObject)
{
AutoResultMap currentResultMap = request.CurrentResultMap as AutoResultMap;
if (request.Statement.AllowRemapping)
{
currentResultMap = currentResultMap.Clone();
ResultPropertyCollection propertys = ReaderAutoMapper.Build(request.DataExchangeFactory, reader, ref resultObject);
currentResultMap.Properties.AddRange(propertys);
return(currentResultMap);
}
if (!currentResultMap.IsInitalized)
{
lock (currentResultMap)
{
if (!currentResultMap.IsInitalized)
{
ResultPropertyCollection propertys2 = ReaderAutoMapper.Build(request.DataExchangeFactory, reader, ref resultObject);
currentResultMap.Properties.AddRange(propertys2);
currentResultMap.IsInitalized = true;
}
}
}
return(currentResultMap);
}
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object target = resultObject;
AutoResultMap currentResultMap = request.CurrentResultMap as AutoResultMap;
if (target == null)
{
target = currentResultMap.CreateInstanceOfResultClass();
}
if (!currentResultMap.IsInitalized)
{
lock (currentResultMap)
{
if (!currentResultMap.IsInitalized)
{
ResultProperty property;
property = new ResultProperty {
PropertyName = "value",
ColumnIndex = 0,
TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(target.GetType()),
PropertyStrategy = PropertyStrategyFactory.Get(property)
};
currentResultMap.Properties.Add(property);
currentResultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));
currentResultMap.IsInitalized = true;
}
}
}
currentResultMap.Properties[0].PropertyStrategy.Set(request, currentResultMap, currentResultMap.Properties[0], ref target, reader, null);
return(target);
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when a ResultClass is specified on the statement and
/// the ResultClass is a SimpleType.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object outObject = resultObject;
AutoResultMap resultMap = (AutoResultMap)request.CurrentResultMap;
if (outObject == null)
{
outObject = resultMap.CreateInstanceOfResult(null);
}
if (!resultMap.IsInitalized)
{
lock (resultMap)
{
if (!resultMap.IsInitalized)
{
// Create a ResultProperty
const string propertyName = "value";
const int columnIndex = 0;
ITypeHandler typeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(outObject.GetType());
ResultProperty property = new ResultProperty(
propertyName,
string.Empty,
columnIndex,
string.Empty,
string.Empty,
string.Empty,
false,
string.Empty,
null,
string.Empty,
null,
null,
typeHandler);
//property.PropertyStrategy = PropertyStrategyFactory.Get(property);
resultMap.Properties.Add(property);
resultMap.DataExchange = request.DataExchangeFactory.GetDataExchangeForClass(typeof(int));// set the PrimitiveDataExchange
resultMap.IsInitalized = true;
}
}
}
//为outObject类的属性property赋值
resultMap.Properties[0].PropertyStrategy.Set(request, resultMap, resultMap.Properties[0], ref outObject, reader, null);
return(outObject);
}
/// <summary>
/// Auto-map the reader to the result object.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
/// <returns>The AutoResultMap use to map the resultset.</returns>
private AutoResultMap InitializeAutoResultMap(RequestScope request, ref IDataReader reader, ref object resultObject)
{
AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap;
bool isUseAutoMapCompatibilityMode = false;
if (request.MappedStatement.SqlMap.IsUseAutoMapCompatibilityMode)
{
isUseAutoMapCompatibilityMode = request.MappedStatement.Statement.ForceDisabledAutoMapCompatibilityMode ? false : true;
}
else
{
isUseAutoMapCompatibilityMode = request.MappedStatement.Statement.ForceEnableAutoMapCompatibilityMode ? true : false;
}
if (request.Statement.AllowRemapping)
{
resultMap = resultMap.Clone();
ResultPropertyCollection properties = ReaderAutoMapper.Build(
request.DataExchangeFactory,
reader,
ref resultObject,
isUseAutoMapCompatibilityMode);
resultMap.Properties.AddRange(properties);
}
else
{
if (!resultMap.IsInitalized)
{
lock (resultMap)
{
if (!resultMap.IsInitalized)
{
ResultPropertyCollection properties = ReaderAutoMapper.Build(
request.DataExchangeFactory,
reader,
ref resultObject,
isUseAutoMapCompatibilityMode);
resultMap.Properties.AddRange(properties);
resultMap.IsInitalized = true;
}
}
}
}
return(resultMap);
}
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object obj2 = resultObject;
if (obj2 == null)
{
obj2 = (request.CurrentResultMap as AutoResultMap).CreateInstanceOfResultClass();
}
AutoResultMap map = this.InitializeAutoResultMap(request, ref reader, ref obj2);
for (int i = 0; i < map.Properties.Count; i++)
{
ResultProperty property = map.Properties[i];
map.SetValueOfProperty(ref obj2, property, property.GetDataBaseValue(reader));
}
return(obj2);
}
/// <summary>
/// Initialize an statement for the sqlMap.
/// </summary>
/// <param name="configurationScope">The scope of the configuration</param>
internal virtual void Initialize(ConfigurationScope configurationScope)
{
if (_resultMapName.Length > 0)
{
string[] names = _resultMapName.Split(',');
for (int i = 0; i < names.Length; i++)
{
string name = configurationScope.ApplyNamespace(names[i].Trim());
_resultsMap.Add(configurationScope.SqlMapper.GetResultMap(name));
}
}
if (_parameterMapName.Length > 0)
{
_parameterMap = configurationScope.SqlMapper.GetParameterMap(_parameterMapName);
}
if (_resultClassName.Length > 0)
{
string[] classNames = _resultClassName.Split(',');
for (int i = 0; i < classNames.Length; i++)
{
_resultClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(classNames[i].Trim());
IFactory resultClassFactory = null;
if (Type.GetTypeCode(_resultClass) == TypeCode.Object &&
(_resultClass.IsValueType == false))
{
resultClassFactory = configurationScope.SqlMapper.ObjectFactory.CreateFactory(_resultClass, Type.EmptyTypes);
}
IDataExchange dataExchange = configurationScope.DataExchangeFactory.GetDataExchangeForClass(_resultClass);
IResultMap autoMap = new AutoResultMap(_resultClass, resultClassFactory, dataExchange);
_resultsMap.Add(autoMap);
}
}
if (_parameterClassName.Length > 0)
{
_parameterClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(_parameterClassName);
}
if (_listClassName.Length > 0)
{
_listClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(_listClassName);
_listClassFactory = configurationScope.SqlMapper.ObjectFactory.CreateFactory(_listClass, Type.EmptyTypes);
}
}
internal virtual void Initialize(ConfigurationScope configurationScope)
{
if (this._resultMapName.Length > 0)
{
string[] strArray = this._resultMapName.Split(new char[] { ',' });
for (int i = 0; i < strArray.Length; i++)
{
string name = configurationScope.ApplyNamespace(strArray[i].Trim());
this._resultsMap.Add(configurationScope.SqlMapper.GetResultMap(name));
}
}
if (this._parameterMapName.Length > 0)
{
this._parameterMap = configurationScope.SqlMapper.GetParameterMap(this._parameterMapName);
}
if (this._resultClassName.Length > 0)
{
string[] strArray2 = this._resultClassName.Split(new char[] { ',' });
for (int j = 0; j < strArray2.Length; j++)
{
this._resultClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(strArray2[j].Trim());
IFactory resultClassFactory = null;
if ((Type.GetTypeCode(this._resultClass) == TypeCode.Object) && !this._resultClass.IsValueType)
{
resultClassFactory = configurationScope.SqlMapper.ObjectFactory.CreateFactory(this._resultClass, Type.EmptyTypes);
}
IDataExchange dataExchangeForClass = configurationScope.DataExchangeFactory.GetDataExchangeForClass(this._resultClass);
IResultMap map = new AutoResultMap(this._resultClass, resultClassFactory, dataExchangeForClass);
this._resultsMap.Add(map);
}
}
if (this._parameterClassName.Length > 0)
{
this._parameterClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(this._parameterClassName);
}
if (this._listClassName.Length > 0)
{
this._listClass = configurationScope.SqlMapper.TypeHandlerFactory.GetType(this._listClassName);
this._listClassFactory = configurationScope.SqlMapper.ObjectFactory.CreateFactory(this._listClass, Type.EmptyTypes);
}
}
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object obj2 = resultObject;
AutoResultMap currentResultMap = request.CurrentResultMap as AutoResultMap;
if (obj2 == null)
{
obj2 = currentResultMap.CreateInstanceOfResultClass();
}
int fieldCount = reader.FieldCount;
for (int i = 0; i < fieldCount; i++)
{
ResultProperty property = new ResultProperty {
PropertyName = "value",
ColumnIndex = i,
TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(i))
};
((IList)obj2).Add(property.GetDataBaseValue(reader));
}
return(obj2);
}
/// <summary>
/// Auto-map the reader to the result object.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
/// <returns>The AutoResultMap use to map the resultset.</returns>
private static AutoResultMap InitializeAutoResultMap(RequestScope request, IDataReader reader, ref object resultObject)
{
AutoResultMap resultMap = request.CurrentResultMap as AutoResultMap;
if (request.Statement.AllowRemapping)
{
resultMap = resultMap.Clone();
//根据reader的字段从resultObject类中获取对应的属性类集合
ResultPropertyCollection properties = ReaderAutoMapper.Build(
request.DataExchangeFactory,
reader,
ref resultObject);
resultMap.Properties.AddRange(properties);
}
else
{
if (!resultMap.IsInitalized)
{
lock (resultMap)
{
if (!resultMap.IsInitalized)
{
ResultPropertyCollection properties = ReaderAutoMapper.Build(
request.DataExchangeFactory,
reader,
ref resultObject);
resultMap.Properties.AddRange(properties);
resultMap.IsInitalized = true;
}
}
}
}
return(resultMap);
}
/// <summary>
/// Deserializes the specified configuration in a Statement object.
/// </summary>
/// <param name="modelStore"></param>
/// <param name="config">The config.</param>
/// <param name="configurationSetting">Default settings.</param>
/// <returns></returns>
protected void BaseDeserialize(IModelStore modelStore, IConfiguration config, ConfigurationSetting configurationSetting)
{
nameSpace = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_NAMESPACE);
id = configurationSetting.UseStatementNamespaces ? ApplyNamespace(nameSpace, config.Id) : config.Id;
cacheModelName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_CACHEMODEL);
extendsName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_EXTENDS);
listClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_LISTCLASS);
parameterClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PARAMETERCLASS);
parameterMapName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PARAMETERMAP);
resultClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_RESULTCLASS);
resultMapName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_RESULTMAP);
remapResults = ConfigurationUtils.GetBooleanAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_REMAPRESULTS, false);
sqlSourceClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_SQLSOURCE);
preserveWhitespace = ConfigurationUtils.GetBooleanAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PRESERVEWHITSPACE, configurationSetting.PreserveWhitespace);
// Gets the results Map
if (resultMapName.Length > 0)
{
string[] ids = resultMapName.Split(',');
for (int i = 0; i < ids.Length; i++)
{
string name = ApplyNamespace(nameSpace, ids[i].Trim());
resultsMap.Add(modelStore.GetResultMap(name));
}
}
// Gets the results class
if (resultClassName.Length > 0)
{
string[] classNames = resultClassName.Split(',');
for (int i = 0; i < classNames.Length; i++)
{
resultClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(classNames[i].Trim());
IFactory resultClassFactory = null;
if (Type.GetTypeCode(resultClass) == TypeCode.Object &&
(resultClass.IsValueType == false) && resultClass != typeof(DataRow))
{
resultClassFactory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(resultClass, Type.EmptyTypes);
}
IDataExchange dataExchange = modelStore.DataExchangeFactory.GetDataExchangeForClass(resultClass);
bool isSimpleType = modelStore.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(resultClass);
IResultMap autoMap = new AutoResultMap(resultClass, resultClassFactory, dataExchange, isSimpleType);
resultsMap.Add(autoMap);
}
}
// Gets the ParameterMap
if (parameterMapName.Length > 0)
{
parameterMap = modelStore.GetParameterMap(parameterMapName);
}
// Gets the ParameterClass
if (parameterClassName.Length > 0)
{
parameterClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(parameterClassName);
}
// Gets the listClass
if (listClassName.Length > 0)
{
listClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(listClassName);
listClassFactory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(listClass, Type.EmptyTypes);
}
// Gets the CacheModel
if (cacheModelName.Length > 0)
{
cacheModel = modelStore.GetCacheModel(cacheModelName);
}
// Gets the SqlSource
if (sqlSourceClassName.Length > 0)
{
Type sqlSourceType = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(sqlSourceClassName);
IFactory factory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(sqlSourceType, Type.EmptyTypes);
sqlSource = (ISqlSource)factory.CreateInstance(null);
}
}
/// <summary>
/// Deserializes the specified configuration in a Statement object.
/// </summary>
/// <param name="modelStore"></param>
/// <param name="config">The config.</param>
/// <param name="configurationSetting">Default settings.</param>
/// <returns></returns>
/// <remarks>
/// Updated By: Richard Beacroft
/// Updated Date: 11\10\2013
/// Description: configurationSetting can be null and therefore references to it have to assume that it could be null.
/// </remarks>
protected void BaseDeserialize(IModelStore modelStore, IConfiguration config, ConfigurationSetting configurationSetting)
{
// DefaultModelBuilderTest.Test_DefaultModelBuilder assumes that configurationSetting can be null - added code accordingly.
// Typically, no public method should allow null to be passed-in, best handled by overloading method to exclude parameter, or in .NET 4, use optional parameter.
var preserveWhitespace = (configurationSetting == null) ? false : configurationSetting.PreserveWhitespace;
bool useStatementNamespaces = (configurationSetting == null) ? false : configurationSetting.UseStatementNamespaces;
nameSpace = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_NAMESPACE);
id = useStatementNamespaces ? ApplyNamespace(nameSpace, config.Id) : config.Id;
cacheModelName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_CACHEMODEL);
extendsName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_EXTENDS);
listClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_LISTCLASS);
parameterClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PARAMETERCLASS);
parameterMapName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PARAMETERMAP);
resultClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_RESULTCLASS);
resultMapName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_RESULTMAP);
remapResults = ConfigurationUtils.GetBooleanAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_REMAPRESULTS, false);
sqlSourceClassName = ConfigurationUtils.GetStringAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_SQLSOURCE);
preserveWhitespace = ConfigurationUtils.GetBooleanAttribute(config.Attributes, ConfigConstants.ATTRIBUTE_PRESERVEWHITSPACE, preserveWhitespace);
// Gets the results Map
if (resultMapName.Length > 0)
{
string[] ids = resultMapName.Split(',');
for (int i = 0; i < ids.Length; i++)
{
string name = ApplyNamespace(nameSpace, ids[i].Trim());
resultsMap.Add(modelStore.GetResultMap(name));
}
}
// Gets the results class
if (resultClassName.Length > 0)
{
string[] classNames = resultClassName.Split(',');
for (int i = 0; i < classNames.Length; i++)
{
resultClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(classNames[i].Trim());
IFactory resultClassFactory = null;
if (Type.GetTypeCode(resultClass) == TypeCode.Object &&
(resultClass.IsValueType == false) && resultClass != typeof(DataRow))
{
resultClassFactory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(resultClass, Type.EmptyTypes);
}
IDataExchange dataExchange = modelStore.DataExchangeFactory.GetDataExchangeForClass(resultClass);
bool isSimpleType = modelStore.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(resultClass);
IResultMap autoMap = new AutoResultMap(resultClass, resultClassFactory, dataExchange, isSimpleType);
resultsMap.Add(autoMap);
}
}
// Gets the ParameterMap
if (parameterMapName.Length > 0)
{
parameterMap = modelStore.GetParameterMap(parameterMapName);
}
// Gets the ParameterClass
if (parameterClassName.Length > 0)
{
parameterClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(parameterClassName);
}
// Gets the listClass
if (listClassName.Length > 0)
{
listClass = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(listClassName);
listClassFactory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(listClass, Type.EmptyTypes);
}
// Gets the CacheModel
if (cacheModelName.Length > 0)
{
cacheModel = modelStore.GetCacheModel(cacheModelName);
}
// Gets the SqlSource
if (sqlSourceClassName.Length > 0)
{
Type sqlSourceType = modelStore.DataExchangeFactory.TypeHandlerFactory.GetType(sqlSourceClassName);
IFactory factory = modelStore.DataExchangeFactory.ObjectFactory.CreateFactory(sqlSourceType, Type.EmptyTypes);
sqlSource = (ISqlSource)factory.CreateInstance(null);
}
}
