private static void RunReport(StringBuilder sb, long contextType, IExpression expr) { // Build structured query ResourceEntity re = new ResourceEntity(); re.EntityTypeId = new EntityRef(contextType); StructuredQuery sq = new StructuredQuery { RootEntity = re }; // Convert script to query QueryBuilderSettings qsettings = new QueryBuilderSettings(); qsettings.StructuredQuery = sq; qsettings.ContextEntity = re; ScalarExpression resExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expr, qsettings); sb.AppendLine("OK"); // Render XML sb.AppendLine("\nXML:"); sb.AppendLine(StructuredQueryHelper.ToXml(sq)); // Render SQL sb.AppendLine("\nSQL:"); sq.SelectColumns.Add(new SelectColumn { Expression = resExpr }); sb.AppendLine("declare @tenant as bigint = (select min(Id) from _vTenant) -- test harness"); string sql = EDC.ReadiNow.Metadata.Query.Structured.Builder.QueryBuilder.GetSql(sq); sb.AppendLine(sql); }
public StructuredQuery CreateQuery(string script, EntityRef rootType) { StructuredQuery sq = new StructuredQuery(); sq.RootEntity = new ResourceEntity { EntityTypeId = rootType }; BuilderSettings settings = new BuilderSettings(); settings.RootContextType = ExprTypeHelper.EntityOfType(rootType); settings.TestMode = true; IExpression expr = Factory.ExpressionCompiler.Compile(script, settings); string xml = expr.ToXml( ); QueryBuilderSettings qbSettings = new QueryBuilderSettings(); qbSettings.StructuredQuery = sq; qbSettings.ContextEntity = (ResourceEntity)sq.RootEntity; ScalarExpression queryExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expr, qbSettings); sq.SelectColumns.Add(new SelectColumn { Expression = queryExpr }); return(sq); }
/// <summary> /// Creates a structured query expression. /// </summary> /// <remarks> /// This method does not add the new expression to the target structured query, however it will add new tree nodes to the structured query as they are requred. /// </remarks> public ScalarExpression CreateQueryEngineExpression(IExpression expression, QueryBuilderSettings settings) { if (expression == null) { throw new ArgumentNullException("expression"); } Expression expressionToCreate = expression as Expression; if (expressionToCreate == null) { throw new ArgumentException("Expected instance of type Expression.", "expression"); } using (EntryPointContext.AppendEntryPoint("ExprQuery")) using (new SecurityBypassContext( )) using (Profiler.Measure("ExpressionEngine.CreateQueryEngineExpression")) { if (settings == null) { settings = new QueryBuilderSettings(); } var queryContext = new QueryBuilderContext { Settings = settings }; // Add nodes to the query tree, if necessary. expressionToCreate.ListRoot.BuildQueryNode(queryContext, true); // Build up the expression itself ScalarExpression result = expressionToCreate.Root.BuildQuery(queryContext); // Special handing for bools //if (expressionToCreate.ResultType.Type == DataType.Bool) //{ // if (settings.ConvertBoolsToString) // result = CastFromBool.CastToString(result); //} // Set result type // TODO: return entity type // TODO: return for any expression type var calcExpression = result as CalculationExpression; if (calcExpression != null) { calcExpression.DisplayType = ExprTypeHelper.ToDatabaseType(expressionToCreate.ResultType); } return(result); } }
private static StructuredQuery TestBuildQuery(TestData testData, IExpression expression) { // Need to query against something (anything, whatever), in the case of test cases that don't specify a context EntityRef resourceType = testData.Context != null ? new EntityRef(testData.Context.ExprType.EntityType) : new EntityRef("core:type"); // Create a query to graft results into StructuredQuery sq = new StructuredQuery(); sq.RootEntity = new ResourceEntity { EntityTypeId = resourceType }; // Select a single row (use the type resource as both the type and the instance) EntityRef resource = testData.Context != null && testData.Context.Resource != null ? new EntityRef(testData.Context.Resource.Id) : new EntityRef("core:type"); sq.Conditions.Add(new QueryCondition { Expression = new IdExpression { NodeId = sq.RootEntity.NodeId }, Operator = ConditionType.Equal, Argument = new TypedValue { Type = DatabaseType.IdentifierType, Value = resource.Id } }); // Prep settings var settings = new QueryBuilderSettings(); settings.StructuredQuery = sq; settings.ContextEntity = (ResourceEntity)sq.RootEntity; // Build query ScalarExpression queryExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expression, settings); sq.SelectColumns.Add(new SelectColumn { Expression = queryExpr }); return(sq); }
/// <summary> /// Create a query that converts a calculation into a report that returns a list of IDs. /// </summary> /// <param name="filterCalculation">The calculation script.</param> /// <param name="entityType">The type of resource to load (and filter).</param> /// <param name="exactType">True if the report should return exact types only, false to include derived types.</param> public static StructuredQuery BuildFilterQuery(string filterCalculation, EntityRef entityType, bool exactType) { // Validate if (string.IsNullOrEmpty("filterCalculation")) { throw new ArgumentNullException("filterCalculation"); } if (entityType == null) { throw new ArgumentNullException("entityType"); } // Compile the calculation into an expression BuilderSettings builderSettings = new BuilderSettings { ExpectedResultType = ExprType.Bool, RootContextType = ExprTypeHelper.EntityOfType(entityType), ScriptHost = ScriptHostType.Report, ScriptHostIsApi = true }; IExpression filterCalcExpr = Factory.ExpressionCompiler.Compile(filterCalculation, builderSettings); // Create the structured query var rootEntity = new ResourceEntity { EntityTypeId = entityType, ExactType = exactType }; var query = new StructuredQuery() { RootEntity = rootEntity }; // Generate a report condition for the filter QueryBuilderSettings queryBuilderSettings = new QueryBuilderSettings { ContextEntity = rootEntity, ConvertBoolsToString = false, StructuredQuery = query }; ScalarExpression filterScalarExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(filterCalcExpr, queryBuilderSettings); rootEntity.Conditions = new List <ScalarExpression> { filterScalarExpr }; return(query); }
public ScalarExpression CreateScalarExpression(string script) { BuilderSettings settings = new BuilderSettings(); settings.RootContextType = ExprType.None; //settings.StaticParameterResolver //settings.ExpectedResultType IExpression expr = Factory.ExpressionCompiler.Compile(script, settings); QueryBuilderSettings qbSettings = new QueryBuilderSettings(); //qbSettings.ContextEntity = //qbSettings.StructuredQuery ScalarExpression queryExpr = Factory.ExpressionCompiler.CreateQueryEngineExpression(expr, qbSettings); return(queryExpr); }