private ITypeHandler ResolveTypeHandler(TypeHandlerFactory typeHandlerFactory, Type parameterClassType, string propertyName, string propertyType, string dbType)
{
if (parameterClassType == null)
{
return(typeHandlerFactory.GetUnkownTypeHandler());
}
if (typeof(IDictionary).IsAssignableFrom(parameterClassType))
{
if ((propertyType == null) || (propertyType.Length == 0))
{
return(typeHandlerFactory.GetUnkownTypeHandler());
}
try
{
Type type = TypeUtils.ResolveType(propertyType);
return(typeHandlerFactory.GetTypeHandler(type, dbType));
}
catch (Exception exception)
{
throw new ConfigurationException("Error. Could not set TypeHandler. Cause: " + exception.Message, exception);
}
}
if (typeHandlerFactory.GetTypeHandler(parameterClassType, dbType) != null)
{
return(typeHandlerFactory.GetTypeHandler(parameterClassType, dbType));
}
Type memberTypeForGetter = ObjectProbe.GetMemberTypeForGetter(parameterClassType, propertyName);
return(typeHandlerFactory.GetTypeHandler(memberTypeForGetter, dbType));
}
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
if (parameterObject != null)
{
string property = ((BaseTag)tag).Property;
object obj2 = null;
if ((property != null) && (property.Length > 0))
{
obj2 = ObjectProbe.GetMemberValue(parameterObject, property, base.AccessorFactory);
}
else
{
obj2 = parameterObject;
}
if (obj2 is ICollection)
{
if (obj2 != null)
{
return(((ICollection)obj2).Count < 1);
}
return(true);
}
if ((obj2 != null) && typeof(Array).IsAssignableFrom(obj2.GetType()))
{
return(((Array)obj2).GetLength(0) == 0);
}
if (obj2 != null)
{
return(Convert.ToString(obj2).Equals(""));
}
}
return(true);
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
/// <param name="tag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
if (parameterObject == null)
{
return(true);
}
string propertyName = ((BaseTag)tag).Property;
object value = null;
if (!string.IsNullOrEmpty(propertyName))
{
value = ObjectProbe.GetMemberValue(parameterObject, propertyName, AccessorFactory);
}
else
{
value = parameterObject;
}
if (value is ICollection)
{
return((value == null) || (((ICollection)value).Count < 1));
}
if (value != null && typeof(Array).IsAssignableFrom(value.GetType())) //value.GetType().IsArray
{
return(((Array)value).GetLength(0) == 0);
}
return((value == null) || (Convert.ToString(value).Equals("")));
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
/// <param name="tag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
public override int DoStartFragment(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
IterateContext iterate = (IterateContext)ctx.GetAttribute(tag);
if (iterate == null)
{
string propertyName = ((BaseTag)tag).Property;
object collection;
if (propertyName != null && propertyName.Length > 0)
{
collection = ObjectProbe.GetMemberValue(parameterObject, propertyName, this.AccessorFactory);
}
else
{
collection = parameterObject;
}
iterate = new IterateContext(collection);
ctx.AddAttribute(tag, iterate);
}
if (iterate != null && iterate.HasNext)
{
return(BaseTagHandler.INCLUDE_BODY);
}
else
{
return(BaseTagHandler.SKIP_BODY);
}
}
public override int DoStartFragment(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
IterateContext attribute = (IterateContext)ctx.GetAttribute(tag);
if (attribute == null)
{
object obj2;
string property = ((BaseTag)tag).Property;
if ((property != null) && (property.Length > 0))
{
obj2 = ObjectProbe.GetMemberValue(parameterObject, property, base.AccessorFactory);
}
else
{
obj2 = parameterObject;
}
attribute = new IterateContext(obj2);
ctx.AddAttribute(tag, attribute);
}
if ((attribute != null) && attribute.HasNext)
{
return(1);
}
return(0);
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
/// <param name="tag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
public override int DoStartFragment(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
IterateContext iterate = (IterateContext)ctx.GetAttribute(tag);
if (iterate == null)
{
string propertyName = ((BaseTag)tag).Property;
object collection;
if (!string.IsNullOrEmpty(propertyName))
{
collection = ObjectProbe.GetMemberValue(parameterObject, propertyName, AccessorFactory);
}
else
{
collection = parameterObject;
}
iterate = new IterateContext(collection);
ctx.AddAttribute(tag, iterate);
}
if (iterate.HasNext)
{
return(INCLUDE_BODY);
}
return(SKIP_BODY);
}
/// <summary>
/// Executes the SQL and retuns all rows selected in a map that is keyed on the property named
/// in the keyProperty parameter. The value at each key will be the value of the property specified
/// in the valueProperty parameter. If valueProperty is null, the entire result object will be entered.
/// </summary>
/// <param name="request">The request scope.</param>
/// <param name="session">The session used to execute the statement</param>
/// <param name="parameterObject">The object used to set the parameters in the SQL.</param>
/// <param name="keyProperty">The property of the result object to be used as the key.</param>
/// <param name="valueProperty">The property of the result object to be used as the value (or null)</param>
/// <param name="rowDelegate">A delegate called once per row in the QueryForMapWithRowDelegate method</param>
/// <returns>A IDictionary of object containing the rows keyed by keyProperty.</returns>
///<exception cref="DataMapperException">If a transaction is not in progress, or the database throws an exception.</exception>
internal IDictionary <TKey, TValue> RunQueryForDictionary <TKey, TValue>(RequestScope request,
ISession session,
object parameterObject,
string keyProperty,
string valueProperty,
DictionaryRowDelegate <TKey, TValue> rowDelegate)
{
IDictionary <TKey, TValue> map = new Dictionary <TKey, TValue>();
using (IDbCommand command = request.IDbCommand)
{
IDataReader reader = command.ExecuteReader();
try
{
if (rowDelegate == null)
{
while (reader.Read())
{
object obj = resultStrategy.Process(request, ref reader, null);
TKey key = (TKey)ObjectProbe.GetMemberValue(obj, keyProperty, request.DataExchangeFactory.AccessorFactory);
TValue value = default(TValue);
if (valueProperty != null)
{
value = (TValue)ObjectProbe.GetMemberValue(obj, valueProperty, request.DataExchangeFactory.AccessorFactory);
}
else
{
value = (TValue)obj;
}
map.Add(key, value);
}
}
else
{
while (reader.Read())
{
object obj = resultStrategy.Process(request, ref reader, null);
TKey key = (TKey)ObjectProbe.GetMemberValue(obj, keyProperty, request.DataExchangeFactory.AccessorFactory);
TValue value = default(TValue);
if (valueProperty != null)
{
value = (TValue)ObjectProbe.GetMemberValue(obj, valueProperty, request.DataExchangeFactory.AccessorFactory);
}
else
{
value = (TValue)obj;
}
rowDelegate(key, value, parameterObject, map);
}
}
}
finally
{
reader.Close();
reader.Dispose();
}
ExecuteDelayedLoad(request);
}
return(map);
}
/// <summary>
///
/// </summary>
/// <param name="configurationScope">The scope of the configuration</param>
override internal void Initialize(ConfigurationScope configurationScope)
{
// the propertyName attribute on the selectKey node is optional
if (PropertyName.Length > 0)
{
// Id is equal to the parent <select> node's "id" attribute
IMappedStatement insert = configurationScope.SqlMapper.GetMappedStatement(Id);
Type insertParameterClass = insert.Statement.ParameterClass;
// make sure the PropertyName is a valid settable property of the <insert> node's parameterClass
if (insertParameterClass != null &&
ObjectProbe.IsSimpleType(insertParameterClass) == false)
{
configurationScope.ErrorContext.MoreInfo = String.Format("Looking for settable property named '{0}' on type '{1}' for selectKey node of statement id '{2}'.",
PropertyName, // 0
insert.Statement.ParameterClass.Name, // 1
Id); // 2
// we expect this to throw an exception if the property cannot be found; GetSetter is
// called instead of HasWriteableProperty becuase we want the same wording for
// property not found exceptions; GetSetter and HasWritableProperty both use the
// same internal cache for looking up the ProperyInfo object
ReflectionInfo.GetInstance(insert.Statement.ParameterClass).GetSetter(PropertyName);
}
}
base.Initialize(configurationScope);
}
public void Initialize(IScope scope, Type parameterClass)
{
if (this._directionAttribute.Length > 0)
{
this._direction = (ParameterDirection)Enum.Parse(typeof(ParameterDirection), this._directionAttribute, true);
}
if ((!typeof(IDictionary).IsAssignableFrom(parameterClass) && (parameterClass != null)) && !scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterClass))
{
if (!this._isComplexMemberName)
{
this._getAccessor = scope.DataExchangeFactory.AccessorFactory.GetAccessorFactory.CreateGetAccessor(parameterClass, this._propertyName);
}
else
{
string name = this._propertyName.Substring(this._propertyName.LastIndexOf('.') + 1);
string memberName = this._propertyName.Substring(0, this._propertyName.LastIndexOf('.'));
Type memberTypeForGetter = ObjectProbe.GetMemberTypeForGetter(parameterClass, memberName);
this._getAccessor = scope.DataExchangeFactory.AccessorFactory.GetAccessorFactory.CreateGetAccessor(memberTypeForGetter, name);
}
}
scope.ErrorContext.MoreInfo = "Check the parameter mapping typeHandler attribute '" + this.CallBackName + "' (must be a ITypeHandlerCallback implementation).";
if (this.CallBackName.Length > 0)
{
try
{
ITypeHandlerCallback callback = (ITypeHandlerCallback)Activator.CreateInstance(scope.DataExchangeFactory.TypeHandlerFactory.GetType(this.CallBackName));
this._typeHandler = new CustomTypeHandler(callback);
return;
}
catch (Exception exception)
{
throw new ConfigurationException("Error occurred during custom type handler configuration. Cause: " + exception.Message, exception);
}
}
if (this.CLRType.Length == 0)
{
if ((this._getAccessor != null) && scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(this._getAccessor.MemberType))
{
this._typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(this._getAccessor.MemberType, this._dbType);
}
else
{
this._typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler();
}
}
else
{
Type type = TypeUtils.ResolveType(this.CLRType);
if (scope.DataExchangeFactory.TypeHandlerFactory.IsSimpleType(type))
{
this._typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, this._dbType);
}
else
{
type = ObjectProbe.GetMemberTypeForGetter(type, this.PropertyName);
this._typeHandler = scope.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, this._dbType);
}
}
}
public override object GetData(ParameterProperty mapping, object parameterObject)
{
if (mapping.IsComplexMemberName)
{
return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, base.DataExchangeFactory.AccessorFactory));
}
return(parameterObject);
}
public override object GetData(ParameterProperty mapping, object parameterObject)
{
if (!mapping.IsComplexMemberName && (this._parameterClass == parameterObject.GetType()))
{
return(mapping.GetAccessor.Get(parameterObject));
}
return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, base.DataExchangeFactory.AccessorFactory));
}
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
if (parameterObject == null)
{
return(false);
}
return(ObjectProbe.HasReadableProperty(parameterObject, ((BaseTag)tag).Property));
}
public object Get(RequestScope request, IResultMap resultMap, ResultProperty mapping, ref object target, IDataReader reader)
{
IList list = null;
object obj2 = ObjectProbe.GetMemberValue(target, mapping.PropertyName, request.DataExchangeFactory.AccessorFactory);
if (obj2 == null)
{
obj2 = mapping.ListFactory.CreateInstance(null);
mapping.SetAccessor.Set(target, obj2);
}
list = (IList)obj2;
object sKIP = null;
IResultMap map = mapping.NestedResultMap.ResolveSubMap(reader);
if (map.GroupByProperties.Count > 0)
{
string key = base.GetUniqueKey(map, request, reader);
IDictionary uniqueKeys = request.GetUniqueKeys(map);
if ((uniqueKeys != null) && uniqueKeys.Contains(key))
{
sKIP = uniqueKeys[key];
if (sKIP != null)
{
for (int i = 0; i < map.Properties.Count; i++)
{
ResultProperty property = map.Properties[i];
if (property.PropertyStrategy is GroupByStrategy)
{
property.PropertyStrategy.Set(request, map, property, ref sKIP, reader, null);
}
}
}
sKIP = BaseStrategy.SKIP;
}
else if (((key == null) || (uniqueKeys == null)) || !uniqueKeys.Contains(key))
{
sKIP = _resultMapStrategy.Get(request, resultMap, mapping, ref target, reader);
if (uniqueKeys == null)
{
uniqueKeys = new Hashtable();
request.SetUniqueKeys(map, uniqueKeys);
}
uniqueKeys[key] = sKIP;
}
}
else
{
sKIP = _resultMapStrategy.Get(request, resultMap, mapping, ref target, reader);
}
if ((sKIP != null) && (sKIP != BaseStrategy.SKIP))
{
list.Add(sKIP);
}
return(sKIP);
}
internal IDictionary RunQueryForMap(RequestScope request, ISqlMapSession session, object parameterObject, string keyProperty, string valueProperty, DictionaryRowDelegate rowDelegate)
{
IDictionary dictionary = new Hashtable();
using (IDbCommand command = request.IDbCommand)
{
IDataReader reader = command.ExecuteReader();
try
{
object obj5;
if (rowDelegate != null)
{
goto Label_00C4;
}
while (reader.Read())
{
object obj2 = this._resultStrategy.Process(request, ref reader, null);
object obj3 = ObjectProbe.GetMemberValue(obj2, keyProperty, request.DataExchangeFactory.AccessorFactory);
object obj4 = obj2;
if (valueProperty != null)
{
obj4 = ObjectProbe.GetMemberValue(obj2, valueProperty, request.DataExchangeFactory.AccessorFactory);
}
dictionary.Add(obj3, obj4);
}
goto Label_00E0;
Label_0072:
obj5 = this._resultStrategy.Process(request, ref reader, null);
object key = ObjectProbe.GetMemberValue(obj5, keyProperty, request.DataExchangeFactory.AccessorFactory);
object obj7 = obj5;
if (valueProperty != null)
{
obj7 = ObjectProbe.GetMemberValue(obj5, valueProperty, request.DataExchangeFactory.AccessorFactory);
}
rowDelegate(key, obj7, parameterObject, dictionary);
Label_00C4:
if (reader.Read())
{
goto Label_0072;
}
}
catch
{
throw;
}
finally
{
reader.Close();
reader.Dispose();
}
Label_00E0:
this.ExecutePostSelect(request);
}
return(dictionary);
}
private void CreateParametersForTextCommand()
{
string str = string.Empty;
string parameterDbTypeProperty = this._session.DataSource.DbProvider.ParameterDbTypeProperty;
Type parameterDbType = this._session.DataSource.DbProvider.ParameterDbType;
ParameterPropertyCollection properties = null;
if (this._session.DataSource.DbProvider.UsePositionalParameters)
{
properties = this._request.ParameterMap.Properties;
}
else
{
properties = this._request.ParameterMap.PropertiesList;
}
this._preparedStatement.DbParameters = new IDbDataParameter[properties.Count];
for (int i = 0; i < properties.Count; i++)
{
ParameterProperty key = properties[i];
if (this._session.DataSource.DbProvider.UseParameterPrefixInParameter)
{
str = this._parameterPrefix + "param" + i;
}
else
{
str = "param" + i;
}
IDbDataParameter parameter = this._session.CreateDataParameter();
if ((key.DbType != null) && (key.DbType.Length > 0))
{
object memberValue = Enum.Parse(parameterDbType, key.DbType, true);
ObjectProbe.SetMemberValue(parameter, parameterDbTypeProperty, memberValue, this._request.DataExchangeFactory.ObjectFactory, this._request.DataExchangeFactory.AccessorFactory);
}
if (this._session.DataSource.DbProvider.SetDbParameterSize && (key.Size != -1))
{
parameter.Size = key.Size;
}
if (this._session.DataSource.DbProvider.SetDbParameterPrecision)
{
parameter.Precision = key.Precision;
}
if (this._session.DataSource.DbProvider.SetDbParameterScale)
{
parameter.Scale = key.Scale;
}
parameter.Direction = key.Direction;
parameter.ParameterName = str;
this._preparedStatement.DbParametersName.Add(key.PropertyName);
this._preparedStatement.DbParameters[i] = parameter;
if (!this._session.DataSource.DbProvider.UsePositionalParameters)
{
this._propertyDbParameterMap.Add(key, parameter);
}
}
}
private void RetrieveOutputParameters(RequestScope request, ISqlMapSession session, IDbCommand command, object result)
{
if (request.ParameterMap != null)
{
int count = request.ParameterMap.PropertiesList.Count;
for (int i = 0; i < count; i++)
{
ParameterProperty mapping = request.ParameterMap.GetProperty(i);
if ((mapping.Direction == ParameterDirection.Output) || (mapping.Direction == ParameterDirection.InputOutput))
{
string columnName = string.Empty;
if (!session.DataSource.DbProvider.UseParameterPrefixInParameter)
{
columnName = mapping.ColumnName;
}
else
{
columnName = session.DataSource.DbProvider.ParameterPrefix + mapping.ColumnName;
}
if (mapping.TypeHandler == null)
{
lock (mapping)
{
if (mapping.TypeHandler == null)
{
Type memberTypeForGetter = ObjectProbe.GetMemberTypeForGetter(result, mapping.PropertyName);
mapping.TypeHandler = request.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(memberTypeForGetter);
}
}
}
IDataParameter parameter = (IDataParameter)command.Parameters[columnName];
object obj2 = parameter.Value;
object dataBaseValue = null;
if (obj2 == DBNull.Value)
{
if (mapping.HasNullValue)
{
dataBaseValue = mapping.TypeHandler.ValueOf(mapping.GetAccessor.MemberType, mapping.NullValue);
}
else
{
dataBaseValue = mapping.TypeHandler.NullValue;
}
}
else
{
dataBaseValue = mapping.TypeHandler.GetDataBaseValue(parameter.Value, result.GetType());
}
request.IsRowDataFound = request.IsRowDataFound || (dataBaseValue != null);
request.ParameterMap.SetOutputParameter(ref result, mapping, dataBaseValue);
}
}
}
}
public override void SetData(ref object target, ParameterProperty mapping, object dataBaseValue)
{
if (mapping.IsComplexMemberName)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue, base.DataExchangeFactory.ObjectFactory, base.DataExchangeFactory.AccessorFactory);
}
else
{
base.DataExchangeFactory.AccessorFactory.SetAccessorFactory.CreateSetAccessor(this._parameterClass, mapping.PropertyName).Set(target, dataBaseValue);
}
}
private string ProcessDynamicElements(object parameterObject)
{
StringTokenizer tokenizer = new StringTokenizer(this._simpleSqlStatement, "$", true);
StringBuilder builder = new StringBuilder();
string current = null;
string str2 = null;
IEnumerator enumerator = tokenizer.GetEnumerator();
while (enumerator.MoveNext())
{
current = (string)enumerator.Current;
if ("$".Equals(str2))
{
if ("$".Equals(current))
{
builder.Append("$");
current = null;
}
else
{
object obj2 = null;
if (parameterObject != null)
{
if (this._dataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterObject.GetType()))
{
obj2 = parameterObject;
}
else
{
obj2 = ObjectProbe.GetMemberValue(parameterObject, current, this._dataExchangeFactory.AccessorFactory);
}
}
if (obj2 != null)
{
builder.Append(obj2.ToString());
}
enumerator.MoveNext();
current = (string)enumerator.Current;
if (!"$".Equals(current))
{
throw new DataMapperException("Unterminated dynamic element in sql (" + this._simpleSqlStatement + ").");
}
current = null;
}
}
else if (!"$".Equals(current))
{
builder.Append(current);
}
str2 = current;
}
return(builder.ToString());
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
/// <param name="sqlTag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
protected long Compare(SqlTagContext ctx, SqlTag sqlTag, object parameterObject)
{
var tag = (Conditional)sqlTag;
string propertyName = tag.Property;
string literal = tag.Literal;
string comparePropertyName = tag.CompareProperty;
string compareValue = tag.CompareValue;
object value1 = null;
Type type = null;
if (propertyName != null && propertyName.Length > 0)
{
// check to see if we are a list
//if (fpropertyName.StartsWith("["))
//{
//}
value1 = ObjectProbe.GetMemberValue(parameterObject, propertyName, AccessorFactory);
type = value1.GetType();
}
else if (!String.IsNullOrEmpty(literal))
{
value1 = literal;
type = value1.GetType();
}
else
{
value1 = parameterObject;
if (value1 != null)
{
type = parameterObject.GetType();
}
else
{
type = typeof(object);
}
}
if (comparePropertyName != null && comparePropertyName.Length > 0)
{
object value2 = ObjectProbe.GetMemberValue(parameterObject, comparePropertyName, AccessorFactory);
return(CompareValues(type, value1, value2));
}
else if (!String.IsNullOrEmpty(compareValue))
{
return(CompareValues(type, value1, compareValue));
}
else
{
throw new DataMapperException("Error comparing in conditional fragment. Uknown 'compare to' values.");
}
}
/// <summary>
/// Gets the data to be set into a IDataParameter.
/// </summary>
/// <param name="mapping"></param>
/// <param name="parameterObject"></param>
public override object GetData(ParameterProperty mapping, object parameterObject)
{
if (parameterObject != null)
{
if (DataExchangeFactory.TypeHandlerFactory.IsSimpleType(parameterObject.GetType()))
{
return(parameterObject);
}
return(ObjectProbe.GetMemberValue(parameterObject, mapping.PropertyName, DataExchangeFactory.AccessorFactory));
}
return(null);
}
public ITypeHandler ResolveTypeHandler(Type clazz, string memberName, string clrType, string dbType, bool forSetter)
{
ITypeHandler typeHandler = null;
if (clazz == null)
{
return(this.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler());
}
if (typeof(IDictionary).IsAssignableFrom(clazz))
{
if ((clrType == null) || (clrType.Length == 0))
{
return(this.DataExchangeFactory.TypeHandlerFactory.GetUnkownTypeHandler());
}
try
{
Type type = TypeUtils.ResolveType(clrType);
return(this.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type, dbType));
}
catch (Exception exception)
{
throw new ConfigurationErrorsException("Error. Could not set TypeHandler. Cause: " + exception.Message, exception);
}
}
if (this.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(clazz, dbType) != null)
{
return(this.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(clazz, dbType));
}
if ((clrType == null) || (clrType.Length == 0))
{
Type memberTypeForSetter = null;
if (forSetter)
{
memberTypeForSetter = ObjectProbe.GetMemberTypeForSetter(clazz, memberName);
}
else
{
memberTypeForSetter = ObjectProbe.GetMemberTypeForGetter(clazz, memberName);
}
return(this.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(memberTypeForSetter, dbType));
}
try
{
Type type3 = TypeUtils.ResolveType(clrType);
typeHandler = this.DataExchangeFactory.TypeHandlerFactory.GetTypeHandler(type3, dbType);
}
catch (Exception exception2)
{
throw new ConfigurationErrorsException("Error. Could not set TypeHandler. Cause: " + exception2.Message, exception2);
}
return(typeHandler);
}
/// <summary>
/// </summary>
/// <param name="ctx"></param>
/// <param name="tag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
/// <remarks>
/// Updated By: Richard Beacroft
/// Updated Date: 11\10\2013
/// Description: Builds full property name and checks to see if the property is readable.
/// Not sure why it doesn't also cater for class Fields?
/// </remarks>
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
if (parameterObject == null)
{
return(false);
}
var baseTag = (BaseTag)tag;
// build property full name from property name - specifically handles references to current iterate item, i.e. "[]."
var propertyFullName = ctx.ReplaceIterateCurrentProperty(baseTag);
return(ObjectProbe.HasReadableProperty(parameterObject, propertyFullName));
}
internal override void Initialize(ConfigurationScope configurationScope)
{
if (this.PropertyName.Length > 0)
{
IMappedStatement mappedStatement = configurationScope.SqlMapper.GetMappedStatement(base.Id);
Type parameterClass = mappedStatement.Statement.ParameterClass;
if ((parameterClass != null) && !ObjectProbe.IsSimpleType(parameterClass))
{
configurationScope.ErrorContext.MoreInfo = string.Format("Looking for settable property named '{0}' on type '{1}' for selectKey node of statement id '{2}'.", this.PropertyName, mappedStatement.Statement.ParameterClass.Name, base.Id);
ReflectionInfo.GetInstance(mappedStatement.Statement.ParameterClass).GetSetter(this.PropertyName);
}
}
base.Initialize(configurationScope);
}
public virtual object ExecuteInsert(ISqlMapSession session, object parameterObject)
{
object memberValue = null;
SelectKey selectKey = null;
RequestScope request = this._statement.Sql.GetRequestScope(this, parameterObject, session);
if (this._statement is Insert)
{
selectKey = ((Insert)this._statement).SelectKey;
}
if ((selectKey != null) && !selectKey.isAfter)
{
memberValue = this._sqlMap.GetMappedStatement(selectKey.Id).ExecuteQueryForObject(session, parameterObject);
ObjectProbe.SetMemberValue(parameterObject, selectKey.PropertyName, memberValue, request.DataExchangeFactory.ObjectFactory, request.DataExchangeFactory.AccessorFactory);
}
this._preparedCommand.Create(request, session, this.Statement, parameterObject);
using (IDbCommand command = request.IDbCommand)
{
if (this._statement is Insert)
{
command.ExecuteNonQuery();
}
else if (((this._statement is Procedure) && (this._statement.ResultClass != null)) && this._sqlMap.TypeHandlerFactory.IsSimpleType(this._statement.ResultClass))
{
IDataParameter parameter = command.CreateParameter();
parameter.Direction = ParameterDirection.ReturnValue;
command.Parameters.Add(parameter);
command.ExecuteNonQuery();
memberValue = parameter.Value;
memberValue = this._sqlMap.TypeHandlerFactory.GetTypeHandler(this._statement.ResultClass).GetDataBaseValue(memberValue, this._statement.ResultClass);
}
else
{
memberValue = command.ExecuteScalar();
if ((this._statement.ResultClass != null) && this._sqlMap.TypeHandlerFactory.IsSimpleType(this._statement.ResultClass))
{
memberValue = this._sqlMap.TypeHandlerFactory.GetTypeHandler(this._statement.ResultClass).GetDataBaseValue(memberValue, this._statement.ResultClass);
}
}
if ((selectKey != null) && selectKey.isAfter)
{
memberValue = this._sqlMap.GetMappedStatement(selectKey.Id).ExecuteQueryForObject(session, parameterObject);
ObjectProbe.SetMemberValue(parameterObject, selectKey.PropertyName, memberValue, request.DataExchangeFactory.ObjectFactory, request.DataExchangeFactory.AccessorFactory);
}
this.RetrieveOutputParameters(request, session, command, parameterObject);
}
this.RaiseExecuteEvent();
return(memberValue);
}
protected object GetBindValue(SqlTagContext ctx, string bindName, object parameterObject)
{
var bindingExpression = ctx.GetBindExpression(bindName);
if (bindingExpression == null)
{
return(null);
}
if (String.IsNullOrEmpty(bindingExpression.FullPropertyName))
{
return(bindingExpression.Value);
}
return(ObjectProbe.GetMemberValue(parameterObject, bindingExpression.FullPropertyName, AccessorFactory));
}
public override void SetData(ref object target, ResultProperty mapping, object dataBaseValue)
{
Type c = target.GetType();
if (((c != this._parameterClass) && !c.IsSubclassOf(this._parameterClass)) && !this._parameterClass.IsAssignableFrom(c))
{
throw new ArgumentException(string.Concat(new object[] { "Could not set value in class '", target.GetType(), "' for property '", mapping.PropertyName, "' of type '", mapping.MemberType, "'" }));
}
if (mapping.IsComplexMemberName)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue, base.DataExchangeFactory.ObjectFactory, base.DataExchangeFactory.AccessorFactory);
}
else
{
mapping.SetAccessor.Set(target, dataBaseValue);
}
}
public object GetMemberValue(SqlTagContext ctx, BaseTag tag, string propertyName, object parameterObject)
{
var iteratorContext = FindParentIteratorContext(ctx, tag);
if (iteratorContext != null)
{
var indexOfIndexer = propertyName.IndexOf(ReflectionMapper.THIS_ENUMERATOR_PLACEHOLDER);
if (indexOfIndexer == 0)
{
parameterObject = iteratorContext.Current;
propertyName = propertyName.Substring(indexOfIndexer + ReflectionMapper.THIS_ENUMERATOR_PLACEHOLDER.Length);
}
}
return(ObjectProbe.GetMemberValue(parameterObject, propertyName, _accessorFactory));
}
/// <summary>
///
/// </summary>
/// <param name="ctx"></param>
/// <param name="tag"></param>
/// <param name="parameterObject"></param>
/// <returns></returns>
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
if (parameterObject == null)
{
return(true);
}
string propertyName = ((BaseTag)tag).Property;
object value;
if (!string.IsNullOrEmpty(propertyName))
{
value = ObjectProbe.GetMemberValue(parameterObject, propertyName, AccessorFactory);
}
else
{
value = parameterObject;
}
return(value == null);
}
/// <summary>
/// Sets the value to the result property.
/// </summary>
/// <param name="mapping"></param>
/// <param name="target"></param>
/// <param name="dataBaseValue"></param>
public override void SetData(ref object target, ResultProperty mapping, object dataBaseValue)
{
Type targetType = target.GetType();
if ((targetType != _parameterClass) &&
!targetType.IsSubclassOf(_parameterClass))
{
throw new ArgumentException("Could not set value of type '" + target.GetType() + "' in property '" + mapping.PropertyName + "' of type '" + _parameterClass + "'");
}
if (mapping.IsComplexMemberName)
{
ObjectProbe.SetMemberValue(target, mapping.PropertyName, dataBaseValue,
this.DataExchangeFactory.ObjectFactory,
this.DataExchangeFactory.AccessorFactory);
}
else
{
mapping.SetAccessor.Set(target, dataBaseValue);
}
}
public override bool IsCondition(SqlTagContext ctx, SqlTag tag, object parameterObject)
{
object obj2;
if (parameterObject == null)
{
return(true);
}
string property = ((BaseTag)tag).Property;
if ((property != null) && (property.Length > 0))
{
obj2 = ObjectProbe.GetMemberValue(parameterObject, property, base.AccessorFactory);
}
else
{
obj2 = parameterObject;
}
return(obj2 == null);
}
