/// <summary>
/// Build the PreparedStatement
/// </summary>
/// <param name="session"></param>
/// <param name="sqlStatement"></param>
public void BuildPreparedStatement(ISqlMapSession session, string sqlStatement)
{
RequestScope request = new RequestScope( _dataExchangeFactory, session, _statement);
PreparedStatementFactory factory = new PreparedStatementFactory( session, request, _statement, sqlStatement);
_preparedStatement = factory.Prepare();
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when a ResultMap is specified on the statement.
/// </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;
IResultMap resultMap = request.CurrentResultMap.ResolveSubMap(reader);
if (outObject == null)
{
object[] parameters = null;
if (resultMap.Parameters.Count > 0)
{
parameters = new object[resultMap.Parameters.Count];
// Fill parameters array
for (int index = 0; index < resultMap.Parameters.Count; index++)
{
ResultProperty resultProperty = resultMap.Parameters[index];
parameters[index] = resultProperty.ArgumentStrategy.GetValue(request, resultProperty, ref reader, null);
}
}
outObject = resultMap.CreateInstanceOfResult(parameters);
}
// For each Property in the ResultMap, set the property in the object
for (int index = 0; index < resultMap.Properties.Count; index++)
{
ResultProperty property = resultMap.Properties[index];
property.PropertyStrategy.Set(request, resultMap, property, ref outObject, reader, null);
}
return outObject;
}
///<summary>
/// Sets value of the specified <see cref="ResultProperty"/> on the target object
/// when a 'select' attribute exists and fills an <see cref="IList"/> property
/// on the <see cref="ResultProperty"/> are empties.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="resultMap">The result map.</param>
/// <param name="mapping">The ResultProperty.</param>
/// <param name="target">The target.</param>
/// <param name="reader">The current <see cref="IDataReader"/></param>
/// <param name="keys">The keys</param>
public void Set(RequestScope request, IResultMap resultMap,
ResultProperty mapping, ref object target, IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
PostBindind postSelect = new PostBindind();
postSelect.Statement = selectStatement;
postSelect.Keys = keys;
postSelect.Target = target;
postSelect.ResultProperty = mapping;
if (mapping.IsLazyLoad)
{
object values = mapping.LazyFactory.CreateProxy(selectStatement, keys, target, mapping.SetAccessor);
mapping.SetAccessor.Set(target, values);
}
else
{
if (mapping.SetAccessor.MemberType == typeof(IList))
{
postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForIList;
}
else
{
postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForStrongTypedIList;
}
request.QueueSelect.Enqueue(postSelect);
}
}
/// <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 as AutoResultMap).CreateInstanceOfResultClass();
}
AutoResultMap resultMap = InitializeAutoResultMap(request, ref 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>
/// Executes the specified <see cref="PostBindind"/>.
/// </summary>
/// <param name="postSelect">The <see cref="PostBindind"/>.</param>
/// <param name="request">The <see cref="RequestScope"/></param>
public void Execute(PostBindind postSelect, RequestScope request)
{
IFactory factory = request.DataExchangeFactory.ObjectFactory.CreateFactory(postSelect.ResultProperty.SetAccessor.MemberType, Type.EmptyTypes);
object values = factory.CreateInstance(null);
postSelect.Statement.ExecuteQueryForList(request.Session, postSelect.Keys, (IList)values);
postSelect.ResultProperty.SetAccessor.Set(postSelect.Target, values);
}
/// <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;
}
/// <summary>
/// Gets the value of an argument constructor.
/// </summary>
/// <param name="request">The current <see cref="RequestScope"/>.</param>
/// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param>
/// <param name="reader">The current <see cref="IDataReader"/>.</param>
/// <param name="keys">The keys</param>
/// <returns>The paremeter value.</returns>
public object GetValue(RequestScope request, ResultProperty mapping,
ref IDataReader reader, object keys)
{
if (mapping.TypeHandler == null ||
mapping.TypeHandler is UnknownTypeHandler) // Find the TypeHandler
{
lock(mapping)
{
if (mapping.TypeHandler == null || mapping.TypeHandler is UnknownTypeHandler)
{
int columnIndex = 0;
if (mapping.ColumnIndex == ResultProperty.UNKNOWN_COLUMN_INDEX)
{
columnIndex = reader.GetOrdinal(mapping.ColumnName);
}
else
{
columnIndex = mapping.ColumnIndex;
}
Type systemType =((IDataRecord)reader).GetFieldType(columnIndex);
mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(systemType);
}
}
}
object dataBaseValue = mapping.GetDataBaseValue( reader );
request.IsRowDataFound = request.IsRowDataFound || (dataBaseValue != null);
return dataBaseValue;
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>
/// when no resultClass or resultMap attribute are specified.
/// </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 (reader.FieldCount == 1)
{
ResultProperty property = new ResultProperty();
property.PropertyName = "value";
property.ColumnIndex = 0;
property.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(reader.GetFieldType(0));
outObject = property.GetDataBaseValue(reader);
}
else if (reader.FieldCount > 1)
{
object[] newOutObject = new object[reader.FieldCount];
int count = reader.FieldCount;
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));
newOutObject[i] = property.GetDataBaseValue(reader);
}
outObject = newOutObject;
}
else
{
// do nothing if 0 fields
}
return outObject;
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="session"></param>
/// <param name="statement"></param>
/// <param name="commandText"></param>
/// <param name="request"></param>
public PreparedStatementFactory(ISqlMapSession session, RequestScope request, IStatement statement, string commandText)
{
_session = session;
_request = request;
_statement = statement;
_commandText = commandText;
}
/// <summary>
/// Executes the specified <see cref="PostBindind"/>.
/// </summary>
/// <param name="postSelect">The <see cref="PostBindind"/>.</param>
/// <param name="request">The <see cref="RequestScope"/></param>
public void Execute(PostBindind postSelect, RequestScope request)
{
// How to: Examine and Instantiate Generic Types with Reflection
// http://msdn2.microsoft.com/en-us/library/b8ytshk6.aspx
Type[] typeArgs = postSelect.ResultProperty.SetAccessor.MemberType.GetGenericArguments();
Type genericList = typeof(IList<>);
Type constructedType = genericList.MakeGenericType(typeArgs);
Type elementType = postSelect.ResultProperty.SetAccessor.MemberType.GetGenericArguments()[0];
Type mappedStatementType = postSelect.Statement.GetType();
Type[] typeArguments = { typeof(SqlMapSession), typeof(object) };
MethodInfo[] mis = mappedStatementType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance);
MethodInfo mi = null;
foreach (MethodInfo m in mis)
{
if (m.IsGenericMethod &&
m.Name == "ExecuteQueryForList" &&
m.GetParameters().Length == 2)
{
mi = m;
break;
}
}
MethodInfo miConstructed = mi.MakeGenericMethod(elementType);
// Invoke the method.
object[] args = { request.Session, postSelect.Keys };
object values = miConstructed.Invoke(postSelect.Statement, args);
postSelect.ResultProperty.SetAccessor.Set(postSelect.Target, values);
}
/// <summary>
/// Gets the value of an argument constructor.
/// </summary>
/// <param name="request">The current <see cref="RequestScope"/>.</param>
/// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param>
/// <param name="reader">The current <see cref="IDataReader"/>.</param>
/// <param name="keys">The keys</param>
/// <returns>The paremeter value.</returns>
public object GetValue(RequestScope request, ResultProperty mapping,
ref IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
return selectStatement.ExecuteQueryForObject(request.Session, keys);
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultObject">The result object.</param>
/// <returns>The result object</returns>
public object Process(RequestScope request, ref IDataReader reader, object resultObject)
{
object outObject = resultObject;
IResultMap resultMap = request.CurrentResultMap.ResolveSubMap(reader);
string uniqueKey = GetUniqueKey(resultMap, request, reader);
// Gets the [key, result object] already build
IDictionary buildObjects = request.GetUniqueKeys(resultMap);
if (buildObjects != null && buildObjects.Contains(uniqueKey))
{
// Unique key is already known, so get the existing result object and process additional results.
outObject = buildObjects[uniqueKey];
// process resulMapping attribute wich point to a groupBy attribute
for (int index = 0; index < resultMap.Properties.Count; index++)
{
ResultProperty resultProperty = resultMap.Properties[index];
if (resultProperty.PropertyStrategy is PropertStrategy.GroupByStrategy)
{
resultProperty.PropertyStrategy.Set(request, resultMap, resultProperty, ref outObject, reader, null);
}
}
outObject = SKIP;
}
else if (uniqueKey == null || buildObjects == null || !buildObjects.Contains(uniqueKey))
{
// Unique key is NOT known, so create a new result object and process additional results.
// Fix IBATISNET-241
if (outObject == null)
{
// temp ?, we don't support constructor tag with groupBy attribute
outObject = resultMap.CreateInstanceOfResult(null);
}
for (int index = 0; index < resultMap.Properties.Count; index++)
{
ResultProperty resultProperty = resultMap.Properties[index];
resultProperty.PropertyStrategy.Set(request, resultMap, resultProperty, ref outObject, reader, null);
}
if (buildObjects == null)
{
buildObjects = new Hashtable();
request.SetUniqueKeys(resultMap, buildObjects);
}
buildObjects[uniqueKey] = outObject;
}
return outObject;
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>.
/// </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)
{
IResultMap resultMap = request.CurrentResultMap.ResolveSubMap(reader);
if (resultMap.GroupByPropertyNames.Count>0)
{
return _groupByStrategy.Process(request, ref reader, resultObject);
}
else
{
return _resultMapStrategy.Process(request, ref reader, resultObject);
}
}
/// <summary>
/// Create an IDbCommand for the SqlMapSession and the current SQL Statement
/// and fill IDbCommand IDataParameter's with the parameterObject.
/// </summary>
/// <param name="request"></param>
/// <param name="session">The SqlMapSession</param>
/// <param name="statement">The IStatement</param>
/// <param name="parameterObject">
/// The parameter object that will fill the sql parameter
/// </param>
/// <returns>An IDbCommand with all the IDataParameter filled.</returns>
public void Create(RequestScope request, ISqlMapSession session, IStatement statement, object parameterObject )
{
// the IDbConnection & the IDbTransaction are assign in the CreateCommand
request.IDbCommand = new DbCommandDecorator(session.CreateCommand(statement.CommandType), request);
request.IDbCommand.CommandText = request.PreparedStatement.PreparedSql;
if (_logger.IsDebugEnabled)
{
_logger.Debug("Statement Id: [" + statement.Id + "] PreparedStatement : [" + request.IDbCommand.CommandText + "]");
}
ApplyParameterMap( session, request.IDbCommand, request, statement, parameterObject );
}
/// <summary>
/// Executes the specified <see cref="PostBindind"/>.
/// </summary>
/// <param name="postSelect">The <see cref="PostBindind"/>.</param>
/// <param name="request">The <see cref="RequestScope"/></param>
public void Execute(PostBindind postSelect, RequestScope request)
{
IList values = postSelect.Statement.ExecuteQueryForList(request.Session, postSelect.Keys);
Type elementType = postSelect.ResultProperty.SetAccessor.MemberType.GetElementType();
Array array = Array.CreateInstance(elementType, values.Count);
int count = values.Count;
for(int i=0;i<count;i++)
{
array.SetValue(values[i],i);
}
postSelect.ResultProperty.SetAccessor.Set(postSelect.Target, array);
}
/// <summary>
/// Build the PreparedStatement
/// </summary>
/// <param name="session"></param>
/// <param name="commandText"></param>
/// <param name="request"></param>
public PreparedStatement BuildPreparedStatement(ISqlMapSession session, RequestScope request, string commandText)
{
if ( _preparedStatement == null )
{
lock(_synRoot)
{
if (_preparedStatement==null)
{
PreparedStatementFactory factory = new PreparedStatementFactory( session, request, _statement, commandText);
_preparedStatement = factory.Prepare();
}
}
}
return _preparedStatement;
}
public override bool Equals(object obj)
{
if (this != obj)
{
if (!(obj is RequestScope))
{
return(false);
}
RequestScope scope = (RequestScope)obj;
if (this._id != scope._id)
{
return(false);
}
}
return(true);
}
/// <summary>
/// Gets the value of an argument constructor.
/// </summary>
/// <param name="request">The current <see cref="RequestScope"/>.</param>
/// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param>
/// <param name="reader">The current <see cref="IDataReader"/>.</param>
/// <param name="keys">The keys</param>
/// <returns>The paremeter value.</returns>
public object GetValue(RequestScope request, ResultProperty mapping,
ref IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
IList values = selectStatement.ExecuteQueryForList(request.Session, keys);
Type elementType = mapping.MemberType.GetElementType();
Array array = Array.CreateInstance(elementType, values.Count);
int count = values.Count;
for(int i=0;i<count;i++)
{
array.SetValue(values[i],i);
}
return array;
}
///<summary>
/// Sets value of the specified <see cref="ResultProperty"/> on the target object
/// when a 'select' attribute exists and fills an Array property
/// on the <see cref="ResultProperty"/> are empties.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="resultMap">The result map.</param>
/// <param name="mapping">The ResultProperty.</param>
/// <param name="target">The target.</param>
/// <param name="reader">The <see cref="IDataReader"/></param>
/// <param name="keys">The keys</param>
public void Set(RequestScope request, IResultMap resultMap,
ResultProperty mapping, ref object target, IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
PostBindind postSelect = new PostBindind();
postSelect.Statement = selectStatement;
postSelect.Keys = keys;
postSelect.Target = target;
postSelect.ResultProperty = mapping;
if (mapping.IsLazyLoad)
{
throw new NotImplementedException("Lazy load no supported for System.Array property:" + mapping.SetAccessor.Name);
}
postSelect.Method = PostBindind.ExecuteMethod.ExecuteQueryForArrayList;
request.QueueSelect.Enqueue(postSelect);
}
/// <summary>
/// Gets the value of an argument constructor.
/// </summary>
/// <param name="request">The current <see cref="RequestScope"/>.</param>
/// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param>
/// <param name="reader">The current <see cref="IDataReader"/>.</param>
/// <param name="keys">The keys</param>
/// <returns>The paremeter value.</returns>
public object GetValue(RequestScope request, ResultProperty mapping,
ref IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
if (mapping.MemberType == typeof(IList))
{
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
return selectStatement.ExecuteQueryForList(request.Session, keys);
}
else // Strongly typed List
{
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
IFactory factory = request.DataExchangeFactory.ObjectFactory.CreateFactory(mapping.MemberType, Type.EmptyTypes);
object values = factory.CreateInstance(null);
selectStatement.ExecuteQueryForList(request.Session, keys, (IList)values);
return values;
}
}
/// <summary>
/// Processes the specified <see cref="IDataReader"/>.
/// </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)
{
// Check if the ResultClass is a 'primitive' Type
if (request.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(request.CurrentResultMap.Class))
{
return _simpleTypeStrategy.Process(request, ref reader, resultObject);
}
else if (typeof(IDictionary).IsAssignableFrom(request.CurrentResultMap.Class))
{
return _dictionaryStrategy.Process(request, ref reader, resultObject);
}
else if (typeof(IList).IsAssignableFrom(request.CurrentResultMap.Class))
{
return _listStrategy.Process(request, ref reader, resultObject);
}
else
{
return _autoMapStrategy.Process(request, ref reader, resultObject);
}
}
/// <summary>
/// Gets the value of the specified <see cref="ResultProperty"/> that must be set on the target object.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="resultMap">The result map.</param>
/// <param name="mapping">The mapping.</param>
/// <param name="reader">The reader.</param>
/// <param name="target">The target object</param>
public object Get(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader)
{
object[] parameters = null;
bool isParameterFound = false;
IResultMap resultMapping = mapping.NestedResultMap.ResolveSubMap(reader);
if (resultMapping.Parameters.Count > 0)
{
parameters = new object[resultMapping.Parameters.Count];
// Fill parameters array
for (int index = 0; index < resultMapping.Parameters.Count; index++)
{
ResultProperty resultProperty = resultMapping.Parameters[index];
parameters[index] = resultProperty.ArgumentStrategy.GetValue(request, resultProperty, ref reader, null);
request.IsRowDataFound = request.IsRowDataFound || (parameters[index] != null);
isParameterFound = isParameterFound || (parameters[index] != null);
}
}
object obj = null;
// If I have a constructor tag and all argumments values are null, the obj is null
if (resultMapping.Parameters.Count > 0 && isParameterFound == false)
{
obj = null;
}
else
{
obj = resultMapping.CreateInstanceOfResult(parameters);
// Fills properties on the new object
if (this.FillObjectWithReaderAndResultMap(request, reader, resultMapping, ref obj) == false)
{
obj = null;
}
}
return obj;
}
/// <summary>
/// Gets the value of an argument constructor.
/// </summary>
/// <param name="request">The current <see cref="RequestScope"/>.</param>
/// <param name="mapping">The <see cref="ResultProperty"/> with the argument infos.</param>
/// <param name="reader">The current <see cref="IDataReader"/>.</param>
/// <param name="keys">The keys</param>
/// <returns>The paremeter value.</returns>
public object GetValue(RequestScope request, ResultProperty mapping,
ref IDataReader reader, object keys)
{
// Get the select statement
IMappedStatement selectStatement = request.MappedStatement.SqlMap.GetMappedStatement(mapping.Select);
reader = DataReaderTransformer.Transform(reader, request.Session.DataSource.DbProvider);
Type[] typeArgs = mapping.MemberType.GetGenericArguments();
Type genericList = typeof(IList<>);
Type constructedType = genericList.MakeGenericType(typeArgs);
Type elementType = mapping.MemberType.GetGenericArguments()[0];
Type mappedStatementType = selectStatement.GetType();
Type[] typeArguments = { typeof(SqlMapSession), typeof(object) };
MethodInfo[] mis = mappedStatementType.GetMethods(BindingFlags.InvokeMethod | BindingFlags.Public | BindingFlags.Instance);
MethodInfo mi = null;
foreach (MethodInfo m in mis)
{
if (m.IsGenericMethod &&
m.Name == "ExecuteQueryForList" &&
m.GetParameters().Length == 2)
{
mi = m;
break;
}
}
MethodInfo miConstructed = mi.MakeGenericMethod(elementType);
// Invoke the method.
object[] args = { request.Session, keys };
object values = miConstructed.Invoke(selectStatement, args);
return values;
}
/// <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;
if (request.Statement.AllowRemapping)
{
resultMap = resultMap.Clone();
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>
/// Fills the object with reader and result map.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="reader">The reader.</param>
/// <param name="resultMap">The result map.</param>
/// <param name="resultObject">The result object.</param>
/// <returns>Indicates if we have found a row.</returns>
protected bool FillObjectWithReaderAndResultMap(RequestScope request,IDataReader reader,
IResultMap resultMap, ref object resultObject)
{
bool dataFound = false;
if (resultMap.Properties.Count>0)
{
// For each Property in the ResultMap, set the property in the object
for(int index=0; index< resultMap.Properties.Count; index++)
{
request.IsRowDataFound = false;
ResultProperty property = resultMap.Properties[index];
property.PropertyStrategy.Set(request, resultMap, property, ref resultObject, reader, null);
dataFound = dataFound || request.IsRowDataFound;
}
request.IsRowDataFound = dataFound;
return dataFound;
}
else
{
return true;
}
}
/// <summary>
/// Executes the specified <see cref="PostBindind"/>.
/// </summary>
/// <param name="postSelect">The <see cref="PostBindind"/>.</param>
/// <param name="request">The <see cref="RequestScope"/></param>
public void Execute(PostBindind postSelect, RequestScope request)
{
object value = postSelect.Statement.ExecuteQueryForObject(request.Session, postSelect.Keys);
postSelect.ResultProperty.SetAccessor.Set(postSelect.Target, value);
}
/// <summary>
/// Gets the value of the specified <see cref="ResultProperty"/> that must be set on the target object.
/// </summary>
/// <param name="request">The request.</param>
/// <param name="resultMap">The result map.</param>
/// <param name="mapping">The mapping.</param>
/// <param name="reader">The reader.</param>
/// <param name="target">The target object</param>
public object Get(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader)
{
throw new NotSupportedException("Get method on ResultMapStrategy is not supported");
}
/// <summary>
/// Initializes a new instance of the <see cref="DataReaderDecorator"/> class.
/// </summary>
/// <param name="dataReader">The data reader.</param>
/// <param name="request">The request scope</param>
public DataReaderDecorator(IDataReader dataReader, RequestScope request)
{
_innerDataReader = dataReader;
_request = request;
}
/// <summary>
/// Applies the parameter map.
/// </summary>
/// <param name="session">The session.</param>
/// <param name="command">The command.</param>
/// <param name="request">The request.</param>
/// <param name="statement">The statement.</param>
/// <param name="parameterObject">The parameter object.</param>
protected virtual void ApplyParameterMap( ISqlMapSession session, IDbCommand command,
RequestScope request, IStatement statement, object parameterObject)
{
StringCollection properties = request.PreparedStatement.DbParametersName;
IDbDataParameter[] parameters = request.PreparedStatement.DbParameters;
StringBuilder paramLogList = new StringBuilder(); // Log info
StringBuilder typeLogList = new StringBuilder(); // Log info
int count = properties.Count;
for ( int i = 0; i < count; ++i )
{
IDbDataParameter sqlParameter = parameters[i];
IDbDataParameter parameterCopy = command.CreateParameter();
ParameterProperty property = request.ParameterMap.GetProperty(i);
#region Logging
if (_logger.IsDebugEnabled)
{
paramLogList.Append(sqlParameter.ParameterName);
paramLogList.Append("=[");
typeLogList.Append(sqlParameter.ParameterName);
typeLogList.Append("=[");
}
#endregion
if (command.CommandType == CommandType.StoredProcedure)
{
#region store procedure command
// A store procedure must always use a ParameterMap
// to indicate the mapping order of the properties to the columns
if (request.ParameterMap == null) // Inline Parameters
{
throw new DataMapperException("A procedure statement tag must alway have a parameterMap attribute, which is not the case for the procedure '"+statement.Id+"'.");
}
else // Parameters via ParameterMap
{
if (property.DirectionAttribute.Length == 0)
{
property.Direction = sqlParameter.Direction;
}
sqlParameter.Direction = property.Direction;
}
#endregion
}
#region Logging
if (_logger.IsDebugEnabled)
{
paramLogList.Append(property.PropertyName);
paramLogList.Append(",");
}
#endregion
request.ParameterMap.SetParameter(property, parameterCopy, parameterObject );
parameterCopy.Direction = sqlParameter.Direction;
// With a ParameterMap, we could specify the ParameterDbTypeProperty
if (request.ParameterMap != null)
{
if (property.DbType != null && property.DbType.Length > 0)
{
string dbTypePropertyName = session.DataSource.DbProvider.ParameterDbTypeProperty;
object propertyValue = ObjectProbe.GetMemberValue(sqlParameter, dbTypePropertyName, request.DataExchangeFactory.AccessorFactory);
ObjectProbe.SetMemberValue(parameterCopy, dbTypePropertyName, propertyValue,
request.DataExchangeFactory.ObjectFactory, request.DataExchangeFactory.AccessorFactory);
}
else
{
//parameterCopy.DbType = sqlParameter.DbType;
}
}
else
{
//parameterCopy.DbType = sqlParameter.DbType;
}
#region Logging
if (_logger.IsDebugEnabled)
{
if (parameterCopy.Value == DBNull.Value)
{
paramLogList.Append("null");
paramLogList.Append("], ");
typeLogList.Append("System.DBNull, null");
typeLogList.Append("], ");
}
else
{
paramLogList.Append(parameterCopy.Value.ToString());
paramLogList.Append("], ");
// sqlParameter.DbType could be null (as with Npgsql)
// if PreparedStatementFactory did not find a dbType for the parameter in:
// line 225: "if (property.DbType.Length >0)"
// Use parameterCopy.DbType
//typeLogList.Append( sqlParameter.DbType.ToString() );
typeLogList.Append(parameterCopy.DbType.ToString());
typeLogList.Append(", ");
typeLogList.Append(parameterCopy.Value.GetType().ToString());
typeLogList.Append("], ");
}
}
#endregion
// JIRA-49 Fixes (size, precision, and scale)
if (session.DataSource.DbProvider.SetDbParameterSize)
{
if (sqlParameter.Size > 0)
{
parameterCopy.Size = sqlParameter.Size;
}
}
if (session.DataSource.DbProvider.SetDbParameterPrecision)
{
parameterCopy.Precision = sqlParameter.Precision;
}
if (session.DataSource.DbProvider.SetDbParameterScale)
{
parameterCopy.Scale = sqlParameter.Scale;
}
parameterCopy.ParameterName = sqlParameter.ParameterName;
command.Parameters.Add( parameterCopy );
}
#region Logging
if (_logger.IsDebugEnabled && properties.Count>0)
{
_logger.Debug("Statement Id: [" + statement.Id + "] Parameters: [" + paramLogList.ToString(0, paramLogList.Length - 2) + "]");
_logger.Debug("Statement Id: [" + statement.Id + "] Types: [" + typeLogList.ToString(0, typeLogList.Length - 2) + "]");
}
#endregion
}
/// <summary>
/// Builds a new <see cref="RequestScope"/> and the sql command text to execute.
/// </summary>
/// <param name="parameterObject">The parameter object (used in DynamicSql)</param>
/// <param name="session">The current session</param>
/// <param name="mappedStatement">The <see cref="IMappedStatement"/>.</param>
/// <returns>A new <see cref="RequestScope"/>.</returns>
public RequestScope GetRequestScope(IMappedStatement mappedStatement,
object parameterObject, ISqlMapSession session)
{
RequestScope request = new RequestScope(_dataExchangeFactory, session, _statement);
request.PreparedStatement = BuildPreparedStatement(session, request, _sqlStatement);
request.MappedStatement = mappedStatement;
return request;
}
