private VariableDeclaration TransformMapDefinitionFromLinqQuerySyntax(string query, out string entityName)
{
entityName = null;
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqQuery(query, RequiresSelectNewAnonymousType);
var queryExpression = ((QueryExpression)variableDeclaration.Initializer);
var expression = queryExpression.FromClause.InExpression;
if (expression is MemberReferenceExpression) // collection
{
var mre = (MemberReferenceExpression)expression;
entityName = mre.MemberName;
queryExpression.FromClause.InExpression = mre.TargetObject;
//doc["@metadata"]["Raven-Entity-Name"]
var metadata = new IndexerExpression(
new IndexerExpression(new IdentifierExpression(queryExpression.FromClause.Identifier), new List <Expression> {
new PrimitiveExpression("@metadata", "@metadata")
}),
new List <Expression> {
new PrimitiveExpression(Constants.RavenEntityName, Constants.RavenEntityName)
}
);
queryExpression.MiddleClauses.Insert(0,
new QueryExpressionWhereClause
{
Condition =
new BinaryOperatorExpression(
metadata,
BinaryOperatorType.Equality,
new PrimitiveExpression(mre.MemberName, mre.MemberName)
)
});
}
var selectOrGroupClause = queryExpression.SelectOrGroupClause;
var projection = ((QueryExpressionSelectClause)selectOrGroupClause).Projection;
if (projection is ObjectCreateExpression == false)
{
return(variableDeclaration);
}
var objectInitializer = ((ObjectCreateExpression)projection).ObjectInitializer;
var identifierExpression = new IdentifierExpression(queryExpression.FromClause.Identifier);
if (objectInitializer.CreateExpressions.OfType <NamedArgumentExpression>().Any(x => x.Name == Constants.DocumentIdFieldName))
{
return(variableDeclaration);
}
objectInitializer.CreateExpressions.Add(
new NamedArgumentExpression
{
Name = Constants.DocumentIdFieldName,
Expression = new MemberReferenceExpression(identifierExpression, Constants.DocumentIdFieldName)
});
return(variableDeclaration);
}
private VariableDeclaration TransformMapDefinitionFromLinqMethodSyntax(out string entityName)
{
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.Map);
AddEntityNameFilteringIfNeeded(variableDeclaration, out entityName);
variableDeclaration.AcceptVisitor(new AddDocumentIdToLambdas(), null);
return(variableDeclaration);
}
private VariableInitializer TransformMapDefinitionFromLinqMethodSyntax(string query, out string entityName)
{
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqMethods(query, RequiresSelectNewAnonymousType);
AddEntityNameFilteringIfNeeded(variableDeclaration, out entityName);
variableDeclaration.AcceptVisitor(new AddDocumentIdToLambdas(), null);
return(variableDeclaration);
}
public AbstractTransformer GenerateInstance()
{
TransformToClass();
GeneratedType = QueryParsingUtils.Compile(CompiledQueryText, CSharpSafeName, CompiledQueryText, extensions, basePath, configuration);
var abstractTransformer = (AbstractTransformer)Activator.CreateInstance(GeneratedType);
abstractTransformer.SourceCode = CompiledQueryText;
abstractTransformer.Init(transformerDefinition);
return(abstractTransformer);
}
public AbstractViewGenerator GenerateInstance()
{
TransformQueryToClass();
GeneratedType = QueryParsingUtils.Compile(CompiledQueryText, CSharpSafeName, CompiledQueryText, extensions, basePath);
var abstractViewGenerator = (AbstractViewGenerator)Activator.CreateInstance(GeneratedType);
abstractViewGenerator.SourceCode = CompiledQueryText;
return(abstractViewGenerator);
}
private void HandleTransformResults(ConstructorDeclaration ctor)
{
try
{
if (string.IsNullOrEmpty(indexDefinition.TransformResults))
{
return;
}
VariableInitializer translatorDeclaration;
if (indexDefinition.TransformResults.Trim().StartsWith("from"))
{
translatorDeclaration =
QueryParsingUtils.GetVariableDeclarationForLinqQuery(indexDefinition.TransformResults,
requiresSelectNewAnonymousType: false);
}
else
{
translatorDeclaration =
QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.TransformResults,
requiresSelectNewAnonymousType: false);
}
translatorDeclaration.AcceptVisitor(new ThrowOnInvalidMethodCallsForTransformResults(), null);
// this.Translator = (Database,results) => from doc in results ...;
ctor.Body.Statements.Add(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"TransformResultsDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclaration(null, "Database"),
new ParameterDeclaration(null, "results")
},
Body = translatorDeclaration.Initializer.Clone()
})));
}
catch (InvalidOperationException ex)
{
throw new IndexCompilationException(ex.Message, ex)
{
IndexDefinitionProperty = "TransformResults",
ProblematicText = indexDefinition.TransformResults
};
}
}
public AbstractViewGenerator GenerateInstance()
{
TransformQueryToClass();
try
{
File.Delete(Path.GetTempFileName());
}
catch (Exception)
{
throw new InvalidOperationException(@"Raven could not write to the temp directory.
This is usually the result of security settings when running in IIS.
Raven requiers access to the temp directory in order to compile indexes.");
}
GeneratedType = QueryParsingUtils.Compile(CSharpSafeName, CompiledQueryText);
return((AbstractViewGenerator)Activator.CreateInstance(GeneratedType));
}
private VariableDeclaration TransformMapDefinitionFromLinqMethodSyntax(out string entityName)
{
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.Map);
AddEntityNameFilteringIfNeeded(variableDeclaration, out entityName);
var invocationExpression = ((InvocationExpression)variableDeclaration.Initializer);
var targetExpression = ((MemberReferenceExpression)invocationExpression.TargetObject);
do
{
AddDocumentIdFieldToLambdaIfCreatingNewObject((LambdaExpression)invocationExpression.Arguments.Last());
invocationExpression = (InvocationExpression)targetExpression.TargetObject;
targetExpression = (MemberReferenceExpression)invocationExpression.TargetObject;
} while (targetExpression.TargetObject is InvocationExpression);
return(variableDeclaration);
}
private VariableDeclaration TransformMapDefinitionFromLinqQuerySyntax(out string entityName)
{
entityName = null;
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqQuery(indexDefinition.Map);
var queryExpression = ((QueryExpression)variableDeclaration.Initializer);
var expression = queryExpression.FromClause.InExpression;
if (expression is MemberReferenceExpression) // collection
{
var mre = (MemberReferenceExpression)expression;
entityName = mre.MemberName;
queryExpression.FromClause.InExpression = mre.TargetObject;
//doc["@metadata"]["Raven-Entity-Name"]
var metadata = new IndexerExpression(
new IndexerExpression(new IdentifierExpression(queryExpression.FromClause.Identifier), new List <Expression> {
new PrimitiveExpression("@metadata", "@metadata")
}),
new List <Expression> {
new PrimitiveExpression("Raven-Entity-Name", "Raven-Entity-Name")
}
);
queryExpression.MiddleClauses.Insert(0,
new QueryExpressionWhereClause
{
Condition =
new BinaryOperatorExpression(
metadata,
BinaryOperatorType.Equality,
new PrimitiveExpression(mre.MemberName, mre.MemberName)
)
});
}
var selectOrGroupClause = queryExpression.SelectOrGroupClause;
var projection = ((QueryExpressionSelectClause)selectOrGroupClause).Projection;
var objectInitializer = ((ObjectCreateExpression)projection).ObjectInitializer;
var identifierExpression = new IdentifierExpression(queryExpression.FromClause.Identifier);
objectInitializer.CreateExpressions.Add(
new NamedArgumentExpression
{
Name = "__document_id",
Expression = new MemberReferenceExpression(identifierExpression, "__document_id")
});
return(variableDeclaration);
}
private bool AddDocumentIdFieldToLambdaIfCreatingNewObject(LambdaExpression lambdaExpression)
{
var objectCreateExpression = QueryParsingUtils.GetAnonymousCreateExpression(lambdaExpression.Body) as AnonymousTypeCreateExpression;
if (objectCreateExpression == null)
{
return(false);
}
var initializers = objectCreateExpression.Initializers;
if (initializers.OfType <NamedExpression>().Any(x => x.Name == Constants.DocumentIdFieldName))
{
return(false);
}
var parameter = lambdaExpression.Parameters.First();
var identifier = parameter.Name;
// Support getting the __document_id from IGrouping parameter
var castExpression = parameter.Parent.Parent.Parent as CastExpression;
if (castExpression != null)
{
var simpleType = castExpression.Type as SimpleType;
if (simpleType != null && simpleType.Identifier == "Func<IGrouping<dynamic,dynamic>, dynamic>")
{
identifier += ".Key";
}
}
var identifierExpression = new IdentifierExpression(identifier);
objectCreateExpression.Initializers.Add(new NamedExpression
{
Name = Constants.DocumentIdFieldName,
Expression = new MemberReferenceExpression(identifierExpression, Constants.DocumentIdFieldName)
});
return(true);
}
private void HandleReduceDefinition(ConstructorDeclaration ctor)
{
try
{
if (!indexDefinition.IsMapReduce)
{
return;
}
VariableInitializer reduceDefinition;
AstNode groupBySource;
string groupByParameter;
string groupByIdentifier;
if (indexDefinition.Reduce.Trim().StartsWith("from"))
{
reduceDefinition = QueryParsingUtils.GetVariableDeclarationForLinqQuery(indexDefinition.Reduce,
RequiresSelectNewAnonymousType);
var queryExpression = ((QueryExpression)reduceDefinition.Initializer);
var queryContinuationClause = queryExpression.Clauses.OfType <QueryContinuationClause>().FirstOrDefault();
if (queryContinuationClause == null)
{
throw new IndexCompilationException("Reduce query must contain a 'group ... into ...' clause")
{
ProblematicText = indexDefinition.Reduce,
IndexDefinitionProperty = "Reduce",
};
}
var queryGroupClause = queryContinuationClause.PrecedingQuery.Clauses.OfType <QueryGroupClause>().FirstOrDefault();
if (queryGroupClause == null)
{
throw new IndexCompilationException("Reduce query must contain a 'group ... into ...' clause")
{
ProblematicText = indexDefinition.Reduce,
IndexDefinitionProperty = "Reduce",
};
}
groupByIdentifier = queryContinuationClause.Identifier;
groupBySource = queryGroupClause.Key;
groupByParameter =
queryContinuationClause.PrecedingQuery.Clauses.OfType <QueryFromClause>().First().Identifier;
}
else
{
reduceDefinition = QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.Reduce,
RequiresSelectNewAnonymousType);
var initialInvocation = ((InvocationExpression)reduceDefinition.Initializer);
var invocation = initialInvocation;
var target = (MemberReferenceExpression)invocation.Target;
while (target.MemberName != "GroupBy")
{
if (!(target.Target is InvocationExpression))
{
// we've reached the initial results variable without encountering a GroupBy call
throw new IndexCompilationException("Reduce expression must contain a call to GroupBy")
{
ProblematicText = indexDefinition.Reduce,
IndexDefinitionProperty = "Reduce",
};
}
invocation = (InvocationExpression)target.Target;
target = (MemberReferenceExpression)invocation.Target;
}
var lambdaExpression = GetLambdaExpression(invocation);
groupByParameter = lambdaExpression.Parameters.First().Name;
groupBySource = lambdaExpression.Body;
groupByIdentifier = null;
}
var mapFields = captureSelectNewFieldNamesVisitor.FieldNames.ToList();
captureSelectNewFieldNamesVisitor.Clear(); // reduce override the map fields
reduceDefinition.Initializer.AcceptVisitor(captureSelectNewFieldNamesVisitor, null);
reduceDefinition.Initializer.AcceptVisitor(captureQueryParameterNamesVisitorForReduce, null);
reduceDefinition.Initializer.AcceptVisitor(new ThrowOnInvalidMethodCalls(groupByIdentifier), null);
ValidateMapReduceFields(mapFields);
// this.ReduceDefinition = from result in results...;
ctor.Body.Statements.Add(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"ReduceDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclaration(null, "results")
},
Body = reduceDefinition.Initializer.Clone()
})));
ctor.Body.Statements.Add(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"GroupByExtraction"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclaration(null, groupByParameter)
},
Body = groupBySource.Clone()
})));
}
catch (InvalidOperationException ex)
{
throw new IndexCompilationException(ex.Message)
{
ProblematicText = indexDefinition.Reduce,
IndexDefinitionProperty = "Reduce",
};
}
}
private void HandleReduceDefintion(ConstructorDeclaration ctor)
{
if (!indexDefinition.IsMapReduce)
{
return;
}
VariableDeclaration reduceDefiniton;
Expression groupBySource;
string groupByParamter;
if (indexDefinition.Reduce.Trim().StartsWith("from"))
{
reduceDefiniton = QueryParsingUtils.GetVariableDeclarationForLinqQuery(indexDefinition.Reduce, RequiresSelectNewAnonymousType);
var sourceSelect = (QueryExpression)((QueryExpression)reduceDefiniton.Initializer).FromClause.InExpression;
groupBySource = ((QueryExpressionGroupClause)sourceSelect.SelectOrGroupClause).GroupBy;
groupByParamter = sourceSelect.FromClause.Identifier;
}
else
{
reduceDefiniton = QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.Reduce, RequiresSelectNewAnonymousType);
var invocation = ((InvocationExpression)reduceDefiniton.Initializer);
var target = (MemberReferenceExpression)invocation.TargetObject;
while (target.MemberName != "GroupBy")
{
invocation = (InvocationExpression)target.TargetObject;
target = (MemberReferenceExpression)invocation.TargetObject;
}
var lambdaExpression = GetLambdaExpression(invocation);
groupByParamter = lambdaExpression.Parameters[0].ParameterName;
groupBySource = lambdaExpression.ExpressionBody;
}
var mapFields = captureSelectNewFieldNamesVisitor.FieldNames.ToList();
captureSelectNewFieldNamesVisitor.Clear(); // reduce override the map fields
reduceDefiniton.Initializer.AcceptVisitor(captureSelectNewFieldNamesVisitor, null);
reduceDefiniton.Initializer.AcceptChildren(captureQueryParameterNamesVisitorForReduce, null);
reduceDefiniton.Initializer.AcceptVisitor(new ThrowOnInvalidMethodCalls(), null);
ValidateMapReduceFields(mapFields);
// this.ReduceDefinition = from result in results...;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"ReduceDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, "results")
},
ExpressionBody = reduceDefiniton.Initializer
})));
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"GroupByExtraction"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, groupByParamter)
},
ExpressionBody = groupBySource
})));
}
private void TransformToClass()
{
if (transformerDefinition.TransformResults == null)
{
throw new TransformCompilationException("Cannot compile a transformer without a transformer function");
}
try
{
CSharpSafeName = "Transformer_" + Regex.Replace(Name, @"[^\w\d]", "_");
var type = new TypeDeclaration
{
Modifiers = Modifiers.Public,
BaseTypes =
{
new SimpleType(typeof(AbstractTransformer).FullName)
},
Name = CSharpSafeName,
ClassType = ClassType.Class
};
var body = new BlockStatement();
// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
var viewText = new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new StringLiteralExpression(uniqueTextToken)));
body.Statements.Add(viewText);
var ctor = new ConstructorDeclaration
{
Name = CSharpSafeName,
Modifiers = Modifiers.Public,
Body = body
};
type.Members.Add(ctor);
VariableInitializer translatorDeclaration;
if (transformerDefinition.TransformResults.Trim().StartsWith("from"))
{
translatorDeclaration =
QueryParsingUtils.GetVariableDeclarationForLinqQuery(transformerDefinition.TransformResults,
requiresSelectNewAnonymousType: false);
}
else
{
translatorDeclaration =
QueryParsingUtils.GetVariableDeclarationForLinqMethods(transformerDefinition.TransformResults,
requiresSelectNewAnonymousType: false);
}
translatorDeclaration.AcceptVisitor(new ThrowOnInvalidMethodCallsForTransformResults(), null);
// this.Translator = (results) => from doc in results ...;
ctor.Body.Statements.Add(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"TransformResultsDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclaration(null, "results")
},
Body = translatorDeclaration.Initializer.Clone()
})));
CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
var sb = new StringBuilder("@\"");
sb.AppendLine(transformerDefinition.TransformResults.Replace("\"", "\"\""));
sb.Append("\"");
CompiledQueryText = CompiledQueryText.Replace('"' + uniqueTextToken + '"', sb.ToString());
}
catch (Exception ex)
{
throw new TransformCompilationException(ex.Message, ex);
}
}
private void TransformQueryToClass()
{
string entityName;
var mapDefinition = TransformMapDefinition(out entityName);
CSharpSafeName = "Index_" + Regex.Replace(Name, @"[^\w\d]", "_");
var type = new TypeDeclaration(Modifiers.Public, new List <AttributeSection>())
{
BaseTypes =
{
new TypeReference("AbstractViewGenerator")
},
Name = CSharpSafeName,
Type = ClassType.Class
};
var ctor = new ConstructorDeclaration(CSharpSafeName,
Modifiers.Public,
new List <ParameterDeclarationExpression>(), null);
type.Children.Add(ctor);
ctor.Body = new BlockStatement();
//this.ForEntityName = entityName;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ForEntityName"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(entityName, entityName))));
// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(mapReduceTextToken, mapReduceTextToken))));
// this.MapDefinition = from doc in docs ...;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "MapDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, "docs")
},
ExpressionBody = mapDefinition.Initializer
})));
if (indexDefinition.IsMapReduce)
{
VariableDeclaration reduceDefiniton;
Expression groupBySource;
string groupByParamter;
if (indexDefinition.Reduce.Trim().StartsWith("from"))
{
reduceDefiniton = QueryParsingUtils.GetVariableDeclarationForLinqQuery(indexDefinition.Reduce);
var sourceSelect = (QueryExpression)((QueryExpression)reduceDefiniton.Initializer).FromClause.InExpression;
groupBySource = ((QueryExpressionGroupClause)sourceSelect.SelectOrGroupClause).GroupBy;
groupByParamter = sourceSelect.FromClause.Identifier;
}
else
{
reduceDefiniton = QueryParsingUtils.GetVariableDeclarationForLinqMethods(indexDefinition.Reduce);
var invocation = ((InvocationExpression)reduceDefiniton.Initializer);
var target = (MemberReferenceExpression)invocation.TargetObject;
while (target.MemberName != "GroupBy")
{
invocation = (InvocationExpression)target.TargetObject;
target = (MemberReferenceExpression)invocation.TargetObject;
}
var lambdaExpression = ((LambdaExpression)invocation.Arguments[0]);
groupByParamter = lambdaExpression.Parameters[0].ParameterName;
groupBySource = lambdaExpression.ExpressionBody;
}
// this.ReduceDefinition = from result in results...;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"ReduceDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, "results")
},
ExpressionBody = reduceDefiniton.Initializer
})));
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(),
"GroupByExtraction"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, groupByParamter)
},
ExpressionBody = groupBySource
})));
}
CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
var compiledQueryText = "@\"" + indexDefinition.Map.Replace("\"", "\"\"");
if (indexDefinition.Reduce != null)
{
compiledQueryText += Environment.NewLine + indexDefinition.Reduce.Replace("\"", "\"\"");
}
compiledQueryText += "\"";
CompiledQueryText = CompiledQueryText.Replace("\"" + mapReduceTextToken + "\"",
compiledQueryText);
}
private void TransformQueryToClass()
{
CSharpSafeName = "Index_" + Regex.Replace(Name, @"[^\w\d]", "_");
var type = new TypeDeclaration
{
Modifiers = Modifiers.Public,
BaseTypes =
{
new SimpleType(typeof(AbstractViewGenerator).FullName)
},
Name = CSharpSafeName,
ClassType = ClassType.Class
};
var body = new BlockStatement();
// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
var viewText = new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new StringLiteralExpression(uniqueTextToken)));
body.Statements.Add(viewText);
var ctor = new ConstructorDeclaration
{
Name = CSharpSafeName,
Modifiers = Modifiers.Public,
Body = body
};
type.Members.Add(ctor);
HandleMapFunctions(ctor);
HandleTransformResults(ctor);
HandleReduceDefinition(ctor);
AddAdditionalInformation(ctor);
CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
var sb = new StringBuilder("@\"");
foreach (var map in indexDefinition.Maps)
{
sb.AppendLine(map.Replace("\"", "\"\""));
}
if (indexDefinition.Reduce != null)
{
sb.AppendLine(indexDefinition.Reduce.Replace("\"", "\"\""));
}
if (indexDefinition.TransformResults != null)
{
sb.AppendLine(indexDefinition.TransformResults.Replace("\"", "\"\""));
}
sb.Length = sb.Length - 2;
sb.Append("\"");
CompiledQueryText = CompiledQueryText.Replace('"' + uniqueTextToken + '"', sb.ToString());
}
private VariableInitializer TransformMapDefinitionFromLinqQuerySyntax(string query, out string entityName)
{
entityName = null;
var variableDeclaration = QueryParsingUtils.GetVariableDeclarationForLinqQuery(query, RequiresSelectNewAnonymousType);
var queryExpression = ((QueryExpression)variableDeclaration.Initializer);
var fromClause = queryExpression.Clauses.OfType <QueryFromClause>().First();
var expression = fromClause.Expression;
if (expression is MemberReferenceExpression) // collection
{
var mre = (MemberReferenceExpression)expression;
entityName = mre.MemberName;
fromClause.Expression = mre.Target;
//doc["@metadata"]["Raven-Entity-Name"]
var metadata = new IndexerExpression(
new IndexerExpression(new IdentifierExpression(fromClause.Identifier), new List <Expression> {
new StringLiteralExpression("@metadata")
}),
new List <Expression> {
new StringLiteralExpression(Constants.RavenEntityName)
}
);
// string.Equals(doc["@metadata"]["Raven-Entity-Name"], "Blogs", StringComparison.OrdinalIgnoreCase)
var binaryOperatorExpression =
new InvocationExpression(
new MemberReferenceExpression(new TypeReferenceExpression(new PrimitiveType("string")), "Equals"),
new List <Expression>
{
metadata,
new StringLiteralExpression(mre.MemberName),
new MemberReferenceExpression(new TypeReferenceExpression(new SimpleType(typeof(StringComparison).FullName)), "InvariantCultureIgnoreCase")
});
queryExpression.Clauses.InsertAfter(fromClause,
new QueryWhereClause
{
Condition = binaryOperatorExpression
});
}
var projection =
QueryParsingUtils.GetAnonymousCreateExpression(
queryExpression.Clauses.OfType <QuerySelectClause>().First().Expression);
var anonymousTypeCreateExpression = projection as AnonymousTypeCreateExpression;
if (anonymousTypeCreateExpression == null)
{
return(variableDeclaration);
}
var objectInitializer = anonymousTypeCreateExpression.Initializers;
var identifierExpression = new IdentifierExpression(fromClause.Identifier);
if (objectInitializer.OfType <NamedExpression>().Any(x => x.Name == Constants.DocumentIdFieldName))
{
return(variableDeclaration);
}
objectInitializer.Add(
new NamedExpression
{
Name = Constants.DocumentIdFieldName,
Expression = new MemberReferenceExpression(identifierExpression, Constants.DocumentIdFieldName)
});
return(variableDeclaration);
}
private void TransformQueryToClass()
{
string entityName;
var mapDefinition = TransformMapDefinition(out entityName);
CSharpSafeName = "Index_" + Regex.Replace(Name, @"[^\w\d]", "_");
var type = new TypeDeclaration(Modifiers.Public, new List <AttributeSection>())
{
BaseTypes =
{
new TypeReference("AbstractViewGenerator")
},
Name = CSharpSafeName,
Type = ClassType.Class
};
var ctor = new ConstructorDeclaration(CSharpSafeName,
Modifiers.Public,
new List <ParameterDeclarationExpression>(), null);
type.Children.Add(ctor);
ctor.Body = new BlockStatement();
//this.ForEntityName = entityName;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ForEntityName"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(entityName, entityName))));
// this.ViewText = "96E65595-1C9E-4BFB-A0E5-80BF2D6FC185"; // Will be replaced later
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "ViewText"),
AssignmentOperatorType.Assign,
new PrimitiveExpression(mapReduceTextToken, mapReduceTextToken))));
// this.MapDefinition = from doc in docs ...;
ctor.Body.AddChild(new ExpressionStatement(
new AssignmentExpression(
new MemberReferenceExpression(new ThisReferenceExpression(), "MapDefinition"),
AssignmentOperatorType.Assign,
new LambdaExpression
{
Parameters =
{
new ParameterDeclarationExpression(null, "docs")
},
ExpressionBody = mapDefinition.Initializer
})));
mapDefinition.Initializer.AcceptVisitor(captureSelectNewFieldNamesVisitor, null);
mapDefinition.Initializer.AcceptVisitor(captureQueryParameterNamesVisitorForMap, null);
HandleTransformResults(ctor);
HandleReduceDefintion(ctor);
AddAdditionalInformation(ctor);
CompiledQueryText = QueryParsingUtils.GenerateText(type, extensions);
var compiledQueryText = "@\"" + indexDefinition.Map.Replace("\"", "\"\"");
if (indexDefinition.Reduce != null)
{
compiledQueryText += Environment.NewLine + indexDefinition.Reduce.Replace("\"", "\"\"");
}
if (indexDefinition.TransformResults != null)
{
compiledQueryText += Environment.NewLine + indexDefinition.TransformResults.Replace("\"", "\"\"");
}
compiledQueryText += "\"";
CompiledQueryText = CompiledQueryText.Replace("\"" + mapReduceTextToken + "\"",
compiledQueryText);
}
