public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
var sqlBuilder = new SqlStringBuilder();
SqlString[] columnNames = null;
if (_propertyName != "*")
{
columnNames = CriterionUtil.GetColumnNames(_propertyName, _projection, criteriaQuery, criteria, enabledFilters);
if (columnNames.Length != 1)
{
throw new HibernateException("Contains may only be used with single-column properties");
}
} else
{
columnNames = new SqlString[]
{
new SqlString("*")
};
}
sqlBuilder.Add("contains(")
.Add(columnNames[0])
.Add(",");
sqlBuilder.Add(criteriaQuery.NewQueryParameter(GetParameterTypedValue(criteria, criteriaQuery)).Single());
sqlBuilder.Add(")");
return sqlBuilder.ToSqlString();
}
/// <summary>
/// Creates an exact clone of the criteria
/// </summary>
/// <returns></returns>
public static ICriteria Clone(ICriteria criteria)
{
CriteriaImpl root = GetRootCriteria(criteria);
CriteriaImpl clone = new CriteriaImpl(root.CriteriaClass, root.Alias, root.Session);
CloneSubcriteriaAndOrders(clone, root);
foreach (DictionaryEntry de in root.FetchModes)
{
clone.SetFetchMode((string) de.Key, (FetchMode) de.Value);
}
foreach (DictionaryEntry de in root.LockModes)
{
clone.SetLockMode((string) de.Key, (LockMode) de.Value);
}
clone.SetMaxResults(root.MaxResults);
clone.SetFirstResult(root.FirstResult);
clone.SetTimeout(root.Timeout);
clone.SetFetchSize(root.FetchSize);
clone.SetCacheable(root.Cacheable);
if (string.IsNullOrEmpty(root.CacheRegion) == false)
clone.SetCacheRegion(root.CacheRegion);
clone.SetProjection(root.Projection);
CloneProjectCrtieria(clone, root);
clone.SetResultTransformer(root.ResultTransformer);
return clone;
}
protected virtual ICriteria BuildCriteria(ISession session)
{
if (cachedCriteria == null)
{
if (detachedCriteria != null)
{
cachedCriteria = detachedCriteria.GetExecutableCriteria(session);
}
else
{
cachedCriteria = session.CreateCriteria(targetType);
if (criterions != null)
{
foreach (var queryCriteria in criterions)
{
cachedCriteria.Add(queryCriteria);
}
}
}
if (orders != null)
{
foreach (var order in orders)
{
cachedCriteria.AddOrder(order);
}
}
}
return cachedCriteria;
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return new TypedValue[]
{
criteriaQuery.GetTypedValue(criteria, _propertyName, _value.ToString().ToLower())
};
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
string entityName = criteriaQuery.GetEntityName(criteria, propertyName);
string actualPropertyName = criteriaQuery.GetPropertyName(propertyName);
string sqlAlias = criteriaQuery.GetSQLAlias(criteria, propertyName);
ISessionFactoryImplementor factory = criteriaQuery.Factory;
IQueryableCollection collectionPersister = GetQueryableCollection(entityName, actualPropertyName, factory);
string[] collectionKeys = collectionPersister.KeyColumnNames;
string[] ownerKeys = ((ILoadable)factory.GetEntityPersister(entityName)).IdentifierColumnNames;
StringBuilder innerSelect = new StringBuilder();
innerSelect.Append("(select 1 from ")
.Append(collectionPersister.TableName)
.Append(" where ")
.Append(
new ConditionalFragment().SetTableAlias(sqlAlias).SetCondition(ownerKeys, collectionKeys).ToSqlStringFragment());
if (collectionPersister.HasWhere)
{
innerSelect.Append(" and (")
.Append(collectionPersister.GetSQLWhereString(collectionPersister.TableName))
.Append(") ");
}
innerSelect.Append(")");
return new SqlString(new string[] {ExcludeEmpty ? "exists" : "not exists", innerSelect.ToString()});
}
public virtual object Translate(LinqExpression expression, ICriteria rootCriteria)
{
this.rootCriteria = rootCriteria;
this.options = null;
return TranslateInternal(expression);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary<string, IFilter> enabledFilters)
{
SqlString[] columnNames =
CriterionUtil.GetColumnNames(_lhsPropertyName, _lhsProjection, criteriaQuery, criteria, enabledFilters);
SqlString[] otherColumnNames =
CriterionUtil.GetColumnNames(_rhsPropertyName, _rhsProjection, criteriaQuery, criteria, enabledFilters);
SqlStringBuilder sb = new SqlStringBuilder();
if (columnNames.Length > 1)
{
sb.Add(StringHelper.OpenParen);
}
bool first = true;
foreach (SqlString sqlString in StringHelper.Add(columnNames, Op, otherColumnNames))
{
if (first == false)
{
sb.Add(" and ");
}
first = false;
sb.Add(sqlString);
}
if (columnNames.Length > 1)
{
sb.Add(StringHelper.ClosedParen);
}
return sb.ToSqlString();
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
return new SqlString(
criteriaQuery.NewQueryParameter(typedValue).Single(),
" as ",
GetColumnAliases(position, criteria, criteriaQuery)[0]);
}
public virtual object Translate(LinqExpression expression, QueryOptions queryOptions)
{
this.rootCriteria = null;
this.options = queryOptions;
return TranslateInternal(expression);
}
public SqlString ToSqlString(ICriteria criteria, int loc, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
//SqlString result = new SqlString(criteriaQuery.GetSQLAlias(criteria));
//result.Replace(sql, "{alias}");
//return result;
return new SqlString(StringHelper.Replace(sql, "{alias}", criteriaQuery.GetSQLAlias(criteria)));
}
private static SqlString GetProjectionArgument(ICriteriaQuery criteriaQuery, ICriteria criteria,
IProjection projection, int loc,
IDictionary<string, IFilter> enabledFilters)
{
SqlString sql = projection.ToSqlString(criteria, loc, criteriaQuery, enabledFilters);
return StringHelper.RemoveAsAliasesFromSql(sql);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
//TODO: add default capacity
SqlStringBuilder sqlBuilder = new SqlStringBuilder();
SqlString[] columnNames =
CriterionUtil.GetColumnNames(propertyName, projection, criteriaQuery, criteria, enabledFilters);
if (columnNames.Length != 1)
{
throw new HibernateException("insensitive like may only be used with single-column properties");
}
if (criteriaQuery.Factory.Dialect is PostgreSQLDialect)
{
sqlBuilder.Add(columnNames[0]);
sqlBuilder.Add(" ilike ");
}
else
{
sqlBuilder.Add(criteriaQuery.Factory.Dialect.LowercaseFunction)
.Add("(")
.Add(columnNames[0])
.Add(")")
.Add(" like ");
}
sqlBuilder.AddParameter();
return sqlBuilder.ToSqlString();
}
public override IType[] GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
IType[] trueTypes = whenTrue.GetTypes(criteria, criteriaQuery);
IType[] falseTypes = whenFalse.GetTypes(criteria, criteriaQuery);
bool areEqual = trueTypes.Length == falseTypes.Length;
if (trueTypes.Length == falseTypes.Length)
{
for (int i = 0; i < trueTypes.Length; i++)
{
if(trueTypes[i] != falseTypes[i])
{
areEqual = false;
break;
}
}
}
if(areEqual == false)
{
string msg = "Both true and false projections must return the same types."+ Environment.NewLine +
"But True projection returns: ["+StringHelper.Join(", ", trueTypes) +"] "+ Environment.NewLine+
"And False projection returns: ["+StringHelper.Join(", ", falseTypes)+ "]";
throw new HibernateException(msg);
}
return trueTypes;
}
/// <summary>
/// Render the SQL fragment
/// </summary>
public virtual string ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
string[] columns = criteriaQuery.GetColumnAliasesUsingProjection(criteria, propertyName);
StringBuilder fragment = new StringBuilder();
ISessionFactoryImplementor factory = criteriaQuery.Factory;
for (int i = 0; i < columns.Length; i++)
{
// TODO H3: bool lower = _ignoreCase && type.SqlTypes( factory )[ i ] == Types.VARCHAR
bool lower = false;
if (lower)
{
fragment.Append(factory.Dialect.LowercaseFunction)
.Append('(');
}
fragment.Append(columns[i]);
if (lower)
{
fragment.Append(')');
}
fragment.Append(ascending ? " asc" : " desc");
if (i < columns.Length - 1)
{
fragment.Append(", ");
}
}
return fragment.ToString();
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
//TODO: add default capacity
SqlStringBuilder sqlBuilder = new SqlStringBuilder();
SqlString[] columnNames =
CriterionUtil.GetColumnNames(_propertyName, _projection, criteriaQuery, criteria, enabledFilters);
bool opNeeded = false;
for (int i = 0; i < columnNames.Length; i++)
{
if (opNeeded)
{
sqlBuilder.Add(" or ");
}
opNeeded = true;
sqlBuilder.Add(columnNames[i])
.Add(" is not null");
}
if (columnNames.Length > 1)
{
sqlBuilder.Insert(0, "(");
sqlBuilder.Add(")");
}
return sqlBuilder.ToSqlString();
}
private static object ResultsFromCriteria(ICriteria criteria, Expression expression)
{
System.Type elementType = TypeSystem.GetElementType(expression.Type);
return Activator.CreateInstance(typeof(CriteriaResultReader<>)
.MakeGenericType(elementType), criteria);
}
private static CriteriaImpl GetRootCriteria(ICriteria criteria)
{
CriteriaImpl impl = criteria as CriteriaImpl;
if (impl != null)
return impl;
return GetRootCriteria(((CriteriaImpl.Subcriteria)criteria).Parent);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
//Implementation changed from H3.2 to use SqlString
string[] columns = criteriaQuery.GetIdentifierColumns(criteria);
SqlStringBuilder result = new SqlStringBuilder(4 * columns.Length + 2);
if (columns.Length > 1)
{
result.Add(StringHelper.OpenParen);
}
for (int i = 0; i < columns.Length; i++)
{
if (i > 0)
{
result.Add(" and ");
}
result.Add(columns[i])
.Add(" = ");
AddValueOrProjection(criteria, criteriaQuery, enabledFilters, result);
}
if (columns.Length > 1)
{
result.Add(StringHelper.ClosedParen);
}
return result.ToSqlString();
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (_projection != null)
return _projection.GetTypedValues(criteria, criteriaQuery);
return new TypedValue[] {criteriaQuery.GetTypedIdentifierValue(criteria, value)};
}
public CriteriaJoinWalker(IOuterJoinLoadable persister, CriteriaQueryTranslator translator,
ISessionFactoryImplementor factory, ICriteria criteria, string rootEntityName,
IDictionary<string, IFilter> enabledFilters)
: base(translator.RootSQLAlias, persister, factory, enabledFilters)
{
this.translator = translator;
querySpaces = translator.GetQuerySpaces();
if (translator.HasProjection)
{
resultTypes = translator.ProjectedTypes;
InitProjection(
translator.GetSelect(enabledFilters),
translator.GetWhereCondition(enabledFilters),
translator.GetOrderBy(),
translator.GetGroupBy(),
translator.GetHavingCondition(enabledFilters),
enabledFilters,
LockMode.None);
}
else
{
resultTypes = new IType[] {TypeFactory.ManyToOne(persister.EntityName)};
InitAll(translator.GetWhereCondition(enabledFilters), translator.GetOrderBy(), LockMode.None);
}
userAliasList.Add(criteria.Alias); //root entity comes *last*
userAliases = ArrayHelper.ToStringArray(userAliasList);
}
private static SqlString[] GetColumnNamesUsingPropertyName(
ICriteriaQuery criteriaQuery,
ICriteria criteria,
string propertyName,
object value,
ICriterion critertion)
{
string[] columnNames = criteriaQuery.GetColumnsUsingProjection(criteria, propertyName);
IType propertyType = criteriaQuery.GetTypeUsingProjection(criteria, propertyName);
if (value != null && !(value is System.Type) && !propertyType.ReturnedClass.IsInstanceOfType(value))
{
throw new QueryException(string.Format(
"Type mismatch in {0}: {1} expected type {2}, actual type {3}",
critertion.GetType(), propertyName, propertyType.ReturnedClass, value.GetType()));
}
if (propertyType.IsCollectionType)
{
throw new QueryException(string.Format(
"cannot use collection property ({0}.{1}) directly in a criterion,"
+ " use ICriteria.CreateCriteria instead",
criteriaQuery.GetEntityName(criteria), propertyName));
}
return Array.ConvertAll<string, SqlString>(columnNames, delegate(string col)
{
return new SqlString(col);
});
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (projection == null)
return NoValues;
else
return projection.GetTypedValues(criteria, criteriaQuery);
}
/// <summary>
/// Render a SqlString for the expression.
/// </summary>
/// <param name="criteria"></param>
/// <param name="criteriaQuery"></param>
/// <param name="enabledFilters"></param>
/// <returns>
/// A SqlString that contains a valid Sql fragment.
/// </returns>
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
criteriaQuery.AddUsedTypedValues(GetTypedValues(criteria, criteriaQuery));
ISpatialDialect spatialDialect = (ISpatialDialect)criteriaQuery.Factory.Dialect;
string[] columnsUsingProjection = criteriaQuery.GetColumnsUsingProjection(criteria, this.propertyName);
IType typeUsingProjection = criteriaQuery.GetTypeUsingProjection(criteria, this.propertyName);
if (typeUsingProjection.ReturnedClass != typeof(IGeometry))
{
throw new QueryException(string.Format("Type mismatch in {0}: {1} expected type {2}, actual type {3}", GetType(), this.propertyName, typeof(IGeometry), typeUsingProjection.ReturnedClass));
}
if (typeUsingProjection.IsCollectionType)
{
throw new QueryException(string.Format("cannot use collection property ({0}.{1}) directly in a criterion, use ICriteria.CreateCriteria instead", criteriaQuery.GetEntityName(criteria), this.propertyName));
}
SqlStringBuilder builder = new SqlStringBuilder(2 * columnsUsingProjection.Length);
for (int i = 0; i < columnsUsingProjection.Length; i++)
{
if (i > 0)
{
builder.Add(" AND ");
}
builder.Add(spatialDialect.GetSpatialValidationString(columnsUsingProjection[i], this.validation, true));
}
return builder.ToSqlString();
}
public FilterFacet(string name, ICriteria filter)
{
Argument.EnsureNotBlank("name", name);
this.name = name;
this.filter = filter;
}
/// <summary>
/// Render a SqlString for the expression.
/// </summary>
/// <param name="criteria"></param>
/// <param name="criteriaQuery"></param>
/// <param name="enabledFilters"></param>
/// <returns>
/// A SqlString that contains a valid Sql fragment.
/// </returns>
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
criteriaQuery.AddUsedTypedValues(GetTypedValues(criteria, criteriaQuery));
ISpatialDialect spatialDialect = (ISpatialDialect)criteriaQuery.Factory.Dialect;
string[] columns1 = GetColumnNames(criteria, criteriaQuery, this.propertyName);
string[] columns2 = null;
if (!(this.anotherGeometry is IGeometry))
{
columns2 = GetColumnNames(criteria, criteriaQuery, (string)this.anotherGeometry);
}
SqlStringBuilder builder = new SqlStringBuilder(10 * columns1.Length);
for (int i = 0; i < columns1.Length; i++)
{
if (i > 0)
{
builder.Add(" AND ");
}
if (this.anotherGeometry is IGeometry)
{
builder.Add(spatialDialect.GetSpatialRelationString(columns1[i], this.relation, Parameter.Placeholder, true));
}
else
{
builder.Add(spatialDialect.GetSpatialRelationString(columns1[i], this.relation, columns2[i], true));
}
}
return builder.ToSqlString();
}
protected Join(IDictionary<string, Join> joins, string toTable, string alias, ICriteria onCriteria)
: base(toTable, alias)
{
this.joins = joins;
this.onCriteria = onCriteria;
if (!ReferenceEquals(this.onCriteria, null))
{
var aliases = JoinAliasLocator.Locate(this.onCriteria.ToStringIgnoreParams());
if (aliases != null && aliases.Count > 0)
referencedAliases = aliases;
}
var toTableAliases = JoinAliasLocator.Locate(this.Table);
if (toTableAliases != null && toTableAliases.Count > 0)
{
if (referencedAliases == null)
referencedAliases = toTableAliases;
else
{
foreach (var x in toTableAliases)
referencedAliases.Add(x);
}
}
if (joins != null)
{
if (joins.ContainsKey(this.Name))
throw new ArgumentException(String.Format(
"There is already a join with alias '{0}'", this.Name));
joins.Add(this.Name, this);
}
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (projection != null)
return projection.GetTypedValues(criteria, criteriaQuery);
return base.GetTypedValues(criteria, criteriaQuery);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
if (_criteria.Count == 0)
{
return EmptyExpression;
}
//TODO: add default capacity
SqlStringBuilder sqlBuilder = new SqlStringBuilder();
sqlBuilder.Add("(");
for (int i = 0; i < _criteria.Count - 1; i++)
{
sqlBuilder.Add(
((ICriterion) _criteria[i]).ToSqlString(criteria, criteriaQuery, enabledFilters));
sqlBuilder.Add(Op);
}
sqlBuilder.Add(
((ICriterion) _criteria[_criteria.Count - 1]).ToSqlString(criteria, criteriaQuery, enabledFilters));
sqlBuilder.Add(")");
return sqlBuilder.ToSqlString();
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery,
IDictionary<string, IFilter> enabledFilters)
{
ISQLFunction sqlFunction = GetFunction(criteriaQuery);
List<string> tokens = new List<string>();
string replacemenToken = Guid.NewGuid().ToString("n");
for (int i = 0; i < args.Length; i++)
{
tokens.Add(replacemenToken);
}
string functionStatement = sqlFunction.Render(tokens, criteriaQuery.Factory).ToString();
string[] splitted = functionStatement.Split(new string[] {replacemenToken}, StringSplitOptions.RemoveEmptyEntries);
SqlStringBuilder sb = new SqlStringBuilder();
for (int i = 0; i < splitted.Length; i++)
{
sb.Add(splitted[i]);
if (i < args.Length)
{
int loc = (position + 1) * 1000 + i;
SqlString projectArg = GetProjectionArgument(criteriaQuery, criteria, args[i], loc, enabledFilters);
sb.Add(projectArg);
}
}
sb.Add(" as ");
sb.Add(GetColumnAliases(position)[0]);
return sb.ToSqlString();
}
private JObject BuildCriteria(ICriteria criteria)
{
if (criteria is RangeCriteria)
return Build((RangeCriteria)criteria);
if (criteria is RegexpCriteria)
return Build((RegexpCriteria)criteria);
if (criteria is PrefixCriteria)
return Build((PrefixCriteria)criteria);
if (criteria is TermCriteria)
return Build((TermCriteria)criteria);
if (criteria is TermsCriteria)
return Build((TermsCriteria)criteria);
if (criteria is NotCriteria)
return Build((NotCriteria)criteria);
if (criteria is QueryStringCriteria)
return Build((QueryStringCriteria)criteria);
// Base class formatters using name property
if (criteria is SingleFieldCriteria)
return Build((SingleFieldCriteria)criteria);
if (criteria is CompoundCriteria)
return Build((CompoundCriteria)criteria);
throw new InvalidOperationException(String.Format("Unknown criteria type {0}", criteria.GetType()));
}
public LeftJoin(IDictionary <string, Join> joins, string toTable, string alias, ICriteria onCriteria)
: base(joins, toTable, alias, onCriteria)
{
}
/// <summary>
/// Initializes a new instance of the <see cref="LeftJoin"/> class.
/// </summary>
/// <param name="toTable">To table.</param>
/// <param name="alias">The alias.</param>
/// <param name="onCriteria">The ON criteria.</param>
public LeftJoin(string toTable, string alias, ICriteria onCriteria)
: base(null, toTable, alias, onCriteria)
{
}
///<summary>
/// Return typed values for all parameters in the rendered SQL fragment
///</summary>
///<returns>
///An array of TypedValues for the Expression.
///</returns>
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(_criterion.GetTypedValues(criteria, criteriaQuery));
}
public List <Product> GetFullProductList()
{
ICriteria crit = GetCriteria();
return(crit.List <Product>() as List <Product>);
}
public IList <Product> GetProductList()
{
ICriteria crit = GetCriteria();
return(crit.List <Product>());
}
/// <summary>
/// constructor for criteria. This criteria will be used to build total query and result query
/// </summary>
/// <param name="query"></param>
/// <param name="page"></param>
/// <param name="limit"></param>
public CriteriaPager(ICriteria criteria, int page, int limit)
: base(page, limit)
{
Criteria = criteria;
Initialize();
}
public async Task ManyToOneIdAsync()
{
Building madison = new Building();
madison.Id = 1;
madison.Number = "4800";
Building college = new Building();
college.Id = 2;
college.Number = "6363";
Office acctg = new Office();
acctg.Id = 3;
acctg.Worker = "Bean Counter";
acctg.Location = college;
Office hr = new Office();
hr.Id = 4;
hr.Worker = "benefits";
hr.Location = madison;
Office it = new Office();
hr.Id = 5;
it.Worker = "servers";
it.Location = madison;
ISession s = OpenSession();
await(s.SaveAsync(madison));
await(s.SaveAsync(college));
await(s.SaveAsync(acctg));
await(s.SaveAsync(hr));
await(s.SaveAsync(it));
await(s.FlushAsync());
s.Close();
s = OpenSession();
ICriteria c = s.CreateCriteria(typeof(Office));
c.Add(Expression.Eq("Location.Id", madison.Id));
IList results = await(c.ListAsync());
Assert.AreEqual(2, results.Count, "2 objects");
foreach (Office office in results)
{
Assert.AreEqual(madison.Id, office.Location.Id, "same location as criteria specified");
}
c = s.CreateCriteria(typeof(Office));
c.Add(Expression.Eq("Location.Id", college.Id));
results = await(c.ListAsync());
Assert.AreEqual(1, results.Count, "1 objects");
foreach (Office office in results)
{
Assert.AreEqual(college.Id, office.Location.Id, "same location as criteria specified");
}
await(s.DeleteAsync("from Office "));
await(s.DeleteAsync("from Building"));
await(s.FlushAsync());
s.Close();
}
public ComposedCriteriaTests(ICriteria criteria) : base(criteria)
{
}
public LoginPageCriteria()
{
PageReady = UsernameVisible.AND(PasswordEnabled);
}
/// <summary>
/// Prepare list of used images
/// Many be associated with products, as thumbnail, icon, or std. images
/// or as additional images
/// or to option swathces
/// </summary>
private void InitAssociatedImageUrls()
{
associatedImages = new List <string>();
// ADD PRODUCT IMAGES
ICriteria criteria = NHibernateHelper.CreateCriteria <Product>();
criteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
IList <Product> products = ProductDataSource.LoadForCriteria(criteria);
foreach (Product product in products)
{
if (product.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ImageUrl);
}
if (product.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.ThumbnailUrl);
}
if (product.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(product.IconUrl);
}
}
// ADDITIONAL IMAGES
ICriteria imageCriteria = NHibernateHelper.CreateCriteria <ProductImage>();
imageCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <ProductImage> images = ProductImageDataSource.LoadForCriteria(imageCriteria);
foreach (ProductImage image in images)
{
associatedImages.Add(image.ImageUrl);
}
// OPTION SWATCHES
ICriteria choicesCriteria = NHibernateHelper.CreateCriteria <OptionChoice>();
choicesCriteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%")));
IList <OptionChoice> choices = OptionChoiceDataSource.LoadForCriteria(choicesCriteria);
foreach (OptionChoice choice in choices)
{
if (choice.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ImageUrl);
}
if (choice.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(choice.ThumbnailUrl);
}
}
// ADD CATEGORY IMAGES
ICriteria categoryCriteria = NHibernateHelper.CreateCriteria <Category>();
categoryCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
categoryCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Category> categories = CategoryDataSource.LoadForCriteria(categoryCriteria);
foreach (Category category in categories)
{
if (category.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(category.ThumbnailUrl);
}
}
// ADD LINK IMAGES
ICriteria linksCriteria = NHibernateHelper.CreateCriteria <Link>();
linksCriteria.Add(Restrictions.Eq("Store", AbleContext.Current.Store));
linksCriteria.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"));
IList <Link> links = LinkDataSource.LoadForCriteria(linksCriteria);
foreach (Link link in links)
{
if (link.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(link.ThumbnailUrl);
}
}
// ADD GIFT WRAPING IMAGES
ICriteria wrapstylesCriteria = NHibernateHelper.CreateCriteria <WrapStyle>();
wrapstylesCriteria.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"));
IList <WrapStyle> wrapStyles = WrapStyleDataSource.LoadForCriteria(wrapstylesCriteria);
foreach (WrapStyle ws in wrapStyles)
{
if (ws.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ImageUrl);
}
if (ws.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(ws.ThumbnailUrl);
}
}
// ADD VARIANT IMAGES
ICriteria variantsCriteria = NHibernateHelper.CreateCriteria <ProductVariant>();
criteria.Add(Restrictions.Disjunction()
.Add(Restrictions.Like("ImageUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("ThumbnailUrl", "~/Assets/ProductImages/%"))
.Add(Restrictions.Like("IconUrl", "~/Assets/ProductImages/%")));
int variantsCount = ProductVariantDataSource.CountForCriteria(variantsCriteria.Clone() as ICriteria);
int maxVariantsToCache = 500;
// avoid loading all variants at same time
for (int index = 0; index < variantsCount; index += maxVariantsToCache)
{
variantsCriteria.SetMaxResults(maxVariantsToCache);
variantsCriteria.SetFirstResult(index);
IList <ProductVariant> productVariants = ProductVariantDataSource.LoadForCriteria(variantsCriteria);
foreach (ProductVariant productVariant in productVariants)
{
if (productVariant.ImageUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ImageUrl);
}
if (productVariant.ThumbnailUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.ThumbnailUrl);
}
if (productVariant.IconUrl.StartsWith("~/Assets/ProductImages/"))
{
associatedImages.Add(productVariant.IconUrl);
}
}
}
}
public override IType[] GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
_subQuery.InitializeInnerQueryAndParameters(criteriaQuery);
return(_subQuery.GetTypes());
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(_typedValues);
}
public Entidad GetByCriteria(ICriteria <Entidad> criteria)
{
return(_dbContext.Entidades.Single(criteria.Criteria));
}
public override SqlString ToGroupSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
throw new InvalidOperationException("not a grouping projection");
}
public override IType[] GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(new IType[] { NHibernateUtil.Double });
}
public IList <Entidad> GetCollectionByCriteria(ICriteria <Entidad> criteria)
{
return(_dbContext.Entidades.Where(criteria.Criteria).ToList());
}
/// <summary>
/// Gets all the Addresses in the Repository.
/// </summary>
/// <returns>An IList containing all Addresses in the Repository.</returns>
public IList <Address> GetAll()
{
ICriteria criteria = Session.CreateCriteria <Address>();
return(criteria.List <Address>());
}
/// <summary>
/// 添加查询条件
/// </summary>
/// <param name="criteria">查询条件</param>
public IQuery <TEntity, TKey> Filter(ICriteria <TEntity> criteria)
{
And(criteria.GetPredicate());
return(this);
}
private static ICriteria ExtendCriteria(ICriteria criteria, string segment)
{
return(criteria.GetCriteriaByPath(segment) ?? criteria.CreateCriteria(segment, JoinType.LeftOuterJoin));
}
public void Criteria()
{
using (ISession s = OpenSession())
using (ITransaction txn = s.BeginTransaction())
{
Fum fum = new Fum(FumKey("fum"));
fum.Fo = new Fum(FumKey("fo"));
fum.FumString = "fo fee fi";
fum.Fo.FumString = "stuff";
Fum fr = new Fum(FumKey("fr"));
fr.FumString = "goo";
Fum fr2 = new Fum(FumKey("fr2"));
fr2.FumString = "soo";
fum.Friends = new HashedSet();
fum.Friends.Add(fr);
fum.Friends.Add(fr2);
s.Save(fr);
s.Save(fr2);
s.Save(fum.Fo);
s.Save(fum);
ICriteria baseCriteria = s.CreateCriteria(typeof(Fum))
.Add(Expression.Like("FumString", "f", MatchMode.Start));
baseCriteria.CreateCriteria("Fo")
.Add(Expression.IsNotNull("FumString"));
baseCriteria.CreateCriteria("Friends")
.Add(Expression.Like("FumString", "g%"));
IList list = baseCriteria.List();
Assert.AreEqual(1, list.Count);
Assert.AreSame(fum, list[0]);
baseCriteria = s.CreateCriteria(typeof(Fum))
.Add(Expression.Like("FumString", "f%"))
.SetResultTransformer(CriteriaSpecification.AliasToEntityMap);
baseCriteria.CreateCriteria("Fo", "fo")
.Add(Expression.IsNotNull("FumString"));
baseCriteria.CreateCriteria("Friends", "fum")
.Add(Expression.Like("FumString", "g", MatchMode.Start));
IDictionary map = (IDictionary)baseCriteria.UniqueResult();
Assert.AreSame(fum, map["this"]);
Assert.AreSame(fum.Fo, map["fo"]);
Assert.IsTrue(fum.Friends.Contains(map["fum"]));
Assert.AreEqual(3, map.Count);
baseCriteria = s.CreateCriteria(typeof(Fum))
.Add(Expression.Like("FumString", "f%"))
.SetResultTransformer(CriteriaSpecification.AliasToEntityMap)
.SetFetchMode("Friends", FetchMode.Eager);
baseCriteria.CreateCriteria("Fo", "fo")
.Add(Expression.Eq("FumString", fum.Fo.FumString));
map = (IDictionary)baseCriteria.List()[0];
Assert.AreSame(fum, map["this"]);
Assert.AreSame(fum.Fo, map["fo"]);
Assert.AreEqual(2, map.Count);
list = s.CreateCriteria(typeof(Fum))
.CreateAlias("Friends", "fr")
.CreateAlias("Fo", "fo")
.Add(Expression.Like("FumString", "f%"))
.Add(Expression.IsNotNull("Fo"))
.Add(Expression.IsNotNull("fo.FumString"))
.Add(Expression.Like("fr.FumString", "g%"))
.Add(Expression.EqProperty("fr.id.Short", "id.Short"))
.List();
Assert.AreEqual(1, list.Count);
Assert.AreSame(fum, list[0]);
txn.Commit();
}
using (ISession s = OpenSession())
using (ITransaction txn = s.BeginTransaction())
{
ICriteria baseCriteria = s.CreateCriteria(typeof(Fum))
.Add(Expression.Like("FumString", "f%"));
baseCriteria.CreateCriteria("Fo")
.Add(Expression.IsNotNull("FumString"));
baseCriteria.CreateCriteria("Friends")
.Add(Expression.Like("FumString", "g%"));
Fum fum = (Fum)baseCriteria.List()[0];
Assert.AreEqual(2, fum.Friends.Count);
s.Delete(fum);
s.Delete(fum.Fo);
foreach (object friend in fum.Friends)
{
s.Delete(friend);
}
txn.Commit();
}
}
public override SqlString ToGroupSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
return(_projection.ToGroupSqlString(criteria, criteriaQuery, enabledFilters));
}
public IList <T> GetAll()
{
ICriteria criteria = Session.CreateCriteria(typeof(T));
return(criteria.List <T>());
}
public TypedValue GetParameterTypedValue(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
object icvalue = ignoreCase ? value.ToString().ToLower() : value;
return(CriterionUtil.GetTypedValue(criteriaQuery, criteria, _projection, propertyName, icvalue));
}
public PERTraineePageCriteria()
{
PageReady = LoadIconDisappeared.AND(MainFrameVisibleAndEnabled);
}
public TypedValue GetTypedIdentifierValue(ICriteria subcriteria, object value)
{
NHibernate_Persister_Entity.ILoadable loadable = (NHibernate_Persister_Entity.ILoadable)GetPropertyMapping(GetEntityName(subcriteria));
return(new TypedValue(loadable.IdentifierType, value));
}
/// <summary>
/// Converts the SimpleExpression to a <see cref="SqlString"/>.
/// </summary>
/// <returns>A SqlString that contains a valid Sql fragment.</returns>
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
SqlString[] columnNames =
CriterionUtil.GetColumnNamesForSimpleExpression(
propertyName,
_projection,
criteriaQuery,
criteria,
this,
value);
TypedValue typedValue = GetParameterTypedValue(criteria, criteriaQuery);
Parameter[] parameters = criteriaQuery.NewQueryParameter(typedValue).ToArray();
if (ignoreCase)
{
if (columnNames.Length != 1)
{
throw new HibernateException(
"case insensitive expression may only be applied to single-column properties: " +
propertyName);
}
return(new SqlString(
criteriaQuery.Factory.Dialect.LowercaseFunction,
StringHelper.OpenParen,
columnNames[0],
StringHelper.ClosedParen,
Op,
parameters.Single()));
}
else
{
SqlStringBuilder sqlBuilder = new SqlStringBuilder(4 * columnNames.Length);
var columnNullness = typedValue.Type.ToColumnNullness(typedValue.Value, criteriaQuery.Factory);
if (columnNullness.Length != columnNames.Length)
{
throw new AssertionFailure("Column nullness length doesn't match number of columns.");
}
for (int i = 0; i < columnNames.Length; i++)
{
if (i > 0)
{
sqlBuilder.Add(" and ");
}
if (columnNullness[i])
{
sqlBuilder.Add(columnNames[i])
.Add(Op)
.Add(parameters[i]);
}
else
{
sqlBuilder.Add(columnNames[i])
.Add(" is null ");
}
}
return(sqlBuilder.ToSqlString());
}
}
public string[] GetIdentifierColumns(ICriteria subcriteria)
{
string[] idcols = ((NHibernate_Persister_Entity.ILoadable)GetPropertyMapping(GetEntityName(subcriteria))).IdentifierColumnNames;
return(StringHelper.Qualify(GetSQLAlias(subcriteria), idcols));
}
public IType GetType(ICriteria subcriteria, string propertyName)
{
return(GetPropertyMapping(GetEntityName(subcriteria, propertyName)).ToType(GetPropertyName(propertyName)));
}
internal IType ResultType(ICriteria criteria)
{
return(TypeFactory.ManyToOne(GetEntityName(criteria)));
//return Factory.getTypeResolver().getTypeFactory().manyToOne(getEntityName(criteria));
}
public IType GetIdentifierType(ICriteria subcriteria)
{
return(((NHibernate_Persister_Entity.ILoadable)GetPropertyMapping(GetEntityName(subcriteria))).IdentifierType);
}
