public void CopyToTest()
{
TestDetachedQuery origin = new TestDetachedQuery();
origin.SetMaxResults(10).SetFirstResult(5).SetCacheable(true).SetReadOnly(true).SetTimeout(444).SetFlushMode
(FlushMode.Auto).SetCacheRegion("A_REGION").SetResultTransformer(new AliasToBeanResultTransformer(typeof(NoFoo)));
origin.SetComment(MyComment);
origin.SetLockMode("LM1", LockMode.Upgrade);
origin.SetProperties(new Foo("Pallino", "Pinco"));
origin.SetInt64(1, 1);
origin.SetBinary(2, Array.Empty <byte>());
origin.SetBoolean(3, false);
origin.SetDateTime(6, DateTime.MaxValue);
origin.SetCharacter("5", 'A');
origin.SetDateTime("6", DateTime.MaxValue);
origin.SetDecimal("7", 10.15m);
origin.SetParameterList("UntypedList", new int[] { 1, 2, 3 });
origin.SetParameterList("TypedList", new Int64[] { 1, 2, 3 }, NHibernateUtil.Int64);
TestDetachedQuery tdq = new TestDetachedQuery();
tdq.SetLockMode("LM1", LockMode.Read);
tdq.SetLockMode("LM2", LockMode.Write);
tdq.SetProperties(new Foo("Fulano", "De Tal"));
tdq.SetAnsiString(1, ""); //will be override
tdq.SetByte(4, 255);
tdq.SetCharacter(5, 'A');
tdq.SetDateTime(6, DateTime.MinValue); // will be override
tdq.SetDateTime("6", DateTime.MinValue); // will be override
tdq.SetDouble("8", 8.1f);
tdq.SetEntity("9", new Foo("Fulano", "De Tal"));
tdq.SetParameterList("UntypedList", new int[] { 5, 6, 7, 8 }); // will be override
tdq.SetParameterList("TypedList", new Int64[] { 5, 6, 7, 8 }, NHibernateUtil.Int64); // will be override
tdq.SetComment("other comment"); // will be override
origin.CopyTo(tdq);
Assert.AreEqual(5, tdq.Selection.FirstRow);
Assert.AreEqual(444, tdq.Selection.Timeout);
Assert.IsTrue(tdq.Cacheable);
Assert.IsTrue(tdq.ReadOnly);
Assert.AreEqual(FlushMode.Auto, tdq.FlushMode);
Assert.AreEqual("A_REGION", tdq.CacheRegion);
Assert.IsNotNull(tdq.ResultTransformer);
Assert.That(tdq.Comment, Is.EqualTo(MyComment));
// merge/override of LockModes
Assert.AreEqual(2, tdq.LockModes.Count);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM1"));
Assert.AreEqual(LockMode.Upgrade, tdq.LockModes["LM1"]);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM2"));
Assert.AreEqual(LockMode.Write, tdq.LockModes["LM2"]);
// merge of OptionalUntypeParams (eventually override by IQuery)
Assert.AreEqual(2, tdq.OptionalUntypeParams.Count);
Assert.IsTrue(tdq.OptionalUntypeParams[0].Equals(new Foo("Fulano", "De Tal")));
Assert.IsTrue(tdq.OptionalUntypeParams[1].Equals(new Foo("Pallino", "Pinco")));
// merge/override positional parameters
Assert.IsTrue(tdq.PosParams[1].Type.Equals(NHibernateUtil.Int64));
Assert.IsTrue(tdq.PosParams[2].Type.Equals(NHibernateUtil.Binary));
Assert.IsTrue(tdq.PosParams[3].Type.Equals(NHibernateUtil.Boolean));
Assert.IsTrue(tdq.PosParams[4].Type.Equals(NHibernateUtil.Byte));
Assert.IsTrue(tdq.PosParams[5].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.PosParams[6].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.PosParams[6].Value.Equals(DateTime.MaxValue));
// merge/override named parameters
Assert.IsTrue(tdq.NamedParams["5"].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.NamedParams["6"].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.NamedParams["6"].Value.Equals(DateTime.MaxValue));
Assert.IsTrue(tdq.NamedParams["7"].Type.Equals(NHibernateUtil.Decimal));
Assert.IsTrue(tdq.NamedParams["8"].Type.Equals(NHibernateUtil.Double));
Assert.IsTrue(tdq.NamedParams["9"].Type.Equals(NHibernateUtil.Entity(typeof(Foo))));
// merge/override named parameters list
int expected = 1;
foreach (int i in tdq.NamedUntypeListParams["UntypedList"])
{
Assert.AreEqual(expected, i);
expected++;
}
// merge/override named params lists
long lexpected = 1;
foreach (long i in (tdq.NamedListParams["TypedList"].Value as IEnumerable))
{
Assert.AreEqual(lexpected, i);
lexpected++;
}
}
/// <summary>
/// Uses heuristics to deduce a NHibernate type given a string naming the type.
/// </summary>
/// <param name="typeName">the type name</param>
/// <param name="parameters">parameters for the type</param>
/// <param name="length">optionally, the size of the type</param>
/// <returns></returns>
public static IType HeuristicType(string typeName, IDictionary <string, string> parameters, int?length)
{
IType type = Basic(typeName);
if (type == null)
{
string[] parsedTypeName;
TypeClassification typeClassification = GetTypeClassification(typeName);
if (typeClassification == TypeClassification.Length)
{
parsedTypeName = typeName.Split(LengthSplit);
}
else
{
parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName }
};
System.Type typeClass;
try
{
typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
}
catch (Exception)
{
typeClass = null;
}
if (typeClass != null)
{
if (typeof(IType).IsAssignableFrom(typeClass))
{
try
{
type = (IType)Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(typeClass);
}
catch (Exception e)
{
throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
}
InjectParameters(type, parameters);
}
else if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
{
type = new CompositeCustomType(typeClass, parameters);
}
else if (typeof(IUserType).IsAssignableFrom(typeClass))
{
type = new CustomType(typeClass, parameters);
}
else if (typeof(ILifecycle).IsAssignableFrom(typeClass))
{
type = NHibernateUtil.Entity(typeClass);
}
else if (typeClass.IsEnum)
{
try
{
type = (IType)Activator.CreateInstance(typeof(EnumType <>).MakeGenericType(typeClass));
}
catch (Exception e)
{
throw new MappingException("Can't instantiate enum " + typeClass.FullName + "; The enum can't be empty", e);
}
}
else if (IsNullableEnum(typeClass))
{
try
{
type = (IType)Activator.CreateInstance(typeof(EnumType <>).MakeGenericType(typeClass.GetGenericArguments()[0]));
}
catch (Exception e)
{
throw new MappingException("Can't instantiate enum " + typeClass.FullName + "; The enum can't be empty", e);
}
}
else if (typeClass.IsSerializable)
{
if (typeClassification == TypeClassification.Length)
{
type = GetSerializableType(typeClass, Int32.Parse(parsedTypeName[1]));
}
else if (length != null)
{
type = GetSerializableType(typeClass, length.Value);
}
else
{
type = GetSerializableType(typeClass);
}
}
}
}
return(type);
}
/// <summary>
/// Uses heuristics to deduce a NHibernate type given a string naming the type.
/// </summary>
/// <param name="typeName">the type name</param>
/// <param name="parameters">parameters for the type</param>
/// <param name="length">optionally, the size of the type</param>
/// <returns></returns>
public static IType HeuristicType(string typeName, IDictionary <string, string> parameters, int?length)
{
IType type = Basic(typeName);
if (type != null)
{
return(type);
}
string[] parsedTypeName;
TypeClassification typeClassification = GetTypeClassification(typeName);
if (typeClassification == TypeClassification.LengthOrScale)
{
parsedTypeName = typeName.Split(LengthSplit);
}
else
{
parsedTypeName = typeClassification == TypeClassification.PrecisionScale ? typeName.Split(PrecisionScaleSplit) : new[] { typeName }
};
System.Type typeClass;
try
{
typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
}
catch (Exception)
{
typeClass = null;
}
if (typeClass == null)
{
return(null);
}
if (typeof(IType).IsAssignableFrom(typeClass))
{
try
{
type = (IType)Cfg.Environment.BytecodeProvider.ObjectsFactory.CreateInstance(typeClass);
}
catch (Exception e)
{
throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
}
InjectParameters(type, parameters);
var obsolete = typeClass.GetCustomAttribute <ObsoleteAttribute>(false);
if (obsolete != null)
{
_log.Warn("{0} is obsolete. {1}", typeName, obsolete.Message);
}
return(type);
}
if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
{
return(new CompositeCustomType(typeClass, parameters));
}
if (typeof(IUserType).IsAssignableFrom(typeClass))
{
return(new CustomType(typeClass, parameters));
}
if (typeof(ILifecycle).IsAssignableFrom(typeClass))
{
return(NHibernateUtil.Entity(typeClass));
}
var unwrapped = typeClass.UnwrapIfNullable();
if (unwrapped.IsEnum)
{
return((IType)Activator.CreateInstance(typeof(EnumType <>).MakeGenericType(unwrapped)));
}
if (!typeClass.IsSerializable)
{
return(null);
}
if (typeClassification == TypeClassification.LengthOrScale)
{
return(GetSerializableType(typeClass, Int32.Parse(parsedTypeName[1])));
}
if (length.HasValue)
{
return(GetSerializableType(typeClass, length.Value));
}
return(GetSerializableType(typeClass));
}
/// <summary>
///
/// </summary>
/// <param name="name"></param>
/// <param name="val"></param>
/// <returns></returns>
public IQuery SetEntity(string name, object val)
{
SetParameter(name, val, NHibernateUtil.Entity(NHibernateProxyHelper.GuessClass(val)));
return(this);
}
private static IType GetBySystemType(System.Type typeClass, IDictionary <string, string> parameters, int?length)
{
if (typeof(IType).IsAssignableFrom(typeClass))
{
try
{
var type = (IType)Environment.ObjectsFactory.CreateInstance(typeClass);
InjectParameters(type, parameters);
var obsolete = typeClass.GetCustomAttribute <ObsoleteAttribute>(false);
if (obsolete != null)
{
_log.Warn("{0} ({1}) is obsolete. {2}", typeClass.FullName, type.Name, obsolete.Message);
}
return(type);
}
catch (HibernateException)
{
throw;
}
catch (Exception e)
{
throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
}
}
if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
{
return(new CompositeCustomType(typeClass, parameters));
}
if (typeof(IUserType).IsAssignableFrom(typeClass))
{
return(new CustomType(typeClass, parameters));
}
if (typeof(ILifecycle).IsAssignableFrom(typeClass))
{
return(NHibernateUtil.Entity(typeClass));
}
var unwrapped = typeClass.UnwrapIfNullable();
if (unwrapped.IsEnum)
{
return((IType)Activator.CreateInstance(typeof(EnumType <>).MakeGenericType(unwrapped)));
}
if (!typeClass.IsSerializable)
{
return(null);
}
if (length.HasValue)
{
return(GetSerializableType(typeClass, length.Value));
}
return(GetSerializableType(typeClass));
}
public void PropertiesSet()
{
TestDetachedQuery tdq = new TestDetachedQuery();
tdq.SetMaxResults(10).SetFirstResult(5).SetCacheable(true).SetReadOnly(true).SetTimeout(444).SetFlushMode(
FlushMode.Auto).SetCacheRegion("A_REGION").SetResultTransformer(new AliasToBeanResultTransformer(typeof(NoFoo))).
SetIgnoreUknownNamedParameters(true).SetComment(MyComment);
Assert.AreEqual(10, tdq.Selection.MaxRows);
Assert.AreEqual(5, tdq.Selection.FirstRow);
Assert.AreEqual(444, tdq.Selection.Timeout);
Assert.IsTrue(tdq.Cacheable);
Assert.IsTrue(tdq.ReadOnly);
Assert.AreEqual(FlushMode.Auto, tdq.FlushMode);
Assert.AreEqual("A_REGION", tdq.CacheRegion);
Assert.IsNotNull(tdq.ResultTransformer);
Assert.IsTrue(tdq.ShouldIgnoredUnknownNamedParameters);
Assert.That(tdq.Comment, Is.EqualTo(MyComment));
tdq.SetLockMode("LM1", LockMode.Upgrade);
tdq.SetLockMode("LM2", LockMode.Write);
Assert.AreEqual(2, tdq.LockModes.Count);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM1"));
Assert.AreEqual(LockMode.Upgrade, tdq.LockModes["LM1"]);
Assert.IsTrue(tdq.LockModes.ContainsKey("LM2"));
Assert.AreEqual(LockMode.Write, tdq.LockModes["LM2"]);
tdq.SetProperties(new Foo("Pallino", "Pinco"));
tdq.SetProperties(new Foo("Fulano", "De Tal"));
Assert.AreEqual(2, tdq.OptionalUntypeParams.Count);
Assert.IsTrue(tdq.OptionalUntypeParams[0].Equals(new Foo("Pallino", "Pinco")));
Assert.IsTrue(tdq.OptionalUntypeParams[1].Equals(new Foo("Fulano", "De Tal")));
tdq.SetAnsiString(1, "");
tdq.SetBinary(2, new byte[] { });
tdq.SetBoolean(3, false);
tdq.SetByte(4, 255);
tdq.SetCharacter(5, 'A');
tdq.SetDateTime(6, DateTime.MaxValue);
tdq.SetDecimal(7, 10.15m);
tdq.SetDouble(8, 8.1f);
tdq.SetEntity(9, new Foo("Fulano", "De Tal"));
tdq.SetEnum(10, FlushMode.Auto);
tdq.SetInt16(11, 1);
tdq.SetInt32(12, 1);
tdq.SetInt64(13, 1);
tdq.SetSingle(14, 1.1f);
tdq.SetString(15, "");
tdq.SetTime(16, DateTime.Now);
tdq.SetTimestamp(17, DateTime.Now);
tdq.SetGuid(18, Guid.Empty);
Assert.IsTrue(tdq.PosParams[1].Type.Equals(NHibernateUtil.AnsiString));
Assert.IsTrue(tdq.PosParams[2].Type.Equals(NHibernateUtil.Binary));
Assert.IsTrue(tdq.PosParams[3].Type.Equals(NHibernateUtil.Boolean));
Assert.IsTrue(tdq.PosParams[4].Type.Equals(NHibernateUtil.Byte));
Assert.IsTrue(tdq.PosParams[5].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.PosParams[6].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.PosParams[7].Type.Equals(NHibernateUtil.Decimal));
Assert.IsTrue(tdq.PosParams[8].Type.Equals(NHibernateUtil.Double));
Assert.IsTrue(tdq.PosParams[9].Type.Equals(NHibernateUtil.Entity(typeof(Foo))));
Assert.IsTrue(tdq.PosParams[10].Type.Equals(NHibernateUtil.Enum(typeof(FlushMode))));
Assert.IsTrue(tdq.PosParams[11].Type.Equals(NHibernateUtil.Int16));
Assert.IsTrue(tdq.PosParams[12].Type.Equals(NHibernateUtil.Int32));
Assert.IsTrue(tdq.PosParams[13].Type.Equals(NHibernateUtil.Int64));
Assert.IsTrue(tdq.PosParams[14].Type.Equals(NHibernateUtil.Single));
Assert.IsTrue(tdq.PosParams[15].Type.Equals(NHibernateUtil.String));
Assert.IsTrue(tdq.PosParams[16].Type.Equals(NHibernateUtil.Time));
Assert.IsTrue(tdq.PosParams[17].Type.Equals(NHibernateUtil.Timestamp));
Assert.IsTrue(tdq.PosParams[18].Type.Equals(NHibernateUtil.Guid));
tdq.SetAnsiString("1", "");
tdq.SetBinary("2", new byte[] { });
tdq.SetBoolean("3", false);
tdq.SetByte("4", 255);
tdq.SetCharacter("5", 'A');
tdq.SetDateTime("6", DateTime.MaxValue);
tdq.SetDecimal("7", 10.15m);
tdq.SetDouble("8", 8.1f);
tdq.SetEntity("9", new Foo("Fulano", "De Tal"));
tdq.SetEnum("10", FlushMode.Auto);
tdq.SetInt16("11", 1);
tdq.SetInt32("12", 1);
tdq.SetInt64("13", 1);
tdq.SetSingle("14", 1.1f);
tdq.SetString("15", "");
tdq.SetTime("16", DateTime.Now);
tdq.SetTimestamp("17", DateTime.Now);
tdq.SetGuid("18", Guid.Empty);
Assert.IsTrue(tdq.NamedParams["1"].Type.Equals(NHibernateUtil.AnsiString));
Assert.IsTrue(tdq.NamedParams["2"].Type.Equals(NHibernateUtil.Binary));
Assert.IsTrue(tdq.NamedParams["3"].Type.Equals(NHibernateUtil.Boolean));
Assert.IsTrue(tdq.NamedParams["4"].Type.Equals(NHibernateUtil.Byte));
Assert.IsTrue(tdq.NamedParams["5"].Type.Equals(NHibernateUtil.Character));
Assert.IsTrue(tdq.NamedParams["6"].Type.Equals(NHibernateUtil.DateTime));
Assert.IsTrue(tdq.NamedParams["7"].Type.Equals(NHibernateUtil.Decimal));
Assert.IsTrue(tdq.NamedParams["8"].Type.Equals(NHibernateUtil.Double));
Assert.IsTrue(tdq.NamedParams["9"].Type.Equals(NHibernateUtil.Entity(typeof(Foo))));
Assert.IsTrue(tdq.NamedParams["10"].Type.Equals(NHibernateUtil.Enum(typeof(FlushMode))));
Assert.IsTrue(tdq.NamedParams["11"].Type.Equals(NHibernateUtil.Int16));
Assert.IsTrue(tdq.NamedParams["12"].Type.Equals(NHibernateUtil.Int32));
Assert.IsTrue(tdq.NamedParams["13"].Type.Equals(NHibernateUtil.Int64));
Assert.IsTrue(tdq.NamedParams["14"].Type.Equals(NHibernateUtil.Single));
Assert.IsTrue(tdq.NamedParams["15"].Type.Equals(NHibernateUtil.String));
Assert.IsTrue(tdq.NamedParams["16"].Type.Equals(NHibernateUtil.Time));
Assert.IsTrue(tdq.NamedParams["17"].Type.Equals(NHibernateUtil.Timestamp));
Assert.IsTrue(tdq.NamedParams["18"].Type.Equals(NHibernateUtil.Guid));
tdq.SetParameter(10, 123456m);
Assert.AreEqual(1, tdq.PosUntypeParams.Count);
Assert.IsTrue(tdq.PosUntypeParams.ContainsKey(10));
tdq.SetParameter("Any", 123456m);
Assert.AreEqual(1, tdq.NamedUntypeParams.Count);
Assert.IsTrue(tdq.NamedUntypeParams.ContainsKey("Any"));
tdq.SetParameterList("UntypedList", new int[] { 1, 2, 3 });
Assert.IsTrue(tdq.NamedUntypeListParams.ContainsKey("UntypedList"));
tdq.SetParameterList("TypedList", new Int64[] { 1, 2, 3 }, NHibernateUtil.Int64);
Assert.IsTrue(tdq.NamedListParams.ContainsKey("TypedList"));
Assert.IsNotNull((tdq.NamedListParams["TypedList"].Value as IEnumerable));
}
/// <summary>
///
/// </summary>
/// <param name="position"></param>
/// <param name="val"></param>
/// <returns></returns>
public IQuery SetEntity(int position, object val)
{
SetParameter(position, val, NHibernateUtil.Entity(NHibernateProxyHelper.GuessClass(val)));
return(this);
}
public override string ToLoggableString(object value, ISessionFactoryImplementor factory)
{
return(value == null ? "null" :
NHibernateUtil.Entity(NHibernateProxyHelper.GetClassWithoutInitializingProxy(value)).ToLoggableString(value, factory));
}
public void ToStringWithNoIdentifier()
{
NHibernateUtil.Entity(typeof(Master)).ToLoggableString(new Master(),
(ISessionFactoryImplementor)Sfi);
}
/// <summary>
/// Uses heuristics to deduce a NHibernate type given a string naming the
/// type.
/// </summary>
/// <param name="typeName"></param>
/// <returns>An instance of <c>NHibernate.Type.IType</c></returns>
/// <remarks>
/// When looking for the NHibernate type it will look in the cache of the Basic types first.
/// If it doesn't find it in the cache then it uses the typeName to get a reference to the
/// Class (Type in .NET). Once we get the reference to the .NET class we check to see if it
/// implements IType, ICompositeUserType, IUserType, ILifecycle (Association), or
/// IPersistentEnum. If none of those are implemented then we will serialize the Type to the
/// database using NHibernate.Type.SerializableType(typeName)
/// </remarks>
public static IType HeuristicType(string typeName)
{
IType type = TypeFactory.Basic(typeName);
if (type == null)
{
string[] parsedTypeName;
TypeClassification typeClassification = GetTypeClassification(typeName);
if (typeClassification == TypeClassification.Length)
{
parsedTypeName = typeName.Split(lengthSplit);
}
else if (typeClassification == TypeClassification.PrecisionScale)
{
parsedTypeName = typeName.Split(precisionScaleSplit);
}
else
{
parsedTypeName = new string[] { typeName };
}
System.Type typeClass;
try
{
typeClass = ReflectHelper.ClassForName(parsedTypeName[0]); //typeName);
}
catch (Exception)
{
typeClass = null;
}
if (typeClass != null)
{
if (typeof(IType).IsAssignableFrom(typeClass))
{
try
{
type = ( IType )Activator.CreateInstance(typeClass);
}
catch (Exception e)
{
throw new MappingException("Could not instantiate IType " + typeClass.Name + ": " + e, e);
}
}
else if (typeof(ICompositeUserType).IsAssignableFrom(typeClass))
{
type = new CompositeCustomType(typeClass);
}
else if (typeof(IUserType).IsAssignableFrom(typeClass))
{
type = new CustomType(typeClass);
}
else if (typeof(ILifecycle).IsAssignableFrom(typeClass))
{
type = NHibernateUtil.Entity(typeClass);
}
else if (typeClass.IsEnum)
{
type = NHibernateUtil.Enum(typeClass);
}
else if (typeClass.IsSerializable)
{
if (typeClassification == TypeClassification.Length)
{
type = GetSerializableType(typeClass, Int32.Parse(parsedTypeName[1]));
}
else
{
type = GetSerializableType(typeClass);
}
}
}
}
return(type);
}
public static string EntityName(Type type)
{
return(NHibernateUtil.Entity(type).Name);
}
private string GetEntityName(IQuerySource querySource)
{
return(NHibernateUtil.Entity(querySource.ItemType).Name);
}