public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
methodInfoRegistry.Register(new[] { LinqExtensionMethods.SetOptionsDefinition }, typeof(OptionsExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//Register new clause type
customNodeTypeRegistry.Register(WhereMissingExpressionNode.SupportedMethods,
typeof(WhereMissingExpressionNode));
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void When_Brackets_Expect_Reference()
{
var parser = new ExpressionTreeParser();
Check(1 - (5.8 - 12) - 3, parser.Parse("1 - (5.8 - 12) - 3"));
Check(2 * (2 + 3) * 4, parser.Parse("2 * ((2 + 3)) * 4"));
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.Fetch <object, object>(null, null)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.FetchMany <object, object>(null, null)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetch <object, object, object>(null, null)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.GetMethodDefinition(() => EagerFetchingExtensionMethods.ThenFetchMany <object, object, object>(null, null)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.GetMethodDefinition(() => default(IQueryable <object>).WithLock(LockMode.Read)),
ReflectHelper.GetMethodDefinition(() => default(IEnumerable <object>).WithLock(LockMode.Read))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public void Initialization_InjectExpressionTreeParser()
{
var expressionTreeParser = new ExpressionTreeParser(new MethodInfoBasedNodeTypeRegistry(), new NullExpressionTreeProcessor());
var queryParser = new QueryParser(expressionTreeParser);
Assert.That(queryParser.ExpressionTreeParser, Is.SameAs(expressionTreeParser));
}
static NhRelinqQueryParser()
{
var preTransformerRegistry = new ExpressionTransformerRegistry();
// NH-3247: must remove .Net compiler char to int conversion before
// parameterization occurs.
preTransformerRegistry.Register(new RemoveCharToIntConversion());
PreProcessor = new TransformingExpressionTreeProcessor(preTransformerRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
transformerRegistry.Register(new RemoveRedundantCast());
transformerRegistry.Register(new SimplifyCompareTransformer());
// If needing a compound processor for adding other processing, do not use
// ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry), it would
// cause NH-3961 again by including a PartialEvaluatingExpressionTreeProcessor.
// Directly instantiate a CompoundExpressionTreeProcessor instead.
var processor = new TransformingExpressionTreeProcessor(transformerRegistry);
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
QueryParser = new QueryParser(expressionTreeParser);
}
public static IQueryParser CreateFetchXmlQueryParser()
{
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
RegisterCustomNodes(customNodeTypeRegistry);
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
// Register custom expression transformers executed _after_ partial evaluation here (this should be the default):
// transformerRegistry.Register (new MyExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
// To register custom expression transformers executed _before_ partial evaluation, use this code:
// var earlyTransformerRegistry = new ExpressionTransformerRegistry();
// earlyTransformerRegistry.Register (new MyEarlyExpressionTransformer());
// processor.InnerProcessors.Insert (0, new TransformingExpressionTreeProcessor (tranformationProvider));
// Add custom processors here (use Insert (0, ...) to add at the beginning):
// processor.InnerProcessors.Add (new MyExpressionTreeProcessor());
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public void When_Conditional_Expect_Reference()
{
var parser = new ExpressionTreeParser();
Check(1, parser.Parse("1 >= 0 ? 1 : 2"));
Check(2, parser.Parse("1 >= 3 ? 1 : 2"));
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("Fetch") }, typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("FetchMany") }, typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetch") }, typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(new[] { typeof(EagerFetchingExtensionMethods).GetMethod("ThenFetchMany") }, typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
typeof(LinqExtensionMethods).GetMethod("Cacheable"),
typeof(LinqExtensionMethods).GetMethod("CacheMode"),
typeof(LinqExtensionMethods).GetMethod("CacheRegion"),
}, typeof(CacheableExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable(null)),
ReflectionHelper.GetMethodDefinition(() => Queryable.AsQueryable <object>(null)),
}, typeof(AsQueryableExpressionNode)
);
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public NHibernateNodeTypeProvider()
{
var methodInfoRegistry = new MethodInfoBasedNodeTypeRegistry();
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.Fetch, default(IQueryable <object>), default(Expression <Func <object, object> >)) },
typeof(FetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchLazyProperties, default(IQueryable <object>)) },
typeof(FetchLazyPropertiesExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.FetchMany, default(IQueryable <object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(FetchManyExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetch, default(INhFetchRequest <object, object>), default(Expression <Func <object, object> >)) },
typeof(ThenFetchOneExpressionNode));
methodInfoRegistry.Register(
new[] { ReflectHelper.FastGetMethodDefinition(EagerFetchingExtensionMethods.ThenFetchMany, default(INhFetchRequest <object, object>), default(Expression <Func <object, IEnumerable <object> > >)) },
typeof(ThenFetchManyExpressionNode));
methodInfoRegistry.Register(
new[]
{
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IQueryable <object>), default(LockMode)),
ReflectHelper.FastGetMethodDefinition(LinqExtensionMethods.WithLock, default(IEnumerable <object>), default(LockMode))
},
typeof(LockExpressionNode));
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(methodInfoRegistry);
defaultNodeTypeProvider = nodeTypeProvider;
}
public void GetQueryOperatorExpression_ArrayLength_NotRegistered()
{
var expressionTreeParser = new ExpressionTreeParser(new MethodInfoBasedNodeTypeRegistry(), new NullExpressionTreeProcessor());
var memberExpression = (UnaryExpression)ExpressionHelper.MakeExpression(() => new int[0].Length);
var queryOperatorExpression = expressionTreeParser.GetQueryOperatorExpression(memberExpression);
Assert.That(queryOperatorExpression, Is.Null);
}
public void GetQueryOperatorExpression_MemberExpression_NotRegistered()
{
var expressionTreeParser = new ExpressionTreeParser(new MethodInfoBasedNodeTypeRegistry(), new NullExpressionTreeProcessor());
var memberExpression = (MemberExpression)ExpressionHelper.MakeExpression(() => new List <int> ().Count);
var queryOperatorExpression = expressionTreeParser.GetQueryOperatorExpression(memberExpression);
Assert.That(queryOperatorExpression, Is.Null);
}
internal static QueryParser CreateQueryParser()
{
var expressionTreeParser = new ExpressionTreeParser(
CreateNodeTypeProvider(),
CreateExpressionTreeProcessor());
return(new QueryParser(expressionTreeParser));
}
private SubQueryFindingExpressionTreeVisitor(INodeTypeProvider nodeTypeProvider)
{
ArgumentUtility.CheckNotNull("nodeTypeProvider", nodeTypeProvider);
_nodeTypeProvider = nodeTypeProvider;
_expressionTreeParser = new ExpressionTreeParser(_nodeTypeProvider, new NullExpressionTreeProcessor());
_queryParser = new QueryParser(_expressionTreeParser);
}
public virtual void SetUp()
{
SourceNode = ExpressionNodeObjectMother.CreateMainSource();
ClauseGenerationContext = new ClauseGenerationContext(ExpressionTreeParser.CreateDefaultNodeTypeProvider());
QueryModel = SourceNode.Apply(null, ClauseGenerationContext);
SourceClause = QueryModel.MainFromClause;
SourceReference = (QuerySourceReferenceExpression)QueryModel.SelectClause.Selector;
}
public void CreateDefaultProcessor_WithoutEvaluatableExpressionFilter_UsesANullImplementation()
{
var inputTransformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(inputTransformerRegistry);
Assert.That(processor.InnerProcessors.Count, Is.EqualTo(2));
Assert.That(processor.InnerProcessors[0], Is.TypeOf(typeof(PartialEvaluatingExpressionTreeProcessor)));
Assert.That(((PartialEvaluatingExpressionTreeProcessor)processor.InnerProcessors[0]).Filter, Is.Not.Null);
}
private static void CreateDefaultNodeTypeProvider()
{
Console.WriteLine("Creating NodeTypeProvider...");
var stopwatch = Stopwatch.StartNew();
ExpressionTreeParser.CreateDefaultNodeTypeProvider();
stopwatch.Stop();
Console.WriteLine("Time taken: {0}ms, reference time: ~30ms", stopwatch.ElapsedMilliseconds);
}
public override string GenerateSelect <T>(out IList <QueryInfo> parameters, List <Expression <Func <T, bool> > > where = null, Dictionary <Expression <Func <T, object> >, RowOrder> orderBy = null, int page = 1, int count = int.MaxValue)
{
parameters = new List <QueryInfo>();
var builder = new StringBuilder();
var tableName = DotEntityDb.GetTableNameForType <T>();
var whereString = "";
if (where != null)
{
var parser = new ExpressionTreeParser();
var whereStringBuilder = new List <string>();
foreach (var wh in where)
{
whereStringBuilder.Add(parser.GetWhereString(wh));
}
parameters = parser.QueryInfoList;
whereString = string.Join(" AND ", whereStringBuilder).Trim();
}
var orderByStringBuilder = new List <string>();
var orderByString = "";
if (orderBy != null)
{
var parser = new ExpressionTreeParser();
foreach (var ob in orderBy)
{
orderByStringBuilder.Add(parser.GetOrderByString(ob.Key) + (ob.Value == RowOrder.Descending ? " DESC" : ""));
}
orderByString = string.Join(", ", orderByStringBuilder).Trim(',');
}
// make the query now
builder.Append($"SELECT {QueryParserUtilities.GetSelectColumnString(new List<Type>() { typeof(T) })} FROM ");
builder.Append(tableName.ToEnclosed());
if (!string.IsNullOrEmpty(whereString))
{
builder.Append(" WHERE " + whereString);
}
if (!string.IsNullOrEmpty(orderByString))
{
builder.Append(" ORDER BY " + orderByString);
}
if (page > 1 || count != int.MaxValue)
{
var offset = (page - 1) * count;
builder.Append($" LIMIT {offset},{count}");
}
var query = builder.ToString().Trim() + ";";
return(query);
}
private QueryParser CreateQueryParserWithCustimizedPartialEvaluation()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var evaluatableExpressionFilter = new QueryParserIntegrationTestsEvaluatableExpressionFilter();
var expressionTreeParser = new ExpressionTreeParser(
ExpressionTreeParser.CreateDefaultNodeTypeProvider(),
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry, evaluatableExpressionFilter));
return(new QueryParser(expressionTreeParser));
}
private static CompoundNodeTypeProvider CreateNodeTypeProvider()
{
var registry = MethodInfoBasedNodeTypeRegistry.CreateFromTypes(typeof(RelinqQueryParserFactory).Assembly.GetTypes());
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
nodeTypeProvider.InnerProviders.Add(registry);
return(nodeTypeProvider);
}
/// <summary>
/// Creates the parser.
/// </summary>
private static QueryParser CreateParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var proc = CreateCompoundProcessor(transformerRegistry);
var parser = new ExpressionTreeParser(ExpressionTreeParser.CreateDefaultNodeTypeProvider(), proc);
return(new QueryParser(parser));
}
public void CreateDefaultNodeTypeProvider()
{
var result = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
Assert.That(result.InnerProviders.Count, Is.EqualTo(2));
Assert.That(result.InnerProviders[0], Is.TypeOf(typeof(MethodInfoBasedNodeTypeRegistry)));
Assert.That(result.InnerProviders[1], Is.TypeOf(typeof(MethodNameBasedNodeTypeRegistry)));
Assert.That(((MethodInfoBasedNodeTypeRegistry)result.InnerProviders[0]).RegisteredMethodInfoCount, Is.GreaterThan(0));
Assert.That(((MethodNameBasedNodeTypeRegistry)result.InnerProviders[1]).RegisteredNamesCount, Is.GreaterThan(0));
}
public static CustomQueryParser CreateDefault()
{
var compoundNodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
return
(new CustomQueryParser(
new ExpressionTreeParser(
compoundNodeTypeProvider,
ExpressionTreeParserHelper.CreateDefaultProcessor(
ExpressionTransformerRegistry.CreateDefault()))));
}
private static IQueryParser CreateQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var expressionTreeParser
= new ExpressionTreeParser(
CreateNodeTypeProvider(),
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry));
return(new QueryParser(expressionTreeParser));
}
/// <summary>
/// Creates an <c cref="IExpressionTreeProcessor"/> that will execute
/// <c cref="AllowSpecialCharactersExpressionTransformer"/>
/// before executing <c cref="PartialEvaluatingExpressionTreeProcessor"/>
/// and other default processors.
/// </summary>
internal static IExpressionTreeProcessor CreateExpressionTreeProcessor()
{
var firstRegistry = new ExpressionTransformerRegistry();
firstRegistry.Register(new AllowSpecialCharactersExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(ExpressionTransformerRegistry.CreateDefault());
processor.InnerProcessors.Insert(0, new TransformingExpressionTreeProcessor(firstRegistry));
return(processor);
}
static MongoQueryParser()
{
var nodeTypeProvider = new MongoNodeTypeProvider();
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
queryParser = new QueryParser(expressionTreeParser);
}
public static IQueryParser CreateQueryParser()
{
//Create Custom node registry
var customNodeTypeRegistry = new MethodInfoBasedNodeTypeRegistry();
//register the "Nest" clause type
customNodeTypeRegistry.Register(NestExpressionNode.SupportedMethods,
typeof(NestExpressionNode));
//register the "Explain" expression node parser
customNodeTypeRegistry.Register(ExplainExpressionNode.SupportedMethods,
typeof(ExplainExpressionNode));
//register the "UseKeys" expression node parser
customNodeTypeRegistry.Register(UseKeysExpressionNode.SupportedMethods,
typeof(UseKeysExpressionNode));
//register the "UseIndex" expression node parser
customNodeTypeRegistry.Register(UseIndexExpressionNode.SupportedMethods,
typeof(UseIndexExpressionNode));
//register the "ExtentName" expression node parser
customNodeTypeRegistry.Register(ExtentNameExpressionNode.SupportedMethods,
typeof(ExtentNameExpressionNode));
//register the "ToQueryRequest" expression node parser
customNodeTypeRegistry.Register(ToQueryRequestExpressionNode.SupportedMethods,
typeof(ToQueryRequestExpressionNode));
//This creates all the default node types
var nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
//add custom node provider to the providers
nodeTypeProvider.InnerProviders.Add(customNodeTypeRegistry);
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
//Register transformer to handle enum == and != comparisons
transformerRegistry.Register(new EnumComparisonExpressionTransformer());
//Register transformer to handle string comparisons
transformerRegistry.Register(new StringComparisonExpressionTransformer());
//Register transformer to handle DateTime comparisons
transformerRegistry.Register(new DateTimeComparisonExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
/// <summary>
/// The create query parser.
/// </summary>
/// <returns>
/// The <see cref="IQueryParser" />.
/// </returns>
public static IQueryParser CreateQueryParser()
{
CompoundNodeTypeProvider nodeTypeProvider = ExpressionTreeParser.CreateDefaultNodeTypeProvider();
var earlyTransformerRegistry = new ExpressionTransformerRegistry();
earlyTransformerRegistry.Register(new DateTimeEarlyExpressionTransformer());
CompoundExpressionTreeProcessor processor = CreateDefaultProcessor(earlyTransformerRegistry);
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
var queryParser = new QueryParser(expressionTreeParser);
return(queryParser);
}
public MartenQueryParser()
{
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
var expressionTreeParser =
new ExpressionTreeParser(MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly(), processor);
_parser = new QueryParser(expressionTreeParser);
}
private static IQueryParser CreateQueryParser()
{
var nodeTypeProvider = new CompoundNodeTypeProvider(new INodeTypeProvider[]
{
MethodInfoBasedNodeTypeRegistry.CreateFromRelinqAssembly()
});
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider,
ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry));
return(new QueryParser(expressionTreeParser));
}
static NhRelinqQueryParser()
{
var nodeTypeProvider = new NHibernateNodeTypeProvider();
var transformerRegistry = ExpressionTransformerRegistry.CreateDefault();
// Register custom expression transformers here:
// transformerRegistry.Register (new MyExpressionTransformer());
var processor = ExpressionTreeParser.CreateDefaultProcessor(transformerRegistry);
// Add custom processors here:
// processor.InnerProcessors.Add (new MyExpressionTreeProcessor());
var expressionTreeParser = new ExpressionTreeParser(nodeTypeProvider, processor);
_queryParser = new QueryParser(expressionTreeParser);
}
