private void Load()
{
IClassMetadata classMetadata = m_sessionFactory.GetClassMetadata(m_persistentClass);
if (classMetadata == null)
{
return;
}
Configuration conf = NHibernateHelper.GetSessionFactoryManager().GetConfigurationBySessionFactory(m_sessionFactory);
var persistentClass = conf.GetClassMapping(m_persistentClass);
m_idProperty = persistentClass.GetProperty(classMetadata.IdentifierPropertyName);
this.TableName = persistentClass.Table.Name;
for (int i = 0; i < classMetadata.PropertyNames.Length; ++i)
{
string s = classMetadata.PropertyNames[i];
NHibernate.Mapping.Property property = persistentClass.GetProperty(s);
try
{
var it = property.ColumnIterator.GetEnumerator();
it.MoveNext();
if (it.Current != null && it.Current is NHibernate.Mapping.Column)
{
int length = ((NHibernate.Mapping.Column)it.Current).Length;
bool nullability = classMetadata.PropertyNullability[i];
m_properties[s] = new EntityPropertyMetadata {
Name = s, Length = length, NotNull = !nullability
};
}
}
catch (System.InvalidOperationException)
{
}
}
//if (Attribute.IsDefined(m_persistentClass, typeof(NHibernate.Mapping.Attributes.ClassAttribute)))
//{
// Attribute[] attrs = Attribute.GetCustomAttributes(m_persistentClass, typeof(NHibernate.Mapping.Attributes.ClassAttribute));
// if (attrs.Length > 0)
// {
// ClassAttribute attr = attrs[0] as ClassAttribute;
// m_tableName = attr.Table;
// }
//}
//m_propertyAttributes.Clear();
//PropertyInfo[] pInfos = m_persistentClass.GetProperties();
//foreach (PropertyInfo pInfo in pInfos)
//{
// if (Attribute.IsDefined(pInfo, typeof(NHibernate.Mapping.Attributes.PropertyAttribute)))
// {
// Attribute[] attrs = Attribute.GetCustomAttributes(pInfo, typeof(NHibernate.Mapping.Attributes.PropertyAttribute));
// foreach(var i in attrs)
// {
// PropertyAttribute attr = i as PropertyAttribute;
// m_propertyAttributes.Add(attr.Name == null ? pInfo.Name : attr.Name, attr);
// }
// }
// else if (Attribute.IsDefined(pInfo, typeof(NHibernate.Mapping.Attributes.IdAttribute)))
// {
// Attribute[] attrs = Attribute.GetCustomAttributes(pInfo, typeof(NHibernate.Mapping.Attributes.IdAttribute));
// if (attrs.Length > 0)
// {
// m_idAttribute = attrs[0] as IdAttribute;
// }
// }
//}
}
///// <summary>
///// 根据属性查找实体
///// </summary>
///// <typeparam name="T"></typeparam>
///// <param name="property"></param>
///// <param name="value"></param>
///// <returns></returns>
//public T GetByProperty<T>(string property, object value)
//{
// using (var tx = this.BeginTransaction())
// {
// StringBuilder hql = new StringBuilder();
// hql.Append(string.Format("FROM {0} a ", typeof(T).FullName));
// hql.Append(string.Format("WHERE a.{0} = ?", property));
// object obj = this.Session.CreateQuery(hql.ToString())
// .SetParameter(0, value)
// .UniqueResult();
// this.CommitTransaction();
// return (T)obj;
// }
//}
/// <summary>
///
/// </summary>
/// <param name="proxy"></param>
/// <returns></returns>
public bool IsProxy(object proxy)
{
return(NHibernateHelper.IsProxy(proxy));
}
/// <summary>
///
/// </summary>
/// <param name="proxy"></param>
/// <param name="owner"></param>
public void Initialize(object proxy, object owner)
{
NHibernateHelper.Initialize(proxy, owner, this.Session);
}
private string GetQueryWhere(ISearchExpression se, NHibernate.ISessionFactory sessionFactory, Dictionary <string, object> paramNames)
{
SimpleExpression cse = se as SimpleExpression;
if (cse == null)
{
LogicalExpression le = se as LogicalExpression;
string left = GetQueryWhere(le.LeftHandSide, sessionFactory, paramNames);
string right = GetQueryWhere(le.RightHandSide, sessionFactory, paramNames);
switch (le.LogicOperator)
{
case LogicalOperator.And:
return("(" + left + " and " + right + ")");
case LogicalOperator.Or:
return("(" + left + " or " + right + ")");
case LogicalOperator.Not:
return("(not " + left + ")");
default:
System.Diagnostics.Debug.Assert(false, "Not supported LogicOperator");
return(null);
}
}
else
{
// Change Type
if (!string.IsNullOrEmpty(cse.FullPropertyName))
{
// Convert Data to dest type
bool hasC;
Type destType = NHibernateHelper.GetPropertyType(sessionFactory, typeof(T), cse.FullPropertyName, out hasC);
//hasCollection |= hasC;
IList array = cse.Values as IList;
if (array != null)
{
for (int i = 0; i < array.Count; ++i)
{
if (destType != array[i].GetType())
{
array[i] = ConvertHelper.ChangeType(array[i], destType);
}
}
//paramCnt += array.Count;
}
else
{
if (cse.Values != null)
{
if (destType != cse.Values.GetType())
{
cse.Values = ConvertHelper.ChangeType(cse.Values, destType);
}
}
//paramCnt++;
}
}
string propertyName = cse.FullPropertyName.Replace(":", ".");
string paraName = null;
switch (cse.Operator)
{
case SimpleOperator.Eq:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " = " + ":" + paraName);
case SimpleOperator.NotEq:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " != " + ":" + paraName);
case SimpleOperator.EqProperty:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " = " + ":" + paraName);
case SimpleOperator.Like:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = "%" + cse.Values + "%";
return(propertyName + " like " + ":" + paraName);
case SimpleOperator.InG:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " in " + ":" + paraName);
case SimpleOperator.IsNotNull:
return(propertyName + " is not null ");
case SimpleOperator.IsNull:
return(propertyName + " is null ");
case SimpleOperator.Gt:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " > " + ":" + paraName);
case SimpleOperator.Lt:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " < " + ":" + paraName);
case SimpleOperator.Ge:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " >= " + ":" + paraName);
case SimpleOperator.Le:
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = cse.Values;
return(propertyName + " <= " + ":" + paraName);
case SimpleOperator.GInG:
{
IList data = cse.Values as IList;
// 当用于客户用途查找类型时，只能Like
StringBuilder sb = new StringBuilder();
sb.Append("(");
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = "%" + data[0] + "%";
sb.Append(propertyName + " like " + ":" + paraName);
for (int i = 1; i < data.Count; ++i)
{
sb.Append(" or ");
paraName = CreateParamName(cse, paramNames);
paramNames[paraName] = "%" + data[i] + "%";
sb.Append(propertyName + " like " + ":" + paraName);
}
sb.Append(")");
return(sb.ToString());
}
//case SimpleOperator.Any:
// return NHibernate.Criterion.Expression.EqProperty(propertyName, propertyName);
//case SimpleOperator.Sql:
// return NHibernate.Criterion.Expression.Sql(propertyName);
default:
System.Diagnostics.Debug.Assert(false, "Not supported SimpleOperator");
return(null);
}
}
}
