Exposed
0.56.0
Exposto é uma biblioteca SQL leve em cima de um driver JDBC para o idioma Kotlin. Exposed possui dois sabores de acesso ao banco de dados: TypeAfe SQL WAPPURT DSL e Lightweight Data Access Objects (DAO).
Com o exposto, você tem duas opções para acesso ao banco de dados: embrulhar DSL e um DAO leve. Nosso mascote oficial é o choco, o que é conhecido por sua excelente capacidade de imitação que permite que ele se misture perfeitamente a qualquer ambiente. Semelhante ao nosso mascote, exposto pode ser usado para imitar uma variedade de mecanismos de banco de dados, o que ajuda a criar aplicativos sem dependências em qualquer mecanismo de banco de dados específico e alternar entre eles com muito poucas ou nenhuma alteração.
H2 (versões 2.x; 1.x A versão é descontinuada e será removida em versões futuras)
(Além disso, PostgreSQL usando o driver PGJDBC-NG JDBC)
Os lançamentos de expostos estão disponíveis no repositório central do MAVEN. Você pode declarar este repositório em seu script de construção da seguinte forma:
Aviso: pode ser necessário definir seu alvo Kotlin JVM como 8 e, ao usar a primavera para 17, para que isso funcione corretamente:
Repositórios {// versões após 0,30.1 // versões antes de 0,30.1 não está disponível para NowMavencentral ()
}O repositório central do MAVEN é ativado por padrão para usuários do Maven.
Exposed consiste nos seguintes módulos:
Módulo de base exposto - que contém a API DSL junto com o mapeamento
Exposto-Crypt-fornece tipos adicionais de coluna para armazenar dados criptografados em db e codificar/decodificá-los no lado do cliente
API exposta -dao - dao
Expostos-Java-Time-Extensões de data-hora com base na API de tempo Java8
Exposto -JDBC - Implementação do nível de transporte com base na API Java JDBC
Exposto de Jodatime-Extensões de data-hora baseadas na biblioteca Jodatime
Expostos -Json - Extensões de tipo de dados JSON e JSONB
Exposto-Kotlin-DateTime-Extensões de data-hora baseadas em Kotlinx-DateTime
dinheiro exposto-extensões para apoiar o MonetaryAmount de "javax.money:money-api"
Starter exposto-spring-boot-um acionador de partida para utilizar a exposição como o ORM em vez de hibernar
<pendências>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<stifactId> exposto-core </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<stifactId> exposto-crrypt </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarfactId> exposto-dao </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarfactId> exposto-Java-Time </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarfactId> exposto-jdbc </sutifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarfactId> exposto-Jodatime </sutifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<stifactId> exposto-json </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarifactId> exposto-kotlin-DateTime </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<stifactId> dinheiro exposto </stifactId>
<versão> 0.56.0 </versão>
</dependency>
<pendência>
<GrupidId> org.Jetbrains.exposed </frugiD>
<TarifactId> Exposto-Spring-Boot-Starter </stifactId>
<versão> 0.56.0 </versão>
</dependency>
</dependências> dependências {
implementação 'org.Jetbrains.exposed:Exposed-core:0.56.0'implementation' org.Jetbrains.exposed:Exposed-Crypt:0.56.0'implementation 'org.Jetbrains.exposed:Exposed-dao:0.56.0'Mplementation 'Org.Jetbrains.Exposed:Exposed-jdbc:0.56.0'
implementação 'org.Jetbrains.exposed:Exposed-Jodatime:0.56.0'// orimplementation' org.jetbrains.exposed:exposed-java-the-the DateTime: 0,56,0 '
implementação 'org.Jetbrains.exposed:Exposed-json:0.56.0'implementation' org.jetbrains.exposed:exposed-money:0.56.0'implementation 'org.jetbrains.exposed:exposed-spring-boot-starter:0.56. 0 '} Em build.gradle.kts :
Val ExposedVersion: String by Project
dependências {
implementação ("org.Jetbrains.exposed:Exposed-core:$ExposedVersion")
implementação ("org.Jetbrains.exposed:Exposed-Crypt:$ExposedVersion")
implementação ("org.Jetbrains.exposed:Exposed-dao:$Exposedversion")
implementação ("org.jetbrains.exposed:exposed-jdbc:$exposedversion")
implementação ("org.jetbrains.exposed:exposed-jodatime:$exposedVersion") // orimplementation ("org.jetbrains.exposed:exposed-java-time:$exposedVersion") // orimplementation ("org.jetbrains.exposedversion -kotlin-DateTime: $ exposedVersion ")
implementação ("org.Jetbrains.exposed:Exposed-json:$ExposedVersion")
implementação ("org.Jetbrains.exposed:Exposed-Money:$Exposedversion")
implementação ("org.jetbrains.exposed: Exposed-spring-boot-starter:$ExposedVersion")
} e em gradle.properties
exposedVersion=0.56.0
Confira as amostras para um início rápido.
Atualmente, exposto está disponível para compilações Maven/Gradle . Verifique o MAVEN CENTRAL e a leitura, comece a obter uma visão sobre a configuração exposta.
Para mais informações, visite os links abaixo:
Documentação com exemplos e documentos
Contribuindo para expostos
Guia de migração
Quebrando mudanças e detalhes de migração
Canal frouxo
Rastreador de emissão
Observe que estamos nos afastando dos problemas do GitHub para relatar bugs e recursos. Por favor, registre quaisquer novas solicitações no YouTrack. Você deve estar conectado para visualizar e registrar problemas, caso contrário, será recebido com um 404.
Você tem perguntas? Sinta -se à vontade para solicitar um convite para a Slack Kotlinlang e participar da conversa do projeto em nosso canal #exposed.
Congratulamo -nos ativamente com seus pedidos de tração. No entanto, vincular seu trabalho a um problema existente é preferido.
Bick o repositório e crie seu ramo a partir de Main.
Nomeie seu ramo algo descritivo para o trabalho que você está fazendo. ou seja, acrescenta novidade.
Se você adicionou código que deve ser testado, adicione testes e verifique se o conjunto de testes passa.
Certifique -se de abordar todos os avisos de fiapos.
Se você melhorar o código existente, informe -nos em sua descrição de relações públicas.
Veja as diretrizes de contribuição para obter mais detalhes.
importar org.Jetbrains.exposed.sql. id ", 10) Val Nome: Coluna <String> = varchar (" nome ", comprimento = 50) val cityId: Column<Int?> = (integer("city_id") references Cities.id).nullable()override val primaryKey = PrimaryKey(id, name = "PK_User_ID") // name is optional here}object Cities : Table( ) {val id: coluna <int> = integer ("id"). AutoinCrement () val Nome: Column <tring> = varchar ("nome", 50) Substituir Val PrimaryKey = PrimaryKey (id, nome = "pk_cities_id")
} diversão main () {database.connect ("jdbc: h2: MEM: test", driver = "org.h2.driver", user = "root", senha = "")
transação {
addLogger (stdoutSqllogger) schemautils.create (cidades, usuários) val santpetersburgid = cities.insert {
[nome] = "São Petersburgo"} Get Cities.idval Munichid = Cities.insert {
[nome] = "Munique"} Get Cities.idval Pragaeid = Cities.insert {
It.Update (Nome, Stringliteral ("Praga") .Trim (). Substring (1, 2))
} [Cities.id] Val Praguename = Cities.Selectall (). Onde {Cities.id Eq Pragueid} .single () [cities.name] println ("Praguename = $ Praguename") Users.insert {
É [id] = "Andrey" it [nome] = "Andrey" it [users.cityId] = saintpetersburgid
} Users.insert {
[id] = "Sergey" it [nome] = "Sergey" it [users.cityid] = munichid
} Users.insert {
[id] = "eugene" it [nome] = "eugene" it [users.cityid] = munichid
} Users.insert {
it [id] = "Alex" it [nome] = "Alex" it [users.cityid] = null} users.insert {
it [id] = "smth" it [name] = "algo" it [users.cityid] = null} users.update ({users.id eq "Alex"}) {
it [name] = "Alexey"} users.deletewhere {users.name como "%coisa"} println ("Todas as cidades:") para (City in cities.Selecttall ()) {println ("$ {City [cidades. id]}: $ {city [cities.name]} ")
} println ("junção manual:")
(Usuários INnerjoin Cities)
.Select (Users.name, cities.name)
.onde {
(Users.id.eq ("Andrey") ou usuários.name.eq ("Sergey") AndUsers.id.eq ("Sergey") e Users.cityid.eq (cities.id)
} .ForEach {println ("$ {it [usuários.name]} vive em $ {it [cities.name]}")
} println ("Junte -se com a chave estrangeira:")
(Usuários INnerjoin Cities)
.Select (Users.Name, Users.CityId, Cities.Name)
. Onde {cities.name.eq ("St. Petersburg") ou Users.cityid.isnull ()}
.ForEach {if (it [users.cityid]! = null) {println ("$ {it [usuários.name]} vive em $ {it [cities.name]}")
} else {println ("$ {it [users.name]} vive nenhum lugar")
}
} println ("Funções e grupo por:")
((Cidades innerjoin Usuários)
.Select (Cities.Name, Users.id.Count ())
.groupby (cities.name)
) .Foreach {val CityName = [cities.name] valercount = [ususers.id.count ()] if (userCount> 0) {println ("$ userCount Usuário (s) ao vivo (s) em $ CityName" )
} else {println ("Ninguém mora em $ CityName")
}
} Schemautils.drop (usuários, cidades)
}
}SQL gerado:
SQL: Criar tabela se não existir cidades (id int auto_increntle, nome varchar (50) não nulo, restrição pk_cities_id chave primária (id))
SQL: Crie a tabela se não existe usuários (id varchar (10), nome varchar (50) não nulo, city_id int null, restrição pk_user_id chave primária (id), restrição fk_users_city_id__id Key estrangeiro (city_id) refere -se cidades (id) na exclusão de restrição restrita Na atualização restrita)
SQL: Inserir em cidades (nome) valores ('São Petersburgo')
SQL: Inserir em cidades (nome) valores ('Munique')
SQL: Inserir em cidades (nome) valores (substring (Trim ('Praga'), 1, 2))
Sql: selecione cidades.id, cidades.name de cidades onde cidades.id = 3praguename = pr
SQL: Inserir nos usuários (id, nome, city_id) valores ('Andrey', 'Andrey', 1)
SQL: Inserir em usuários (ID, nome, City_Id) valores ('Sergey', 'Sergey', 2)
SQL: Inserir nos usuários (ID, nome, City_Id) valores ('Eugene', 'Eugene', 2)
SQL: Inserir em usuários (id, nome, city_id) valores ('Alex', 'Alex', NULL)
SQL: Insira nos usuários (id, nome, city_id) valores ('smth', 'algo', nulo)
SQL: Usuários de atualização Defina o nome = 'Alexey' onde usuários.id = 'Alex'SQL: exclua dos usuários onde usuários.name como'%Thing 'todas as cidades:
SQL: Select Cities.id, Cities.Name das Cities1: St. Petersburg2: Munich3: PR
Junto manual:
SQL: selecione usuários.name, cities.name dos usuários Interior Junção cities on cities.id = users.city_id where ((users.id = 'Andrey') ou (usuários.name = 'Sergey')) e (usuários.id.id = 'Sergey') e (usuários.city_id = cities.id)
Sergey vive em Munichjoin com a Chave Estrangeira:
SQL: selecione usuários.name, users.city_id, cities.name dos usuários Interior Junção de cidades em cidades.id = usuários.city_id where (cities.name = 'St. Petersburg') ou (usuários.city_id é nulo)
Andrey mora em São Petersburgo
Funções e grupo por:
SQL: Selecione Cities.name, count (users.id) de cidades ingressos Juntir usuários em cidades.id = users.city_id grupo por cidades.name1 Usuário (s) Live (s) em St. Petersburg2 Usuário (s) ao vivo (s (s) ) em Munique
SQL: Tabela de soltar se existir usuários
SQL: Tabela de soltar se houver cidades importar org.jetbrains.exposed.dao.*importar org.jetbrains.exposed.dao.id.entityidimport org.jetbrains.exposed.dao.id.intidtableImport org.jetbrains.exposed.sql. .Transactions.TransactionObject Usuários: IntidTable () {Val Nome = Varchar ("Nome", 50) .Index () Val City = Referência ("Cidade", Cidades) Val Age = Inteiro ("Idade")
} Cidades do objeto: intidTable () {val name = varchar ("nome", 50)
} classe Usuário (ID: entityId <int>): Intentity (ID) {Companion Object: IntentityClass <suser> (Usuários) Var nome por usuários.namevar cidade por cidade referenceton users.cityvar idade by users.age
} classe City (ID: EntityId <int>): Intentity (ID) {Objeto Companion: IntentityClass <City> (cidades) VAR Nome By Cities.NameVal Usuários de Usuários de Usuários do Usuários.City.City.City
} diversão main () {database.connect ("jdbc: h2: MEM: test", driver = "org.h2.driver", user = "root", senha = "")
transação {
addLogger (stdoutSqlloGger) schemautils.create (cidades, usuários) val stpete = city.new {
Nome = "São Petersburgo"} Val Munich = City.New {
name = "Munique"} User.new {
Nome = "A" City = Stpete
idade = 5} user.new {
Nome = "B" City = Stpete
idade = 27} user.new {
Nome = "C" City = Munique
idade = 42} println ("cidades: $ {city.all (). JointString {it.name}}") println ("usuários em $ {stpete.name}: $ {stpete.users.jointostring {it.name} } ") println (" adultos: $ {user.find {users.age maioreq 18} .Jointostring {it.name}} ")
}
}SQL gerado:
SQL: Criar tabela se não existe cidades (id int auto_increntlement chave primária, nome Varchar (50) não nulo)
SQL: Crie a tabela se não existe usuários (ID int Auto_Increment Primária Chave, Nome Varchar (50) NÃO NULL, CITY NO NULL, AGE NÃO NULL, RESTIR FK_USERS_CITY__ID CHAVE ESTRAGENS (Cidade) Referências Cidades (ID) Sobre Excluir Restringir na Atualização RESTRINGIR)
SQL: Crie Index Users_name nos usuários (nome)
SQL: Inserir em cidades (nome) valores ('São Petersburgo')
SQL: Inserir em cidades (nome) valores ('Munique')
SQL: selecione cidades.id, cidades.name das cidades
Cidades: São Petersburgo, Munique
SQL: Inserir nos usuários (nome, cidade, idade) valores ('a', 1, 5)
SQL: Inserir nos usuários (nome, cidade, idade) valores ('b', 1, 27)
SQL: Inserir em usuários (nome, cidade, idade) valores ('c', 2, 42)
SQL: selecione usuários.id, usuários.name, users.city, usuários.age dos usuários onde usuários.city = 1Users em St. Petersburg: a, b, b
SQL: selecione usuários.id, usuários.name, users.city, usuários.age dos usuários onde usuários.age> = 18Adults: b, c, c,Consulte o guia de contribuição antes de contribuir.
Ao contribuir para o projeto exposto, você concorda que suas contribuições serão licenciadas sob licença Apache, versão 2.0.
