use of com.bakdata.conquery.apiv1.query.SecondaryIdQuery in project conquery by bakdata.
the class StoredQueriesProcessorTest method mockManagedSecondaryIdQueryFrontEnd.
private static ManagedQuery mockManagedSecondaryIdQueryFrontEnd(User user, ManagedExecutionId id, ExecutionState execState, CQElement root, Dataset dataset) {
final SecondaryIdQuery sid = new SecondaryIdQuery();
sid.setSecondaryId(new SecondaryIdDescription() {
{
setDataset(DATASET_0);
setName("sid");
}
});
sid.setRoot(root);
return mockManagedQuery(sid, user, id, execState, dataset);
}
use of com.bakdata.conquery.apiv1.query.SecondaryIdQuery in project conquery by bakdata.
the class QueryProcessor method tryReuse.
/**
* Determine if the submitted query does reuse ONLY another query and restart that instead of creating another one.
*/
private ManagedExecution<?> tryReuse(QueryDescription query, ManagedExecutionId executionId, DatasetRegistry datasetRegistry, ConqueryConfig config, ExecutionManager executionManager, User user) {
ManagedExecution<?> execution = datasetRegistry.getMetaRegistry().resolve(executionId);
if (execution == null) {
return null;
}
// Direct reuse only works if the queries are of the same type (As reuse reconstructs the Query for different types)
if (!query.getClass().equals(execution.getSubmitted().getClass())) {
return null;
}
// If SecondaryIds differ from selected and prior, we cannot reuse them.
if (query instanceof SecondaryIdQuery) {
final SecondaryIdDescription selectedSecondaryId = ((SecondaryIdQuery) query).getSecondaryId();
final SecondaryIdDescription reusedSecondaryId = ((SecondaryIdQuery) execution.getSubmitted()).getSecondaryId();
if (!selectedSecondaryId.equals(reusedSecondaryId)) {
return null;
}
}
// If the user is not the owner of the execution, we definitely create a new Execution, so the owner can cancel it
if (!user.isOwner(execution)) {
final ManagedExecution<?> newExecution = executionManager.createExecution(datasetRegistry, execution.getSubmitted(), user, execution.getDataset());
newExecution.setLabel(execution.getLabel());
newExecution.setTags(execution.getTags().clone());
storage.updateExecution(newExecution);
execution = newExecution;
}
ExecutionState state = execution.getState();
if (state.equals(ExecutionState.RUNNING)) {
log.trace("The Execution[{}] was already started and its state is: {}", execution.getId(), state);
return execution;
}
log.trace("Re-executing Query {}", execution);
executionManager.execute(datasetRegistry, execution, config);
return execution;
}
use of com.bakdata.conquery.apiv1.query.SecondaryIdQuery in project conquery by bakdata.
the class ReusedQueryTest method execute.
@Override
public void execute(String name, TestConquery testConquery) throws Exception {
final StandaloneSupport conquery = testConquery.getSupport(name);
final String testJson = In.resource("/tests/query/SECONDARY_ID_MIXED/SECONDARY_IDS_MIXED.test.json").withUTF8().readAll();
final Dataset dataset = conquery.getDataset();
final QueryTest test = (QueryTest) JsonIntegrationTest.readJson(dataset, testJson);
// Manually import data, so we can do our own work.
{
ValidatorHelper.failOnError(log, conquery.getValidator().validate(test));
importSecondaryIds(conquery, test.getContent().getSecondaryIds());
conquery.waitUntilWorkDone();
LoadingUtil.importTables(conquery, test.getContent().getTables());
conquery.waitUntilWorkDone();
LoadingUtil.importConcepts(conquery, test.getRawConcepts());
conquery.waitUntilWorkDone();
LoadingUtil.importTableContents(conquery, test.getContent().getTables());
conquery.waitUntilWorkDone();
}
final SecondaryIdQuery query = (SecondaryIdQuery) IntegrationUtils.parseQuery(conquery, test.getRawQuery());
final ManagedExecutionId id = IntegrationUtils.assertQueryResult(conquery, query, 4L, ExecutionState.DONE, conquery.getTestUser(), 201);
assertThat(id).isNotNull();
final MetaStorage metaStorage = conquery.getMetaStorage();
final ManagedQuery execution = (ManagedQuery) metaStorage.getExecution(id);
// Normal reuse
{
final ConceptQuery reused = new ConceptQuery(new CQReusedQuery(execution.getId()));
IntegrationUtils.assertQueryResult(conquery, reused, 2L, ExecutionState.DONE, conquery.getTestUser(), 201);
}
// Reuse by API
{
final URI reexecuteUri = HierarchyHelper.hierarchicalPath(conquery.defaultApiURIBuilder(), QueryResource.class, "reexecute").buildFromMap(Map.of(ResourceConstants.DATASET, conquery.getDataset().getName(), ResourceConstants.QUERY, execution.getId().toString()));
final FullExecutionStatus status = conquery.getClient().target(reexecuteUri).request(MediaType.APPLICATION_JSON).post(Entity.entity(null, MediaType.APPLICATION_JSON_TYPE)).readEntity(FullExecutionStatus.class);
assertThat(status.getStatus()).isIn(ExecutionState.RUNNING, ExecutionState.DONE);
}
// Reuse in SecondaryId
{
final SecondaryIdQuery reused = new SecondaryIdQuery();
reused.setRoot(new CQReusedQuery(execution.getId()));
reused.setSecondaryId(query.getSecondaryId());
IntegrationUtils.assertQueryResult(conquery, reused, 4L, ExecutionState.DONE, conquery.getTestUser(), 201);
}
// Reuse in SecondaryId, but do exclude
{
final SecondaryIdQuery reused = new SecondaryIdQuery();
final CQAnd root = new CQAnd();
reused.setRoot(root);
final CQReusedQuery reuse = new CQReusedQuery(execution.getId());
reuse.setExcludeFromSecondaryId(true);
// We select only a single event of the query by the exact filtering.
final CQConcept cqConcept = new CQConcept();
final ConceptId conceptId = new ConceptId(conquery.getDataset().getId(), "concept");
final Concept<?> concept = conquery.getNamespaceStorage().getConcept(conceptId);
cqConcept.setElements(List.of(concept));
final CQTable cqTable = new CQTable();
cqTable.setConcept(cqConcept);
final CentralRegistry centralRegistry = conquery.getNamespaceStorage().getCentralRegistry();
final Connector connector = centralRegistry.resolve(new ConnectorId(conceptId, "connector1"));
cqTable.setConnector(connector);
cqTable.setFilters(List.of(new FilterValue.CQRealRangeFilter((Filter<Range<BigDecimal>>) centralRegistry.resolve(new FilterId(connector.getId(), "filter")), new Range<>(BigDecimal.valueOf(1.01d), BigDecimal.valueOf(1.01d)))));
cqConcept.setTables(List.of(cqTable));
cqConcept.setExcludeFromSecondaryId(false);
root.setChildren(List.of(reuse, cqConcept));
reused.setSecondaryId(query.getSecondaryId());
IntegrationUtils.assertQueryResult(conquery, reused, 1L, ExecutionState.DONE, conquery.getTestUser(), 201);
}
// Reuse Multiple times with different query types
{
final SecondaryIdQuery reused1 = new SecondaryIdQuery();
reused1.setRoot(new CQReusedQuery(execution.getId()));
reused1.setSecondaryId(query.getSecondaryId());
final ManagedExecutionId reused1Id = IntegrationUtils.assertQueryResult(conquery, reused1, 4L, ExecutionState.DONE, conquery.getTestUser(), 201);
final ManagedQuery execution1 = (ManagedQuery) metaStorage.getExecution(reused1Id);
{
final SecondaryIdQuery reused2 = new SecondaryIdQuery();
reused2.setRoot(new CQReusedQuery(execution1.getId()));
reused2.setSecondaryId(query.getSecondaryId());
final ManagedExecutionId reused2Id = IntegrationUtils.assertQueryResult(conquery, reused2, 4L, ExecutionState.DONE, conquery.getTestUser(), 201);
final ManagedQuery execution2 = (ManagedQuery) metaStorage.getExecution(reused2Id);
assertThat(reused2Id).as("Query should be reused.").isEqualTo(reused1Id);
// Now we change to ConceptQuery
final ConceptQuery reused3 = new ConceptQuery(new CQReusedQuery(execution2.getId()));
IntegrationUtils.assertQueryResult(conquery, reused3, 2L, ExecutionState.DONE, conquery.getTestUser(), 201);
}
{
final SecondaryIdQuery reusedDiffId = new SecondaryIdQuery();
reusedDiffId.setRoot(new CQReusedQuery(execution1.getId()));
// ignored is a single global value and therefore the same as by-PID
reusedDiffId.setSecondaryId(conquery.getNamespace().getStorage().getSecondaryId(new SecondaryIdDescriptionId(conquery.getDataset().getId(), "ignored")));
final ManagedExecutionId executionId = IntegrationUtils.assertQueryResult(conquery, reusedDiffId, 2L, ExecutionState.DONE, conquery.getTestUser(), 201);
assertThat(executionId).as("Query should NOT be reused.").isNotEqualTo(reused1Id);
}
{
// Reuse by another user (create a copy of the actual query)
final SecondaryIdQuery reused = new SecondaryIdQuery();
reused.setRoot(new CQReusedQuery(execution.getId()));
reused.setSecondaryId(query.getSecondaryId());
User shareHolder = new User("shareholder", "ShareHolder", conquery.getMetaStorage());
conquery.getMetaProcessor().addUser(shareHolder);
shareHolder.addPermissions(Set.of(dataset.createPermission(Set.of(Ability.READ)), execution.createPermission(Set.of(Ability.READ))));
ManagedExecutionId copyId = IntegrationUtils.assertQueryResult(conquery, reused, 4L, ExecutionState.DONE, shareHolder, 201);
ManagedExecution<?> copy = metaStorage.getExecution(copyId);
// Contentwise the label and tags should be the same
assertThat(copy).usingRecursiveComparison().comparingOnlyFields("label", "tags").isEqualTo(execution);
// However the Object holding the tags must be different, so the two are not linked here
assertThat(copy.getTags()).isNotSameAs(execution.getTags());
// And the ids must be different
assertThat(copy.getId()).isNotSameAs(execution.getId());
}
}
}
Aggregations