requery
1.6.0
Un mappage d'objets léger mais puissant et un générateur SQL pour Java/Kotlin/Android avec prise en charge de RxJava et Java 8. Créez ou mappez facilement des bases de données, effectuez des requêtes et des mises à jour à partir de n'importe quelle plate-forme utilisant Java.
Définissez des entités à partir d'une classe abstraite :
@ 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
}ou depuis une interface :
@ Entity
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
@ OneToMany
Set < Phone > getPhoneNumbers ();
String getEmail ();
}ou utilisez des types immuables tels que ceux générés par @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 ();
}(Notez que certaines fonctionnalités ne seront pas disponibles lors de l'utilisation de types immuables, voir ici)
Requêtes : requête basée sur DSL qui correspond à 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 ();Relations : représentez les relations plus efficacement avec Java 8 Streams, RxJava Observables ou des itérables simples. (les ensembles et les listes sont pris en charge)
@ 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))
}Prise en charge spécifique de Kotlin à l'aide de références de propriétés et de fonctions infixes :
data {
val result = select( Person :: class ) where ( Person ::age gt 21 ) and ( Person ::name eq " Bob " ) limit 10
}Flux Java 8 :
data . select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. stream (). forEach ( System . out :: println );Prise en charge de Java 8 en option et temporelle :
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
Optional < String > getEmail ();
ZonedDateTime getBirthday ();
}Observables RxJava :
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observable ();RxJava observe la requête sur les modifications de table :
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observableResult (). subscribe (:: updateFromResult );Séparation en lecture/écriture Avec les types immuables, séparez éventuellement les requêtes (lecture) et les mises à jour (écriture) :
int rows = data . update ( Person . class )
. set ( Person . ABOUT , "student" )
. where ( Person . AGE . lt ( 21 )). get (). value ();requery utilise le traitement des annotations au moment de la compilation pour générer des classes de modèles d'entités et des attributs de mappage. Sur Android, cela signifie que vous obtenez à peu près les mêmes performances de lecture des objets à partir d'une requête que si elle était remplie à l'aide de l'API Cursor et ContentValues standard.
Les classes compilées fonctionnent avec l'API de requête pour tirer parti des attributs générés au moment de la compilation. Créez des requêtes de type sécurisé et évitez les requêtes concaténées de chaînes difficiles à gérer et sujettes aux erreurs.
Vous pouvez définir des relations un-à-un, un-à-plusieurs, plusieurs-à-un et plusieurs-à-plusieurs dans vos modèles à l'aide d'annotations. Les relations peuvent être parcourues dans les deux sens. De nombreux types de relations peuvent être chargés dans des objets de collection Java standard ou dans un type de résultat plus efficace. À partir d'un résultat, créez facilement un flux, un observable RxJava, un itérateur, une liste ou une carte.
Les tables de jonction plusieurs-à-plusieurs peuvent être générées automatiquement. De plus, le modèle de relation est validé au moment de la compilation, éliminant les erreurs d'exécution.
requery fournit un ensemble moderne d'interfaces pour les requêtes persistantes et exécutées. Quelques différences clés entre les fournisseurs de requêtes et les fournisseurs JPA comme Hibernate ou EclipseLink :
CriteriaQuery .Conçu spécifiquement pour le support Android. Voir requery-android/example pour un exemple de projet Android utilisant des entités basées sur la liaison de données et l'interface. Pour plus d'informations, consultez la page Android.
Testé sur certaines des bases de données les plus populaires :
Un sous-ensemble des annotations JPA mappées sur les annotations de requête sont pris en charge. Voir ici pour plus d'informations.
Les upserts sont générés avec les instructions de requête spécifiques à la base de données appropriées :
merge into when matched/not matchedon conflict do update (nécessite la version 9.5 ou ultérieure)on duplicate key update Les versions sont disponibles sur 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 '
}Pour plus d'informations sur le traitement des diplômes et des annotations, consultez le 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.
