Exposed
0.56.0
Exposed est une bibliothèque SQL légère au-dessus d'un pilote JDBC pour la langue Kotlin. Exposed a deux saveurs d'accès à la base de données: TypeSafe SQL Emballage DSL et les objets d'accès aux données léger (DAO).
Avec Exposed, vous avez deux options pour l'accès à la base de données: Emballage DSL et un DAO léger. Notre mascotte officielle est la seiche, qui est bien connue pour sa capacité de mimétisme exceptionnelle qui lui permet de se fondre parfaitement dans n'importe quel environnement. Semblable à notre mascotte, l'exposition peut être utilisée pour imiter une variété de moteurs de base de données, ce qui vous aide à créer des applications sans dépendances sur un moteur de base de données spécifique et à basculer entre eux avec très peu ou pas de changements.
H2 (versions 2.x; 1.x La version est obsolète et sera supprimée dans les futures versions)
(Aussi, PostgreSQL à l'aide du pilote JDBC PGJDBC-NG)
Les versions exposées sont disponibles dans le référentiel central de Maven. Vous pouvez déclarer ce référentiel dans votre script de construction comme suit:
AVERTISSEMENT: vous devrez peut-être fixer votre cible Kotlin JVM à 8, et lorsque vous utilisez Spring à 17, pour que cela fonctionne correctement:
Repositaires {// versions après 0,30.1 // versions avant 0,30.1 n'est pas disponible pour NowMavencentral ()
}Le référentiel Maven Central est activé par défaut pour les utilisateurs de Maven.
Exposed se compose des modules suivants:
Module de base au cœur exposé, qui contient à la fois une API DSL avec la cartographie
Crypt exposé - fournit des types de colonnes supplémentaires pour stocker des données cryptées en dB et encoder / décoder sur côté client
API DAO exposé - DAO
Extensions exposées-java - Extensions de date de date basées sur l'API de l'heure Java8
exposé-JDBC - Implémentation du niveau de transport basé sur l'API Java JDBC
Extensions exposées-jodatime - Date-temps basée sur la bibliothèque jodatime
Exposed-json - Extensions de type de données JSON et JSONB
Exposez-kotlin-datetime - Extensions de date de date basées sur le kotlinx-datetime
Money exposé - Extensions pour soutenir monétaryamount de "javax.money:money-api"
exposé-spring-boot-starter - un démarreur pour Spring Boot à utiliser exposé comme orm au lieu d'hibernate
<dépendances>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> Core exposé </ arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> Crypt exposé </ arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> exposée-dao </ arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> Exposed-java-time </refactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> exposé-jdbc </letefactid>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> exposé-jodatime </ arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> Exposed-Json </RetingActid>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> exposé-kotlin-datetime </refactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> Exposed-Money </ Arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
<dépendance>
<groupId> org.JetBrains.exposed </rom grouped>
<ArtefactId> exposé-spring-boot-starter </ arfactive>
<version> 0,56.0 </DERNÉE>
</Dependance>
</DENDENDENCES> dépendances {
Implémentation 'org.JetBrains.exposed: Exposed-core:0.56.0'implementation' org.jetbrains.exposed:exposed-crypt:0.56.0'implementation 'org.jetbrains.exposed: exposée-dao:0.56.0'implementationation 'org.jetbrains.exposed: exposition-jdbc:0.56.0'
Implémentation 'org.JetBrains.exposed:exposed-jodatime:0.56.0'// orimplementation' org.jetbrains.exposed:exposed-java-time:0.56.0'// orimplementation 'org.jetbrains.exposed: exposed-kotlin-kotlin- DateTime: 0,56.0 '
Implémentation 'org.JetBrains.exposed: Exposed-Json:0.56.0'IMPLIMENTATION' Org.JetBrains.exposed: Exposed-Money:0.56.0'Implementation 'org.JetBrains.exposed: Exposed-spring-boot-starter:0.56. 0 '} Dans build.gradle.kts :
Val ExposedVersion: String by Project
dépendances {
Implémentation ("org.Jetbrains.exposed: Exposed-core :$exposedVersion")
Implémentation ("org.Jetbrains.exposed: Exposed-Crypt:$exposedVersion")
Implémentation ("org.Jetbrains.exposed: Exposed-dao:$exposedVersion")
implémentation ("org.jetbrains.exposed: exposition-jdbc:$exposedversion")
Implémentation ("org.jetbrains.exposed: exposition-jodatime:$exposedversion") // orimplementation ("org.jetbrains.exposed: exposition-java-time:$exposedversion") // orimplementation ("org.jetbrains.exposed: exposée exposée -Kotlin-Datetime: $ exposé ")
implémentation ("org.jetbrains.exposed: exposée-json:$exposedVersion")
Implémentation ("org.Jetbrains.exposed: Exposed-Money :$exposedVersion")
Implémentation ("org.Jetbrains.exposed: Exposed-Spring-boot-starter :$exposedVersion")
} et dans gradle.properties
exposedVersion=0.56.0
Consultez les échantillons pour un démarrage rapide.
Actuellement, exposé est disponible pour les constructions Maven / Gradle . Vérifiez le Maven Central et lisez le démarrage pour obtenir un aperçu de la mise en place de l'exposition.
Pour plus d'informations, visitez les liens ci-dessous:
Documentation avec des exemples et des documents
Contribuant à
Guide de migration
Breaking Changes et Tous les détails de la migration
Canal lâche
Émission de tracker
Veuillez noter que nous nous éloignons des problèmes de GitHub pour la déclaration des bogues et des fonctionnalités. Veuillez enregistrer toutes les nouvelles demandes sur YouTrack. Vous devez être connecté pour afficher et enregistrer les problèmes, sinon vous serez accueilli avec un 404.
Avez-vous des questions? N'hésitez pas à demander une invitation au Slack de Kotlinlang et à rejoindre la conversation du projet sur notre canal #expose.
Nous accueillons activement vos demandes de traction. Cependant, la liaison de votre travail à un problème existant est préférable.
Fourk le repo et créez votre branche à partir de la main.
Nommez votre branche quelque chose qui est descriptif au travail que vous faites. c'est-à-dire qu'ajoute-new-thing.
Si vous avez ajouté du code qui doit être testé, ajoutez des tests et assurez-vous que la suite de test passe.
Assurez-vous de traiter tous les avertissements de peluches.
Si vous améliorez le code existant, veuillez nous en informer dans votre description de relations publiques.
Voir les directives de contribution pour plus de détails.
import org.jetbrains.exposed.sql. * import org.jetbrains.exposed.sql.sqlexpressionbuilder.likeImport org.jetbrains.exposed.sql.transacts.transactionObject Userst: Table () {val id: colonne <string> = varchar (" id ", 10) Nom de Val: colonne <string> = varchar (" name ", longueur = 50) Val CityId: Colonne <int?> = (Integer ("City_id") Références Cities.id) .Nullable () Override Val primaireKey = primairey (id, name = "pk_user_id") // nom est facultatif ici} objet Cities : Table () {val id: colonne <nt> = entier ("id"). 50) Override Val primationKey = primorKey (id, name = "pk_cities_id")
} fun main () {database.connect ("jdbc: h2: mem: test", driver = "org.h2.driver", user = "root", mot de passe = "")
transaction {
addLogger (stdoutsqllogger) schemaUtils.Create (villes, utilisateurs) val saintpetersburgid = cities.insert {
it [name] = "Saint-Pétersbourg"} Get Cities.idval Munichid = Cities.insert {
it [name] = "munich"} get cities.idval pragueid = cities.insert {
it.update (nom, stringliteral ("prague") .trim (). substring (1, 2))
} [Cities.id] val praguename = cities.selectall (). Où {cities.id eq pragueid} .single () [cities.name] println ("praguename = $ praguename") users.insert {
it [id] = "andrey" it [name] = "andrey" it [users.cityId] = saintpetersburgid
} Users.insert {
it [id] = "sergey" it [name] = "sergey" it [users.cityId] = Munichid
} Users.insert {
it [id] = "eugene" it [name] = "eugene" it [users.cityId] = Munichid
} Users.insert {
it [id] = "alex" it [name] = "alex" it [users.cityId] = null} users.insert {
it [id] = "smth" it [name] = "quelque chose" it [users.cityId] = null} users.update ({users.id eq "alex"}) {
it [name] = "Alexey"} users.deleTewhere {Users.name Like "% Thing"} println ("All Cities:") for (City in Cities.Selectall ()) {println ("$ {ville [villes. id]}: $ {ville [cities.name]} ")
} println ("manuel join:")
(Utilisateurs Innerjoin Cities)
.Select (users.name, cities.name)
.où {
(Users.id.eq ("Andrey") ou userst.name.eq ("sergey")) etUsers.id.eq ("sergey") et users.cityid.eq (cities.id)
} .ForEach {println ("$ {it [users.name]} vit dans $ {it [cities.name]}")
} println ("Rejoignez avec la clé étrangère:")
(Utilisateurs Innerjoin Cities)
.Select (users.name, users.cityid, cities.name)
.Where {cities.name.eq ("st. Petersburg") ou users.cityid.isnull ()}
.ForEach {if (it [users.cityId]! = null) {println ("$ {it [users.name]} vit dans $ {it [cities.name]}")
} else {println ("$ {it [users.name]} ne vie nulle part")
}
} println ("Fonctions et groupe par:")
((Villes utilisateurs innerjoin)
.Select (cities.name, users.id.count ())
.groupby (cities.name)
. )
} else {println ("Personne ne vit à $ Cityname")
}
} SchemaUtils.drop (utilisateurs, villes)
}
}SQL généré:
SQL: Créer une table s'il n'existe pas les villes (id int auto_increment, nom varchar (50) pas null, contrainte pk_cities_id clé primaire (id))
SQL: Create Table If not existe des utilisateurs (ID VARCHAR (10), nom Varchar (50) Not Null, City_id int null, CONSTRAINT PK_USER_ID Primary Key (ID), CONSTRAINT FK_USERS_CITY_ID__ID FORT Sur la mise à jour restreinte)
SQL: Insérer dans les valeurs des villes (nom) («Saint-Pétersbourg»)
SQL: Insérer dans les valeurs des villes (nom) («Munich»)
SQL: Insérer dans les valeurs des villes (nom) (sous-chaîne (Trim («Prague»), 1, 2))
SQL: Select Cities.id, Cities.Name from Cities Where Cities.id = 3pragUename = PR
SQL: Insérer dans les utilisateurs (ID, Name, City_id) Valeurs ('Andrey', 'Andrey', 1)
SQL: Insérer dans les utilisateurs (ID, Name, City_id) Valeurs («Sergey», «Sergey», 2)
SQL: Insérer dans les utilisateurs (ID, Name, City_id) Valeurs ('Eugene', 'Eugene', 2)
SQL: Insérer dans les utilisateurs (ID, Name, City_id) Valeurs ('Alex', 'Alex', null)
SQL: Insérer dans les utilisateurs (id, nom, city_id) valeurs ('smth', 'quelque chose', null)
SQL: Mettez à jour les utilisateurs set name = 'Alexey' où utilisateurs.id = 'alex'sql: supprimer des utilisateurs où les utilisateurs.
SQL: Select Cities.id, Cities.Name From Cities1: Saint-Pétersbourg2: Munich3: PR
Join manuel:
SQL: SELECT USERS.NAME, Cities.name From Users Inner Join Cities on Cities.id = Users.City_id Where ((Users.id = 'Andrey') ou (Users.Name = 'Sergey')) et (Users.id = 'sergey') et (users.city_id = cities.id)
Sergey vit à Munichjoin avec une clé étrangère:
SQL: SELECT USERS.NAME, USERS.CITY_ID, Cities.name From Users Inner Join Cities on Cities.id = Users.City_id Where (Cities.Name = 'St. Petersburg') ou (Users.City_id est nul)
Andrey vit à Saint-Pétersbourg
Fonctions et groupe par:
SQL: SELECT CITY.NAME, COUNT (USERS.ID) dans les villes Inner Rejoignez les utilisateurs sur Cities.id = Users.City_id Group by Cities.name1 User (S) Live (S) à Saint-Pétersbourg2 User (S) en direct (S en direct (S ) à Munich
SQL: Tablette de dépose si il existe des utilisateurs
SQL: table de dépôt si existe des villes import org.jetbrains.exposed.dao. * import org.jetbrains.exposed.dao.id.entityidimport org.jetbrains.exposed.dao.id.intidtablemport org.jetbrains.exposed.sql. * import org.jetbrains.exposed.sql. .transacts.transactionObject User: IntidTable () {val name = varchar ("name", 50) .Index () Val City = référence ("ville", villes) Val Age = Integer ("Age")
} objets Cities: IntidTable () {val name = varchar ("name", 50)
} classe utilisateur (id: entityId <nt>): Intentity (id) {compagne Object: IntentityClass <User> (utilisateurs) var nom par users.namevar ville par la ville référencée users.cityvar Âge par users.age
} Class City (id: EntityId <nt>): Intentity (id) {Companion Object: IntentityClass <gity> (Cities) var Name by Cities.NameVal Users by utilisateur référentiel utilisateurs.city
} fun main () {database.connect ("jdbc: h2: mem: test", driver = "org.h2.driver", user = "root", mot de passe = "")
transaction {
addLogger (stdoutsqllogger) schemaUtils.Create (villes, utilisateurs) val stpete = ville.new {
name = "Saint-Pétersbourg"} Val Munich = City.new {
name = "Munich"} user.new {
name = "a" City = stpete
Âge = 5} user.new {
name = "b" ville = stpete
Âge = 27} user.new {
name = "C" City = Munich
Âge = 42} println ("Cities: $ {City.all (). jointoString {it.name}}") println ("utilisateurs dans $ {stpete.name}: $ {stpete.users.jointString {it.name} } ") println (" adultes: $ {user.find {users.age Greareeq 18} .jointostring {it.name}} ")
}
}SQL généré:
SQL: Créer une table s'il n'existe pas les villes (id int Auto_increment Clé primaire, nom varchar (50) pas null)
SQL: Créer la table Si non existe des utilisateurs (id int Auto_increment Clé primaire, nom varchar (50) pas null, ville int not null, âge int not null, contrainte fk_users_city__id clé étrangère (ville) références villes (id) sur la suppression de la mise à jour de la mise à jour LIMITER)
SQL: Créer des index USERS_NAME sur les utilisateurs (nom)
SQL: Insérer dans les valeurs des villes (nom) («Saint-Pétersbourg»)
SQL: Insérer dans les valeurs des villes (nom) («Munich»)
SQL: Select Cities.id, Cities.Name From Cities
Villes: Saint-Pétersbourg, Munich
SQL: Insérer dans les utilisateurs (nom, ville, âge) Valeurs ('A', 1, 5)
SQL: Insérer dans les utilisateurs (nom, ville, âge) Valeurs ('B', 1, 27)
SQL: Insérer dans les utilisateurs (nom, ville, âge) Valeurs ('C', 2, 42)
SQL: SELECT USERS.ID, USERS.NAME, USER
SQL: SELECT USERS.ID, USERS.NAME, USERVeuillez consulter le guide de contribution avant de contribuer.
En contribuant au projet exposé, vous acceptez que vos contributions seront concédées sous licence Apache, version 2.0.
