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();
}
