private void ValidateFilterClause(FilterClause filter, ODataUrlValidationContext validationContext)
{
if (filter != null)
{
ValidateItem(filter, validationContext);
validationContext.ExpressionValidator.ValidateNode(filter.Expression);
}
}
public void DistanceFunctionDefinedForGeometry()
{
FilterClause filter = ParseFilter("geo.distance(GeometryPoint, geometry'POINT(10 30)') eq 2", HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType(), HardCodedTestModel.GetPeopleSet());
filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
filter.Expression.As <BinaryOperatorNode>().Left.ShouldBeSingleValueFunctionCallQueryNode("geo.distance");
filter.Expression.As <BinaryOperatorNode>().Right.ShouldBeConstantQueryNode(2d);
}
public OeQueryContext CreateQueryContext(ODataUri odataUri, int pageSize, bool navigationNextLink, OeMetadataLevel metadataLevel)
{
List <OeParseNavigationSegment> navigationSegments = null;
if (odataUri.Path.LastSegment is KeySegment ||
odataUri.Path.LastSegment is NavigationPropertySegment)
{
navigationSegments = new List <OeParseNavigationSegment>();
ODataPathSegment previousSegment = null;
foreach (ODataPathSegment segment in odataUri.Path)
{
if (segment is NavigationPropertySegment navigationSegment)
{
navigationSegments.Add(new OeParseNavigationSegment(navigationSegment, null));
}
else if (segment is KeySegment)
{
IEdmEntitySet previousEntitySet;
var keySegment = segment as KeySegment;
navigationSegment = null;
if (previousSegment is EntitySetSegment)
{
var previousEntitySetSegment = previousSegment as EntitySetSegment;
previousEntitySet = previousEntitySetSegment.EntitySet;
}
else if (previousSegment is NavigationPropertySegment)
{
navigationSegment = previousSegment as NavigationPropertySegment;
previousEntitySet = (IEdmEntitySet)navigationSegment.NavigationSource;
}
else
{
throw new InvalidOperationException("invalid segment");
}
FilterClause keyFilter = CreateFilterClause(previousEntitySet, keySegment.Keys);
navigationSegments.Add(new OeParseNavigationSegment(navigationSegment, keyFilter));
}
previousSegment = segment;
}
}
if (pageSize > 0)
{
odataUri.Top = pageSize;
IEdmEntityType edmEntityType = GetEntityType(odataUri.Path, navigationSegments);
odataUri.OrderBy = OeSkipTokenParser.GetUniqueOrderBy(_edmModel, edmEntityType, odataUri.OrderBy, odataUri.Apply);
}
var entitySetSegment = (EntitySetSegment)odataUri.Path.FirstSegment;
IEdmEntitySet entitySet = entitySetSegment.EntitySet;
Db.OeEntitySetAdapter entitySetAdapter = _dataAdapter.EntitySetAdapters.FindByEntitySetName(entitySet.Name);
bool isCountSegment = odataUri.Path.LastSegment is CountSegment;
return(new OeQueryContext(_edmModel, odataUri, entitySet, navigationSegments,
isCountSegment, pageSize, navigationNextLink, _dataAdapter.IsDatabaseNullHighestValue, metadataLevel, entitySetAdapter));
}
/// <summary>
/// Binds a <see cref="SyntacticTree"/>.
/// </summary>
/// <param name="syntax">The query descriptor token to bind.</param>
/// <returns>The bound query descriptor.</returns>
public ODataUri BindTree(SyntacticTree syntax)
{
ExceptionUtils.CheckArgumentNotNull(syntax, "syntax");
ExceptionUtils.CheckArgumentNotNull(syntax.Path, "syntax.Path");
// Make a copy of query options since we may consume some of them as we bind the query
bindingState.QueryOptions = new List <CustomQueryOptionToken>(syntax.QueryOptions);
ParameterAliasValueAccessor parameterAliasValueAccessor = new ParameterAliasValueAccessor(syntax.ParameterAliases);
ODataPath path = null;
FilterClause filter = null;
OrderByClause orderBy = null;
long? skip = null;
long? top = null;
SelectExpandClause selectExpand = null;
bool? count = null;
// set parameterAliasValueAccessor for uri path, $filter, $orderby
this.bindingState.Configuration.ParameterAliasValueAccessor = parameterAliasValueAccessor;
// First bind the path
path = ODataPathFactory.BindPath(syntax.Path, this.bindingState.Configuration);
// If the path leads to a collection, then create a range variable that represents iterating over the collection
var rangeVariable = NodeFactory.CreateImplicitRangeVariable(path);
if (rangeVariable != null)
{
this.bindingState.RangeVariables.Push(rangeVariable);
}
if (syntax.Filter != null || syntax.OrderByTokens.Any())
{
this.bindingState.ImplicitRangeVariable = this.bindingState.RangeVariables.Peek();
}
// Apply filter first, then order-by, skip, top, select and expand
filter = BindFilter(syntax, rangeVariable);
orderBy = BindOrderBy(syntax, rangeVariable, path);
skip = BindSkip(syntax, rangeVariable, path);
top = BindTop(syntax, rangeVariable, path);
selectExpand = BindSelectExpand(syntax, path, this.bindingState.Configuration);
count = BindQueryCount(syntax, path);
// Add the remaining query options to the query descriptor.
List <QueryNode> boundQueryOptions = MetadataBinder.ProcessQueryOptions(this.bindingState, this.bindMethod);
Debug.Assert(bindingState.QueryOptions == null, "this.queryOptions == null");
bindingState.RangeVariables.Pop();
bindingState.ImplicitRangeVariable = null;
return(new ODataUri(parameterAliasValueAccessor, path, boundQueryOptions, selectExpand, filter, orderBy, skip, top, count));
}
/// <summary>
/// Initializes a new instance of the <see cref="Join"/> class.
/// </summary>
/// <param name="joinType">Type of the join to create.</param>
/// <param name="table">The table to join.</param>
/// <param name="on">The join condition.</param>
public Join(JoinType joinType, IDataSource table, ConditionBase on)
{
JoinType = joinType;
Table = table;
if (!(on is null))
{
On = new FilterClause(on);
}
}
internal static SyncConfiguration DeserializeFromDmSet(DmSet set)
{
if (set == null)
{
return(null);
}
if (!set.Tables.Contains("DotmimSync__ServiceConfiguration"))
{
return(null);
}
SyncConfiguration configuration = new SyncConfiguration();
var dmRowConfiguration = set.Tables["DotmimSync__ServiceConfiguration"].Rows[0];
configuration.BatchDirectory = dmRowConfiguration["BatchDirectory"] as String;;
configuration.Archive = dmRowConfiguration["Archive"] as String;;
configuration.ConflictResolutionPolicy = (ConflictResolutionPolicy)dmRowConfiguration["ConflictResolutionPolicy"];
configuration.DownloadBatchSizeInKB = (int)dmRowConfiguration["DownloadBatchSizeInKB"];
configuration.UseBulkOperations = (bool)dmRowConfiguration["UseBulkOperations"];
configuration.UseVerboseErrors = (bool)dmRowConfiguration["UseVerboseErrors"];
configuration.SerializationFormat = (SerializationFormat)dmRowConfiguration["SerializationConverter"];
if (set.Tables.Contains("DotmimSync__Filters"))
{
var dmTableFilterParameters = set.Tables["DotmimSync__Filters"];
foreach (var dmRowFilter in dmTableFilterParameters.Rows)
{
FilterClause filterClause = new FilterClause();
var tableName = dmRowFilter["TableName"] as String;
var columnName = dmRowFilter["ColumnName"] as String;
configuration.Filters.Add(tableName, columnName);
}
}
var configTables = set.Tables.Where(tbl => !tbl.TableName.StartsWith("DotmimSync__"));
if (configTables != null)
{
foreach (var configTable in configTables)
{
configuration.ScopeSet.Tables.Add(configTable.Clone());
}
}
if (set.Relations != null && set.Relations.Count > 0)
{
foreach (var r in set.Relations)
{
var relation = r.Clone(configuration.ScopeSet);
configuration.ScopeSet.Relations.Add(relation);
}
}
return(configuration);
}
public void IntersectsWorksInFilter()
{
FilterClause filter = ParseFilter("geo.intersects(GeometryPoint, GeometryPolygon)", HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
filter.Expression.ShouldBeSingleValueFunctionCallQueryNode("geo.intersects");
filter.Expression.As <SingleValueFunctionCallNode>().Parameters.Count().Should().Be(2);
filter.Expression.As <SingleValueFunctionCallNode>().Parameters.ElementAt(0).ShouldBeSingleValuePropertyAccessQueryNode(HardCodedTestModel.GetPersonGeometryPointProp());
filter.Expression.As <SingleValueFunctionCallNode>().Parameters.ElementAt(1).ShouldBeSingleValuePropertyAccessQueryNode(HardCodedTestModel.GetPersonGeometryPolygonProp());
}
public Query()
{
_selectClause = new SelectClause(this);
_fromClause = new FromClause(this);
_whereClause = new FilterClause(this, AbstractQueryClause <FilterItem> .PREFIX_WHERE);
_groupByClause = new GroupByClause(this);
_havingClause = new FilterClause(this, AbstractQueryClause <FilterItem> .PREFIX_HAVING);
_orderByClause = new OrderByClause(this);
} // constructor
/// <summary>Translates a <see cref="FilterClause"/> into a string.</summary>
/// <param name="filterClause">The filter clause to translate.</param>
/// <returns>The translated String.</returns>
internal String TranslateFilterClause(FilterClause filterClause)
{
Debug.Assert(filterClause != null, "filterClause != null");
rangeVariables.Push(filterClause.RangeVariable);
string query = this.TranslateNode(filterClause.Expression);
rangeVariables.Pop();
return(query);
}
public void HandlesNotStartsWith()
{
// Act
var result = new FilterClause("startsWith(input, 'abcd') eq false");
// Assert
Assert.AreEqual(result.FieldName, "input");
Assert.IsTrue(result.Predicate("234567"));
Assert.IsFalse(result.Predicate("abcd"));
}
public void HandlesStartsWith()
{
// Act
var result = new FilterClause("startsWith(input, 'abcd')");
// Assert
Assert.AreEqual(result.FieldName, "input");
Assert.IsTrue(result.Predicate("abcdef"));
Assert.IsFalse(result.Predicate("fedcba"));
}
public void HandlesNotContains()
{
// Act
var result = new FilterClause("contains(input,'abcd') eq false");
// Assert
Assert.AreEqual(result.FieldName, "input");
Assert.IsTrue(result.Predicate("12345"));
Assert.IsFalse(result.Predicate("123abcd45"));
}
public void HandlesNe()
{
// Act
var result = new FilterClause("input ne 'abcd'");
// Assert
Assert.AreEqual(result.FieldName, "input");
Assert.IsTrue(result.Predicate("dcba"));
Assert.IsFalse(result.Predicate("abcd"));
}
public void LengthFunctionWorksInFilter()
{
FilterClause filter = ParseFilter("geo.length(GeometryLineString) eq 2.0", HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
var bon = Assert.IsType<BinaryOperatorNode>(filter.Expression);
var functionCallNode = bon.Left.ShouldBeSingleValueFunctionCallQueryNode("geo.length");
var parameter = Assert.Single(functionCallNode.Parameters);
parameter.ShouldBeSingleValuePropertyAccessQueryNode(HardCodedTestModel.GetPersonGeometryLineStringProp());
bon.Right.ShouldBeConstantQueryNode(2.0d);
}
public void FilterSegmentConstructWithNullParameterAliasShouldThrowException()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
Action create = () => new FilterSegment(null, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
Assert.Throws <ArgumentNullException>("expression", create);
}
public void FilterSegmentConstructWithNullParameterAliasShouldThrowException()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
Action create = () => new FilterSegment(null, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
create.ShouldThrow <ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: expression");
}
public static string BindFilterQueryOption(FilterClause filterClause, IEdmModel model)
{
if (filterClause == null || model == null)
{
return(string.Empty);
}
SQLFilterBinder binder = new SQLFilterBinder(model);
return(binder.BindFilterClause(filterClause) + Environment.NewLine);
}
public void LengthFunctionWorksInFilter()
{
FilterClause filter = ParseFilter("geo.length(GeometryLineString) eq 2.0", HardCodedTestModel.TestModel, HardCodedTestModel.GetPersonType());
filter.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
filter.Expression.As <BinaryOperatorNode>().Left.ShouldBeSingleValueFunctionCallQueryNode("geo.length");
filter.Expression.As <BinaryOperatorNode>().Left.As <SingleValueFunctionCallNode>().Parameters.Count().Should().Be(1);
filter.Expression.As <BinaryOperatorNode>().Left.As <SingleValueFunctionCallNode>().Parameters.ElementAt(0).ShouldBeSingleValuePropertyAccessQueryNode(HardCodedTestModel.GetPersonGeometryLineStringProp());
filter.Expression.As <BinaryOperatorNode>().Right.ShouldBeConstantQueryNode(2.0d);
}
public void FilterSegmentShouldNotBeSingleResult()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
ParameterAliasNode expression = filterClause.Expression as ParameterAliasNode;
FilterSegment filterSegment = new FilterSegment(expression, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
filterSegment.SingleResult.Should().BeFalse();
}
public void FilterSegmentShouldHaveSameTypeAsRangeVariableTypeDefinition()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
ParameterAliasNode expression = filterClause.Expression as ParameterAliasNode;
FilterSegment filterSegment = new FilterSegment(expression, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
filterSegment.EdmType.Equals(filterClause.RangeVariable.TypeReference.Definition).Should().BeFalse();
}
public void FilterOptionSetCorrectly()
{
BinaryOperatorNode filterExpression = new BinaryOperatorNode(BinaryOperatorKind.Equal, new ConstantNode(1), new ConstantNode(1));
FilterClause filterClause = new FilterClause(filterExpression, new EntityRangeVariable(ExpressionConstants.It, HardCodedTestModel.GetPersonTypeReference(), HardCodedTestModel.GetPeopleSet()));
ExpandedNavigationSelectItem expansion = new ExpandedNavigationSelectItem(new ODataExpandPath(new NavigationPropertySegment(ModelBuildingHelpers.BuildValidNavigationProperty(), null)), HardCodedTestModel.GetPeopleSet(), filterClause, null, null, null, null, null, null, null);
expansion.FilterOption.Expression.ShouldBeBinaryOperatorNode(BinaryOperatorKind.Equal);
expansion.FilterOption.Expression.As <BinaryOperatorNode>().Left.ShouldBeConstantQueryNode(1);
expansion.FilterOption.Expression.As <BinaryOperatorNode>().Right.ShouldBeConstantQueryNode(1);
}
/// <summary>
/// Creates the price range query.
/// </summary>
/// <param name="priceLists">The price lists.</param>
/// <param name="index">The index.</param>
/// <param name="field">The field.</param>
/// <param name="currency">The currency.</param>
/// <param name="lowerbound">The lowerbound.</param>
/// <param name="upperbound">The upperbound.</param>
/// <param name="lowerboundincluded">
/// if set to <c>true</c> [lowerboundincluded].
/// </param>
/// <param name="upperboundincluded">
/// if set to <c>true</c> [upperboundincluded].
/// </param>
/// <returns></returns>
private static BooleanFilter CreatePriceRangeQuery(
string[] priceLists,
int index,
string field,
string currency,
string lowerbound,
string upperbound,
bool lowerboundincluded,
bool upperboundincluded)
{
var query = new BooleanFilter();
// create left part
var filter =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
"*",
"*",
true,
false);
var leftClause = new FilterClause(filter, Occur.MUST_NOT);
query.Add(leftClause);
// create right part
if (index == priceLists.Count()) // last element
{
//var rangefilter = NumericRangeFilter.;
var filter2 =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded);
var rightClause = new FilterClause(filter2, Occur.MUST);
query.Add(rightClause);
}
else
{
query.Add(new FilterClause(
CreatePriceRangeQuery(
priceLists,
index + 1,
field,
currency,
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded),
Occur.SHOULD));
}
return(query);
}
/// <summary>
/// Checks if the specified game must be retained accordingly to the specified filter
/// </summary>
/// <param name="rawGame"> PGN Raw game</param>
/// <param name="iAvgELO"> Game average ELO</param>
/// <param name="filterClause"> Filter clause</param>
/// <returns>
/// true if must be retained
/// </returns>
private bool IsRetained(PgnGame rawGame, int iAvgELO, FilterClause filterClause)
{
bool bRetVal = true;
string strGameResult;
string strGameDate;
if (iAvgELO == -1)
{
bRetVal = filterClause.m_bIncludesUnrated;
}
else if (filterClause.m_bAllRanges)
{
bRetVal = true;
}
else
{
iAvgELO = iAvgELO / 100 * 100;
bRetVal = filterClause.m_hashRanges.ContainsKey(iAvgELO);
}
if (bRetVal)
{
if (!filterClause.m_bAllPlayers || !filterClause.m_bAllEnding)
{
GetPGNGameInfo(rawGame, out strGameResult, out strGameDate);
if (!filterClause.m_bAllPlayers)
{
if (!filterClause.m_hashPlayerList.ContainsKey(rawGame.BlackPlayer) &&
!filterClause.m_hashPlayerList.ContainsKey(rawGame.WhitePlayer))
{
bRetVal = false;
}
}
if (bRetVal && !filterClause.m_bAllEnding)
{
if (strGameResult == "1-0")
{
bRetVal = filterClause.m_bEndingWhiteWinning;
}
else if (strGameResult == "0-1")
{
bRetVal = filterClause.m_bEndingBlackWinning;
}
else if (strGameResult == "1/2-1/2")
{
bRetVal = filterClause.m_bEndingDraws;
}
else
{
bRetVal = false;
}
}
}
}
return(bRetVal);
}
internal static ICriteria FilterContentQuery(this ICriteria criteria, FilterClause filterClause, IODataServiceMetadata metadata)
{
var criterionVisitor = new NHibernateCriterionVisitor(criteria, filterClause, metadata);
var criterion = criterionVisitor.Visit(filterClause.Expression);
if (null != criterion)
{
criteria.Add(criterion);
}
return(criteria);
}
/// <summary>
/// Build a SQL filter statement (e.g.: ColumA = param0).
/// </summary>
/// <param name="sqlFilterOperator"></param>
/// <param name="filter"></param>
/// <param name="index"></param>
/// <param name="paramters"></param>
/// <returns></returns>
private string BuildParam(string sqlFilterOperator, FilterClause filter, int index, DynamicParameters paramters)
{
string parameterName = string.Empty;
string filterClause = string.Empty;
parameterName = "@param" + index.ToString();
filterClause = sqlFilterOperator + " " + filter.BuildFilterClause + " " + parameterName;
paramters.Add(parameterName, filter.ColumnValue);
return(filterClause);
}
public void HandlesNotIn()
{
// Act
var result = new FilterClause("input in ( 1 , 2 ) eq false");
// Assert
Assert.AreEqual(result.FieldName, "input");
Assert.IsTrue(result.Predicate(3.ToString()));
Assert.IsFalse(result.Predicate(1.ToString()));
Assert.IsFalse(result.Predicate(2.ToString()));
}
public void FilterSegmentWithExpressionShouldConstructSuccessfully()
{
const string filterExpression = "ID eq 1";
FilterClause filterClause = CreateFilterClause(filterExpression);
BinaryOperatorNode expression = filterClause.Expression as BinaryOperatorNode;
FilterSegment filterSegment = new FilterSegment(expression, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
filterSegment.Expression.Equals(expression).Should().BeTrue();
filterSegment.RangeVariable.Equals(filterClause.RangeVariable).Should().BeTrue();
}
public void FilterSegmentWithAllParametersShouldConstructSuccessfully()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
ParameterAliasNode expression = filterClause.Expression as ParameterAliasNode;
FilterSegment filterSegment = new FilterSegment(expression, filterClause.RangeVariable, HardCodedTestModel.GetPet1Set());
filterSegment.Expression.Equals(expression).Should().BeTrue();
filterSegment.RangeVariable.Equals(filterClause.RangeVariable).Should().BeTrue();
}
public void FilterSegmentConstructWithNullNavigationSourceShouldThrowException()
{
const string filterExpression = "@a1";
FilterClause filterClause = CreateFilterClause(filterExpression);
ParameterAliasNode expression = filterClause.Expression as ParameterAliasNode;
Action create = () => new FilterSegment(expression, filterClause.RangeVariable, null);
create.ShouldThrow <ArgumentNullException>().WithMessage("Value cannot be null.\r\nParameter name: navigationSource");
}
public bool IsFilterable(FilterClause filterClause, OeModelBoundSettings settings)
{
if (settings != null)
{
var filterableVisitor = new FilterableVisitor(this, settings);
filterClause.Expression.Accept(filterableVisitor);
return(filterableVisitor.IsFilterable);
}
return(true);
}
/// <summary>
/// Builds the query.
/// </summary>
/// <param name="criteria">The criteria.</param>
/// <returns></returns>
public virtual object BuildQuery(ISearchCriteria criteria)
{
var queryBuilder = new QueryBuilder();
var queryFilter = new BooleanFilter();
var query = new BooleanQuery();
queryBuilder.Query = query;
queryBuilder.Filter = queryFilter;
if (criteria.CurrentFilters != null)
{
foreach (var filter in criteria.CurrentFilters)
{
// Skip currencies that are not part of the filter
if (filter.GetType() == typeof(PriceRangeFilter)) // special filtering
{
var currency = (filter as PriceRangeFilter).Currency;
if (!currency.Equals(criteria.Currency, StringComparison.OrdinalIgnoreCase))
{
continue;
}
}
var filterQuery = LuceneQueryHelper.CreateQuery(criteria, filter, Occur.SHOULD);
// now add other values that should also be counted?
if (filterQuery != null)
{
var clause = new FilterClause(filterQuery, Occur.MUST);
queryFilter.Add(clause);
}
}
}
return queryBuilder;
}
protected string BindFilterClause(FilterClause filterClause)
{
return Bind(filterClause.Expression);
}
/// <summary>
/// Creates the price range query.
/// </summary>
/// <param name="priceLists">The price lists.</param>
/// <param name="index">The index.</param>
/// <param name="field">The field.</param>
/// <param name="currency">The currency.</param>
/// <param name="lowerbound">The lowerbound.</param>
/// <param name="upperbound">The upperbound.</param>
/// <param name="lowerboundincluded">
/// if set to <c>true</c> [lowerboundincluded].
/// </param>
/// <param name="upperboundincluded">
/// if set to <c>true</c> [upperboundincluded].
/// </param>
/// <returns></returns>
private static BooleanFilter CreatePriceRangeQuery(
string[] priceLists,
int index,
string field,
string currency,
string lowerbound,
string upperbound,
bool lowerboundincluded,
bool upperboundincluded)
{
var query = new BooleanFilter();
// create left part
var filter =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
"*",
"*",
true,
false);
var leftClause = new FilterClause(filter, Occur.MUST_NOT);
query.Add(leftClause);
// create right part
if (index == priceLists.Count()) // last element
{
//var rangefilter = NumericRangeFilter.;
var filter2 =
new TermRangeFilter(
String.Format("{0}_{1}_{2}", field, currency, priceLists[index - 1].ToLower()),
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded);
var rightClause = new FilterClause(filter2, Occur.MUST);
query.Add(rightClause);
}
else
{
query.Add(new FilterClause(
CreatePriceRangeQuery(
priceLists,
index + 1,
field,
currency,
lowerbound,
upperbound,
lowerboundincluded,
upperboundincluded),
Occur.SHOULD));
}
return query;
}
public virtual void VisitFilterClause (FilterClause filterClause)
{
VisitChildren (filterClause);
}
public void VisitFilterClause(FilterClause filterClause)
{
StartNode(filterClause);
Space(policy.SpaceBeforeCatchParentheses);
WriteKeyword(FilterClause.FilterKeywordRole);
Space(policy.SpaceBeforeCatchParentheses);
LPar();
Space(policy.SpacesWithinCatchParentheses);
filterClause.Expression.AcceptVisitor(this);
Space(policy.SpacesWithinCatchParentheses);
RPar();
EndNode(filterClause);
}