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) { }