public static void LoadViewOutputColumns(ISchemaMetadataProvider schemaMetadata, string ddl, Action <OutputColumnDescriptor> collector)
{
TSqlFragment sqlF = ScriptDomFacade.Parse(ddl);
//CreateViewStatement stmt_CreateView = (CreateViewStatement)((TSqlScript)sqlF).Batches[0].Statements[0];
SelectStatement stmt_sel = (SelectStatement)((TSqlScript)sqlF).Batches[0].Statements[0];
BatchOutputColumnTypeResolver batchResolver = new BatchOutputColumnTypeResolver(schemaMetadata, stmt_sel, new BatchWithoutParameters());
StatementOutputColumnTypeResolverV2 resolver = new StatementOutputColumnTypeResolverV2(batchResolver, stmt_sel);
QuerySpecification first = TopQuerySpecification(stmt_sel.QueryExpression);
foreach (SelectElement se in first.SelectElements)
{
if (se is SelectScalarExpression scalarExpr)
{
OutputColumnDescriptor col = resolver.ResolveSelectScalarExpression(scalarExpr);
collector(col);
}
else
{
throw new NotImplementedException(se.WhatIsThis());
}
}
}
public static IEnumerable <T> GetFromRepository <T>(QuerySpecification querySpecification = null) where T : class, new()
{
using (var ctx = ContextRegistry.NamedContextsFor(
ContextRegistry.CreateNamed(ContextRegistry.Kind,
UnikContextTypes.UnikWarehouseContextResourceKind)))
{
List <T> reports = new List <T>();
var repository = ReportDataProvider.OpenCoreRepository <T>();
Func <QuerySpecification, DataEnvelope <T, NoMetadata> > function = null;
if (querySpecification == null)
{
function = qe => repository.All();
}
else
{
function = qe => repository.Query(qe);
}
bool loop = true;
while (loop)
{
var qr = function(querySpecification);
if (qr.Items.Any())
{
reports.AddRange(qr.Items.ToArray());
}
qr.Bookmark.Forward();
loop = qr.Bookmark.More;
}
return(reports);
}
}
public static void LoadFunctionOutputColumns(ISchemaMetadataProvider schemaMetadata, IBatchParameterMetadata parameterMetadata, string functionBodyScript, Action <OutputColumnDescriptor> collector)
{
functionBodyScript = RemoveTrailingBlockComment(functionBodyScript);
if (functionBodyScript.Trim()[0] == '(')
{
int idx = functionBodyScript.IndexOf('(');
int lastix = functionBodyScript.LastIndexOf(')');
functionBodyScript = functionBodyScript.Substring(idx + 1, lastix - idx - 2);
functionBodyScript = functionBodyScript.Trim();
}
TSqlFragment sqlF = ScriptDomFacade.Parse(functionBodyScript);
SelectStatement stmt_sel = (SelectStatement)((TSqlScript)sqlF).Batches[0].Statements[0];
BatchOutputColumnTypeResolver batchResolver = new BatchOutputColumnTypeResolver(schemaMetadata, sqlF, parameterMetadata);
StatementOutputColumnTypeResolverV2 resolver = new StatementOutputColumnTypeResolverV2(batchResolver, stmt_sel);
QuerySpecification first = TopQuerySpecification(stmt_sel.QueryExpression);
foreach (SelectElement se in first.SelectElements)
{
if (se is SelectScalarExpression scalarExpr)
{
OutputColumnDescriptor col = resolver.ResolveSelectScalarExpression(scalarExpr);
collector(col);
}
else
{
throw new NotImplementedException(se.WhatIsThis());
}
}
}
private async Task QueryAndDeleteEnrollmentGroups()
{
Console.WriteLine("\nCreating a query for enrollmentGroups...");
QuerySpecification querySpecification = new QuerySpecification("SELECT * FROM enrollmentGroups");
using (Query query = _provisioningServiceClient.CreateEnrollmentGroupQuery(querySpecification, QueryPageSize))
{
while (query.HasNext())
{
Console.WriteLine("\nQuerying the next enrollmentGroups...");
QueryResult queryResult = await query.NextAsync().ConfigureAwait(false);
var items = queryResult.Items;
foreach (EnrollmentGroup enrollment in items)
{
if (!groupEnrollmentsToBeRetained.Contains(enrollment.EnrollmentGroupId, StringComparer.OrdinalIgnoreCase))
{
Console.WriteLine($"EnrollmentGroup to be deleted: {enrollment.EnrollmentGroupId}");
_enrollmentGroupsDeleted++;
await _provisioningServiceClient.DeleteEnrollmentGroupAsync(enrollment.EnrollmentGroupId).ConfigureAwait(false);
}
}
}
}
}
public override void EnterQuerySpecification(MySqlParser.QuerySpecificationContext context)
{
if (!_isFirst)
{
if (_isOtherListener == 1)
{
QuerySpecification querySpecification =
new QuerySpecification(context.SourceInterval, context, context.GetText());
if (Rules.Count > 0)
{
Rules.Remove(Rules[Rules.Count - 1]);
}
Rules.Add(querySpecification);
}
_isOtherListener++;
}
if (_isOtherListener == 1 && Rules.Count > 0 && _isFirst)
{
//ownRule = new QuerySpecification(context.SourceInterval, context, context.GetText());
Rules.Remove(Rules[Rules.Count - 1]);
_isFirst = false;
}
}
private IList<Tag> DoSearch(QuerySpecification<Tag> specification)
{
return this.tagRepository
.FindAll(specification)
.OrderBy(t => t.Name)
.ToList();
}
/// <summary>
/// Retrieves all the <typeparamref name="TEntity" />s
/// in the database that meet the criteria in
/// <paramref name="specification" /> and that the
/// <paramref name="person" /> has authorization to view.
/// </summary>
///
/// <param name="person">
/// The <see cref="Person" /> to check authorizations for.
/// </param>
///
/// <param name="specification">
/// The <see cref="QuerySpecification{TEntity}" /> that
/// defines the criteria a <typeparamref name="TEntity" />
/// must meet to be part of the result set.
/// </param>
///
/// <returns>
/// All the <typeparamref name="TEntity" />s
/// in the database that meet the criteria in
/// <paramref name="specification" /> and that the
/// <paramref name="person" /> has authorization to view.
/// </returns>
///
/// <exception cref="ArgumentNullException">
/// Thrown when either <paramref name="person" /> or
/// <paramref name="specification" /> are <c>null</c>.
/// </exception>
public IReadOnlyCollection <TEntity> List(Person person, QuerySpecification <TEntity> specification)
{
// Validate parameters
if (person == null)
{
throw new ArgumentNullException(nameof(person));
}
if (specification == null)
{
throw new ArgumentNullException(nameof(specification));
}
// Get the entities that fulfill the
// specification from the database
IList <TEntity> entities = this
.ApplySpecification(specification)
.ToList()
;
// Return the entities the Person
// is allowed to view
return(entities
.Where(x => this.AuthorizedToView(person, x))
.ToList()
.AsReadOnly()
);
}
private async Task QueryAndDeleteIndividualEnrollments()
{
Console.WriteLine("\nCreating a query for enrollments...");
QuerySpecification querySpecification = new QuerySpecification("SELECT * FROM enrollments");
using (Query query = _provisioningServiceClient.CreateIndividualEnrollmentQuery(querySpecification, QueryPageSize))
{
while (query.HasNext())
{
Console.WriteLine("\nQuerying the next enrollments...");
QueryResult queryResult = await query.NextAsync().ConfigureAwait(false);
var items = queryResult.Items;
List <IndividualEnrollment> individualEnrollments = new List <IndividualEnrollment>();
foreach (IndividualEnrollment enrollment in items)
{
if (!individualEnrollmentsToBeRetained.Contains(enrollment.RegistrationId, StringComparer.OrdinalIgnoreCase))
{
individualEnrollments.Add(enrollment);
Console.WriteLine($"Individual Enrollment to be deleted: {enrollment.RegistrationId}");
_individualEnrollmentsDeleted++;
}
}
if (individualEnrollments.Count > 0)
{
await DeleteBulkIndividualEnrollments(individualEnrollments).ConfigureAwait(false);
}
await Task.Delay(1000).ConfigureAwait(false);
}
}
}
public IEnumerable <WorkflowInstanceInfo> GetInstances(WorkflowStatus?filter = null)
{
if (null == filter)
{
var queryResult = _instanceData.All();
return(queryResult.Items.EmptyIfNull());
}
else
{
var qs = new QuerySpecification
{
BookMark = new GenericPageBookmark {
PageSize = 1000
},
Where = new Filter
{
PredicateJoin = PredicateJoin.And,
Rules = new Comparison[]
{
new Comparison
{
Data = filter.Value.EnumName(),
Field = "Status",
Test = Test.Equal
}
}
}
};
var queryResult = _instanceData.Query(qs);
return(queryResult.Items.EmptyIfNull());
}
}
private void AnalyzeJoins(IList <SqlRuleProblem> problems, SqlRuleExecutionContext ruleExecutionContext,
QuerySpecification querySpecification)
{
var visitor = new CollectJoinVisitor();
querySpecification.Accept(visitor);
foreach (var join in visitor.Joins)
{
// We should have already handled the first table reference here, as it's included from an earlier part
// of the query. As such, we now handle the second table only.
var tablePartitions = CollectFromTableReference(ruleExecutionContext, join.SecondTableReference,
join.SecondTableReference).ToList();
if (tablePartitions.Count == 0)
{
continue;
}
if (join is QualifiedJoin qualifiedJoin)
{
var condition = qualifiedJoin.SearchCondition;
SearchConstraints(condition, tablePartitions);
}
foreach (var partitionedColumn in tablePartitions)
{
SqlRuleProblem problem = CreateProblem(ruleExecutionContext, partitionedColumn);
problems.Add(problem);
}
}
}
public static List<ColumnInfo> CollectColumnNames(QuerySpecification querySpecification)
{
var columns = new List<ColumnInfo>();
foreach (var sqlFragment in querySpecification.SelectElements)
{
var identifiers = ((Column)((SelectColumn)sqlFragment).Expression).Identifiers;
if (IsWildcard(querySpecification))
{
columns.Add(new ColumnInfo
{
TableName = identifiers[0].Value.ToLower(),
ColumnName = "*"
});
}
else
{
columns.Add(new ColumnInfo
{
TableName = TableFromFullyQualifiedColumnName(FullyQualifiedColumnNameFromIdentifiers(identifiers), querySpecification),
ColumnName = ColumnFromFullyQualifiedColumnName(FullyQualifiedColumnNameFromIdentifiers(identifiers))
});
}
}
return columns;
}
/// <summary>
/// Gets the table from column.
/// </summary>
/// <param name="sqlObj">The SQL object.</param>
/// <param name="query">The query.</param>
/// <param name="column">The column.</param>
/// <returns></returns>
protected static TSqlObject GetTableFromColumn(TSqlObject sqlObj, QuerySpecification query, ColumnReferenceExpression column)
{
var tables = new List <NamedTableReference>();
var namedTableVisitor = new NamedTableReferenceVisitor();
query.FromClause.Accept(namedTableVisitor);
if (column.MultiPartIdentifier.Identifiers.Count == 2)
{
tables.AddRange(namedTableVisitor.Statements.Where(x => x.Alias?.Value == column.MultiPartIdentifier.Identifiers[0].Value));
}
else
{
//they did NOT use a two part name, so logic dictates that this column SHOULD only appear once in the list of tables, but we will have to search all of the tables.
tables.AddRange(namedTableVisitor.Statements);
}
var referencedTables = sqlObj.GetReferenced().Where(x => x.ObjectType == Table.TypeClass && tables.Any(t => x.Name.CompareTo(t.SchemaObject.Identifiers) >= 5));
foreach (var referencedTable in referencedTables)
{
string fullColumnName = referencedTable.Name.ToString() + ".[" + column.MultiPartIdentifier.Identifiers.Last().Value + "]";
var retColumn = referencedTable.GetReferencedRelationshipInstances(Table.Columns).FirstOrDefault(p => _comparer.Equals(p.ObjectName.ToString(), fullColumnName));
if (retColumn != null)
{
return(referencedTable);
}
}
return(null);
}
public static IList <FieldPairReference> GetFieldPairReferences(
this QuerySpecification querySpecification,
ILogger logger,
SchemaFile file
)
{
var selectVariablePairs = querySpecification
.SelectElements
.GetFieldPairs(logger, file);
var fromCalusePairs = querySpecification
.FromClause
?.TableReferences
.GetFieldPairs(logger, file)
?? new List <FieldPairReference>();
var whereClausePairs = querySpecification
.WhereClause
?.SearchCondition
.GetFieldPairs(logger, file)
?? new List <FieldPairReference>();
return(selectVariablePairs
.Concat(fromCalusePairs)
.Concat(whereClausePairs)
.ToList());
}
/**********************************************************************************
* Retrive Individual Enrollment from DPS
*********************************************************************************/
public async Task <IndividualEnrollment> GetDpsEnrollment(string registrationId)
{
IndividualEnrollment enrollment = null;
try
{
QuerySpecification querySpecification = new QuerySpecification("SELECT * FROM enrollments");
using (Query query = _provisioningServiceClient.CreateIndividualEnrollmentQuery(querySpecification))
{
while (query.HasNext() && enrollment == null)
{
QueryResult queryResults = await query.NextAsync().ConfigureAwait(false);
foreach (IndividualEnrollment item in queryResults.Items)
{
_logger.LogInformation($"GetDpsEnrollment found enrollment : {item}");
if (item.RegistrationId.Equals(registrationId))
{
enrollment = item;
break;
}
}
}
}
}
catch (Exception e)
{
_logger.LogError($"Exception in GetDpsEnrollment() : {e.Message}");
}
return(enrollment);
}
public override void ExplicitVisit(SelectStatement node)
{
QuerySpecification querySpecification = node.QueryExpression as QuerySpecification;
FromClause fromClause = querySpecification.FromClause;
// There could be more than one TableReference!
// TableReference is not sure to be a NamedTableReference, could be as example a QueryDerivedTable
NamedTableReference namedTableReference = fromClause.TableReferences[0] as NamedTableReference;
TableReferenceWithAlias tableReferenceWithAlias = fromClause.TableReferences[0] as TableReferenceWithAlias;
string baseIdentifier = namedTableReference?.SchemaObject.BaseIdentifier?.Value;
string schemaIdentifier = namedTableReference?.SchemaObject.SchemaIdentifier?.Value;
string databaseIdentifier = namedTableReference?.SchemaObject.DatabaseIdentifier?.Value;
string serverIdentifier = namedTableReference?.SchemaObject.ServerIdentifier?.Value;
string alias = tableReferenceWithAlias.Alias?.Value;
Console.WriteLine("From:");
Console.WriteLine($" {"Server:",-10} {serverIdentifier}");
Console.WriteLine($" {"Database:",-10} {databaseIdentifier}");
Console.WriteLine($" {"Schema:",-10} {schemaIdentifier}");
Console.WriteLine($" {"Table:",-10} {baseIdentifier}");
Console.WriteLine($" {"Alias:",-10} {alias}");
// Example of changing the alias:
//(fromClause.TableReferences[0] as NamedTableReference).Alias = new Identifier() { Value = baseIdentifier[0].ToString() };
Console.WriteLine("Statement:");
Console.WriteLine(node.ToSqlString().Indent(2));
Console.WriteLine("¯".Multiply(40));
base.ExplicitVisit(node);
}
/// <summary>
/// List a set of module twins.
/// </summary>
/// <param name="pageSize">The size of each page to be retrieved from the service. Service may override this size.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A pageable set of module twins <see cref="AsyncPageable{T}"/>.</returns>
public virtual AsyncPageable <TwinData> GetTwinsAsync(int?pageSize = null, CancellationToken cancellationToken = default)
{
async Task <Page <TwinData> > FirstPageFunc(int?pageSizeHint)
{
var querySpecification = new QuerySpecification
{
Query = HubModuleQuery
};
Response <IReadOnlyList <TwinData> > response =
await _queryRestClient.GetTwinsAsync(querySpecification, null, pageSizeHint?.ToString(CultureInfo.InvariantCulture), cancellationToken).ConfigureAwait(false);
response.GetRawResponse().Headers.TryGetValue(ContinuationTokenHeader, out string continuationToken);
return(Page.FromValues(response.Value, continuationToken, response.GetRawResponse()));
}
async Task <Page <TwinData> > NextPageFunc(string nextLink, int?pageSizeHint)
{
var querySpecification = new QuerySpecification();
Response <IReadOnlyList <TwinData> > response =
await _queryRestClient.GetTwinsAsync(querySpecification, nextLink, pageSizeHint?.ToString(CultureInfo.InvariantCulture), cancellationToken).ConfigureAwait(false);
response.GetRawResponse().Headers.TryGetValue(ContinuationTokenHeader, out string continuationToken);
return(Page.FromValues(response.Value, continuationToken, response.GetRawResponse()));
}
return(PageableHelpers.CreateAsyncEnumerable(FirstPageFunc, NextPageFunc, pageSize));
}
internal gsWhereTermBase GetWhereTerm(ExistsPredicate existsPredicate, gsExistsOrNotExists existsOrNotExists)
{
gsWhereTermExistsOrNotExists whereTerm = new gsWhereTermExistsOrNotExists();
whereTerm.ExistsType = existsOrNotExists;
if (existsPredicate.Subquery.QueryExpression is QuerySpecification)
{
gsSelectQuery subQry = new gsSelectQuery();
subQry.QryName = $"subQry{gsSelectQuery.GetNextID()}";
whereTerm.QueryName = subQry.QryName;
QuerySpecification qrySpec = existsPredicate.Subquery.QueryExpression as QuerySpecification;
gsSelectQueryParser qryParser = new gsSelectQueryParser();
qryParser.ProcessQuerySpecification(qrySpec, subQry);
whereTerm.Sql = subQry.ToString();
}
else
{
throw new NotImplementedException($"QuerySpecification {existsPredicate.Subquery.QueryExpression.GetType().Name} not supported");
}
return(whereTerm);
}
internal HttpMessage CreateGetTwinsRequest(QuerySpecification querySpecification, string xMsContinuation, string xMsMaxItemCount)
{
var message = _pipeline.CreateMessage();
var request = message.Request;
request.Method = RequestMethod.Post;
var uri = new RawRequestUriBuilder();
uri.Reset(endpoint);
uri.AppendPath("/devices/query", false);
uri.AppendQuery("api-version", apiVersion, true);
request.Uri = uri;
if (xMsContinuation != null)
{
request.Headers.Add("x-ms-continuation", xMsContinuation);
}
if (xMsMaxItemCount != null)
{
request.Headers.Add("x-ms-max-item-count", xMsMaxItemCount);
}
request.Headers.Add("Content-Type", "application/json");
var content = new Utf8JsonRequestContent();
content.JsonWriter.WriteObjectValue(querySpecification);
request.Content = content;
return(message);
}
/// <summary>
/// List a set of module twins.
/// </summary>
/// <param name="pageSize">The size of each page to be retrieved from the service. Service may override this size.</param>
/// <param name="cancellationToken">The cancellation token.</param>
/// <returns>A pageable set of module twins <see cref="Pageable{T}"/>.</returns>
public virtual Pageable <TwinData> GetTwins(int?pageSize = null, CancellationToken cancellationToken = default)
{
Page <TwinData> FirstPageFunc(int?pageSizeHint)
{
var querySpecification = new QuerySpecification
{
Query = HubModuleQuery
};
Response <IReadOnlyList <TwinData> > response = _registryManagerClient.QueryIotHub(
querySpecification,
null,
pageSizeHint?.ToString(CultureInfo.InvariantCulture),
cancellationToken);
response.GetRawResponse().Headers.TryGetValue(ContinuationTokenHeader, out string continuationToken);
return(Page.FromValues(response.Value, continuationToken, response.GetRawResponse()));
}
Page <TwinData> NextPageFunc(string nextLink, int?pageSizeHint)
{
var querySpecification = new QuerySpecification();
Response <IReadOnlyList <TwinData> > response = _registryManagerClient.QueryIotHub(
querySpecification,
nextLink,
pageSizeHint?.ToString(CultureInfo.InvariantCulture),
cancellationToken);
response.GetRawResponse().Headers.TryGetValue(ContinuationTokenHeader, out string continuationToken);
return(Page.FromValues(response.Value, continuationToken, response.GetRawResponse()));
}
return(PageableHelpers.CreateEnumerable(FirstPageFunc, NextPageFunc, pageSize));
}
public override void ExplicitVisit(QuerySpecification node)
{
//node.FromClause
//node.ForClause
//node.SelectElements
base.ExplicitVisit(node);
}
private IList <Tag> DoSearch(QuerySpecification <Tag> specification)
{
return(this.tagRepository
.FindAll(specification)
.OrderBy(t => t.Name)
.ToList());
}
private BooleanIsNullExpression GetIsNotNull()
{
var isNull = new BooleanIsNullExpression();
isNull.IsNot = true;
var query = (isNull.Expression = new ScalarSubquery()) as ScalarSubquery;
var spec = (query.QueryExpression = new QuerySpecification()) as QuerySpecification;
spec.SelectElements.Add(new SelectStarExpression());
var fromTable = new QueryDerivedTable();
spec.FromClause = new FromClause();
spec.FromClause.TableReferences.Add(fromTable);
var subQuerySpec = new QuerySpecification();
var version = new GlobalVariableExpression();
version.Name = "@@version";
var columnName = new IdentifierOrValueExpression();
//var v = (columnName.ValueExpression = new StringLiteral()) as StringLiteral;
//v.Value = "v";
columnName.Identifier = new Identifier();
columnName.Identifier.Value = "v";
subQuerySpec.SelectElements.Add(new SelectScalarExpression {Expression = version, ColumnName = columnName});
fromTable.QueryExpression = subQuerySpec;
fromTable.Alias = new Identifier {Value = "edition"};
spec.WhereClause = new WhereClause();
var likePredicate = (spec.WhereClause.SearchCondition = new LikePredicate()) as LikePredicate;
var col = (likePredicate.FirstExpression = new ColumnReferenceExpression()) as ColumnReferenceExpression;
col.ColumnType = ColumnType.Regular;
col.MultiPartIdentifier = new MultiPartIdentifier();
col.MultiPartIdentifier.Identifiers.Add(new Identifier {Value = "v"});
var ver = (likePredicate.SecondExpression = new StringLiteral()) as StringLiteral;
ver.Value = "%Enterprise%";
return isNull;
}
// TODO
#endregion
#region SetItemVariable
// TODO
#endregion
#region SetColumnAssignmentEquals
// TODO
#endregion
#region SetColumnAssignmentOperator
// TODO
#endregion
#region SetVariableColumnAssignment
// TODO
#endregion
#region SetVariableAssignment
// TODO
#endregion
#region WithCommonTable
// TODO
#endregion
#region OperatorQueryExpression
// TODO
#endregion
#region QuerySpecification
public virtual bool Action(QuerySpecification child)
{
if (child.SelectClause != null)
{
Scan(child.SelectClause);
}
if (child.FromClause != null)
{
_HTML += " FROM ";
for (int i = 0; i < child.FromClause.Count; i++)
{
if (i > 0)
{
_HTML += " ";
}
Scan(child.FromClause[i]);
}
}
if (child.WhereClause != null)
{
_HTML += " WHERE ";
Scan(child.WhereClause);
}
if (child.GroupByClause != null)
{
_HTML += " GROUP BY ";
for (int i = 0; i < child.GroupByClause.Count; i++)
{
if (i > 0)
{
_HTML += ",";
}
Scan(child.GroupByClause[i]);
}
}
if (child.HavingClause != null)
{
_HTML += " HAVING ";
Scan(child.HavingClause);
}
if (child.OrderByClause != null)
{
Stringifier str = new Stringifier();
str.AddSpace();
str.Add("ORDER BY");
str.AddSpace();
foreach (OrderByItem item in child.OrderByClause)
{
str.Add(item);
if (item != child.OrderByClause.Last())
{
str.Add(",");
str.AddSpace();
}
}
_HTML += str.Statement;
}
return(false);
}
public IQueryable <T> Queryable <T>() where T : class
{
var query = new QuerySpecification <T>();
query.WithUnitOfWork(unitOfWork.For <TDatabase>());
return(query.ToIQueryable());
}
/// <summary>
/// Método para asignar criterios de fitros y criterios de paginación.
/// </summary>
/// <param name="paginationCatalog">Especificación de paginación.</param>
/// <param name="criteriaExpression">Especificación de filtros para la expresión de búsqueda.</param>
/// <returns>Especificación de búsqueda.</returns>
private QuerySpecification <TEntity> GetQuerySpecification(PaginationCatalog paginationCatalog, Expression <Func <TEntity, bool> > criteriaExpression)
{
QuerySpecification <TEntity> spec = new QuerySpecification <TEntity>(criteriaExpression);
spec.Paginate(SetPagination(paginationCatalog));
return(spec);
}
private IList <DbObjectTableSource> GetAvailTables(QuerySpecification query)
{
IList <DbObjectTableSource> ret = new List <DbObjectTableSource>();
AddAvailTables(query.FromClause, ret);
return((ret.Count == 0) ? null : ret);
}
public WorkflowContext(string persistenceContext, string machineContext, string initialState, string repositoryKey)
{
_persistenceContext = persistenceContext;
_machineContext = machineContext;
_cachedState = initialState;
_machineStateData = Catalog.Preconfigure().ConfigureWorkflowDataRepository <WorkflowMachineState>()
.ConfiguredResolve <IDataRepositoryService <WorkflowMachineState,
WorkflowMachineState,
DataEnvelope <WorkflowMachineState, NoMetadata>,
NoMetadata,
DatumEnvelope <WorkflowMachineState, NoMetadata>,
NoMetadata> >
(repositoryKey);
WorkflowMachineState current = null;
var qs = new QuerySpecification
{
BookMark = new GenericPageBookmark {
PageSize = 100
},
Where = new Filter
{
PredicateJoin = PredicateJoin.And,
Rules = new Comparison[]
{
new Comparison
{
Data = _persistenceContext,
Field = "Parent",
Test = Test.Equal
},
new Comparison
{
Data = _machineContext,
Field = "StateMachine",
Test = Test.Equal
}
}
}
};
var queryResult = _machineStateData.Query(qs).Items.EmptyIfNull();
current = queryResult.FirstOrDefault();
if (null != current)
{
_cachedState = current.State;
_cachedId = current.Id;
}
else
{
_cachedId = string.Format("MS{0}-{1}", _persistenceContext, _machineContext);
ChangeState(_cachedState);
}
}
public static async Task RunSample()
{
Console.WriteLine("Starting sample...");
using (ProvisioningServiceClient provisioningServiceClient =
ProvisioningServiceClient.CreateFromConnectionString(_provisioningConnectionString))
{
#region Create a new enrollmentGroup config
Console.WriteLine("\nCreating a new enrollmentGroup...");
string certificatePassword = ReadCertificatePassword();
var certificate = new X509Certificate2(_x509RootCertPath, certificatePassword);
Attestation attestation = X509Attestation.CreateFromRootCertificates(certificate);
EnrollmentGroup enrollmentGroup =
new EnrollmentGroup(
_enrollmentGroupId,
attestation);
Console.WriteLine(enrollmentGroup);
#endregion
#region Create the enrollmentGroup
Console.WriteLine("\nAdding new enrollmentGroup...");
EnrollmentGroup enrollmentGroupResult =
await provisioningServiceClient.CreateOrUpdateEnrollmentGroupAsync(enrollmentGroup).ConfigureAwait(false);
Console.WriteLine("\nEnrollmentGroup created with success.");
Console.WriteLine(enrollmentGroupResult);
#endregion
#region Get info of enrollmentGroup
Console.WriteLine("\nGetting the enrollmentGroup information...");
EnrollmentGroup getResult =
await provisioningServiceClient.GetEnrollmentGroupAsync(SampleEnrollmentGroupId).ConfigureAwait(false);
Console.WriteLine(getResult);
#endregion
#region Query info of enrollmentGroup doc
Console.WriteLine("\nCreating a query for enrollmentGroups...");
QuerySpecification querySpecification = new QuerySpecification("SELECT * FROM enrollmentGroups");
using (Query query = provisioningServiceClient.CreateEnrollmentGroupQuery(querySpecification))
{
while (query.HasNext())
{
Console.WriteLine("\nQuerying the next enrollmentGroups...");
QueryResult queryResult = await query.NextAsync().ConfigureAwait(false);
Console.WriteLine(queryResult);
}
}
#endregion
#region Delete info of enrollmentGroup
Console.WriteLine("\nDeleting the enrollmentGroup...");
await provisioningServiceClient.DeleteEnrollmentGroupAsync(getResult).ConfigureAwait(false);
#endregion
}
}
public void SetupChecks()
{
if (base.TargetTable != base.BaseTable)
{
QuerySpecification mainSelect = base.TargetTable.GetQueryExpression().GetMainSelect();
this.UpdatableTableCheck = mainSelect.CheckQueryCondition;
this._checkRangeVariable = mainSelect.RangeVariables[0];
}
}
private void AddColumns(QuerySpecification qrySpec, gsSelectQuery qry)
{
foreach (var selectElement in qrySpec.SelectElements)
{
gsColumnParserBase colParser = gsColumnParserFactory.CreateParser(selectElement);
gsSelectColumn selCol = colParser.Parse();
qry.Columns.Add(selCol);
}
}
public IQuery <T> Query <T>(Func <IQueryable <T>, IQueryable <T> > expression) where T : class
{
var query = new QuerySpecification <T>();
query.WithUnitOfWork(unitOfWork.For <TDatabase>());
query = new QuerySpecification <T>(expression(query.ToIQueryable()));
return(new Query <T>(query));
}
private void AddDistinct(QuerySpecification qrySpec, gsSelectQuery qry)
{
if (qrySpec.UniqueRowFilter != UniqueRowFilter.Distinct)
{
return;
}
qry.Distinct = true;
}
/// <summary>
/// Builds an <see cref="IQueryable{T}" /> that
/// is composed of the criteria in a
/// <see cref="QuerySpecification{TEntity}" />.
/// </summary>
///
/// <param name="specification">
/// The <see cref="QuerySpecification{TEntity}" /> that
/// defines the criteria a <typeparamref name="TEntity" />
/// must meet to be part of the result set.
/// </param>
///
/// <returns>
/// An <see cref="IQueryable{T}" /> that is
/// composed of the criteria in
/// <paramref name="specification" />.
/// </returns>
protected virtual IQueryable <TEntity> ApplySpecification(QuerySpecification <TEntity> specification)
{
if (specification is PaginatedQuerySpecification <TEntity> paginatedSpecification)
{
return(PaginatedQuerySpecificationEvaluator.ApplySpecificationTo(paginatedSpecification, this._context.Set <TEntity>()));
}
return(QuerySpecificationEvaluator.ApplySpecificationTo(specification, this._context.Set <TEntity>()));
}
public void Select_Query_Is_Converted_Into_Select_Count_Star()
{
var original = new QuerySpecification();
original.FromClause = new FromClause();
original.FromClause.TableReferences.Add(new NamedTableReference()
{
SchemaObject = new SchemaObjectName()
{
BaseIdentifier = { Value = "Bert"}
}
});
var selectCol1 = new ColumnReferenceExpression();
selectCol1.MultiPartIdentifier.Identifiers.Add(new Identifier()
{
Value = "Bertram"
});
//original.SelectElements.Add(new ColumnReferenceExpression());
}
/// <summary>
/// Initializes a new instance of the <see cref="Select"/> class.
/// </summary>
/// <param name="querySpecification">The query specification.</param>
/// <param name="bodyColumnTypes">The body column types.</param>
public Select(QuerySpecification querySpecification, IDictionary<string, DataType> bodyColumnTypes)
{
// Get any table aliases.
var aliasResolutionVisitor = new AliasResolutionVisitor();
querySpecification.Accept(aliasResolutionVisitor);
this.TableAliases = aliasResolutionVisitor.Aliases;
var outerJoinedTables = new List<string>();
if (querySpecification.FromClause != null)
{
foreach (var join in querySpecification.FromClause.TableReferences.OfType<QualifiedJoin>())
{
FillOuterJoins(outerJoinedTables, join, false);
}
}
var topInt = querySpecification.TopRowFilter != null ? querySpecification.TopRowFilter.Expression as IntegerLiteral : null;
this.IsSingleRow = topInt != null && topInt.Value == "1" && querySpecification.TopRowFilter.Percent == false;
this.Columns = querySpecification.SelectElements.OfType<SelectScalarExpression>().Select(x => new SelectColumn(x, bodyColumnTypes, this.TableAliases, outerJoinedTables)).ToList();
}
private void ResolveNames(QuerySpecification qs)
{
var ss = qs.FindAscendant<SelectStatement>();
var nr = new SqlNameResolver();
nr.SchemaManager = CreateSchemaManager();
nr.DefaultTableDatasetName = "Test";
//nr.DefaultTableSchemaName = "dbo"; TODO: delete
nr.DefaultFunctionDatasetName = "Test";
//nr.DefaultFunctionSchemaName = "dbo"; TODO: delete
nr.Execute(ss);
}
private static IEnumerable<Expression> WhereClauseExpressions(QuerySpecification querySpecification)
{
var whereClauses = new List<Expression>();
if (querySpecification.WhereClause != null)
{
var searchCondition = querySpecification.WhereClause.SearchCondition;
CollectWhereClauses(whereClauses, searchCondition);
}
return whereClauses;
}
private static string TableFromFullyQualifiedColumnName(string fullyQualifiedColumnName,
QuerySpecification querySpecification)
{
var parts = fullyQualifiedColumnName.Split('.');
if (parts.Count() < 2)
throw new ApplicationException( "Make sure all column names in select and where clauses have the table name in the SQL (e.g., tableName.columnName).");
var aliasOrTableName = parts[parts.Count() - 2];
var tableName = ReplaceAliasWithTableName(querySpecification, aliasOrTableName);
return StripFilterViewPrefixFromTableName(tableName);
}
private static string ReplaceAliasWithTableName(QuerySpecification querySpecification, string aliasOrTableName)
{
var tableName = aliasOrTableName;
var tablesAnJoinInfos = TableAndJoinInfos(querySpecification);
var tableAndJoinInfoToReplace = tablesAnJoinInfos.Values.Where(x => x.AliasName != null & x.AliasName == tableName).FirstOrDefault();
if (tableAndJoinInfoToReplace != null)
tableName = tableAndJoinInfoToReplace.TableName.ToLower();
return tableName;
}
private static bool IsWildcard(QuerySpecification querySpecification)
{
return ((Column)((SelectColumn)querySpecification.SelectElements[0]).Expression).ColumnType == ColumnType.Wildcard;
}
private string GenerateCode(QuerySpecification qs)
{
var cg = new SqlCodeGen.SqlServerCodeGenerator();
cg.ResolveNames = true;
var sw = new StringWriter();
cg.Execute(sw, qs);
return sw.ToString();
}
public static Dictionary<string, OrderByInfo> OrderByInfos(QuerySpecification querySpecification, OrderByClause orderByClause)
{
var orderByInfos = new Dictionary<string, OrderByInfo>();
if (orderByClause != null)
{
foreach (var expressionWithSortOrder in orderByClause.OrderByElements)
{
var tableName = TableFromFullyQualifiedColumnName(ExpressionPartName(expressionWithSortOrder.Expression),querySpecification);
var columnName = ColumnFromFullyQualifiedColumnName(ExpressionPartName(expressionWithSortOrder.Expression));
var descending = expressionWithSortOrder.SortOrder == SortOrder.Descending;
orderByInfos.Add(tableName + "." + columnName, new OrderByInfo
{
TableName = tableName,
ColumnName = columnName,
Descending = descending
});
}
}
return orderByInfos;
}
private void ResolveNames(QuerySpecification qs)
{
var ss = qs.FindAscendant<SelectStatement>();
var nr = new SqlNameResolver();
nr.SchemaManager = CreateSchemaManager();
nr.DefaultTableDatasetName = Jhu.Graywulf.Test.Constants.TestDatasetName;
nr.DefaultFunctionDatasetName = Jhu.Graywulf.Test.Constants.TestDatasetName;
nr.Execute(ss);
}
private void CreateSelectForFunctionUnderTest(ObjectIdentifier name)
{
var select = new QuerySpecification();
select.SelectElements.Add(new SelectStarExpression());
var from = new FromClause();
var reference = new SchemaObjectFunctionTableReference();
foreach (var p in _parameters)
{
reference.Parameters.Add(new VariableReference(){Name = p.Name});
}
reference.SchemaObject = name.ToSchemaObjectName();
from.TableReferences.Add(reference);
select.FromClause = from;
_functionSelect.QueryExpression = select;
}
public override void Visit(QuerySpecification node) { this.action(node); }
private QuerySpecification BuildSelectSubQuery(QuerySpecification originalSelectQuery)
{
var subQuerySelect = new QuerySpecification();
var countStar = new FunctionCall();
countStar.FunctionName = new Identifier {Value = "count"};
countStar.Parameters.Add(
new ColumnReferenceExpression
{
ColumnType = ColumnType.Wildcard
}
);
subQuerySelect.SelectElements.Add(new SelectScalarExpression()
{
Expression = countStar
});
subQuerySelect.FromClause = originalSelectQuery.FromClause;
return subQuerySelect;
}
public static Dictionary<string, TableAndJoinInfo> TableAndJoinInfos(QuerySpecification querySpecification)
{
var tables = new Dictionary<string, TableAndJoinInfo>();
foreach (var tableSource in querySpecification.FromClauses)
{
CollectTablesNames(tables, tableSource);
}
return tables;
}
private BooleanComparisonExpression BuildWhilePredicate(QuerySpecification subQuery)
{
var query = new BooleanComparisonExpression();
query.ComparisonType = BooleanComparisonType.GreaterThan;
var scalarQuery = (query.FirstExpression = new ScalarSubquery()) as ScalarSubquery;
scalarQuery.QueryExpression = subQuery;
query.SecondExpression = new IntegerLiteral
{
Value = "0"
};
return query;
}
public static Dictionary<string, WhereClauseInfo> WhereClauseInfos(QuerySpecification querySpecification)
{
var whereClauseExpressions = WhereClauseExpressions(querySpecification);
var whereClauseInfos = new Dictionary<string, WhereClauseInfo>();
foreach (var whereClauseExpression in whereClauseExpressions)
{
var tableName = TableFromFullyQualifiedColumnName(WhereClauseColumn(whereClauseExpression), querySpecification);
var columnName = ColumnFromFullyQualifiedColumnName(WhereClauseColumn(whereClauseExpression));
var operatorAbbreviation = ExpressionComparisonPart(whereClauseExpression);
var values = WhereClauseValues(whereClauseExpression);
var whereClauseInfo = new WhereClauseInfo
{
TableName = tableName,
ColumnName = columnName,
OperatorAbbreviation = operatorAbbreviation,
Values = values
};
whereClauseInfos.Add(whereClauseInfo.TableName + "." + whereClauseInfo.ColumnName, whereClauseInfo);
}
return whereClauseInfos;
}
public override void ExplicitVisit(QuerySpecification fragment)
{
_fragments.Add(fragment);
}
public ExpressionNameTypeValidator(QuerySpecification querySpecification)
: base(querySpecification)
{
}
