jpa search helper
3.3.0
Biblioteca para construir e executar consultas avançadas e dinâmicas usando JPA no Spring Boot.
Map<String, String> , para oferecer suporte a endpoints GET com parâmetros de consulta.Através do jpa-search-helper seu controller* poderá receber requisições como esta:
Modo 1 :
curl -X GET
' https://myexampledomain.com/persons?
firstName=Biagio
&lastName_startsWith=Toz
&birthDate_gte=19910101
&country_in=IT,FR,DE
&address_eq=Via Roma 1,Via Milano/,1,20 West/,34th Street
&company.name_in=Microsoft,Apple,Google
&company.employees_between=500,5000 'Modo 2 :
curl -X POST -H " Content-type: application/json " -d ' {
"filter" : {
"operator": "and", // the first filter must contain a root operator: AND, OR or NOT
"filters" : [
{
"operator": "eq",
"key": "firstName",
"value": "Biagio"
},
{
"operator": "or",
"filters": [
{
"operator": "startsWith",
"key": "lastName",
"value": "Toz",
"options": {
"ignoreCase": true
}
},
{
"operator": "endsWith",
"key": "lastName",
"value": "ZZI",
"options": {
"ignoreCase": true,
"trim" : true
}
}
]
},
{
"operator": "in",
"key": "company.name",
"values": ["Microsoft", "Apple", "Google"]
},
{
"operator": "or",
"filters": [
{
"operator": "gte",
"key": "birthDate",
"value": "19910101"
},
{
"operator": "lte",
"key": "birthDate",
"value": "20010101"
}
]
},
{
"operator": "between",
"key" : "company.employees",
"values": [500, 5000],
"options": {
"negate": true
}
}
]
},
"options": {
"pageSize": 10,
"pageOffset": 0,
"sortKey": "birthDate",
"sortDesc": false
}
} ' ' https://myexampledomain.com/persons '..como você faz isso? Leia este leia-me!
* Atenção: a biblioteca não expõe controladores/Endpoints HTTP, mas apenas oferece o repositório que irá construir e executar as consultas.
| Auxiliar de pesquisa JPA | Bota Primavera | Java |
|---|---|---|
| [v0.0.1 - v2.1.1] | 3.2.x | [17 - 23] |
| [v3.0.0 - v3.2.2] | 3.3.x | [17 - 23] |
| [v3.3.0 - mais recente] | 3.4.x | [17 - 23] |
<dependency>
<groupId>app.tozzi</groupId>
<artifactId>jpa-search-helper</artifactId>
<version>3.3.0</version>
</dependency>
implementation 'app.tozzi:jpa-search-helper:3.3.0
@Searchable Comece aplicando a anotação @Searchable aos campos do seu Modelo de Domínio ou, alternativamente, da sua entidade JPA, que você deseja disponibilizar para pesquisa . Se você tiver campos que deseja tornar pesquisáveis em outros objetos, anote-os com @NestedSearchable .
@ Data
public class Person {
@ Searchable
private String firstName ;
@ Searchable
private String lastName ;
@ Searchable ( entityFieldKey = "dateOfBirth" )
private Date birthDate ;
@ Searchable
private String country ;
@ Searchable
private String fillerOne ;
@ Searchable
private String fillerTwo ;
@ NestedSearchable
private Company company ;
@ Data
public static class Company {
@ Searchable ( entityFieldKey = "companyEntity.name" )
private String name ;
@ Searchable ( entityFieldKey = "companyEntity.employeesCount" )
private int employees ;
}
}A anotação permite que você especifique:
Propriedades principais:
entityFieldKey : o nome do campo definido no bean de entidade (não deve ser especificado se estiver usando a anotação no bean de entidade). Se não for especificada, a chave será o nome do campo.
targetType : o tipo de objeto gerenciado por entidade. Se não for especificado, a biblioteca tenta obtê-lo com base no tipo de campo (por exemplo, o campo inteiro sem definição de tipo de destino será INTEGER ). Se não houver nenhum tipo compatível com os gerenciados, será gerenciado como uma string. Tipos gerenciados:
STRING , INTEGER , DOUBLE , FLOAT , LONG , BIGDECIMAL , BOOLEAN , DATE , LOCALDATE , LOCALDATETIME , LOCALTIME , OFFSETDATETIME , OFFSETTIME , ZONEDDATETIME .Propriedades de validação:
datePattern : apenas para tipos de destino DATE , LOCALDATE , LOCALDATETIME , LOCALTIME , OFFSETDATETIME , OFFSETTIME , ZONEDDATETIME . Define o padrão de data a ser usado.maxSize, minSize : comprimento máximo/mínimo do valor.maxDigits, minDigits : apenas para tipos numéricos. Número máximo/mínimo de dígitos.regexPattern : padrão regex.decimalFormat : apenas para tipos numéricos decimais. Padrão #.##Outro:
sortable : se for falso, o campo pode ser usado para pesquisa, mas não pode ser usado para classificação. Padrão: verdadeiro.trim : aplicar aparar.tags : úteis se o campo Modelo de Domínio puder corresponder a vários campos de entidade (o exemplo está disponível mais abaixo).allowedFilters : filtros permitidos exclusivamente.notAllowedFilters : filtros não permitidos.likeFilters : permitidos filtros like ( contém , startWith , endsWith ). Padrão: verdadeiro.Continuando o exemplo, nossas classes de entidade:
@ Entity
@ Data
public class PersonEntity {
@ Id
private Long id ;
@ Column ( name = "FIRST_NAME" )
private String firstName ;
@ Column ( name = "LAST_NAME" )
private String lastName ;
@ Column ( name = "BIRTH_DATE" )
private Date dateOfBirth ;
@ Column ( name = "COUNTRY" )
private String country ;
@ Column ( name = "FIL_ONE" )
private String fillerOne ;
@ Column ( name = "FIL_TWO" )
private String fillerTwo ;
@ OneToOne
private CompanyEntity companyEntity ;
}
@ Entity
@ Data
public class CompanyEntity {
@ Id
private Long id ;
@ Column ( name = "NAME" )
private String name ;
@ Column ( name = "COUNT" )
private Integer employeesCount ;
}JPASearchRepository Seu repositório Spring JPA deve estender JPASearchRepository<YourEntityClass> .
@ Repository
public interface PersonRepository extends JpaRepository < PersonEntity , Long >, JPASearchRepository < PersonEntity > {
}No seu gerenciador, ou no seu serviço, ou onde você quiser usar o repositório:
Modo 1 : defina um mapa <filter_key#options, value> :
// ...
@ Autowired
private PersonRepository personRepository ;
public List < Person > advancedSearch () {
// Pure example, in real use case it is expected that these filters can be passed directly by the controller
Map < String , String > filters = new HashMap <>();
filters . put ( "firstName_eq" , "Biagio" );
filters . put ( "lastName_startsWith#i" , "Toz" ); // ignore case
filters . put ( "birthDate_gte" , "19910101" );
filters . put ( "country_in" , "IT,FR,DE" );
filters . put ( "company.name_eq#n" , "Bad Company" ); // negation
filters . put ( "company.employees_between" , "500,5000" );
filters . put ( "fillerOne_null#n" , "true" ); // not null
filters . put ( "fillerTwo_empty" , "true" ); // empty
// Without pagination
List < PersonEntity > fullSearch = personRepository . findAll ( filters , Person . class );
filters . put ( "birthDate_sort" : "ASC" ); // sorting key and sorting order
filters . put ( "_limit" , "10" ); // page size
filters . put ( "_offset" , "0" ); // page offset
// With pagination
Page < PersonEntity > sortedAndPaginatedSearch = personRepository . findAllWithPaginationAndSorting ( filters , Person . class );
// ...
}
// ... Modo 2 : em vez de um mapa, você precisará usar JPASearchInput , mostrado aqui, para simplificar, no formato JSON.
{
"filter" : {
"operator" : " and " , // the first filter must contain a root operator: AND, OR or NOT
"filters" : [
{
"operator" : " eq " ,
"key" : " firstName " ,
"value" : " Biagio "
},
{
"operator" : " or " ,
"filters" : [
{
"operator" : " startsWith " ,
"key" : " lastName " ,
"value" : " Toz " ,
"options" : {
"ignoreCase" : true
}
},
{
"operator" : " endsWith " ,
"key" : " lastName " ,
"value" : " ZZI " ,
"options" : {
"ignoreCase" : true ,
"trim" : true
}
}
]
},
{
"operator" : " in " ,
"key" : " company.name " ,
"values" : [ " Microsoft " , " Apple " , " Google " ]
},
{
"operator" : " or " ,
"filters" : [
{
"operator" : " gte " ,
"key" : " birthDate " ,
"value" : " 19910101 "
},
{
"operator" : " lte " ,
"key" : " birthDate " ,
"value" : " 20010101 "
}
]
},
{
"operator" : " empty " ,
"key" : " fillerOne " ,
"options" : {
"negate" : true
}
},
{
"operator" : " between " ,
"key" : " company.employees " ,
"values" : [ 500 , 5000 ],
"options" : {
"negate" : true
}
}
]
},
"options" : {
"pageSize" : 10 ,
"pageOffset" : 0 ,
"sortKey" : " birthDate " ,
"sortDesc" : false
}
} Através do Modo 2 é possível gerenciar filtros complexos com AND , OR e NOT (veja mais adiante).
InvalidFieldException .InvalidValueException .JPASearchException | Nome do filtro | Chave da Biblioteca | Modos suportados |
|---|---|---|
| E | e | 1, 2 |
| OU | ou | 2 |
| NÃO | não | 2 |
Através do Modo 1 , todos os filtros compõem exclusivamente uma busca AND .
Para usar os outros operadores, OR e NOT , você deve usar o Modo 2
| Nome do filtro | Chave da Biblioteca | SQL | Modos suportados | Valor necessário |
|---|---|---|---|---|
| Igual | equação | sql_col=val | 1,2 | sim |
| Contém | contém | sql_col LIKE '%val%' | 1,2 | sim |
| Em | em | sql_col IN (val1, val2, ..., valN) | 1,2 | sim |
| Começa com | começaCom | sql_col LIKE 'val%' | 1,2 | sim |
| Termina com | terminaCom | sql_col LIKE '%val' | 1,2 | sim |
| Maior que | gt | sql_col > val | 1,2 | sim |
| Maior que ou igual | gte | sql_col >= val | 1,2 | sim |
| Menor que | isso | sql_col < val | 1,2 | sim |
| Menor ou igual | lte | sql_col <= val | 1,2 | sim |
| Entre | entre | sql_col ENTRE val1 E val2 | 1,2 | sim |
| Nulo | nulo | sql_col É NULO | 1,2 | não |
| Vazio | vazio | sql_collection_col É NULO | 1,2 | não |
Modo 1
| Descrição da opção | Chave da Biblioteca |
|---|---|
| Ignorar caso | #eu |
| Negação | #n |
| Aparar | #t |
As chaves de opção devem ser anexadas ao filtro; por exemplo , ?firstName_eq#i=Biagio ou ?firstName_eq#i#n=Biagio
Modo 2
| Descrição da opção | Chave da biblioteca (atributos Java) |
|---|---|
| Ignorar caso | ignorarCaso |
| Negação | negar |
| Aparar | aparar |
Para cada filtro é possível definir options
{
// ...
{
"operator" : " eq " ,
"key" : " firstName " ,
"value" : " Biagio " ,
"options" : {
"ignoreCase" : true ,
"trim" : false ,
"negate" : true
}
}
// ...
}Objeto Java:
@ Data
public static class JPASearchFilterOptions {
private boolean ignoreCase ;
private boolean trim ;
private boolean negate ;
} | Nome do filtro | Chave | Valores fixos |
|---|---|---|
| Limite (tamanho da página) | limite | |
| Deslocamento (número da página) | desvio | |
| Organizar | organizar | ASC, DESC |
Modo 1 : por exemplo , ?firstName_sort=DESC&_limit=10&_offset=0
Modo 2 : options de raiz de valor:
{
"filter" : {
// ...
},
"options" : {
"sortKey" : " firstName " ,
"sortDesc" : true ,
"pageSize" : 10 ,
"pageOffset" : 1
}
}Objeto Java:
@ Data
public static class JPASearchOptions {
private String sortKey ;
private Boolean sortDesc = false ;
private Integer pageSize ;
private Integer pageOffset ;
private List < String > selections ;
}, : por exemplo ?myField_in=test1,test2 --> valores a serem pesquisados: [" test1 ", " test2 "]/, por exemplo , ?myField_in=test1,test2/,test3 --> valores a serem pesquisados: [" test1 ", " test2,test3 "] @Projectable Comece aplicando a anotação @Projectable aos campos do seu Modelo de Domínio ou, alternativamente, da sua entidade JPA, que você deseja disponibilizar para seleção . Se você tiver campos que deseja tornar selecionáveis em outros objetos, anote-os com @NestedProjectable .
@ Data
public class Person {
@ Searchable
private String firstName ;
@ Projectable
@ Searchable
private String lastName ;
@ Projectable ( entityFieldKey = "dateOfBirth" )
@ Searchable ( entityFieldKey = "dateOfBirth" )
private Date birthDate ;
@ Searchable
private String country ;
@ Searchable
private String fillerOne ;
@ Searchable
private String fillerTwo ;
@ NestedProjectable
@ NestedSearchable
private Company company ;
@ Data
public static class Company {
@ Searchable ( entityFieldKey = "companyEntity.name" )
private String name ;
@ Projectable ( entityFieldKey = "companyEntity.employeesCount" )
@ Searchable ( entityFieldKey = "companyEntity.employeesCount" )
private int employees ;
}
}A anotação permite que você especifique:
Propriedades principais:
entityFieldKey : o nome do campo definido no bean de entidade (não deve ser especificado se estiver usando a anotação no bean de entidade). Se não for especificada, a chave será o nome do campo.JPASearchRepository Seu repositório Spring JPA deve estender JPAProjectionRepository<YourEntityClass> .
@ Repository
public interface PersonRepository extends JpaRepository < PersonEntity , Long >, JPASearchRepository < PersonEntity >, JPAProjectionRepository < PersonEntity > {
} No seu gerenciador, ou no seu serviço, ou onde você quiser usar o repositório:
Modo 1 : definir (ou adicionar ao mapa usado para a pesquisa no Modo 1) um mapa:
, // ...
@ Autowired
private PersonRepository personRepository ;
public List < Person > advancedSearch () {
// Pure example, in real use case it is expected that these filters can be passed directly by the controller
Map < String , String > filters = new HashMap <>();
filters . put ( "firstName_eq" , "Biagio" );
filters . put ( "lastName_startsWith#i" , "Toz" ); // ignore case
filters . put ( "birthDate_gte" , "19910101" );
filters . put ( "country_in" , "IT,FR,DE" );
filters . put ( "company.name_eq#n" , "Bad Company" ); // negation
filters . put ( "company.employees_between" , "500,5000" );
filters . put ( "fillerOne_null#n" , "true" ); // not null
filters . put ( "fillerTwo_empty" , "true" ); // empty
// Selections
filters . put ( "selections" , "lastName,birthDate,company.employees" );
// Without sorting
List < Map < String , Object >> result = personRepository . projection ( filters , Person . class , PersonEntity . class );
filters . put ( "birthDate_sort" : "ASC" ); // sorting key and sorting order
// With sorting
List < Map < String , Object >> sortedAndPaginatedSearch = personRepository . projectionWithSorting ( filters , Person . class , PersonEntity . class );
// ... convert the list of maps into your model
}
// ... Modo 2 : em vez de um mapa, você precisará usar JPASearchInput , mostrado aqui, para simplificar, no formato JSON.
{
"filter" : {
"operator" : " and " , // the first filter must contain a root operator: AND, OR or NOT
"filters" : [
{
"operator" : " eq " ,
"key" : " firstName " ,
"value" : " Biagio "
},
{
"operator" : " or " ,
"filters" : [
{
"operator" : " startsWith " ,
"key" : " lastName " ,
"value" : " Toz " ,
"options" : {
"ignoreCase" : true
}
},
{
"operator" : " endsWith " ,
"key" : " lastName " ,
"value" : " ZZI " ,
"options" : {
"ignoreCase" : true ,
"trim" : true
}
}
]
},
{
"operator" : " in " ,
"key" : " company.name " ,
"values" : [ " Microsoft " , " Apple " , " Google " ]
},
{
"operator" : " or " ,
"filters" : [
{
"operator" : " gte " ,
"key" : " birthDate " ,
"value" : " 19910101 "
},
{
"operator" : " lte " ,
"key" : " birthDate " ,
"value" : " 20010101 "
}
]
},
{
"operator" : " empty " ,
"key" : " fillerOne " ,
"options" : {
"negate" : true
}
},
{
"operator" : " between " ,
"key" : " company.employees " ,
"values" : [ 500 , 5000 ],
"options" : {
"negate" : true
}
}
]
},
"options" : {
"pageSize" : 10 ,
"pageOffset" : 0 ,
"sortKey" : " birthDate " ,
"sortDesc" : false ,
"selections" : [
" lastName " ,
" birthDate " ,
" company.employees "
]
}
}Para ambos os modos, a projeção retornará um resultado List<Map<String, Object>> onde a estrutura do mapa e as chaves refletirão a estrutura da entidade (para ficar claro toJson(entityList) == toJson(mapList) )
Nota 1:
Tenha cuidado: a projeção padrão força todos os relacionamentos Join como LEFT JOIN. Se você não deseja esse comportamento, opte por usar os métodos de repositório (métodos com sufixo 'Clássico') que permitem possivelmente modificar apenas as relações que você deseja modificar
Nota 2:
A projeção, querendo ou não, sempre extrairá os campos que representam as chaves primárias de uma entidade (ou entidades relacionadas)
Nota 3:
A paginação não é suportada
InvalidFieldException .JPASearchException É possível forçar junções com fetch para permitir que o Hibernate (ou seu framework JPA) execute uma única consulta para os relacionamentos definidos na entidade. Isso só é possível sem paginação :
// ...
Map < String , JoinFetch > fetches = Map . of ( "companyEntity" , JoinFetch . LEFT );
personRepository . findAll ( filters , Person . class , fetches );
// ...Se você possui um Modelo de Domínio que é resultado da conversão de múltiplas entidades, é possível especificar explicitamente um mapa (string, string) cuja chave representa o nome do campo Modelo de Domínio e o valor é o nome do campo de a entidade a ser pesquisada:
// ...
Map < String , String > entityFieldMap = Map . of ( "company" , "companyEntity.name" );
// Without pagination
personRepository . findAll ( filters , Person . class , fetches , entityFieldMap );
// With pagination
personRepository . findAllWithPaginationAndSorting ( filters , Person . class , entityFieldMap );
// ...Outro caso especial poderia ser quando um objeto pode ser repetido dentro do Modelo de Domínio para representar múltiplas partes da entidade. A solução para a pesquisa:
@ Entity
public class CoupleEntity {
@ Id
private Long id ;
@ Column ( name = "p1_fn" )
private String p1FirstName ;
@ Column ( name = "p1_ln" )
private String p1LastName ;
@ Column ( name = "p2_fn" )
private String p2FirstName ;
@ Column ( name = "p2_ln" )
private String p2LastName ;
}
@ Data
public class Couple {
@ NestedSearchable
private Person p1 ;
@ NestedSearchable
private Person p2 ;
@ Data
public static class Person {
@ Searchable ( tags = {
@ Tag ( fieldKey = "p1.firstName" , entityFieldKey = "p1FirstName" ),
@ Tag ( fieldKey = "p2.firstName" , entityFieldKey = "p2FirstName" ),
})
private String firstName ;
@ Searchable ( tags = {
@ Tag ( fieldKey = "p1.lastName" , entityFieldKey = "p1LastName" ),
@ Tag ( fieldKey = "p2.lastName" , entityFieldKey = "p2LastName" ),
})
private String lastName ;
}
}curl - request GET
- url ' https://www.myexampledomain.com/couples?
p1.firstName_iEq=Romeo
&p2.firstName_iEq=Giulietta ' Observação: esta biblioteca não expõe nenhum endpoint e, portanto, nenhum controlador. Um exemplo de projeto, exaustivo e completo, está disponível aqui.
Controlador:
@ RestController
@ RequestMapping ( "/persons" )
public class PersonController {
@ Autowired
private PersonManager personManager ;
@ GetMapping ( produces = MediaType . APPLICATION_JSON_VALUE )
public List < Person > findPersons ( @ RequestParam Map < String , String > requestParams ) {
return personManager . find ( requestParams );
}
@ GetMapping ( path = "/projection" , produces = MediaType . APPLICATION_JSON_VALUE )
public List < Person > projection ( @ RequestParam Map < String , String > requestParams ) {
return personManager . projection ( requestParams );
}
}Bean de serviço/gerente:
@ Service
public class PersonManager {
@ Autowired
private PersonRepository personRepository ;
public List < Person > find ( Map < String , String > filters ) {
return personRepository . findAllWithPaginationAndSorting ( filters , Person . class ). stream (). map ( this :: toModel ). toList ();
}
public List < Person > projection ( Map < String , String > filters ) {
return personRepository . projection ( filters , Person . class , PersonEntity . class ). stream (). map ( this :: toModel ). toList ();
}
private static Person toModel ( PersonEntity personEntity ) {
// ...
}
private static Person toModel ( Map < String , Object > entityMap ) {
// ...
}
}Enrolar:
curl - X GET
' http://localhost:8080/persons?
firstName=Biagio
&lastName_startsWith=Toz
&birthDate_gte=19910101
&country_in=IT,FR,DE
&company.name_in=Microsoft,Apple
&company.employees_between=500,5000 'ou
curl - X GET
' http://localhost:8080/persons/projection?
firstName=Biagio
&lastName_startsWith=Toz
&birthDate_gte=19910101
&country_in=IT,FR,DE
&company.name_in=Microsoft,Apple
&company.employees_between=500,5000
&selections=firstName,birthDate ' Controlador:
@ RestController
@ RequestMapping ( "/persons" )
@ Validated
public class PersonController {
@ Autowired
private PersonManager personManager ;
@ PostMapping ( produces = MediaType . APPLICATION_JSON_VALUE , consumes = MediaType . APPLICATION_JSON_VALUE )
public List < Person > findPersons ( @ Valid @ RequestBody JPASearchInput input ) {
return personManager . find ( input );
}
}
@ PostMapping ( path = "/projection" , produces = MediaType . APPLICATION_JSON_VALUE , consumes = MediaType . APPLICATION_JSON_VALUE )
public List < Person > projection ( @ Valid @ RequestBody JPASearchInput input ) {
return personManager . projection ( input );
}
}Bean de serviço/gerente:
@ Service
public class PersonManager {
@ Autowired
private PersonRepository personRepository ;
public List < Person > find ( JPASearchInput input ) {
return personRepository . findAllWithPaginationAndSorting ( input , Person . class ). stream (). map ( this :: toModel ). toList ();
}
public List < Person > find ( JPASearchInput input ) {
return personRepository . projection ( input , Person . class , PersonEntity . class ). stream (). map ( this :: toModel ). toList ();
}
private static Person toModel ( PersonEntity entity ) {
// ...
}
private static Person toModel ( Map < String , Object > entityMap ) {
// ...
}
}Enrolar:
curl -X POST -H " Content-type: application/json " -d ' {
"filter" : {
"operator": "and", // the first filter must contain a root operator: AND, OR or NOT
"filters" : [
{
"operator": "eq",
"key": "firstName",
"value": "Biagio"
},
{
"operator": "or",
"filters": [
{
"operator": "startsWith",
"key": "lastName",
"value": "Toz",
"options": {
"ignoreCase": true
}
},
{
"operator": "endsWith",
"key": "lastName",
"value": "ZZI",
"options": {
"ignoreCase": true,
"trim" : true
}
}
]
},
{
"operator": "in",
"key": "company.name",
"values": ["Microsoft", "Apple", "Google"]
},
{
"operator": "or",
"filters": [
{
"operator": "gte",
"key": "birthDate",
"value": "19910101"
},
{
"operator": "lte",
"key": "birthDate",
"value": "20010101"
}
]
},
{
"operator": "between",
"key" : "company.employees",
"values": [500, 5000],
"options": {
"negate": true
}
}
]
},
"options": {
"pageSize": 10,
"pageOffset": 0,
"sortKey": "birthDate",
"sortDesc": false
}
} ' ' http://localhost:8080/persons 'ou
curl -X POST -H " Content-type: application/json " -d ' {
"filter" : {
"operator": "and", // the first filter must contain a root operator: AND, OR or NOT
"filters" : [
{
"operator": "eq",
"key": "firstName",
"value": "Biagio"
},
{
"operator": "or",
"filters": [
{
"operator": "startsWith",
"key": "lastName",
"value": "Toz",
"options": {
"ignoreCase": true
}
},
{
"operator": "endsWith",
"key": "lastName",
"value": "ZZI",
"options": {
"ignoreCase": true,
"trim" : true
}
}
]
},
{
"operator": "in",
"key": "company.name",
"values": ["Microsoft", "Apple", "Google"]
},
{
"operator": "or",
"filters": [
{
"operator": "gte",
"key": "birthDate",
"value": "19910101"
},
{
"operator": "lte",
"key": "birthDate",
"value": "20010101"
}
]
},
{
"operator": "between",
"key" : "company.employees",
"values": [500, 5000],
"options": {
"negate": true
}
}
]
},
"options": {
"sortKey": "birthDate",
"sortDesc": false,
"selections" : [
"birthDate",
"firstName",
"lastName"
]
}
} ' ' http://localhost:8080/persons/projection '
