requery
1.6.0
Um gerador de SQL e mapeamento de objetos leve, mas poderoso para Java/Kotlin/Android com suporte a RxJava e Java 8. Mapeie ou crie bancos de dados com facilidade, execute consultas e atualizações em qualquer plataforma que use Java.
Defina entidades de uma classe abstrata:
@ 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 de uma interface:
@ Entity
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
@ OneToMany
Set < Phone > getPhoneNumbers ();
String getEmail ();
}ou use tipos imutáveis, como aqueles gerados 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 ();
}(Observe que alguns recursos não estarão disponíveis ao usar tipos imutáveis, veja aqui)
Consultas: consulta baseada em DSL que mapeia para 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 ();Relacionamentos: represente relações de forma mais eficiente com Java 8 Streams, RxJava Observables ou iteráveis simples. (conjuntos e listas são suportados)
@ 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))
}Suporte específico para Kotlin usando referências de propriedades e funções infixas:
data {
val result = select( Person :: class ) where ( Person ::age gt 21 ) and ( Person ::name eq " Bob " ) limit 10
}Fluxos Java 8:
data . select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. stream (). forEach ( System . out :: println );Java 8 opcional e suporte de tempo:
public interface Person {
@ Key @ Generated
int getId ();
String getName ();
Optional < String > getEmail ();
ZonedDateTime getBirthday ();
}Observáveis RxJava:
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observable ();RxJava observa consulta sobre alterações na tabela:
Observable < Person > observable = data
. select ( Person . class )
. orderBy ( Person . AGE . desc ())
. get ()
. observableResult (). subscribe (:: updateFromResult );Separação de leitura/gravação Junto com tipos imutáveis, consultas opcionalmente separadas (leitura) e atualizações (escrita):
int rows = data . update ( Person . class )
. set ( Person . ABOUT , "student" )
. where ( Person . AGE . lt ( 21 )). get (). value ();requery usa processamento de anotação em tempo de compilação para gerar classes de modelo de entidade e atributos de mapeamento. No Android, isso significa que você obtém aproximadamente o mesmo desempenho ao ler objetos de uma consulta como se ela fosse preenchida usando a API padrão Cursor e ContentValues.
As classes compiladas funcionam com a API de consulta para aproveitar as vantagens dos atributos gerados em tempo de compilação. Crie consultas de tipo seguro e evite consultas concatenadas de strings difíceis de manter e propensas a erros.
Você pode definir relações Um-para-Um, Um-para-Muitos, Muitos-para-Um e Muitos-para-Muitos em seus modelos usando anotações. Os relacionamentos podem ser navegados em ambas as direções. De muitos tipos, relações podem ser carregadas em objetos de coleção Java padrão ou em um tipo Result mais eficiente. A partir de um resultado, crie facilmente um Stream, RxJava Observable, Iterator, List ou Map.
Tabelas de junção muitos para muitos podem ser geradas automaticamente. Além disso, o modelo de relação é validado em tempo de compilação, eliminando erros de execução.
requery fornece um conjunto moderno de interfaces para persistir e executar consultas. Algumas diferenças importantes entre os provedores de consulta e JPA, como Hibernate ou EclipseLink:
CriteriaQuery detalhada.Projetado especificamente com suporte para Android em mente. Consulte requery-Android/example para obter um exemplo de projeto Android usando ligação de dados e entidades baseadas em interface. Para mais informações consulte a página Android.
Testado em alguns dos bancos de dados mais populares:
Um subconjunto de anotações JPA mapeadas nas anotações de consulta repetida é suportado. Veja aqui para mais informações.
Upserts são gerados com as instruções de consulta específicas do banco de dados apropriadas:
merge into when matched/not matchedon conflict do update (requer 9.5 ou posterior)on duplicate key update As versões estão disponíveis no 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 obter informações sobre gradle e processamento de anotações e gradle, consulte o 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.
