public void EntityGetMatchesWithRelationship2( ) { var stringField = Entity.Get <EntityType>(new EntityRef("core", "stringField")); var fieldIsOnTypeRel = Entity.Get <Relationship>(new EntityRef("core", "fieldIsOnType")); var query = new StructuredQuery { RootEntity = new ResourceEntity(stringField) }; // Root query type is 'EntityType' // Follow 'Fields' relationship var relatedResource = new RelatedResource { RelationshipDirection = RelationshipDirection.Forward, RelationshipTypeId = fieldIsOnTypeRel.Id, ResourceMustExist = false }; query.RootEntity.RelatedEntities.Add(relatedResource); //// check the condition query.Conditions.Add(new QueryCondition { Expression = new ResourceDataColumn(relatedResource, EntityType.Name_Field), Operator = ConditionType.Equal, Argument = new TypedValue("Person") }); IEnumerable <Field> descriptionStringFields = Entity.GetMatches <Field>(query); Assert.IsTrue(descriptionStringFields.Any( ), "There should be at least one person type"); }
public void EntityGetMatchesWithRelationship( ) { var query = new StructuredQuery { RootEntity = new ResourceEntity(Field.Field_Type) }; // Root query type is 'EntityType' // Follow 'Fields' relationship var relatedResource = new RelatedResource { RelationshipDirection = RelationshipDirection.Forward, RelationshipTypeId = new EntityRef(Field.FieldIsOnType_Field.Id), ResourceMustExist = false }; query.RootEntity.RelatedEntities.Add(relatedResource); query.Conditions.Add(new QueryCondition { Expression = new ResourceDataColumn(relatedResource, EntityType.Name_Field), Operator = ConditionType.Equal, Argument = new TypedValue("Person") }); IEnumerable <Field> personFields = Entity.GetMatches <Field>(query); Assert.IsTrue(personFields.Any( )); }
/// <summary> /// Check if any of the queries grant access to all instances of the provided types. /// If so, update all results as true. /// </summary> /// <param name="entityType"></param> /// <param name="queries"></param> /// <param name="entities"></param> /// <param name="result"></param> /// <returns></returns> private static StructuredQuery CheckIfAnyQueryProvideAccessToAllInstancesOfType(long entityType, IEnumerable <AccessRuleQuery> queries, IList <EntityRef> entities, IDictionary <long, bool> result) { foreach (AccessRuleQuery accessRuleQuery in queries) { StructuredQuery structuredQuery = accessRuleQuery.Query; if (!QueryInspector.IsQueryUndamaged(structuredQuery)) { continue; // note: this gets logged by CheckAccessControlByQuery } bool queryGrantsAll = accessRuleQuery.DoesQueryGrantAllOfTypes(entityType); if (queryGrantsAll) { foreach (EntityRef entityRef in entities) { long id = entityRef.Id; if (result.ContainsKey(id)) { result[id] = true; } } return(structuredQuery); } } return(null); }
public void EntityGetMatches( ) { // Test to load all instances of a particular entity type that have a field matching a particular value. // Test data // (Load all nav sections that have name='Home') var type = new EntityRef("console", "navSection"); var field = new EntityRef("core", "name"); const string value = "Home"; // Create query var query = new StructuredQuery { RootEntity = new ResourceEntity(type) }; query.Conditions.Add(new QueryCondition { Expression = new ResourceDataColumn(query.RootEntity, field), Operator = ConditionType.Equal, Argument = new TypedValue(value) }); // Get results IEnumerable <NavSection> entities = Entity.GetMatches <NavSection>(query); NavSection[] eArr = entities.ToArray( ); Assert.IsTrue(eArr.Count( ) == 1); }
/// <summary> /// Constructor /// </summary> public AccessRuleQuery(long accessRuleId, long reportId, long controlsAccessForTypeId, StructuredQuery query, bool ignoreOnReports) { if (accessRuleId == 0) { throw new ArgumentException("accessRuleId"); } if (reportId == 0) { throw new ArgumentException("reportId"); } if (controlsAccessForTypeId == 0) { throw new ArgumentException("controlsAccessForTypeId"); } if (query == null) { throw new ArgumentNullException("query"); } AccessRuleId = accessRuleId; ReportId = reportId; ControlsAccessForTypeId = controlsAccessForTypeId; Query = query; IgnoreOnReports = ignoreOnReports; _grantsAccessToAllOfType = new ConcurrentDictionary <long, bool>(); }
/// <summary> /// Constrains the query by the filtered entity Ids. /// </summary> /// <param name="structuredQuery">The structured query.</param> /// <param name="filteredEntityIds">The filtered entity Ids.</param> private static void ApplyFilteredEntityIdentifiers(StructuredQuery structuredQuery, List <long> filteredEntityIds) { var condition = new QueryCondition { Expression = new IdExpression { NodeId = structuredQuery.RootEntity.NodeId }, Operator = filteredEntityIds.Count == 1 ? ConditionType.Equal : ConditionType.AnyOf, Arguments = filteredEntityIds.Select(id => new TypedValue { Type = new IdentifierType(), Value = id }).ToList() }; var queryConditions = new List <QueryCondition>(); if (structuredQuery.Conditions != null) { // Add existing conditions queryConditions.AddRange(structuredQuery.Conditions); } // Add new conditions queryConditions.Add(condition); structuredQuery.Conditions = queryConditions; }
public void RemoveUnusedColumns_WithCount_Ensure_AggregateExpressionWithGrouping_Removed( ) { ResourceEntity resNode = new ResourceEntity( ); AggregateEntity aggNode = new AggregateEntity { GroupedEntity = resNode }; aggNode.GroupBy.Add(new ResourceDataColumn( )); SelectColumn col1 = new SelectColumn { Expression = new ResourceDataColumn( ) }; SelectColumn col2 = new SelectColumn { Expression = new AggregateExpression { NodeId = aggNode.NodeId } }; StructuredQuery query = new StructuredQuery( ); query.RootEntity = aggNode; query.SelectColumns.Add(col1); query.SelectColumns.Add(col2); ClientAggregate agg = new ClientAggregate( ); agg.AggregatedColumns.Add(new ReportAggregateField { AggregateMethod = AggregateMethod.Count }); StructuredQuery result = ReportRollupHelper.RemoveUnusedColumns(query, agg); Assert.That(result.SelectColumns.Count, Is.EqualTo(2)); Assert.That(result.SelectColumns [0].Expression, Is.TypeOf <IdExpression>( )); Assert.That(result.SelectColumns [1].Expression, Is.TypeOf <AggregateExpression>( )); }
public void Test_EnsureCached_TwoThreads( ) { CachingQuerySqlBuilder cachingQuerySqlBuilder; Mock <IQuerySqlBuilder> mockQuerySqlBuilder; IQuerySqlBuilder querySqlBuilder; StructuredQuery structuredQuery; QuerySqlBuilderSettings settings; QueryBuild queryBuild; IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( ); structuredQuery = new StructuredQuery( ); settings = new QuerySqlBuilderSettings( ); queryBuild = new QueryBuild( ); mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict); mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings)) .Returns(() => { Thread.Sleep(100); return(queryBuild); }) .Verifiable( ); querySqlBuilder = mockQuerySqlBuilder.Object; cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider); Task task1 = Task.Factory.StartNew(() => cachingQuerySqlBuilder.BuildSql(structuredQuery, settings)); Thread.Sleep(1); // BlockIfPending can handle overlapping, but no coincident requests Task task2 = Task.Factory.StartNew(() => cachingQuerySqlBuilder.BuildSql(structuredQuery, settings)); Task.WaitAll(task1, task2); mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(1)); mockQuerySqlBuilder.VerifyAll( ); }
public void RemoveUnusedColumns_SupportQuickSearch_WithCount_Ensure_FieldExpression_NotReplaced() { SelectColumn col1 = new SelectColumn { Expression = new ResourceDataColumn() }; SelectColumn col2 = new SelectColumn { Expression = new ResourceDataColumn() }; StructuredQuery query = new StructuredQuery(); query.SelectColumns.Add(col1); query.SelectColumns.Add(col2); ClientAggregate agg = new ClientAggregate(); agg.AggregatedColumns.Add(new ReportAggregateField { AggregateMethod = AggregateMethod.Count }); StructuredQuery result = ReportRollupHelper.RemoveUnusedColumns(query, agg, true); Assert.That(result.SelectColumns.Count, Is.EqualTo(2)); Assert.That(result.SelectColumns[0].Expression, Is.TypeOf <ResourceDataColumn>()); Assert.That(result.SelectColumns[1].Expression, Is.TypeOf <ResourceDataColumn>()); Assert.IsTrue(result.SelectColumns[0].IsHidden); Assert.IsTrue(result.SelectColumns[1].IsHidden); }
public void Where_CompositeFilter() { var query = GetEmptyQuery() .WhereGreaterThanOrEqualTo("a", "x") .WhereEqualTo("b", "y") .WhereEqualTo("c", "z"); var expected = new StructuredQuery { Where = CompositeFilter( Filter(new FieldFilter { Field = Field("a"), Op = FieldFilter.Types.Operator.GreaterThanOrEqual, Value = CreateValue("x") }), Filter(new FieldFilter { Field = Field("b"), Op = FieldFilter.Types.Operator.Equal, Value = CreateValue("y") }), Filter(new FieldFilter { Field = Field("c"), Op = FieldFilter.Types.Operator.Equal, Value = CreateValue("z") }) ), From = { new CollectionSelector { CollectionId = "col" } } }; Assert.Equal(expected, query.ToStructuredQuery()); }
/// <summary> /// Applies the sort order. /// </summary> /// <param name="structuredQuery">The structured query.</param> /// <param name="reportSortOrders">The report sort orders.</param> private static void ApplySortOrder(StructuredQuery structuredQuery, IEnumerable <ReportSortOrder> reportSortOrders) { // Check that all sort orders are valid, that is the column ID GUIDs are in the report _and_ the Order is an // orderBy direction _or_ empty. OrderByDirection orderByDirection = OrderByDirection.Ascending; IEnumerable <ReportSortOrder> sortOrders = reportSortOrders as IList <ReportSortOrder> ?? reportSortOrders.ToList(); if (!sortOrders.All(col => structuredQuery.SelectColumns.Any(sc => sc.EntityId.ToString(CultureInfo.InvariantCulture) == col.ColumnId)) || !sortOrders.All(col => Enum.TryParse(col.Order, out orderByDirection) || col.Order == string.Empty)) { throw new ArgumentOutOfRangeException("reportSortOrders"); } // Clear any existing sort order clauses that may be saved with the report structuredQuery.OrderBy.Clear(); foreach (ReportSortOrder sortOrder in sortOrders.Where(sortOrder => Enum.TryParse(sortOrder.Order, out orderByDirection))) { long sortEntityColumnId; if (!long.TryParse(sortOrder.ColumnId, out sortEntityColumnId)) { continue; } SelectColumn sortColumn = structuredQuery.SelectColumns.FirstOrDefault(sc => sc.EntityId == sortEntityColumnId); if (sortColumn != null && sortColumn.Expression != null && sortColumn.Expression.ExpressionId != Guid.Empty && sortColumn.ColumnId != Guid.Empty) { structuredQuery.OrderBy.Add(new OrderByItem { Direction = orderByDirection, Expression = new ColumnReference { EntityId = sortEntityColumnId, ExpressionId = sortColumn.Expression.ExpressionId, ColumnId = sortColumn.ColumnId } }); } } }
public void Test_Cached() { CachingReportToQueryConverter cachingReportToQueryConverter; Mock <IReportToQueryConverter> mockReportToQueryConverter; IReportToQueryConverter reportToQueryConverter; Report report; StructuredQuery structuredQuery; report = new Report(); structuredQuery = new StructuredQuery(); mockReportToQueryConverter = new Mock <IReportToQueryConverter>(MockBehavior.Strict); mockReportToQueryConverter.Setup(x => x.Convert(report, It.IsAny <ReportToQueryConverterSettings>())) .Returns(() => structuredQuery) .Verifiable(); reportToQueryConverter = mockReportToQueryConverter.Object; cachingReportToQueryConverter = new CachingReportToQueryConverter(reportToQueryConverter); Assert.That(cachingReportToQueryConverter.Convert(report, null), Is.SameAs(structuredQuery), "Incorrect conversion"); Assert.That(cachingReportToQueryConverter.Cache, Has.Count.EqualTo(1)); Assert.That(cachingReportToQueryConverter.Cache, Has.Exactly(1).Property("Key").Property("ReportId").EqualTo(report.Id)); Assert.That(cachingReportToQueryConverter.Cache, Has.Exactly(1).Property("Value").Property("StructuredQuery").EqualTo(structuredQuery)); mockReportToQueryConverter.Verify(x => x.Convert(report, It.IsAny <ReportToQueryConverterSettings>()), Times.Exactly(1)); mockReportToQueryConverter.VerifyAll(); }
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 void Test_NewInstance(string cacheTest) { Model.EntityType type; StructuredQuery sq; using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true)) { type = Model.Entity.Create <Model.EntityType>(); type.SetField("core:name", "TmpType1"); type.Save(); sq = new StructuredQuery { RootEntity = new ResourceEntity(type.Id) }; sq.SelectColumns.Add(new SelectColumn { Expression = new ResourceExpression(sq.RootEntity, "core:name") }); ctx.CommitTransaction(); } Test_Scenario(cacheTest, sq, () => { using (var ctx = DatabaseContext.GetContext(true, preventPostSaveActionsPropagating: true)) { var instance = Model.Entity.Create(type); instance.SetField("core:name", "TmpInstance1"); instance.Save(); ctx.CommitTransaction(); } }); }
public static StructuredQuery EntitiesOrderByDescription(string description = "a", EntityRef type = null) { if (type == null) { type = new EntityRef("core:resource"); } Guid resourceGuid = Guid.NewGuid( ); StructuredQuery structuredQuery = new StructuredQuery { RootEntity = new ResourceEntity { EntityTypeId = type, ExactType = false, NodeId = resourceGuid }, SelectColumns = new List <SelectColumn>( ) }; structuredQuery.OrderBy.Add(new OrderByItem { Expression = new ResourceDataColumn(structuredQuery.RootEntity, new EntityRef("core:description")), Direction = OrderByDirection.Ascending }); structuredQuery.SelectColumns.Add(new SelectColumn { Expression = new IdExpression( ) { NodeId = resourceGuid } }); return(structuredQuery); }
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> /// Test scenario /// </summary> private static void Test_Scenario(string cacheTest, StructuredQuery structuredQuery, Action invalidationCallback) { if (cacheTest.Contains("Ignore")) { Assert.Ignore( ); } string [] parts = cacheTest.Split(':').Select(p => p.Trim( )).ToArray( ); bool cached = parts [1].Contains("Cached"); bool invalidate = parts [1].Contains("Invalidate"); if (!cached && !invalidate) { Assert.Fail("Unknown expected result"); } switch (parts [0]) { case "QueryRunner": CachingQueryRunnerTests.Test_Scenario(structuredQuery, invalidationCallback, invalidate); break; case "QuerySqlBuilder": CachingQuerySqlBuilderTests.Test_Scenario(structuredQuery, invalidationCallback, invalidate); invalidate = true; break; default: throw new ArgumentException("Unknown cache"); } }
private void AssertNodes(StructuredQuery query, params Entity[] nodes) { var actual = StructuredQueryHelper.WalkNodes(query.RootEntity); // need to compare IDs instead of nodes because mutations result in clones Assert.That(actual.Select(n => n.NodeId), Is.EquivalentTo(nodes.Select(n => n.NodeId)), "Expected nodes"); }
public void Test_Cached() { CachingQuerySqlBuilder cachingQuerySqlBuilder; Mock <IQuerySqlBuilder> mockQuerySqlBuilder; IQuerySqlBuilder querySqlBuilder; StructuredQuery structuredQuery; QuerySqlBuilderSettings settings; QueryBuild queryBuild; IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( ); structuredQuery = new StructuredQuery( ); settings = new QuerySqlBuilderSettings( ); queryBuild = new QueryBuild( ); mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict); mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings)) .Returns(() => queryBuild) .Verifiable(); querySqlBuilder = mockQuerySqlBuilder.Object; cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider); Assert.That(cachingQuerySqlBuilder.BuildSql(structuredQuery, settings), Is.SameAs(queryBuild), "Incorrect conversion"); Assert.That(cachingQuerySqlBuilder.Cache, Has.Count.EqualTo(1)); mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(1)); mockQuerySqlBuilder.VerifyAll(); }
public void Test_SqlIsUncacheable( ) { CachingQuerySqlBuilder cachingQuerySqlBuilder; Mock <IQuerySqlBuilder> mockQuerySqlBuilder; IQuerySqlBuilder querySqlBuilder; StructuredQuery structuredQuery; QuerySqlBuilderSettings settings; QueryBuild queryBuild; IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( ); structuredQuery = new StructuredQuery( ); settings = new QuerySqlBuilderSettings( ); queryBuild = new QueryBuild( ); queryBuild.SqlIsUncacheable = true; mockQuerySqlBuilder = new Mock <IQuerySqlBuilder>(MockBehavior.Strict); mockQuerySqlBuilder.Setup(x => x.BuildSql(structuredQuery, settings)) .Returns(() => queryBuild) .Verifiable( ); querySqlBuilder = mockQuerySqlBuilder.Object; cachingQuerySqlBuilder = new CachingQuerySqlBuilder(querySqlBuilder, userRuleSetProvider); cachingQuerySqlBuilder.BuildSql(structuredQuery, settings); cachingQuerySqlBuilder.BuildSql(structuredQuery, settings); mockQuerySqlBuilder.Verify(x => x.BuildSql(structuredQuery, settings), Times.Exactly(2)); mockQuerySqlBuilder.VerifyAll( ); }
public void Test_Cached( ) { CachingQueryRunner cachingQueryRunner; Mock <IQueryRunner> mockQueryRunner; IQueryRunner queryRunner; StructuredQuery structuredQuery; QuerySettings settings; QueryBuild queryBuild; QueryResult result; IQuerySqlBuilder queryBuilder = MockQuerySqlBuilder( ); IUserRuleSetProvider userRuleSetProvider = MockUserRuleSetProvider( ); structuredQuery = new StructuredQuery( ); settings = new QuerySettings( ); queryBuild = new QueryBuild( ); result = new QueryResult(queryBuild); mockQueryRunner = new Mock <IQueryRunner>(MockBehavior.Strict); mockQueryRunner.Setup(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>())) .Returns(() => { return(result); }) .Verifiable( ); queryRunner = mockQueryRunner.Object; cachingQueryRunner = new CachingQueryRunner(queryRunner, userRuleSetProvider, queryBuilder); Assert.That(cachingQueryRunner.ExecuteQuery(structuredQuery, settings), Is.SameAs(result)); Assert.That(cachingQueryRunner.Cache, Has.Count.EqualTo(1)); mockQueryRunner.Verify(x => x.ExecutePrebuiltQuery(structuredQuery, settings, It.IsNotNull <QueryBuild>( )), Times.Exactly(1)); mockQueryRunner.VerifyAll( ); }
public static StructuredQuery Entities(EntityRef type = null) { if (type == null) { type = new EntityRef("core:resource"); } Guid resourceGuid = Guid.NewGuid(); StructuredQuery structuredQuery = new StructuredQuery { RootEntity = new ResourceEntity { EntityTypeId = type, ExactType = false, NodeId = resourceGuid }, SelectColumns = new List <SelectColumn>() }; structuredQuery.SelectColumns.Add(new SelectColumn { Expression = new IdExpression() { NodeId = resourceGuid } }); return(structuredQuery); }
/// <summary> /// Executes the specified query. /// </summary> /// <param name="query">The query. This cannot be null.</param> /// <param name="settings">Settings to control SQL generation. Defaults are used if omitted.</param> /// <returns> /// A <see cref="QueryResult"/> containing the query and related details. /// </returns> /// <exception cref="ArgumentNullException"> /// <paramref name="query"/> cannot be null. /// </exception> public QueryResult ExecuteQuery(StructuredQuery query, QuerySettings settings) { if (query == null) { throw new ArgumentNullException(nameof(query)); } if (settings == null) { settings = new QuerySettings { Hint = "QueryEngine" }; } // Check security settings VerifySecuritySettings(settings); QueryBuild querySql; // Allow non-admins to run reports using (new SecurityBypassContext( )) { querySql = _querySqlBuilder.BuildSql(query, settings); } return(ExecutePrebuiltQuery(query, settings, querySql)); }
/// <summary> /// Generate the query SQL. Do not actually run it. /// </summary> /// <param name="query">The structured query object to convert.</param> /// <param name="settings">Build-time settings for the conversion.</param> /// <returns>An object structure containing SQL, and other discovered information.</returns> public QueryBuild BuildSql(StructuredQuery query, QuerySqlBuilderSettings settings) { if (query == null) { throw new ArgumentNullException("query"); } // Initialise settings if (settings == null) { settings = new QuerySqlBuilderSettings( ); } // Optimise tree StructuredQuery optimisedQuery = StructuredQueryHelper.PruneQueryTree(query); // Generate SQL QueryBuilder queryBuilder = new QueryBuilder(optimisedQuery, settings); QueryBuild result = queryBuilder.GetSqlInternal( ); // Logging using (MessageContext msg = new MessageContext("Reports")) { msg.Append(() => new string( '-', 50 )); msg.Append(() => "Final structured query:\n" + StructuredQueryHelper.ToXml(optimisedQuery)); msg.Append(() => new string( '-', 50 )); msg.Append(() => "SQL:\n" + result.Sql); msg.Append(() => new string( '-', 50 )); } // Note: identify cache dependencies after getting SQL, so that any calculations are resolved into the structured query. IdentifyCacheDependencies(optimisedQuery, settings); return(result); }
public void Test_ReturnCached() { CachingReportToQueryConverter cachingReportToQueryConverter; Mock <IReportToQueryConverter> mockReportToQueryConverter; IReportToQueryConverter reportToQueryConverter; Report report; StructuredQuery structuredQuery; CachingReportToQueryConverterKey key; report = new Report(); structuredQuery = new StructuredQuery(); mockReportToQueryConverter = new Mock <IReportToQueryConverter>(MockBehavior.Strict); reportToQueryConverter = mockReportToQueryConverter.Object; cachingReportToQueryConverter = new CachingReportToQueryConverter(reportToQueryConverter); key = new CachingReportToQueryConverterKey(report, ReportToQueryConverterSettings.Default); cachingReportToQueryConverter.Cache.Add(key, new CachingReportToQueryConverterValue(structuredQuery)); Assert.That(cachingReportToQueryConverter.Convert(report), Is.SameAs(structuredQuery), "Incorrect conversion"); mockReportToQueryConverter.Verify(x => x.Convert(report), Times.Never()); mockReportToQueryConverter.VerifyAll(); }
public void Test_WalkNodes_Root( ) { StructuredQuery sq = new StructuredQuery( ); var root = sq.RootEntity = new ResourceEntity( ); AssertNodes(sq, root); }
public static void Test(string test) { // Extract test data TestData testData = GetTestParameters(test); // (Queries do not support parameters) if (testData.ScriptHost == ScriptHostType.Any && testData.Parameters.Count > 0) { testData.ScriptHost = ScriptHostType.Evaluate; } // Attempt to compile IExpression expression = TestCompile(testData); if (testData.Error != null) // script is expected to be invalid. { return; } // Attempt to evaluate if (testData.ScriptHost != ScriptHostType.Report) { TestEvaluation(testData, expression); } // Attempt to build query if (testData.ScriptHost != ScriptHostType.Evaluate) { StructuredQuery query = TestBuildQuery(testData, expression); TestRunQuery(testData, query); } }
/// <summary> /// Patch up the client aggregate with counts _if_ rollup grand totals or sub totals are requested and there is no count included in the client aggregate. /// </summary> /// <param name="clientAggregate"></param> /// <param name="query"></param> public static void EnsureShowTotalsHasCount(StructuredQuery query, ClientAggregate clientAggregate) { // if ((rollupGrandTotals || rollupSubTotals) && clientAggregate.GroupedColumns.Any()) //<< remove commented code and delete the follow_if_ when the builder sets these flags! if (clientAggregate.GroupedColumns.Count > 0) { ReportGroupField reportGroupField = clientAggregate.GroupedColumns.First( ); // Check to see if the first column group contains a count in the aggregate if (clientAggregate.AggregatedColumns.FirstOrDefault(ac => ac.AggregateMethod == AggregateMethod.Count) == null) { // Inject a count aggregate for a column that is _not_ a group column SelectColumn column = query.SelectColumns.FirstOrDefault(sc => clientAggregate.GroupedColumns.All(gc => gc.ReportColumnId != sc.ColumnId)); if (column != null) { clientAggregate.AggregatedColumns.Add(new ReportAggregateField { AggregateMethod = AggregateMethod.Count, IncludedCount = true, ReportColumnId = column.ColumnId, ReportColumnEntityId = column.EntityId, ShowGrandTotals = reportGroupField.ShowGrandTotals, ShowRowCounts = reportGroupField.ShowRowCounts, ShowOptionLabel = reportGroupField.ShowOptionLabel, ShowRowLabels = reportGroupField.ShowRowLabels, ShowSubTotals = reportGroupField.ShowSubTotals }); } } } }
public void EndBefore() { var query = GetEmptyQuery().OrderBy("foo").OrderBy("bar").OrderBy("baz").EndBefore(1, "x"); var expected = new StructuredQuery { OrderBy = { new Order { Field = Field("foo"), Direction = Direction.Ascending }, new Order { Field = Field("bar"), Direction = Direction.Ascending }, new Order { Field = Field("baz"), Direction = Direction.Ascending }, }, EndAt = new Cursor { Before = true, Values = { CreateValue(1), CreateValue("x") } }, From = { new CollectionSelector { CollectionId = "col" } } }; Assert.Equal(expected, query.ToStructuredQuery()); }
/// <summary> /// Actually build the SQL /// </summary> internal static bool DoesRequestAllowForCaching(StructuredQuery query, QuerySqlBuilderSettings settings) { if (query == null) { throw new ArgumentNullException("query"); } if (settings == null) { throw new ArgumentNullException("settings"); } // Note : settings.AdditionalOrderColumns is wholly derived from the query and settings, so we can ignore it // (however it should probably therefore be removed from the QuerySqlBuilderSettings altogether) // For now .. for safety // Note: if we ever want to address this, we need to ensure expression GUIDs get stitched up in QueryResult.ExpressionTypes if (settings.CaptureExpressionMetadata) { LogReasonForNonCaching("CaptureExpressionMetadata"); return(false); } // For now .. for sanity if (settings.DebugMode) { LogReasonForNonCaching("DebugMode"); return(false); } return(true); }
public void SimpleStructuredQuery(String docName) { String repoName = DefaultRepository; PropertyProfile propertyProfile = new PropertyProfile(); propertyProfile.FilterMode = PropertyFilterMode.IMPLIED; OperationOptions operationOptions = new OperationOptions(); operationOptions.Profiles.Add(propertyProfile); // Create query StructuredQuery q = new StructuredQuery(); q.AddRepository(repoName); q.ObjectType = "dm_document"; q.IsIncludeHidden = true; q.IsDatabaseSearch = true; ExpressionSet expressionSet = new ExpressionSet(); expressionSet.AddExpression(new PropertyExpression("object_name", Condition.CONTAINS, docName)); q.RootExpressionSet = expressionSet; // Execute Query int startingIndex = 0; int maxResults = 60; int maxResultsPerSource = 20; QueryExecution queryExec = new QueryExecution(startingIndex, maxResults, maxResultsPerSource); QueryResult queryResult = searchService.Execute(q, queryExec, operationOptions); QueryStatus queryStatus = queryResult.QueryStatus; RepositoryStatusInfo repStatusInfo = queryStatus.RepositoryStatusInfos[0]; if (repStatusInfo.Status == Status.FAILURE) { Console.WriteLine(repStatusInfo.ErrorTrace); throw new Exception("Query failed to return result."); } Console.WriteLine("Query returned result successfully."); // print results Console.WriteLine("DataPackage contains " + queryResult.DataObjects.Count + " objects."); foreach (DataObject dataObject in queryResult.DataObjects) { Console.WriteLine(dataObject.Identity.GetValueAsString()); } }
public IList<DataObject> FindDataObjects(string objectType, List<PropertyExpression> searchCriteria, bool getContent) { Log.Verbose("DataObjectRepository FindDataObjects criteria {@searchCriteria}", searchCriteria); var propertyProfile = new PropertyProfile {FilterMode = PropertyFilterMode.IMPLIED}; var operationOptions = new OperationOptions(); operationOptions.Profiles.Add(propertyProfile); // Create query var query = new StructuredQuery(); query.AddRepository(dfsConfiguration.Repository); query.ObjectType = objectType; query.IsIncludeHidden = true; query.IsDatabaseSearch = true; if (searchCriteria != null && searchCriteria.Count > 0) { query.RootExpressionSet = new ExpressionSet(); foreach (var expression in searchCriteria) { query.RootExpressionSet.AddExpression(expression); } } // Execute Query const int StartingIndex = 0; int maxResults = dfsConfiguration.MaxQueryResults; var queryExec = new QueryExecution(StartingIndex, maxResults, maxResults); var queryResult = dfsContext.SearchService.Execute(query, queryExec, operationOptions); var queryStatus = queryResult.QueryStatus; var repStatusInfo = queryStatus.RepositoryStatusInfos[0]; if (repStatusInfo.Status == Status.FAILURE) { Log.Debug("FindDataObjects failed {@searchCriteria}", searchCriteria); return null; } Log.Debug("FindDataObjects found {0} objects", queryResult.DataObjects.Count); //TODO see if there is a better way to get the contents from a search return queryResult.DataObjects .Select(dataObject => getContent ? GetDataObjectWithContentsObjectId(dataObject.Identity.GetValueAsString()) : GetDataObjectByObjectId(dataObject.Identity.GetValueAsString())) .ToList(); }