DbRequest (Vitam API Reference (1.0.0))

java.lang.Object
- fr.gouv.vitam.metadata.core.database.collections.DbRequest

```
public class DbRequest
extends Object
```
DB Request using MongoDB only

Constructor Summary

Constructors
Constructor and Description

DbRequest()
Constructor

Constructors
Constructor and Description
`DbRequest()` Constructor

Method Summary

All Methods Instance Methods Concrete Methods
Modifier and Type	Method and Description
`protected Set<String>`	`aggregateUnitDepths(Collection<String> ids, int relativeDepth)` Aggregate Unit Depths according to parent relative Depth
`protected Result<MetadataDocument<?>>`	`checkObjectGroupStartupRoots(RequestParserMultiple request, Result<MetadataDocument<?>> defaultStartSet)` Check ObjectGroup at startup against Roots
`protected Set<String>`	`checkUnitAgainstRoots(Set<String> current, Result<MetadataDocument<?>> defaultStartSet)` Check Unit parents against Roots
`protected Result<MetadataDocument<?>>`	`checkUnitStartupRoots(RequestParserMultiple request, Result<MetadataDocument<?>> defaultStartSet)` Check Unit at startup against Roots
`protected Result<MetadataDocument<?>>`	`exactDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, int exactDepth, Integer tenantId, List<org.elasticsearch.search.sort.SortBuilder> sorts, int offset, int limit, String scrollId, Integer scrollTimeout)` Execute one Unit Query using exact Depth
`Result`	`execRequest(RequestParserMultiple requestParser, Result<MetadataDocument<?>> defaultStartSet)` The request should be already analyzed.
`protected Result<MetadataDocument<?>>`	`executeQuery(RequestParserMultiple requestParser, RequestToAbstract requestToMongodb, int rank, Result<MetadataDocument<?>> previous)` Execute one request
`protected Result<MetadataDocument<?>>`	`lastDeleteFilterProjection(DeleteToMongodb requestToMongodb, Result<MetadataDocument<?>> last)` Finalize the queries with last True Delete
`protected Result<MetadataDocument<?>>`	`lastInsertFilterProjection(InsertToMongodb requestToMongodb, Result<MetadataDocument<?>> last, Integer tenantId)` Finalize the queries with last True Insert
`protected Result<MetadataDocument<?>>`	`lastSelectFilterProjection(SelectToMongodb requestToMongodb, Result<MetadataDocument<?>> last, boolean checkConsistency)` Finalize the queries with last True Select
`protected Result<MetadataDocument<?>>`	`lastUpdateFilterProjection(UpdateToMongodb requestToMongodb, Result<MetadataDocument<?>> last, RequestParserMultiple requestParser)` Finalize the queries with last True Update
`protected Result<MetadataDocument<?>>`	`objectGroupQuery(Query realQuery, Result<MetadataDocument<?>> previous, Integer tenantId, List<org.elasticsearch.search.sort.SortBuilder> sorts, int offset, int limit, String scrollId, Integer scrollTimeout)` Execute one relative Depth ObjectGroup Query
`protected Result<MetadataDocument<?>>`	`relativeDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, int relativeDepth, Integer tenantId, List<org.elasticsearch.search.sort.SortBuilder> sorts, int offset, int limit, String scrollId, Integer scrollTimeout)` Execute one relative Depth Unit Query
`protected Result<MetadataDocument<?>>`	`sameDepthUnitQuery(Query realQuery, Result<MetadataDocument<?>> previous, Integer tenantId, List<org.elasticsearch.search.sort.SortBuilder> sorts, int offset, int limit, String scrollId, Integer scrollTimeout)` Execute one relative Depth Unit Query

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail
- DbRequest
```
public DbRequest()
```
  Constructor

Method Detail

execRequest

public Result execRequest(RequestParserMultiple requestParser,
                          Result<MetadataDocument<?>> defaultStartSet)
                   throws InstantiationException,
                          IllegalAccessException,
                          MetaDataExecutionException,
                          InvalidParseOperationException,
                          BadRequestException,
                          MetaDataAlreadyExistException,
                          MetaDataNotFoundException,
                          VitamDBException

