public GRPDEFRecord(RecordReader reader, RecordContext context) : base(reader, context) { this.Definition = new GroupDefinition(); UInt16 groupNameIndex = reader.ReadIndex(); if (groupNameIndex == 0 || groupNameIndex > context.Names.Count) { throw new InvalidDataException("GroupNameIndex is out of range."); } this.Definition.Name = context.Names[groupNameIndex - 1]; while (!reader.IsEOF) { reader.ReadByte(); // 'type' ignored UInt16 segmentIndex = reader.ReadIndex(); if (segmentIndex == 0 || segmentIndex > context.Segments.Count) { throw new InvalidDataException("SegmentIndex is out of range."); } this.Definition.Segments.Add(context.Segments[segmentIndex - 1]); } context.Groups.Add(Definition); }
/// <inheritdoc /> protected override void AddGroupsFromTable(DataTable groupTable, ICollection<GroupDefinition> groups) { if (groupTable.Columns.Count < 2) { throw new ArgumentException("Table with groups must contains minimum two columns. GroupName and GroupId."); } groupTable.Rows.Cast<DataRow>() .ToList() .ForEach( row => { var group = new GroupDefinition(this.Instance, row[0].ToString(), row[1].ToString()) { GroupType = QueryScope.InstanceGroup }; foreach (DataColumn column in groupTable.Columns) { group.GroupParameters.Add(column.ColumnName, row[column].ToString()); } groups.Add(group); }); }
public void ConnectWithUnknownExportingGroup() { using (var source = new CancellationTokenSource()) { var commands = new Mock <ICompositionCommands>(); { commands.Setup(c => c.Add(It.IsAny <GroupCompositionId>(), It.IsAny <GroupDefinition>())) .Returns( Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); } var connector = new Mock <IConnectGroups>(); var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var layer = new ProxyCompositionLayer(commands.Object, connector.Object, systemDiagnostics); var exportingGroup = new GroupDefinition("Group1"); var task = layer.Add(exportingGroup); task.Wait(); var importDefinition = GroupImportDefinition.CreateDefinition( "a", new GroupRegistrationId("b"), null, Enumerable.Empty <ImportRegistrationId>()); Assert.Throws <UnknownPartGroupException>(() => layer.Connect(task.Result, importDefinition, new GroupCompositionId())); } }
/// <inheritdoc /> protected override void AddGroupsFromTable(DataTable groupTable, ICollection <GroupDefinition> groups) { if (groupTable.Columns.Count < 2) { throw new ArgumentException("Table with groups must contains minimum two columns. GroupName and GroupId."); } groupTable.Rows.Cast <DataRow>() .ToList() .ForEach( row => { var group = new GroupDefinition(this.Instance, row[0].ToString(), row[1].ToString()) { GroupType = QueryScope.InstanceGroup }; foreach (DataColumn column in groupTable.Columns) { group.GroupParameters.Add(column.ColumnName, row[column].ToString()); } groups.Add(group); }); }
public RawGroup(GroupDefinition definition, ISpectrum owningSpectrum) { this._definition = definition; this._components = CreateComponents(0); this._owningSpectrum = owningSpectrum; CreateUniqueComponent(definition); }
public SpectraContainerTabPage(ISpectraContainer container, ProjectForm projectForm) : base(container.Name) { this._container = container; this.Name = container.Name; this._projectForm = projectForm; _groupsControl = new TabControl(); _groupsControl.Name = "groupsControl"; _groupsControl.Parent = this; _groupsControl.Dock = DockStyle.Fill; int id = 0; foreach (IGroup group in container.Spectra[0].Parameters) { if (!projectForm.project.BindingsManager.Contains(container, group.Definition.name)) { GroupDefinition gd = group.Definition; if ((gd.Type & GroupType.Hidden) != GroupType.Hidden) { //_groupsControl.TabPages.Add(new GroupTabPage(container.Spectra, gd, projectForm.statusStrip1, _groupsControl)); InsertGroupTabPage(gd.name, id++); } } } //if (projectForm.project.BindingsManager.Contains(container)) // SortableGroupGrids = false; }
public void BuildShouldCreateFlatListWhenGroupingByOneCriteria(GroupDefinition grouping) { // Arrange var sut = Construct(grouping, GroupDefinition.Status); var branch = Substitute.For <IBranch>(); var definition = Substitute.For <IBuildDefinition>(); var branches = new[] { branch }; var definitions = new[] { definition }; var builds = new List <IBuild>(); var b1 = Substitute.For <IBuild>(); b1.Definition.Returns(definition); b1.Branch.Returns(branch); builds.Add(b1); // Act var actual = sut.Build(builds, branches, definitions); // Assert var expectedCount = builds.Count; Assert.Equal(expectedCount, actual.Children.Count()); }
public void Add() { var lockKey = new DatasetLockKey(); var datasetLock = new Mock <ITrackDatasetLocks>(); { datasetLock.Setup(d => d.LockForWriting()) .Returns(lockKey) .Verifiable(); datasetLock.Setup(d => d.RemoveWriteLock(It.IsAny <DatasetLockKey>())) .Callback <DatasetLockKey>(key => Assert.AreSame(lockKey, key)) .Verifiable(); } var originalId = new GroupCompositionId(); var originalDefinition = new GroupDefinition("a"); var storage = new Mock <IStoreGroupsAndConnections>(); { storage.Setup(s => s.Add(It.IsAny <GroupCompositionId>(), It.IsAny <GroupDefinition>())) .Callback <GroupCompositionId, GroupDefinition>( (id, def) => { Assert.AreSame(originalId, id); Assert.AreSame(originalDefinition, def); }); } var commands = new CompositionCommands(datasetLock.Object, storage.Object); var task = commands.Add(originalId, originalDefinition); task.Wait(); datasetLock.Verify(d => d.LockForWriting(), Times.Once()); datasetLock.Verify(d => d.RemoveWriteLock(It.IsAny <DatasetLockKey>()), Times.Once()); }
public GroupDefinitionViewModel(GroupDefinition groupDefinition) { GroupDefinition = groupDefinition; _groupByText = StringLocalizer.GroupBy; SortingDefinitionsViewModel = new SortingDefinitionsViewModel(groupDefinition); SortingDefinitionsViewModel.SelectedSortingDefinitionChanged += OnSelectedSortingDefinitionChanged; }
/// <summary> /// Adds a new <see cref="GroupDefinition"/> to the graph and returns the ID for that group. /// </summary> /// <param name="id">The ID of the group that is being added.</param> /// <param name="group">The group that should be added to the graph.</param> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="id"/> is <see langword="null" />. /// </exception> /// <exception cref="ArgumentNullException"> /// Thrown if <paramref name="group"/> is <see langword="null" />. /// </exception> public void Add(GroupCompositionId id, GroupDefinition group) { { Lokad.Enforce.Argument(() => id); Lokad.Enforce.Argument(() => group); } if (!m_Definitions.ContainsKey(group.Id)) { m_Definitions.Add(group.Id, group); } m_Groups.Add(id, group.Id); m_GroupConnections.AddVertex(id); foreach (var part in group.Parts) { var partId = new PartCompositionId(id, part.Id); m_Parts.Add(partId, new PartCompositionInfo(part)); m_PartConnections.AddVertex(partId); } var parts = PartsForGroup(id); ConnectParts(group.InternalConnections, parts, parts); }
/// <summary> /// The process group. /// </summary> /// <param name="query">The query.</param> /// <param name="parameterValues">The parameter values.</param> /// <param name="result">The result.</param> /// <param name="queryItem">The query item.</param> /// <param name="group">The group.</param> /// <param name="subProgress">The sub progress.</param> protected virtual void ExecuteQuery( QueryInfo query, QueryExecutionParams parameters, QueryInstanceResultInfo result, QueryItemInfo queryItem, GroupDefinition group, ProgressItem subProgress ) { // Log.InfoFormat("146:query:'{0}'", // query // ); var qr = this.ExecuteQueryItemFunction.Invoke( this.Instance, queryItem, string.IsNullOrWhiteSpace(group.Name) ? parameters.DefaultDatabase : group.Name, //group.Name, group.Id, query.Parameters, parameters.Values.ToList(), subProgress ); // костыль. Наверное, прибъется вообще после убиения "групп" qr.Database = group.Name; result.AddDatabaseResult(qr); }
private string GetGroupConditionCommand(GroupDefinition bracketDefinition) { StringBuilder stringBuilder = new StringBuilder(); foreach (var condition in bracketDefinition.SeriesConnection) { switch (condition.Condition) { case Conditions.ColumnCondition: stringBuilder.Append($" {GetRelationString((ColumnConditionDefinition)condition)}"); break; case Conditions.AndConjunction: stringBuilder.Append(" AND"); break; case Conditions.OrConjunction: stringBuilder.Append(" OR"); break; case Conditions.Bracket: stringBuilder.Append($" ( {GetGroupConditionCommand((GroupDefinition)condition)} )"); break; case Conditions.Select: string selectCondition = $" {condition.GetColumnName()} IN ( {GetSelectCommand(condition.GetSelectData())} )"; stringBuilder.Append($" ( {selectCondition.Replace(";", "")} )"); break; } } return(stringBuilder.ToString()); }
private string GetConditionCommand(GroupDefinition bracketDefinition) { StringBuilder stringBuilder = new StringBuilder(); stringBuilder.Append($"WHERE{GetGroupConditionCommand(bracketDefinition)}"); return(stringBuilder.ToString()); }
/// <inheritdoc /> public override IEnumerable <ParameterValue> GetParametersFromDefinition(GroupDefinition definition) { return(new[] { new ParameterValue() { Name = string.Empty, StringValue = string.Empty } }); }
/// <summary> /// Adds a new <see cref="GroupDefinition"/> to the graph and returns the ID for that group. /// </summary> /// <param name="group">The group that should be added to the graph.</param> /// <returns> /// A task which returns the ID for the group. /// </returns> public Task <GroupCompositionId> Add(GroupDefinition group) { { Debug.Assert(group != null, "The definition that should be added should not be a null reference."); } var id = new GroupCompositionId(); var remoteTask = m_Commands.Add(id, group); m_Diagnostics.Log( LevelToLog.Trace, HostConstants.LogPrefix, string.Format( CultureInfo.InvariantCulture, Resources.ProxyCompositionLayer_LogMessage_AddingGroup_WithId, id)); return(remoteTask.ContinueWith( t => { lock (m_Lock) { m_Groups.Add(id, group); m_GroupConnections.AddVertex(id); } return id; })); }
public void Connect() { using (var source = new CancellationTokenSource()) { var commands = new Mock <ICompositionCommands>(); { commands.Setup(c => c.Add(It.IsAny <GroupCompositionId>(), It.IsAny <GroupDefinition>())) .Returns( Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); commands.Setup(c => c.Connect(It.IsAny <GroupConnection>())) .Returns( Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); } var connector = new Mock <IConnectGroups>(); { connector.Setup( c => c.GenerateConnectionFor( It.IsAny <GroupDefinition>(), It.IsAny <GroupImportDefinition>(), It.IsAny <GroupDefinition>())) .Callback <GroupDefinition, GroupImportDefinition, GroupDefinition>( (importingGroup, importDef, exportingGroup) => { }) .Returns(Enumerable.Empty <PartImportToPartExportMap>()); } var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var layer = new ProxyCompositionLayer(commands.Object, connector.Object, systemDiagnostics); var exportingDefinition = new GroupDefinition("Group1"); var addTask = layer.Add(exportingDefinition); var exportingId = addTask.Result; var importingDefinition = new GroupDefinition("Group2"); addTask = layer.Add(importingDefinition); var importingId = addTask.Result; var importDefinition = GroupImportDefinition.CreateDefinition( "a", new GroupRegistrationId("b"), null, Enumerable.Empty <ImportRegistrationId>()); var connectTask = layer.Connect(importingId, importDefinition, exportingId); connectTask.Wait(); Assert.IsTrue(layer.IsConnected(importingId, importDefinition)); Assert.IsTrue(layer.IsConnected(importingId, importDefinition, exportingId)); Assert.AreEqual(exportingId, layer.ConnectedTo(importingId, importDefinition)); } }
public double MemoryInt = 0; ///po normalizacji ///kiedy intensywności mają wejść do parametrów searchu ///tutaj przechowywana będzie intensywność pierwszej składowej ///brana później do obliczania doubleAsterixSum (suma intensywności wolnych ///w search'u) public ContributedGroup(GroupDefinition definition, ISpectrum owningSpectrum) { this._definition = definition; this._components = CreateComponents(0); contribution = new Parameter("contribution", this); this._owningSpectrum = owningSpectrum; CreateUniqueComponent(definition); }
public GroupDefinition <T> Group(String displayName, short row, short column, String visible, int?rowspan = null, int?columnspan = null) { GroupDefinition <T> group = new GroupDefinition <T>(displayName, row, column, visible, rowspan, columnspan); Groups.Add(group); return(group); }
private void refilterCatalog(GroupDefinition themeDefinition) { resetCatalog(); filteredDefinitions.AddRange(filterDecorationListByTheme(themeDefinition)); filteredDefinitions.AddRange(filterStructureListByTheme(themeDefinition)); filteredDefinitions = sortDisplayedList(filteredDefinitions); PooledScrollRect.RefreshList(filteredDefinitions.Count); }
/// <summary> /// Constructor (without database). /// </summary> /// <param name="templateNode">Template node.</param> /// <param name="connection">Information group on connection.</param> public ConcreteTemplateNodeDefinition(TemplateNodeInfo templateNode, ConnectionGroupInfo connection) { this._templateNode = templateNode; this._group = GroupDefinition.NullGroup; this.Connection = connection; this.NodeActivated = true; this.NodeAvailable = true; }
/// <summary> /// Constructor (with database). /// </summary> /// <param name="templateNode">Template node.</param> /// <param name="group">Database.</param> /// /// /// <param name="connection">Connection group information.</param> public ConcreteTemplateNodeDefinition(TemplateNodeInfo templateNode, GroupDefinition @group, ConnectionGroupInfo connection) { Debug.Assert(templateNode.IsInstance); this._templateNode = templateNode; this._group = @group; this.Connection = connection; this.NodeActivated = true; this.NodeAvailable = true; }
public void ReloadFromDataset() { var importingId = new GroupCompositionId(); var exportingId = new GroupCompositionId(); var importingGroup = new GroupDefinition("Group1"); var exportingGroup = new GroupDefinition("Group2"); var importDefinition = GroupImportDefinition.CreateDefinition( "a", new GroupRegistrationId("b"), null, Enumerable.Empty <ImportRegistrationId>()); var state = new GroupCompositionState( new List <Tuple <GroupCompositionId, GroupDefinition> > { new Tuple <GroupCompositionId, GroupDefinition>(importingId, importingGroup), new Tuple <GroupCompositionId, GroupDefinition>(exportingId, exportingGroup), }, new List <Tuple <GroupCompositionId, GroupImportDefinition, GroupCompositionId> > { new Tuple <GroupCompositionId, GroupImportDefinition, GroupCompositionId>(importingId, importDefinition, exportingId) }); using (var source = new CancellationTokenSource()) { var commands = new Mock <ICompositionCommands>(); { commands.Setup(c => c.CurrentState()) .Returns( Task <GroupCompositionState> .Factory.StartNew( () => state, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); } var connector = new Mock <IConnectGroups>(); var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var layer = new ProxyCompositionLayer(commands.Object, connector.Object, systemDiagnostics); var task = layer.ReloadFromDataset(); task.Wait(); Assert.IsTrue(layer.Contains(importingId)); Assert.AreEqual(importingGroup, layer.Group(importingId)); Assert.IsTrue(layer.Contains(exportingId)); Assert.AreEqual(exportingGroup, layer.Group(exportingId)); Assert.IsTrue(layer.IsConnected(importingId, importDefinition)); Assert.IsTrue(layer.IsConnected(importingId, importDefinition, exportingId)); Assert.AreEqual(exportingId, layer.ConnectedTo(importingId, importDefinition)); } }
/// <inheritdoc /> public override IEnumerable <ParameterValue> GetParametersFromDefinition(GroupDefinition definition) { return (definition.GroupParameters.Select( groupParameter => new ParameterValue() { Name = "@" + groupParameter.Key, StringValue = groupParameter.Value })); }
public DefaultGroupGUI(DataGridView gridView, List <ISpectrum> spectra, GroupDefinition groupDefinition, GroupTabPage groupTabPage) { this.gridView = gridView; this.spectra = spectra; this.groupDefinition = groupDefinition; //this.comparers = new List<Comparer<ISpectrum>>(); this.numberFormat = new CultureInfo("en-US", false).NumberFormat; this.numberFormat.NumberDecimalSeparator = "."; this.parentProject = spectra[0].Container.ParentProject; this.groupTabPage = groupTabPage; }
/// <inheritdoc /> public override IEnumerable<ParameterValue> GetParametersFromDefinition(GroupDefinition definition) { return definition.GroupParameters.Select( groupParameter => new ParameterValue() { Name = "@" + groupParameter.Key, StringValue = groupParameter.Value }); }
private void toolStripButton1_Click(object sender, System.EventArgs e) { GroupDefinition gd = new GroupDefinition(); gd = this._patternGroupsDefinition[1]; gd.Type &= ~GroupType.CalcContribution; gd.name = String.Format("Package {0}", this._groupCounter++); groupsGrid.RowCount++; groupsGrid.Rows[groupsGrid.RowCount - 1].Cells[0].Value = gd; groupsGrid.Rows[groupsGrid.RowCount - 1].Cells[1].Value = gd.name; groupsGrid.Rows[groupsGrid.RowCount - 1].Cells[2].Value = (gd.Type & GroupType.CalcContribution) == GroupType.CalcContribution; }
public SortingDefinitionsViewModel(GroupDefinition forGroupDefinition) { ForGroupDefinition = forGroupDefinition; Sortings = new RemoveTrackingObservableCollection <SortingDefinitionViewModel> { new SortingDefinitionViewModel(forGroupDefinition, SortingDefinition.AlphabeticalDescending), new SortingDefinitionViewModel(forGroupDefinition, SortingDefinition.AlphabeticalAscending), new SortingDefinitionViewModel(forGroupDefinition, SortingDefinition.StatusAscending), new SortingDefinitionViewModel(forGroupDefinition, SortingDefinition.StatusDescending) }; SelectedViewModel = Sortings.First(); }
public void Remove() { GroupCompositionId storedId = null; GroupDefinition storedDefinition = null; using (var source = new CancellationTokenSource()) { var commands = new Mock <ICompositionCommands>(); { commands.Setup(c => c.Add(It.IsAny <GroupCompositionId>(), It.IsAny <GroupDefinition>())) .Callback <GroupCompositionId, GroupDefinition>( (id, def) => { storedId = id; storedDefinition = def; }) .Returns( Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); commands.Setup(c => c.Remove(It.IsAny <GroupCompositionId>())) .Callback <GroupCompositionId>(id => storedId = id) .Returns( Task.Factory.StartNew( () => { }, source.Token, TaskCreationOptions.None, new CurrentThreadTaskScheduler())); } var connector = new Mock <IConnectGroups>(); var systemDiagnostics = new SystemDiagnostics((p, s) => { }, null); var layer = new ProxyCompositionLayer(commands.Object, connector.Object, systemDiagnostics); var definition = new GroupDefinition("Group1"); var task = layer.Add(definition); task.Wait(); Assert.AreSame(storedId, task.Result); Assert.AreSame(definition, storedDefinition); Assert.IsTrue(layer.Contains(task.Result)); var otherTask = layer.Remove(task.Result); otherTask.Wait(); Assert.AreSame(task.Result, storedId); Assert.IsFalse(layer.Contains(task.Result)); } }
public SharedGroupTabPage(List <ISpectrum> spectra, GroupDefinition definition, StatusStrip statusStrip, TabControl parentTabControl, ProjectForm parentProjectForm, GroupBinding binding) : base(spectra, definition, statusStrip, parentTabControl, parentProjectForm) { this._binding = binding; grid.FixedCols = 3; UpdateName(); refreshReferences(); }
private static SegmentGroup ConvertGroupDefinition( GroupDefinition def, Dictionary <object, object> objectMap) { SegmentGroup group = new SegmentGroup(); group.Name = def.Name; group.Segments = new LogicalSegment[def.Segments.Count]; for (int i = 0; i < group.Segments.Length; i++) { group.Segments[i] = (LogicalSegment)objectMap[def.Segments[i]]; } return(group); }
private List <StaticGameDataDefinition> filterStructureListByTheme(GroupDefinition themeDefinition) { List <StaticGameDataDefinition> list = new List <StaticGameDataDefinition>(); foreach (StaticGameDataDefinitionKey key in GroupDefinitionHelper.GetKeys <StructureDefinition>(themeDefinition)) { if (int.TryParse(key.Id, out var result) && structureDefinitions.ContainsKey(result)) { list.Add(structureDefinitions[result]); } } return(list); }
public void DefineImportWithObjectImports() { var plugins = CreatePluginTypes(); GroupDefinition groupInfo = null; var repository = new Mock <IPluginRepository>(); { repository.Setup(r => r.Parts()) .Returns(plugins); repository.Setup(r => r.AddGroup(It.IsAny <GroupDefinition>(), It.IsAny <PluginFileInfo>())) .Callback <GroupDefinition, PluginFileInfo>((g, f) => groupInfo = g); } var importEngine = new Mock <IConnectParts>(); { importEngine.Setup(i => i.Accepts(It.IsAny <SerializableImportDefinition>(), It.IsAny <SerializableExportDefinition>())) .Returns(true); } Func <Type, TypeIdentity> identityGenerator = t => TypeIdentity.CreateDefinition(t); Func <IBuildFixedSchedules> scheduleBuilder = () => new FixedScheduleBuilder(); var builder = new GroupDefinitionBuilder( repository.Object, importEngine.Object, identityGenerator, scheduleBuilder, new PluginFileInfo("a", DateTimeOffset.Now)); var firstInfo = builder.RegisterObject(typeof(ImportOnProperty)); var groupImportName = "groupImport"; builder.DefineImport(groupImportName, new List <ImportRegistrationId> { firstInfo.RegisteredImports.First() }); var groupName = "MyGroup"; builder.Register(groupName); Assert.IsNotNull(groupInfo); Assert.AreEqual(new GroupRegistrationId(groupName), groupInfo.GroupImports.First().ContainingGroup); Assert.IsNull(groupInfo.GroupImports.First().ScheduleInsertPosition); Assert.That( groupInfo.GroupImports.First().ImportsToMatch, Is.EquivalentTo( new List <ImportRegistrationId> { firstInfo.RegisteredImports.First(), })); }
/// <inheritdoc /> protected override void ExecuteQuery( QueryInfo query, QueryExecutionParams parameters, QueryInstanceResultInfo result, QueryItemInfo queryItem, GroupDefinition group, ProgressItem subProgress ) { var tempValues = new List<ParameterValue>(parameters.Values); foreach (var parameter in group.GroupParameters) { tempValues.Add(new ParameterValue { Name = "@" + parameter.Key, StringValue = parameter.Value } ); } QueryDatabaseResultInfo databaseResult = this.ExecuteQueryItemFunction.Invoke( this.Instance, queryItem, null, null, query.Parameters, tempValues, subProgress ); databaseResult.Database = group.Name; databaseResult.DatabaseId = group.Id; result.AddDatabaseResult(databaseResult); }
/// <inheritdoc /> public override IEnumerable<ParameterValue> GetParametersFromDefinition(GroupDefinition definition) { return new[] { new ParameterValue() { Name = string.Empty, StringValue = string.Empty } }; }
/// <summary> /// The execute query. /// </summary> /// <param name="query">The query.</param> /// <param name="parameterValues">The parameter values.</param> /// <param name="progress">The progress.</param> /// <param name="groups">The groups.</param> /// <param name="result">The result.</param> /// <param name="queryItem">The query item.</param> private void ExecuteQuery( QueryInfo query, QueryExecutionParams parameters, ProgressItem progress, GroupDefinition[] groups, QueryInstanceResultInfo result, QueryItemInfo queryItem ) { // Log.InfoFormat("query:'{0}'", // query // ); Debug.Assert(groups.Length <= 1); if (groups.Length == 0) { this.ExecuteQuery( query, parameters, result, queryItem, new GroupDefinition( this.Instance, string.Empty, string.Empty ), progress ); ProgressComplete(progress); } else { foreach (var group in groups) { if (group.ChildGroups.Count > 0) { var tempParams = parameters.Clone(); tempParams.AddValues( this.GetGroupsResolver().GetParametersFromDefinition(group) ); this.ExecuteQuery( query, tempParams, progress, group.ChildGroups.ToArray(), result, queryItem ); } ProgressItem subProgress = null; if (progress != null) { try { subProgress = progress.GetChild(); } catch (Exception) { } } this.ExecuteQuery( query, parameters, result, queryItem, @group, subProgress ); ProgressComplete(subProgress); } } }
/// <summary> /// Executes multyquery for database /// </summary> /// <param name="group">Database definition</param> /// <param name="templateNodeQueryInfos">Template nodes</param> /// <param name="progress">Progress item</param> /// <returns>Multyquery result</returns> public MultyQueryResultInfo ExecuteMultyQuery( GroupDefinition @group, List<TemplateNodeQueryInfo> templateNodeQueryInfos, ProgressItem progress ) { //////////////////////////////////////////////////////////////////////////////////////// // string strLogMessage = "DEBUG:MSSQLServerAuditor.Model.ExecuteMultyQuery(2)"; // strLogMessage = strLogMessage + ";GD:" + @group.ToString(); // log.Debug(strLogMessage); //////////////////////////////////////////////////////////////////////////////////////// MultyQueryResultInfo result = new MultyQueryResultInfo(); progress.SetPromisedChildCount(templateNodeQueryInfos.Count); foreach (TemplateNodeQueryInfo queryInfo in templateNodeQueryInfos) { List<QueryInfo> queries = this._model.GetQueryByTemplateNodeQueryInfo(queryInfo); QueryInfo query = queries.FirstOrDefault(x => x.Source == (@group.Instance.Type) || x.Source == QuerySource.SQLite); if ((query.Source == QuerySource.MSSQL || query.Source == QuerySource.TDSQL) && this._skipMsSqlQueries) { continue; } QueryExecutionParams parameters = QueryExecutionParams.CreateFrom(queryInfo); QueryResultInfo queryResult = ExecuteQuery( @group, query, parameters, progress.GetChild() ); result.Add(new TemplateNodeResultItem(queryInfo, queryResult)); if (this._cancellationToken.IsCancellationRequested) { break; } } return result; }
private QueryResultInfo ExecuteQuery( GroupDefinition groupDefinition, QueryInfo query, QueryExecutionParams parameters, ProgressItem progress = null ) { QueryResultInfo queryResult = new QueryResultInfo(); InstanceInfo instance = groupDefinition.Instance; QueryExecutorFactory factory = new QueryExecutorFactory( instance, this.ExecuteQueryItem, this.ExecuteSql ); BaseQueryExecutor executor = factory.GetExecutor( query.Scope ); CurrentStorage storage = this._model.GetVaultProcessor( instance.ConnectionGroup).CurrentStorage; ServerProperties props = instance.InitServerProperties(storage); QueryInstanceResultInfo instanceResult = executor.ExecuteQuerySimple( query, parameters, props.Version, progress, groupDefinition ); queryResult.AddInstanceResult(instanceResult); return queryResult; }
internal IEnumerable<GroupDefinition> ExtractDatabases() { List<GroupDefinition> databases = new List<GroupDefinition>(); foreach (TemplateNodeResultItem resultItem in List) { foreach (var instancePair in resultItem.QueryResult.InstancesResult) { if ((instancePair.Value.ErrorInfo != null) && (!databases.Contains(GroupDefinition.NullGroup))) { databases.Add(GroupDefinition.NullGroup); } foreach (var databasePair in instancePair.Value.DatabasesResult) { GroupDefinition database = new GroupDefinition( instancePair.Value.Instance, databasePair.Value.Database, databasePair.Value.DatabaseId ); if (!databases.Contains(database)) { databases.Add(database); } } } } if (databases.Count == 0) { databases.Add(GroupDefinition.NullGroup); } return databases; }
/// <summary> /// The get child groups definitions. /// </summary> /// <param name="parent">The parent.</param> /// <param name="parentDefinition">The parent definition.</param> /// <param name="parameterValues">The parameter values.</param> /// <param name="version">The version.</param> private void GetChildGroupsDefinitions( QueryItemInfo parent, GroupDefinition parentDefinition, IEnumerable<ParameterValue> parameterValues, InstanceVersion version ) { QueryItemInfo childGroupSql = parent.ChildGroups.GetQueryItemForVersion(version); var tempParams = parameterValues.ToList(); tempParams.AddRange(this.GetParametersFromDefinition(parentDefinition)); try { DataTable[] groupsTabels = this.ExecuteSqlFunction( this.Instance, childGroupSql, null, childGroupSql.Parameters, tempParams, null, true ); foreach (DataTable groupTable in groupsTabels) { this.AddGroupsFromTable(groupTable, parentDefinition.ChildGroups); } if (childGroupSql.ChildGroups == null || childGroupSql.ChildGroups.Count <= 0) { return; } foreach (GroupDefinition childGroup in parentDefinition.ChildGroups) { this.GetChildGroupsDefinitions(childGroupSql, childGroup, tempParams, version); } } catch (OperationCanceledException ex) { log.Error(ex); throw; } catch (Exception ex) { log.Error("instance=" + this.Instance.Name + " query=" + childGroupSql, ex); } }
/// <summary> /// The get parameters from definition. /// </summary> /// <param name="definition"> /// The parent definition. /// </param> /// <returns> /// The <see cref="IEnumerable{T}"/>. /// </returns> public abstract IEnumerable<ParameterValue> GetParametersFromDefinition(GroupDefinition definition);
/// <summary> /// The prepare progress. /// </summary> /// <param name="progress">The progress.</param> /// <param name="groups">The groups.</param> private void PrepareProgress(ProgressItem progress, GroupDefinition[] groups) { if (progress != null) { if (groups.Length > 0) { progress.SetPromisedChildCount(groups.Length); } else { progress.SetProgress(100); } } }