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();
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary enabledFilters)
{
//TODO: add default capacity
SqlStringBuilder sqlBuilder = new SqlStringBuilder();
string[] columnNames = criteriaQuery.GetColumnsUsingProjection(criteria, _propertyName);
for (int i = 0; i < columnNames.Length; i++)
{
if (i > 0)
{
sqlBuilder.Add(" and ");
}
sqlBuilder.Add(columnNames[i])
.Add(" is null");
}
if (columnNames.Length > 1)
{
sqlBuilder.Insert(0, "(");
sqlBuilder.Add(")");
}
return sqlBuilder.ToSqlString();
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
ArrayList list = new ArrayList();
IType type = criteriaQuery.GetTypeUsingProjection(criteria, _propertyName);
if (type.IsComponentType)
{
IAbstractComponentType actype = (IAbstractComponentType) type;
IType[] types = actype.Subtypes;
for (int i = 0; i < types.Length; i++)
{
for (int j = 0; j < _values.Length; j++)
{
object subval = _values[j] == null ?
null :
actype.GetPropertyValues(_values[j])[i];
list.Add(new TypedValue(types[i], subval));
}
}
}
else
{
for (int j = 0; j < _values.Length; j++)
{
list.Add(new TypedValue(type, _values[j]));
}
}
return (TypedValue[]) list.ToArray(typeof(TypedValue));
}
/// <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();
}
/// <summary>
/// Render the SQL Fragment.
/// </summary>
/// <param name="criteria"></param>
/// <param name="position"></param>
/// <param name="criteriaQuery"></param>
/// <param name="enabledFilters"></param>
/// <returns></returns>
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
ISpatialDialect spatialDialect = (ISpatialDialect)criteriaQuery.Factory.Dialect;
string column1 = criteriaQuery.GetColumn(criteria, this.propertyName);
string column2 = criteriaQuery.GetColumn(criteria, this.anotherPropertyName);
SqlString sqlString;
if (this.pattern == null)
{
sqlString = spatialDialect.GetSpatialRelateString(column1, column2, null, false, false);
}
else
{
string column3 = criteriaQuery.GetColumn(criteria, this.pattern);
if (column3 == null)
{
sqlString = spatialDialect.GetSpatialRelateString(column1, column2, this.pattern, true, false);
}
else
{
sqlString = spatialDialect.GetSpatialRelateString(column1, column2, column3, false, false);
}
}
return new SqlStringBuilder()
.Add(sqlString)
.Add(" as y")
.Add(position.ToString())
.Add("_")
.ToSqlString();
}
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 TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (_projection != null)
return _projection.GetTypedValues(criteria, criteriaQuery);
return new TypedValue[] {criteriaQuery.GetTypedIdentifierValue(criteria, value)};
}
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();
}
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();
}
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 sql.Substring(0, sql.LastIndexOfCaseInsensitive(" as "));
}
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 override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (projection == null)
return NoValues;
else
return projection.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();
}
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();
}
/// <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();
}
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);
}
/// <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();
}
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 override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (projection != null)
return projection.GetTypedValues(criteria, criteriaQuery);
return base.GetTypedValues(criteria, criteriaQuery);
}
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)));
}
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;
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return new TypedValue[]
{
criteriaQuery.GetTypedValue(criteria, _propertyName, _value.ToString().ToLower())
};
}
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 SqlString ToSqlString(ICriteria criteria, int loc, ICriteriaQuery criteriaQuery)
{
//SqlString result = new SqlString(criteriaQuery.GetSQLAlias(criteria));
//result.Replace(sql, "{alias}");
//return result;
return new SqlString(StringHelper.Replace(sql, "{alias}", criteriaQuery.GetSQLAlias(criteria)));
}
public CriteriaQueryTranslator(ISessionFactoryImplementor factory, CriteriaImpl criteria, string rootEntityName,
string rootSQLAlias, ICriteriaQuery outerQuery)
: this(factory, criteria, rootEntityName, rootSQLAlias)
{
outerQueryTranslator = outerQuery;
collectedParameterSpecifications = outerQuery.CollectedParameterSpecifications;
namedParameters = outerQuery.CollectedParameters;
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
return new SqlStringBuilder()
.Add(" RAND() ")
.Add(" as ")
.Add(GetColumnAliases(position)[0])
.ToSqlString();
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
List<TypedValue> tv = new List<TypedValue>();
tv.AddRange(criterion.GetTypedValues(criteria, criteriaQuery));
tv.AddRange(whenTrue.GetTypedValues(criteria, criteriaQuery));
tv.AddRange(whenFalse.GetTypedValues(criteria, criteriaQuery));
return tv.ToArray();
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary<string, IFilter> enabledFilters)
{
return new SqlStringBuilder()
.Add(criteriaQuery.NewQueryParameter(typedValue).Single())
.Add(" as ")
.Add(GetColumnAliases(position)[0])
.ToSqlString();
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
TypedValue[] superTv = base.GetTypedValues(criteria, criteriaQuery);
TypedValue[] result = new TypedValue[superTv.Length + 1];
superTv.CopyTo(result, 1);
result[0] = new TypedValue(GetTypes()[0], value, EntityMode.Poco);
return result;
}
public override TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (_lhsProjection == null && _rhsProjection == null)
{
return(NoTypedValues);
}
else
{
List <TypedValue> types = new List <TypedValue>();
if (_lhsProjection != null)
{
types.AddRange(_lhsProjection.GetTypedValues(criteria, criteriaQuery));
}
if (_rhsProjection != null)
{
types.AddRange(_rhsProjection.GetTypedValues(criteria, criteriaQuery));
}
return(types.ToArray());
}
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
ISQLFunction sqlFunction = GetFunction(criteriaQuery);
var arguments = new ArrayList();
for (int i = 0; i < args.Length; i++)
{
SqlString projectArg = GetProjectionArgument(criteriaQuery, criteria, args[i], 0, enabledFilters); // The loc parameter is unused.
arguments.Add(projectArg);
}
SqlStringBuilder sb = new SqlStringBuilder();
sb.Add(sqlFunction.Render(arguments, criteriaQuery.Factory));
sb.Add(" as ");
sb.Add(GetColumnAliases(position)[0]);
return(sb.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
var columnNames = GetColumnNames(_propertyName, _projection, criteriaQuery, criteria, this, _value);
var typedValue = GetParameterTypedValue(criteria, criteriaQuery);
var parameters = criteriaQuery.NewQueryParameter(typedValue).ToArray();
var 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])
{
if (_inverse)
{
sqlBuilder.Add(parameters[i]).Add(Op).Add(columnNames[i]);
}
else
{
sqlBuilder.Add(columnNames[i]).Add(Op).Add(parameters[i]);
}
}
else
{
sqlBuilder.Add(columnNames[i]).Add(" is null ");
}
}
return(sqlBuilder.ToSqlString());
}
/// <summary>
/// Render the SQL fragment
/// </summary>
public virtual SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (projection != null)
{
SqlString produced = projection.ToSqlString(criteria, 0, criteriaQuery);
SqlString truncated = SqlStringHelper.RemoveAsAliasesFromSql(produced);
return(new SqlString(truncated, ascending ? " asc" : " desc"));
}
string[] columns = criteriaQuery.GetColumnAliasesUsingProjection(criteria, propertyName);
Type.IType type = criteriaQuery.GetTypeUsingProjection(criteria, propertyName);
StringBuilder fragment = new StringBuilder();
ISessionFactoryImplementor factory = criteriaQuery.Factory;
for (int i = 0; i < columns.Length; i++)
{
bool lower = ignoreCase && IsStringType(type.SqlTypes(factory)[i]);
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(new SqlString(fragment.ToString()));
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
var columns = CriterionUtil.GetColumnNames(_propertyName, _projection, criteriaQuery, criteria,
enabledFilters);
if (columns.Length != 1)
{
throw new HibernateException(
"IsDescendantOf may only be used with single-column properties / projections.");
}
var lhs = new SqlStringBuilder(6);
lhs.Add(columns[0]);
lhs.Add(".IsDescendantOf(");
lhs.Add(criteriaQuery.NewQueryParameter(_typedValue).Single());
lhs.Add(") = 1");
return(lhs.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, int loc, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
if (projection != null)
{
return
(new SqlString(new object[]
{
aggregate, "(",
StringHelper.RemoveAsAliasesFromSql(projection.ToSqlString(criteria, loc, criteriaQuery,
enabledFilters)), ") as y",
loc.ToString(), "_"
}));
}
else
{
return
(new SqlString(new object[]
{ aggregate, "(", criteriaQuery.GetColumn(criteria, propertyName), ") as y", loc.ToString(), "_" }));
}
}
/// <summary>
/// Determine the type of the elements in the IN clause.
/// </summary>
private IType GetElementType(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (_projection == null)
//return criteriaQuery.GetTypeUsingProjection(criteria, _propertyName);
{
//把计㏕﹚肚String篈
if (this._values[0].ToString().Length > 4000)
{
return(NHibernateUtil.StringClob);
}
return(NHibernateUtil.String);
}
IType[] types = _projection.GetTypes(criteria, criteriaQuery);
if (types.Length != 1)
{
throw new QueryException("Cannot use projections that return more than a single column with InExpression");
}
return(types[0]);
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
var loc = position * GetHashCode();
var val = _projection.ToSqlString(criteria, loc, criteriaQuery, enabledFilters);
val = HierarchyIdStringHelper.RemoveAsAliasesFromSql(val);
var lhs = new SqlStringBuilder();
lhs.Add(val);
lhs.Add(".GetDescendant(");
lhs.Add(criteriaQuery.NewQueryParameter(new TypedValue(NHibernateUtil.String, _child1, EntityMode.Poco)).Single());
lhs.Add(" , ");
lhs.Add(criteriaQuery.NewQueryParameter(new TypedValue(NHibernateUtil.String, _child2, EntityMode.Poco)).Single());
lhs.Add(") as ");
lhs.Add(GetColumnAliases(position)[0]);
var ret = lhs.ToSqlString();
return(ret);
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery)
{
var loc = position * GetHashCode();
var val = _projection.ToSqlString(criteria, loc, criteriaQuery);
val = GetAncestorProjection.RemoveAsAliasesFromSql(val);
var lhs = new SqlStringBuilder();
lhs.Add(val);
lhs.Add(".GetReparentedValue(");
lhs.Add(criteriaQuery.NewQueryParameter(new TypedValue(NHibernateUtil.String, _oldRoot, false)).Single());
lhs.Add(" , ");
lhs.Add(criteriaQuery.NewQueryParameter(new TypedValue(NHibernateUtil.String, _newRoot, false)).Single());
lhs.Add(") as ");
lhs.Add(GetColumnAliases(position)[0]);
var ret = lhs.ToSqlString();
return(ret);
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
InitializeInnerQueryAndParameters(criteriaQuery);
if (innerQuery.HasProjection == false)
{
throw new QueryException("Cannot use subqueries on a criteria without a projection.");
}
ISessionFactoryImplementor factory = criteriaQuery.Factory;
IOuterJoinLoadable persister = (IOuterJoinLoadable)factory.GetEntityPersister(criteriaImpl.EntityOrClassName);
//buffer needs to be before CriteriaJoinWalker for sake of parameter order
SqlStringBuilder buf = new SqlStringBuilder().Add(ToLeftSqlString(criteria, criteriaQuery));
//patch to generate joins on subqueries
//stolen from CriteriaLoader
CriteriaJoinWalker walker =
new CriteriaJoinWalker(persister, innerQuery, factory, criteriaImpl, criteriaImpl.EntityOrClassName, enabledFilters);
SqlString sql = walker.SqlString;
if (criteriaImpl.FirstResult != 0 || criteriaImpl.MaxResults != RowSelection.NoValue)
{
sql = factory.Dialect.GetLimitString(sql, criteriaImpl.FirstResult, criteriaImpl.MaxResults);
}
if (op != null)
{
buf.Add(" ").Add(op).Add(" ");
}
if (quantifier != null)
{
buf.Add(quantifier).Add(" ");
}
return(buf.Add("(").Add(sql).Add(")").ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
string alias = null;
Type targetType = null;
ICriteria aliasedCriteria;
if (string.IsNullOrEmpty(_alias))
{
alias = criteriaQuery.GetSQLAlias(criteria);
string entityName = criteriaQuery.GetEntityName(criteria);
targetType = criteriaQuery.Factory.GetEntityPersister(entityName).GetMappedClass(EntityMode.Poco);
}
else if ((aliasedCriteria = criteria.GetCriteriaByAlias(_alias)) != null)
{
alias = criteriaQuery.GetSQLAlias(aliasedCriteria);
string entityName = criteriaQuery.GetEntityName(aliasedCriteria);
targetType = criteriaQuery.Factory.GetEntityPersister(entityName).GetMappedClass(EntityMode.Poco);
}
if (targetType == null || !targetType.IsAssignableFrom(_entityClass))
{
return(new SqlString("1=0"));
}
IQueryable queryable = ObtainQueryable(criteriaQuery);
string condition = queryable.FilterFragment(alias, enabledFilters);
if (condition.IndexOf(" and ", StringComparison.InvariantCultureIgnoreCase) == 0)
{
condition = condition.Substring(5);
}
if (condition == string.Empty)
{
condition = "1=1";
}
return(new SqlString(condition));
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery)
{
var sqlBuilder = new SqlStringBuilder(5 + (_cases.Length * 4));
sqlBuilder.Add("(case");
foreach (var projectionCase in _cases)
{
sqlBuilder.Add(" when ");
sqlBuilder.Add(projectionCase.Criterion.ToSqlString(criteria, criteriaQuery));
sqlBuilder.Add(" then ");
sqlBuilder.AddObject(CriterionUtil.GetColumnNameAsSqlStringPart(projectionCase.Projection, criteriaQuery, criteria));
}
sqlBuilder.Add(" else ");
sqlBuilder.AddObject(CriterionUtil.GetColumnNameAsSqlStringPart(_elseProjection, criteriaQuery, criteria));
sqlBuilder.Add(" end) as ");
sqlBuilder.Add(GetColumnAlias(position));
return(sqlBuilder.ToSqlString());
}
public static SqlString[] GetColumnNamesForSimpleExpression(
string propertyName,
IProjection projection,
ICriteriaQuery criteriaQuery,
ICriteria criteria,
ICriterion criterion,
object value)
{
if (projection == null)
{
return(GetColumnNamesUsingPropertyName(
criteriaQuery,
criteria,
propertyName,
value,
criterion));
}
else
{
return(GetColumnNamesUsingProjection(projection, criteriaQuery, criteria));
}
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
SqlString[] columns = CriterionUtil.GetColumnNames(null, _projection, criteriaQuery, criteria, enabledFilters);
if (columns.Length != 1)
{
throw new HibernateException("Like may only be used with single-column properties / projections.");
}
var value = SqlStringHelper.RemoveAsAliasesFromSql(_value.ToSqlString(criteria, 0, criteriaQuery, enabledFilters));
var dialect = criteriaQuery.Factory.Dialect;
var builder = new SqlStringBuilder(8)
.Add(dialect.LowercaseFunction)
.Add(StringHelper.OpenParen)
.Add(columns[0])
.Add(StringHelper.ClosedParen)
.Add(" like ")
.Add(dialect.LowercaseFunction)
.Add(StringHelper.OpenParen)
.Add(value)
.Add(StringHelper.ClosedParen);
return(builder.ToSqlString());
}
/// <summary>
/// Render the SQL Fragment.
/// </summary>
/// <param name="criteria"></param>
/// <param name="position"></param>
/// <param name="criteriaQuery"></param>
/// <param name="enabledFilters"></param>
/// <returns></returns>
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
ISpatialDialect spatialDialect = (ISpatialDialect)criteriaQuery.Factory.Dialect;
string column1 = criteriaQuery.GetColumn(criteria, this.propertyName);
SqlString sqlString;
if (this.IsBinaryOperation())
{
string column2 = criteriaQuery.GetColumn(criteria, this.anotherPropertyName);
sqlString = spatialDialect.GetSpatialAnalysisString(column1, this.analysis, column2);
}
else
{
sqlString = spatialDialect.GetSpatialAnalysisString(column1, this.analysis, this.arguments);
}
return(new SqlStringBuilder()
.Add(sqlString)
.Add(" as y")
.Add(position.ToString())
.Add("_")
.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery)
{
SqlStringBuilder sb = new SqlStringBuilder();
sb.Add("(");
for (int i = 0; i < args.Length; i++)
{
int loc = (position + 1) * 1000 + i;
SqlString projectArg = GetProjectionArgument(criteriaQuery, criteria, args[i], loc);
sb.Add(projectArg);
if (i < args.Length - 1)
{
sb.Add(Op);
}
}
sb.Add(")");
sb.Add(" as ");
sb.Add(GetColumnAliases(position)[0]);
return(sb.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, int loc, ICriteriaQuery criteriaQuery)
{
ISessionFactoryImplementor factory = criteriaQuery.Factory;
SqlType[] sqlTypeCodes = NHibernateUtil.Double.SqlTypes(factory);
string sqlType = factory.Dialect.GetCastTypeName(sqlTypeCodes[0]);
var sql = new SqlStringBuilder().Add(aggregate).Add("(");
sql.Add("cast(");
if (projection != null)
{
sql.Add(SqlStringHelper.RemoveAsAliasesFromSql(projection.ToSqlString(criteria, loc, criteriaQuery)));
}
else
{
sql.Add(criteriaQuery.GetColumn(criteria, propertyName));
}
sql.Add(" as ").Add(sqlType).Add(")");
sql.Add(") as ").Add(GetColumnAliases(loc, criteria, criteriaQuery)[0]);
return(sql.ToSqlString());
}
/// <summary>
/// Generates the <see cref="SqlString" /> object (SQL fragment for the select list) the same way as
/// <see cref="ProjectionList.ToSqlString" /> does, but with the slight difference of omitting group by-only
/// <see cref="FqGroupByProjection" /> projections.
/// </summary>
/// <param name="criteria">
/// The criteria.
/// </param>
/// <param name="position">
/// The position.
/// </param>
/// <param name="criteriaQuery">
/// The criteria query.
/// </param>
/// <param name="enabledFilters">
/// The enabled filters.
/// </param>
/// <returns>
/// The generated <see cref="SqlString" /> object.
/// </returns>
public SqlString ToSqlString
(
ICriteria criteria,
int position,
ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters
)
{
var buffer = new SqlStringBuilder();
bool lastHadValue = false;
foreach (IProjection projection in _elements)
{
SqlString value = projection.ToSqlString(criteria, position, criteriaQuery, enabledFilters);
bool hasValue = value.Length > 0;
if (hasValue)
{
if (lastHadValue)
{
buffer.Add(", ");
}
string[] aliases = projection
.GetColumnAliases(position, criteria, criteriaQuery);
position += aliases.Length;
buffer.Add(value);
}
lastHadValue = hasValue;
}
return(buffer.ToSqlString());
}
/// <summary>
/// Render a SqlString for the expression.
/// </summary>
/// <param name="criteria"></param>
/// <param name="criteriaQuery"></param>
/// <returns>
/// A SqlString that contains a valid Sql fragment.
/// </returns>
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
string[] columnNames = criteriaQuery.GetColumnsUsingProjection(criteria, this.propertyName);
ISpatialDialect spatialDialect = (ISpatialDialect)criteriaQuery.Factory.Dialect;
IType typeUsingProjection = criteriaQuery.GetTypeUsingProjection(criteria, this.propertyName);
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));
}
string[] keyColumns = criteriaQuery.GetIdentifierColumns(criteria);
Parameter[] parameters = criteriaQuery.NewQueryParameter(this.GetTypedValues(criteria, criteriaQuery)[0]).ToArray();
string entityType = criteriaQuery.GetEntityName(criteria, this.propertyName);
AbstractEntityPersister entityPersister = (AbstractEntityPersister)criteriaQuery.Factory.GetEntityPersister(entityType);
// Only one key column is assumed
string keyColumn = keyColumns[0];
string alias = criteriaQuery.GetSQLAlias(criteria, this.propertyName);
string tableName = entityPersister.TableName;
int aliasLength = alias.Length + 1;
SqlStringBuilder sqlBuilder = new SqlStringBuilder(10 * columnNames.Length);
for (int i = 0; i < columnNames.Length; i++)
{
if (i > 0)
{
sqlBuilder.Add(" AND ");
}
string geometryColumn = columnNames[i].Remove(0, aliasLength);
sqlBuilder.Add(spatialDialect.GetSpatialFilterString(alias, geometryColumn, keyColumn, tableName, parameters.Single()));
}
return(sqlBuilder.ToSqlString());
}
public virtual TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
var values = new List <TypedValue>();
if (ParameterValues != null)
{
for (int i = 0; i < ParameterValues.Length; i++)
{
values.Add(new TypedValue(TypeFactory.HeuristicType(ParameterTypes[i].Name), ParameterValues[i], EntityMode.Poco));
}
}
if (ReturnType != null && InnerCriterion is SimpleExpression)
{
var simple = InnerCriterion as SimpleExpression;
values.Add(new TypedValue(TypeFactory.HeuristicType(ReturnType.Name), simple.Value, EntityMode.Poco));
}
if (RightFunction != null)
{
values.AddRange(RightFunction.GetTypedValues(criteria, criteriaQuery));
}
return(values.ToArray());
}
public override SqlString ToSqlString(ICriteria criteria, int loc, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
ISessionFactoryImplementor factory = criteriaQuery.Factory;
SqlType[] sqlTypeCodes = NHibernateUtil.Double.SqlTypes(factory);
string sqlType = factory.Dialect.GetCastTypeName(sqlTypeCodes[0]);
string parameter;
if (projection != null)
{
parameter =
StringHelper.RemoveAsAliasesFromSql(projection.ToSqlString(criteria, loc, criteriaQuery, enabledFilters)).ToString();
}
else
{
parameter = criteriaQuery.GetColumn(criteria, propertyName);
}
string expression = string.Format("{0}(cast({1} as {2})) as {3}", aggregate, parameter, sqlType,
GetColumnAliases(loc)[0]);
return(new SqlString(expression));
}
public override SqlString ToSqlString(ICriteria criteria, int position, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
SqlString condition = criterion.ToSqlString(criteria, criteriaQuery, enabledFilters);
SqlString ifTrue = whenTrue.ToSqlString(criteria, position + GetHashCode() + 1, criteriaQuery, enabledFilters);
ifTrue = StringHelper.RemoveAsAliasesFromSql(ifTrue);
SqlString ifFalse = whenFalse.ToSqlString(criteria, position + GetHashCode() + 2, criteriaQuery, enabledFilters);
ifFalse = StringHelper.RemoveAsAliasesFromSql(ifFalse);
return(new SqlStringBuilder()
.Add("(")
.Add("case when ")
.Add(condition)
.Add(" then ")
.Add(ifTrue)
.Add(" else ")
.Add(ifFalse)
.Add(" end")
.Add(")")
.Add(" as ")
.Add(GetColumnAliases(position)[0])
.ToSqlString());
}
public virtual SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
var sql = new SqlStringBuilder();
string leftPropertyName = null;
string rightPropertyName = null;
if (InnerCriterion is SimpleExpression)
{
leftPropertyName = ((SimpleExpression)InnerCriterion).PropertyName;
}
else if (InnerCriterion is PropertyExpression)
{
System.Type type = typeof(PropertyExpression);
leftPropertyName =
type.GetField("_lhsPropertyName", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(InnerCriterion) as
String;
rightPropertyName =
type.GetField("_rhsPropertyName", BindingFlags.NonPublic | BindingFlags.Instance).GetValue(InnerCriterion) as
String;
}
AddParameters(leftPropertyName, sql, criteria, criteriaQuery);
sql.Add(" ").Add(Op).Add(" ");
if (RightFunction != null)
{
RightFunction.AddParameters(rightPropertyName, sql, criteria, criteriaQuery);
}
else
{
sql.AddParameter();
}
return(sql.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery, IDictionary <string, IFilter> enabledFilters)
{
if (_values.Length == 0)
{
return(new SqlString("1=0"));
}
var result = new SqlStringBuilder();
var columnNames = CriterionUtil.GetColumnNames(null, _projection, criteriaQuery, criteria, enabledFilters);
for (int columnIndex = 0; columnIndex < columnNames.Length; columnIndex++)
{
SqlString columnName = columnNames[columnIndex];
if (columnIndex > 0)
{
result.Add(" and ");
}
result.Add(columnName).Add(" in (").Add(StringHelper.ToString(_values)).Add(")");
}
return(result.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
if (this.criteria.Count == 0)
{
return(EmptyExpression);
}
//TODO: add default capacity
SqlStringBuilder sqlBuilder = new SqlStringBuilder();
sqlBuilder.Add("(");
for (int i = 0; i < this.criteria.Count - 1; i++)
{
sqlBuilder.Add(this.criteria[i].ToSqlString(criteria, criteriaQuery));
sqlBuilder.Add(Op);
}
sqlBuilder.Add(this.criteria[this.criteria.Count - 1].ToSqlString(criteria, criteriaQuery));
sqlBuilder.Add(")");
return(sqlBuilder.ToSqlString());
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery,
IDictionary <string, IFilter> enabledFilters)
{
System.Type type = GetCriteriaClass(criteria);
ISearchFactoryImplementor searchFactory = ContextHelper.GetSearchFactory(GetSession(criteria));
ISet <System.Type> types;
IndexSearcher searcher = FullTextSearchHelper.BuildSearcher(searchFactory, out types, type);
if (searcher == null)
{
throw new SearchException("Could not find a searcher for class: " + type.FullName);
}
Lucene.Net.Search.Query query = FullTextSearchHelper.FilterQueryByClasses(types, luceneQuery);
Hits hits = searcher.Search(query);
List <object> ids = new List <object>();
for (int i = 0; i < hits.Length(); i++)
{
object id = DocumentBuilder.GetDocumentId(searchFactory, type, hits.Doc(i));
ids.Add(id);
}
base.Values = ids.ToArray();
return(base.ToSqlString(criteria, criteriaQuery, enabledFilters));
}
public override SqlString ToSqlString(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
var columnNames = CriterionUtil.GetColumnNames(_propertyName, _projection, criteriaQuery, criteria);
var dialect = criteriaQuery.Factory.Dialect;
if (columnNames.Length != 1)
{
throw new HibernateException("accent insensitive like may only be used with single-column properties");
}
var parameter = criteriaQuery.NewQueryParameter(GetParameterTypedValue(criteria, criteriaQuery)).Single();
if (dialect is Oracle8iDialect)
{
return(GenerateOracleExpression(columnNames[0], dialect, parameter).ToSqlString());
}
if (dialect is MsSql2000Dialect)
{
return(GenerateMsSqlExpression(columnNames[0], parameter).ToSqlString());
}
throw new NotSupportedException();
}
/// <summary>
/// Gets the typed values for parameters in this projection
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <param name="criteriaQuery">The criteria query.</param>
/// <returns></returns>
public TypedValue[] GetTypedValues(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(projection.GetTypedValues(criteria, criteriaQuery));
}
public virtual IType[] GetTypes(String alias, ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(projection.GetTypes(alias, criteria, criteriaQuery));
}
public virtual IType[] GetTypes(ICriteria criteria, ICriteriaQuery criteriaQuery)
{
return(projection.GetTypes(criteria, criteriaQuery));
}