The request should be already analyzed.

Parameters:: requestParser - the RequestParserMultiple to execute; defaultStartSet - the set of id from which the request should start, whatever the roots set
Returns:: the Result
Throws:: InstantiationException; IllegalAccessException; MetaDataExecutionException - when select/insert/update/delete on metadata collection exception occurred; InvalidParseOperationException - when json data exception occurred; MetaDataAlreadyExistException - when insert metadata exception; MetaDataNotFoundException - when metadata not found exception; BadRequestException; VitamDBException

checkUnitStartupRoots

protected Result<MetadataDocument<?>> checkUnitStartupRoots(RequestParserMultiple request,
                                                            Result<MetadataDocument<?>> defaultStartSet)
                                                     throws InvalidParseOperationException

Check Unit at startup against Roots

Parameters:: request -; defaultStartSet -
Returns:: the valid root ids
Throws:: InvalidParseOperationException

checkObjectGroupStartupRoots

protected Result<MetadataDocument<?>> checkObjectGroupStartupRoots(RequestParserMultiple request,
                                                                   Result<MetadataDocument<?>> defaultStartSet)
                                                            throws InvalidParseOperationException

Check ObjectGroup at startup against Roots

Parameters:: request -; defaultStartSet -
Returns:: the valid root ids
Throws:: InvalidParseOperationException

checkUnitAgainstRoots

protected Set<String> checkUnitAgainstRoots(Set<String> current,
                                            Result<MetadataDocument<?>> defaultStartSet)
                                     throws InvalidParseOperationException

Check Unit parents against Roots

Parameters:: current - set of result id; defaultStartSet -
Returns:: the valid root ids set
Throws:: InvalidParseOperationException

executeQuery

protected Result<MetadataDocument<?>> executeQuery(RequestParserMultiple requestParser,
                                                   RequestToAbstract requestToMongodb,
                                                   int rank,
                                                   Result<MetadataDocument<?>> previous)
                                            throws MetaDataExecutionException,
                                                   InvalidParseOperationException,
                                                   BadRequestException

Execute one request

Parameters:: requestToMongodb -; rank - current rank query; previous - previous Result from previous level (except in level == 0 where it is the subset of valid roots)
Returns:: the new Result from this request
Throws:: MetaDataExecutionException; InvalidParseOperationException; BadRequestException

exactDepthUnitQuery

protected Result<MetadataDocument<?>> exactDepthUnitQuery(Query realQuery,
                                                          Result<MetadataDocument<?>> previous,
                                                          int exactDepth,
                                                          Integer tenantId,
                                                          List<org.elasticsearch.search.sort.SortBuilder> sorts,
                                                          int offset,
                                                          int limit,
                                                          String scrollId,
                                                          Integer scrollTimeout)
                                                   throws InvalidParseOperationException,
                                                          MetaDataExecutionException,
                                                          BadRequestException

Execute one Unit Query using exact Depth

Parameters:: realQuery -; previous -; exactDepth -; tenantId -; sorts -; offset -; limit -
Returns:: the associated Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; BadRequestException

relativeDepthUnitQuery

protected Result<MetadataDocument<?>> relativeDepthUnitQuery(Query realQuery,
                                                             Result<MetadataDocument<?>> previous,
                                                             int relativeDepth,
                                                             Integer tenantId,
                                                             List<org.elasticsearch.search.sort.SortBuilder> sorts,
                                                             int offset,
                                                             int limit,
                                                             String scrollId,
                                                             Integer scrollTimeout)
                                                      throws InvalidParseOperationException,
                                                             MetaDataExecutionException,
                                                             BadRequestException

Execute one relative Depth Unit Query

Parameters:: realQuery -; previous -; relativeDepth -; tenantId -; sorts -; offset -; limit -
Returns:: the associated Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; BadRequestException

