requery
1.6.0
Un generador de SQL y mapeo de objetos ligero pero potente para Java/Kotlin/Android con soporte para RxJava y Java 8. Asigne o cree bases de datos fácilmente, realice consultas y actualizaciones desde cualquier plataforma que utilice Java.
Definir entidades de una clase abstracta:
@ Entity
abstract class AbstractPerson {
@ Key @ Generated
int id ;
@ Index ( "name_index" ) // table specification
String name ;
@ OneToMany // relationships 1:1, 1:many, many to many
Set < Phone > phoneNumbers ;
@ Converter ( EmailToStringConverter . class ) // custom type conversion
Email email ;
@ PostLoad // lifecycle callbacks
void afterLoad () {
updatePeopleList ();
}
// getter, setters, equals & hashCode automatically generated into Person.java
}o desde una interfaz:
@ Entity
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
@ OneToMany
Set < Phone > getPhoneNumbers ();
String getEmail ();
}o utilice tipos inmutables como los generados por @AutoValue:
@ AutoValue
@ Entity
abstract class Person {
@ AutoValue . Builder
static abstract class Builder {
abstract Builder setId ( int id );
abstract Builder setName ( String name );
abstract Builder setEmail ( String email );
abstract Person build ();
}
static Builder builder () {
return new AutoValue_Person . Builder ();
}
@ Key
abstract int getId ();
abstract String getName ();
abstract String getEmail ();
}(Tenga en cuenta que algunas funciones no estarán disponibles cuando se utilicen tipos inmutables; consulte aquí)
Consultas: consulta basada en dsl que se asigna a SQL
Result < Person > query = data
. select ( Person . class )
. where ( Person . NAME . lower (). like ( "b%" )). and ( Person . AGE . gt ( 20 ))
. orderBy ( Person . AGE . desc ())
. limit ( 5 )
. get ();Relaciones: represente relaciones de manera más eficiente con Java 8 Streams, RxJava Observables o iterables simples. (se admiten conjuntos y listas)
@ Entity
abstract class AbstractPerson {
@ Key @ Generated
int id ;
@ ManyToMany
Result < Group > groups ;
// equivalent to:
// data.select(Group.class)
// .join(Group_Person.class).on(Group_ID.equal(Group_Person.GROUP_ID))
// .join(Person.class).on(Group_Person.PERSON_ID.equal(Person.ID))
// .where(Person.ID.equal(id))
}Soporte específico de Kotlin mediante referencias de propiedades y funciones infijas:
data {
val result = select( Person :: class ) where ( Person ::age gt 21 ) and ( Person ::name eq " Bob " ) limit 10
}Corrientes de Java 8:
data . select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. stream (). forEach ( System . out :: println );Java 8 opcional y soporte de tiempo:
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
Optional < String > getEmail ();
ZonedDateTime getBirthday ();
}Observables de RxJava:
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observable ();RxJava observa la consulta sobre cambios en la tabla:
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observableResult (). subscribe (:: updateFromResult );Separación de lectura/escritura Junto con tipos inmutables, opcionalmente separe consultas (lectura) y actualizaciones (escritura):
int rows = data . update ( Person . class )
. set ( Person . ABOUT , "student" )
. where ( Person . AGE . lt ( 21 )). get (). value ();requery utiliza el procesamiento de anotaciones en tiempo de compilación para generar clases de modelo de entidad y atributos de mapeo. En Android, esto significa que obtiene aproximadamente el mismo rendimiento al leer objetos de una consulta que si se completara utilizando la API estándar Cursor y ContentValues.
Las clases compiladas funcionan con la API de consulta para aprovechar los atributos generados en tiempo de compilación. Cree consultas de tipo seguro y evite consultas concatenadas de cadenas propensas a errores y difíciles de mantener.
Puede definir relaciones uno a uno, uno a muchos, muchos a uno y muchos a muchos en sus modelos mediante anotaciones. Las relaciones se pueden navegar en ambas direcciones. Hay muchos tipos de relaciones que se pueden cargar en objetos de colección estándar de Java o en un tipo de resultado más eficiente. A partir de un resultado, cree fácilmente una secuencia, un observable RxJava, un iterador, una lista o un mapa.
Las tablas de unión de muchos a muchos se pueden generar automáticamente. Además, el modelo de relación se valida en tiempo de compilación, eliminando errores de tiempo de ejecución.
requery proporciona un conjunto moderno de interfaces para persistir y realizar consultas. Algunas diferencias clave entre los proveedores de consultas y JPA como Hibernate o EclipseLink:
CriteriaQuery .Diseñado específicamente teniendo en cuenta la compatibilidad con Android. Consulte requery-android/example para ver un ejemplo de proyecto de Android que utiliza entidades basadas en interfaz y enlace de datos. Para obtener más información, consulte la página de Android.
Probado en algunas de las bases de datos más populares:
Se admite un subconjunto de anotaciones JPA que se asignan a las anotaciones de consulta. Consulte aquí para obtener más información.
Las actualizaciones se generan con las declaraciones de consulta específicas de la base de datos apropiadas:
merge into when matched/not matchedon conflict do update (requiere 9.5 o posterior)on duplicate key update Las versiones están disponibles en bintray jcenter/maven central.
repositories {
jcenter()
}
dependencies {
compile ' io.requery:requery:1.6.1 '
compile ' io.requery:requery-android:1.6.1 ' // for android
annotationProcessor ' io.requery:requery-processor:1.6.1 '
}Para obtener información sobre Gradle y el procesamiento de anotaciones y Gradle, consulte la wiki.
Copyright (C) 2019 requery.io
Licensed under the Apache License, Version 2.0 (the "License");
you may not use this file except in compliance with the License.
You may obtain a copy of the License at
http://www.apache.org/licenses/LICENSE-2.0
Unless required by applicable law or agreed to in writing, software
distributed under the License is distributed on an "AS IS" BASIS,
WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
See the License for the specific language governing permissions and
limitations under the License.
