jpa search helper
3.3.0
Biblioteca para crear y ejecutar consultas avanzadas y dinámicas utilizando JPA en Spring Boot.
Map<String, String> , para admitir puntos finales GET con parámetros de consulta.A través de jpa-search-helper su controlador* podrá recibir solicitudes 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 lo haces? ¡Lea este archivo Léame!
* Tenga en cuenta: la biblioteca no expone controladores/puntos finales HTTP, solo ofrece el repositorio que creará y ejecutará las consultas.
| Ayudante de búsqueda JPA | Bota de 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 - más reciente] | 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 Comience aplicando la anotación @Searchable a los campos de su modelo de dominio o, alternativamente, de su entidad JPA, que desea que estén disponibles para la búsqueda . Si tiene campos que desea que se puedan buscar dentro de otros objetos, anótelos con @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 ;
}
}La anotación le permite especificar:
Propiedades principales:
entityFieldKey : el nombre del campo definido en el bean de entidad (no se debe especificar si se utiliza la anotación en el bean de entidad). Si no se especifica, la clave será el nombre del campo.
targetType : el tipo de objeto gestionado por entidad. Si no se especifica, la biblioteca intenta obtenerlo según el tipo de campo (es decir, el campo entero sin definición de tipo de destino será INTEGER ). Si no hay ningún tipo compatible con los gestionados, se gestionará como una cadena. Tipos gestionados:
STRING , INTEGER , DOUBLE , FLOAT , LONG , BIGDECIMAL , BOOLEAN , DATE , LOCALDATE , LOCALDATETIME , LOCALTIME , OFFSETDATETIME , OFFSETTIME , ZONEDDATETIME .Propiedades de validación:
datePattern : solo para tipos de destino DATE , LOCALDATE , LOCALDATETIME , LOCALTIME , OFFSETDATETIME , OFFSETTIME , ZONEDDATETIME . Define el patrón de fecha a utilizar.maxSize, minSize : longitud máxima/mínima del valor.maxDigits, minDigits : solo para tipos numéricos. Número máximo/mínimo de dígitos.regexPattern : patrón de expresiones regulares.decimalFormat : solo para tipos numéricos decimales. Por defecto #.##Otro:
sortable : si es falso, el campo se puede utilizar para la búsqueda, pero no para ordenar. Valor predeterminado: verdadero.trim : aplicar recorte.tags : útil si el campo Modelo de dominio puede corresponder a múltiples campos de entidad (el ejemplo está disponible más abajo).allowedFilters : filtros permitidos exclusivamente.notAllowedFilters : filtros no permitidos.likeFilters : filtros similares permitidos ( contiene , comienza con , termina con ). Valor predeterminado: verdadero.Siguiendo con el ejemplo, nuestras clases de entidad:
@ 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 Su repositorio Spring JPA debe extender JPASearchRepository<YourEntityClass> .
@ Repository
public interface PersonRepository extends JpaRepository < PersonEntity , Long >, JPASearchRepository < PersonEntity > {
}En tu administrador, o en tu servicio, o donde quieras usar el repositorio:
Modo 1 : define un 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 : en lugar de un mapa, necesitarás usar JPASearchInput , que se muestra aquí, para simplificar, en 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
}
} A través del Modo 2 es posible gestionar filtros complejos con AND , OR y NOT (ver más adelante).
InvalidFieldException .InvalidValueException .JPASearchException | Nombre del filtro | Clave de biblioteca | Modos soportados |
|---|---|---|
| Y | y | 1, 2 |
| O | o | 2 |
| NO | no | 2 |
A través del Modo 1 , todos los filtros componen exclusivamente una búsqueda AND .
Para usar los otros operadores, OR y NOT , debes usar el Modo 2
| Nombre del filtro | Clave de biblioteca | SQL | Modos soportados | Valor requerido |
|---|---|---|---|---|
| igual | ecuación | sql_col = valor | 1,2 | Sí |
| Contiene | contiene | sql_col COMO '%val%' | 1,2 | Sí |
| En | en | sql_col EN (val1, val2, ..., valN) | 1,2 | Sí |
| comienza con | comienza con | sql_col COMO 'val%' | 1,2 | Sí |
| termina con | termina con | sql_col COMO '%val' | 1,2 | Sí |
| Más que | gt | sql_col > valor | 1,2 | Sí |
| Mayor o igual que | gte | col_sql >= valor | 1,2 | Sí |
| Menos que | es | sql_col <valor | 1,2 | Sí |
| Menor o igual | lte | sql_col <= valor | 1,2 | Sí |
| Entre | entre | sql_col ENTRE val1 Y val2 | 1,2 | Sí |
| Nulo | nulo | sql_col ES NULO | 1,2 | No |
| Vacío | vacío | sql_collection_col ES NULO | 1,2 | No |
Modo 1
| Descripción de la opción | Clave de biblioteca |
|---|---|
| ignorar caso | #i |
| Negación | #norte |
| Recortar | #t |
Las claves de opción deben agregarse al filtro; por ejemplo , ?firstName_eq#i=Biagio o ?firstName_eq#i#n=Biagio
Modo 2
| Descripción de la opción | Clave de biblioteca (atributos de Java) |
|---|---|
| ignorar caso | ignorar caso |
| Negación | negar |
| Recortar | recortar |
Para cada filtro es posible 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 ;
} | Nombre del filtro | Llave | Valores fijos |
|---|---|---|
| Límite (tamaño de página) | límite | |
| Desplazamiento (número de página) | compensar | |
| Clasificar | clasificar | ASC, DESC |
Modo 1 : por ejemplo , ?firstName_sort=DESC&_limit=10&_offset=0
Modo 2 : options valor raíz:
{
"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 ejemplo , ?myField_in=test1,test2 --> valores a buscar: [" test1 ", " test2 "]/, : por ejemplo , ?myField_in=test1,test2/,test3 --> valores a buscar: [" test1 ", " test2,test3 "] @Projectable Comience aplicando la anotación @Projectable a los campos de su modelo de dominio o, alternativamente, de su entidad JPA, que desea que estén disponibles para su selección . Si tiene campos que desea que sean seleccionables dentro de otros objetos, anótelos con @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 ;
}
}La anotación le permite especificar:
Propiedades principales:
entityFieldKey : el nombre del campo definido en el bean de entidad (no se debe especificar si se utiliza la anotación en el bean de entidad). Si no se especifica, la clave será el nombre del campo.JPASearchRepository Su repositorio Spring JPA debe extender JPAProjectionRepository<YourEntityClass> .
@ Repository
public interface PersonRepository extends JpaRepository < PersonEntity , Long >, JPASearchRepository < PersonEntity >, JPAProjectionRepository < PersonEntity > {
} En tu administrador, o en tu servicio, o donde quieras usar el repositorio:
Modo 1 : define (o añade al mapa utilizado para la búsqueda del Modo 1) un 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 : en lugar de un mapa, necesitarás usar JPASearchInput , que se muestra aquí, para simplificar, en 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 modos, la proyección devolverá un resultado List<Map<String, Object>> donde la estructura del mapa y las claves reflejarán la estructura de la entidad (para que quede claro toJson(entityList) == toJson(mapList) )
Nota 1:
Tenga cuidado: la proyección predeterminada fuerza que todas las relaciones de unión sean UNIÓN IZQUIERDA. Si no desea este comportamiento, elija utilizar los métodos del repositorio (métodos con el sufijo 'Clásico') que le permiten posiblemente modificar solo las relaciones que desea modificar.
Nota 2:
La proyección, independientemente de si lo deseas o no, siempre extraerá los campos que representan las claves primarias de una entidad (o entidades relacionadas)
Nota 3:
La paginación no es compatible
InvalidFieldException .JPASearchException Es posible forzar uniones con fetch para permitir que Hibernate (o su marco JPA) ejecute una única consulta para las relaciones definidas en la entidad. Esto sólo es posible sin paginación :
// ...
Map < String , JoinFetch > fetches = Map . of ( "companyEntity" , JoinFetch . LEFT );
personRepository . findAll ( filters , Person . class , fetches );
// ...Si se tiene un Modelo de Dominio que es resultado de la conversión de múltiples entidades, es posible especificar explícitamente un mapa (cadena, string) cuya clave represente el nombre del campo del Modelo de Dominio y el valor sea el nombre del campo de la entidad a buscar:
// ...
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 );
// ...Otro caso especial podría ser cuando un objeto se puede repetir dentro del modelo de dominio para representar múltiples partes de la entidad. La solución para la búsqueda:
@ 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 ' Tenga en cuenta: esta biblioteca no expone ningún punto final y, por lo tanto, ningún controlador. Un proyecto de ejemplo, exhaustivo y completo, está disponible aquí.
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 servicio/administrador:
@ 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 ) {
// ...
}
}Rizo:
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 'o
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 servicio/administrador:
@ 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 ) {
// ...
}
}Rizo:
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 'o
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 '