aggregateUnitDepths
```
protected Set<String> aggregateUnitDepths(Collection<String> ids,
                                          int relativeDepth)
```
Aggregate Unit Depths according to parent relative Depth

Parameters:

ids -

relativeDepth -

Returns:

the aggregate set of multi level parents for this relativeDepth

sameDepthUnitQuery

protected Result<MetadataDocument<?>> sameDepthUnitQuery(Query realQuery,
                                                         Result<MetadataDocument<?>> previous,
                                                         Integer tenantId,
                                                         List<org.elasticsearch.search.sort.SortBuilder> sorts,
                                                         int offset,
                                                         int limit,
                                                         String scrollId,
                                                         Integer scrollTimeout)
                                                  throws InvalidParseOperationException,
                                                         MetaDataExecutionException,
                                                         BadRequestException

Execute one relative Depth Unit Query

Parameters:: realQuery -; previous -; tenantId -; sorts -; offset -; limit -
Returns:: the associated Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; BadRequestException

objectGroupQuery

protected Result<MetadataDocument<?>> objectGroupQuery(Query realQuery,
                                                       Result<MetadataDocument<?>> previous,
                                                       Integer tenantId,
                                                       List<org.elasticsearch.search.sort.SortBuilder> sorts,
                                                       int offset,
                                                       int limit,
                                                       String scrollId,
                                                       Integer scrollTimeout)
                                                throws InvalidParseOperationException,
                                                       MetaDataExecutionException,
                                                       BadRequestException

Execute one relative Depth ObjectGroup Query

Parameters:: realQuery -; previous - units, Note: only immediate Unit parents are allowed; tenantId -; sorts -; offset -; limit -
Returns:: the associated Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; BadRequestException

lastSelectFilterProjection

protected Result<MetadataDocument<?>> lastSelectFilterProjection(SelectToMongodb requestToMongodb,
                                                                 Result<MetadataDocument<?>> last,
                                                                 boolean checkConsistency)
                                                          throws InvalidParseOperationException,
                                                                 MetaDataExecutionException,
                                                                 VitamDBException

Finalize the queries with last True Select

Parameters:: requestToMongodb -; last -
Returns:: the final Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; VitamDBException

lastUpdateFilterProjection

protected Result<MetadataDocument<?>> lastUpdateFilterProjection(UpdateToMongodb requestToMongodb,
                                                                 Result<MetadataDocument<?>> last,
                                                                 RequestParserMultiple requestParser)
                                                          throws InvalidParseOperationException,
                                                                 MetaDataExecutionException,
                                                                 MetadataInvalidUpdateException

Finalize the queries with last True Update

Parameters:: requestToMongodb -; last -; requestParser -
Returns:: the final Result
Throws:: InvalidParseOperationException; MetaDataExecutionException; MetadataInvalidUpdateException

lastInsertFilterProjection

protected Result<MetadataDocument<?>> lastInsertFilterProjection(InsertToMongodb requestToMongodb,
                                                                 Result<MetadataDocument<?>> last,
                                                                 Integer tenantId)
                                                          throws InvalidParseOperationException,
                                                                 MetaDataAlreadyExistException,
                                                                 MetaDataExecutionException,
                                                                 MetaDataNotFoundException

Finalize the queries with last True Insert

Parameters:: requestToMongodb -; last -
Returns:: the final Result
Throws:: InvalidParseOperationException; MetaDataAlreadyExistException; MetaDataExecutionException; MetaDataNotFoundException

lastDeleteFilterProjection

protected Result<MetadataDocument<?>> lastDeleteFilterProjection(DeleteToMongodb requestToMongodb,
                                                                 Result<MetadataDocument<?>> last)
                                                          throws InvalidParseOperationException,
                                                                 MetaDataExecutionException

Finalize the queries with last True Delete

Parameters:: requestToMongodb -; last -
Returns:: the final Result
Throws:: InvalidParseOperationException; MetaDataExecutionException

Class DbRequest

Constructor Summary