Exposed
0.56.0
Exposed es una biblioteca SQL liviana encima de un controlador JDBC para el idioma Kotlin. Exposed tiene dos sabores de acceso a la base de datos: TypeSafe SQL Wrepping DSL y objetos de acceso de datos ligeros (DAO).
Con expuesto, tiene dos opciones para el acceso a la base de datos: envolver DSL y un DAO ligero. Nuestra mascota oficial es la sepia, que es conocida por su excelente capacidad de imitación que le permite combinarse sin problemas con cualquier entorno. Similar a nuestra mascota, Exposed se puede usar para imitar una variedad de motores de bases de datos, lo que le ayuda a crear aplicaciones sin dependencias en ningún motor de base de datos específico y cambiar entre ellos con muy pocos o ningún cambio.
H2 (versiones 2.x; 1.x La versión está en desuso y se eliminará en versiones futuras)
(Además, PostgreSQL usando el controlador PGJDBC-NG JDBC)
Las versiones de exposición están disponibles en el repositorio central de Maven. Puede declarar este repositorio en su script de compilación de la siguiente manera:
ADVERTENCIA: Es posible que deba establecer su objetivo Kotlin JVM en 8, y al usar Spring a 17, para que esto funcione correctamente:
Repositorios {// versiones después de 0.30.1 // Las versiones antes de 0.30.1 no están disponibles para NowMavencentral ()
}El repositorio central Maven está habilitado de forma predeterminada para los usuarios de Maven.
Exposed consiste en los siguientes módulos:
módulo base de núcleo expuesto, que contiene ambas API DSL junto con el mapeo
Exposed-Crypt: proporciona tipos de columnas adicionales para almacenar datos cifrados en DB y codificarlo/decodificarlo en el lado del cliente
Exposed -Dao - API DAO
Exposido-java-tiempo-extensiones de fecha de fecha basadas en la API de tiempo de Java8
Exposed -JDBC - Implementación del nivel de transporte basada en Java JDBC API
Exposed-Jodatime: extensiones de fecha de fecha basadas en la biblioteca de Jodatime
Exposed -Json - Extensiones de datos JSON y JSONB
Exposed-kotlin-datetime: extensiones de fecha de fecha basadas en kotlinx-datetime
Money Exposed-Extensiones para apoyar MonetaryMount de "Javax.Money:Money-API"
spring-spring-boot starter: un inicio para la bota de primavera para utilizar expuesto como el ORM en lugar de hibernado
<pendencias>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactID> norlejado expuesto </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactID> expuesto-crypt </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactid> expuesto-dao </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactID> expuesto-java-tiempo </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactid> exposed-jdbc </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactID> exposed-jodatime </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<ArFactId> Exposed-Json </artifactId>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<ArFactId> Exposed-kotlin-datetime </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<ArFactId> Exposed-Money </artifactId>
<Versión> 0.56.0 </Versión>
</pendency>
<pendencia>
<MoupRId> org.jetbrains.ExPOSED </GroupId>
<artifactID> expuesto-spring-boot starter </artifactid>
<Versión> 0.56.0 </Versión>
</pendency>
</dependencias> dependencias {
Implementación 'org.jetbrains. Exexposited: expuesto-core:0.56.0'implementation' org.jetbrains. Exexposited: expuesto-crypto:0.56.0'implementation 'org.jetbrains.Exted:exposed-dao:0.56.0'plementation' org.jetbrains.expede:expone-jdbc:0.56.0 '
Implementación 'org.jetbrains.Exputed:exposed-jodatime:0.56.0'// orimplementation' org.jetbrains.expeded:exposed-java-time:0.56.0'// orimplementation 'org.jetbrains.exposed:exposed-kotlin-- DateTime: 0.56.0 '
Implementación 'org.jetbrains.Extreed:exposed-json:0.56.0'implementation' org.jetbrains.expone:exposed-money:0.56.0'implementation 'org.jetbrains.Exted:exposed-spring-boot-starter:0.56. 0 '} En build.gradle.kts :
Val exposedVersion: cadena por proyecto
dependencias {
Implementación ("org.jetbrains.Expede:exposed-core:$exposed Version")
Implementación ("org.jetbrains.Expede:-exposed-cryppT:$exposedVersion")
Implementación ("org.jetbrains.Expede:exposed-dao:$exposedVersion")
Implementación ("org.jetbrains.Exputed:exposed-jdbc:$exposedversion")
Implementación ("org.jetbrains.Expuesta:exposed-jodatime:$exposedversion") // oimplementation ("org.jetbrains.Exputed:exposed-java-time:$exposedversion") // oimplementation ("org.jetbrains.exposed:exposed:exposed -kotlin-datetime: $ exposedversion ")
Implementación ("org.jetbrains.Expede:exposed-json:$exposed Version")
Implementación ("org.jetbrains.Expede:-exposed-dinero:$exposedversion")
Implementación ("org.jetbrains.Expede:expone-spring-boot-starter:$exposedversion")
} y en gradle.properties
exposedVersion=0.56.0
Echa un vistazo a las muestras para un comienzo rápido.
Actualmente, Exposed está disponible para compilaciones Maven/Gradle . Consulte el Maven Central y lea Comenzando a obtener una idea de la configuración de la exposición.
Para obtener más información, visite los enlaces a continuación:
Documentación con ejemplos y documentos
Contribuyendo a expuesto
Guía de migración
Rompiendo cambios y cualquier detalle de migración
Canal flojo
Rastreador de emisión
Tenga en cuenta que nos estamos alejando de los problemas de GitHub para informar de errores y características. Registre cualquier solicitud nueva en yoTrack. Debe iniciarse para ver y registrar problemas, de lo contrario, se cumplirá con un 404.
¿Tienes preguntas? Siéntase libre de solicitar una invitación para la holgura de Kotlinlang y unirse a la conversación del proyecto en nuestro canal #exposed.
Agradecemos activamente sus solicitudes de extracción. Sin embargo, se prefiere vincular su trabajo a un problema existente.
Bifurca el repositorio y crea su rama desde Main.
Nombra tu rama algo que sea descriptivo para el trabajo que estás haciendo. es decir, agrega algo.
Si ha agregado un código que debe probarse, agregue pruebas y asegúrese de que la suite de prueba pase.
Asegúrese de abordar cualquier advertencia de pelusa.
Si mejora el código existente, háganos saber en su descripción de relaciones públicas.
Consulte las pautas de contribución para obtener más detalles.
importar org.jetbrains.exposed.sql.*Importar org.jetbrains.exposed.sql.sqlexpressionBuilder.likeImport org.jetbrains.exposed.sql.transactions.transactionObject users: table () {val id: columna <tring> = varchar (" id ", 10) nombre de val: columna <tring> = varchar (" nombre ", longitud = 50) val cityid: Columna <int ?> = (integer ("city_id") References Cities.id) .nullable () anverride val primario = primario (id, name = "pk_user_id") // El nombre es opcional aquí} Cities de objeto: table () { Val id: columna <int> = integer ("id"). autoincrement () val name: column <string> = varchar ("name", 50) anular valkey = PrimaryKey (id, name = "PK_CITY_ID")
} diversión Main () {database.connect ("jdbc: h2: mem: test", driver = "org.h2.driver", user = "root", contraseña = "")
transacción {
addlogger (stdoutsqllogger) schemautils.create (ciudades, usuarios) val saintpetersburgid = ciudad.insert {
IT [nombre] = "San Petersburgo"} Obtener ciudades.idval munichid = CITIESS.INSERT {
IT [nombre] = "Munich"} Get Cities.idval pragueid = CITIESS.INSERT {
it.update (nombre, stringLiteral ("praga") .trim (). subcadena (1, 2))
} [Ciudades.id] val Praguename = Cities.Selectall (). Donde {Cities.id eq pragueid} .singleger () [Cities.name] println ("praguename = $ praguename") uss.insert {
IT [id] = "Andrey" it [name] = "Andrey" It [users.cityid] = saintPeTersBurgid
} Users.insert {
IT [id] = "Sergey" it [name] = "Sergey" It [ussers.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] = "something" it [users.cityid] = null} users.update ({ussers.id eq "alex"}) {
It [name] = "Alexey"} users.deletewhere {users.name Like "%Thing"} println ("Todas las ciudades:") para (City in Cities.Selectall ()) {println ("$ {City [Cities. id]}: $ {City [CITIESS.NAME]} ")
} println ("Manual Join:")
(Los usuarios internos de las ciudades)
.select (ussers.name, ciudad.name)
.dónde {
(Users.id.eq ("Andrey") o Uss.name.eq ("Sergey")) Andusers.id.eq ("Sergey") y Uss.cityid.eq (Cities.id)
} .ForEach {println ("$ {it [users.name]} vive en $ {it [ciudad.name]}")
} println ("Únete a la clave extranjera:")
(Los usuarios internos de las ciudades)
.select (ussers.name, ussers.cityid, ciudad.name)
donde {ciudad.name.eq ("st. Petersburg") o ussers.cityid.isnull ()}
.ForEach {if (it [ussers.cityId]! = null) {println ("$ {it [users.name]} vive en $ {it [CITES.NAME]}")
} else {println ("$ {it [users.name]} no vive ahora")
}
} println ("Funciones y grupos por:")
((Cities InnerJoin Usuarios)
.Select (Cities.name, Users.id.count ())
.Groupby (CITies.Name)
) .ForEach {val cityName = it [CITies.Name] val urserCount = it [users.id.count ()] if (Usercount> 0) {println ("$ UserCount User (s) Live (s) en $ CityName" )
} else {println ("Nadie vive en $ CityName")
}
} SchemaUtils.drop (usuarios, ciudades)
}
}SQL generado:
SQL: Crear tabla si no existe Ciudades (ID int Auto_incement, nombre Varchar (50) No NULL, Restricción PK_CITY_ID Clave primaria (ID))
SQL: Crear tabla si no existe usuarios (id varchar (10), nombre varchar (50) no null, city_id int null, restrict pk_user_id clave primaria (id), restricción fk_users_city_id__id rlaz extranjero (city_id) Referencias de las ciudades (id) en delete restrictiva En la actualización de actualización)
SQL: inserte en valores de ciudades (nombre) ('San Petersburgo')
SQL: Inserte en valores de ciudades (nombre) ('Munich')
SQL: Inserte en valores de ciudades (nombre) (subcadena (Trim ('Praga'), 1, 2)))
SQL: seleccionar ciudad.id, ciudad.name de las ciudades donde las ciudades.id = 3praguename = PR
SQL: inserte en los valores de los usuarios (ID, nombre, City_ID) ('Andrey', 'Andrey', 1)
SQL: inserte en los usuarios de usuarios (ID, nombre, City_ID) ('Sergey', 'Sergey', 2)
SQL: inserte en los valores de los usuarios (ID, nombre, City_ID) ('Eugene', 'Eugene', 2)
SQL: inserte en los usuarios de usuarios (ID, nombre, City_ID) ('Alex', 'Alex', NULL)
SQL: inserte en los valores de los usuarios (ID, Nombre, City_ID) ('Smth', 'Algo', NULL)
SQL: actualizar usuarios set name = 'Alexey' donde ussers.id = 'Alex'SQL: Eliminar de los usuarios donde usuarios. Nombre como'%cosa 'todas las ciudades:
SQL: Select Cities.id, Cities.Name from Cities1: San Petersburgo2: Munich3: PR
Manual unirse:
SQL: Seleccione Uss.Name, Cities.Name de los usuarios Inner Unione Cities en Cities.id = Users.city_id Where ((Users.id = 'Andrey') o (Ussers.name = 'Sergey')) y (Uss.id = 'Sergey') y (ussers.city_id = ciudad.id)
Sergey vive en Munichjoin con la clave extranjera:
SQL: Seleccione Uss.name, Uss.city_id, Cities.Name de los usuarios Inters Unirse Cities en Cities.id = Users.city_id Where (Cities.name = 'St. Petersburg') o (Uss.City_ID es nulo)
Andrey vive en San Petersburgo
Funciones y grupo por:
SQL: Seleccionar Cities.name, Count (Uss.id) de Cities Inner se une a los usuarios de Cities.id = Uss.city_id Group por Cities.Name1 User (s) Live (s) en St. Petersburg2 User (s) Live (s) Live (s) ) en Munich
SQL: Tabla de caída si existe usuarios
SQL: Tabla de caída si existe las ciudades importar org.jetbrains.exposed.dao.*importar org.jetbrains.eSposed.dao.id.entityIdImport org.jetbrains.exposed.dao.id.intidtableImport org.jetbrains.exposed.sql.*importar org.jetbrains.eSposed.sql .Transactions.TransactionObject usuarios: intidTable () {val name = varchar ("nombre", 50) .index () val city = reference ("City", Cities) val age = integer ("edad")
} Ciudades de objeto: intidtable () {val name = varchar ("nombre", 50)
} Class User (id: entityID <int>): intitity (id) {objeto acompañante: intencityclass <serem> (usuarios) VAR nombre por usuarios. Namevar Ciudad por la ciudad referenciada usuarios.cityvar Age por usuarios.
} Class City (id: entityID <int>): intitity (id) {objeto complementario: intencityclass <city> (ciudad) var name por ciudad.nameval usuarios por usuarios de usuarios de referencia de usuarios. Ciudad
} diversión Main () {database.connect ("jdbc: h2: mem: test", driver = "org.h2.driver", user = "root", contraseña = "")
transacción {
addlogger (stdoutsqllogger) schemautils.create (ciudades, usuarios) val stpete = city.new {
name = "San Petersburgo"} val Munich = City.new {
name = "Munich"} user.new {
nombre = "A" Ciudad = Stpete
edad = 5} user.new {
nombre = "B" Ciudad = Stpete
edad = 27} user.new {
nombre = "C" Ciudad = Munich
Age = 42} println ("CITies: $ {City.all (). JUNTOSTRING {IT.NAME}}") println ("Usuarios en $ {stpete.name}: $ {stpete.users.jointostring {it.name} } ") println (" adultos: $ {user.find {users.age greatereq 18} .Jointostring {it.name}} ")
}
}SQL generado:
SQL: Crear tabla si no existe Ciudades (ID int Auto_incement Clave primaria, nombre Varchar (50) No nulo)
SQL: Crear tabla si no existe los usuarios (ID int Auto_incement Clave primaria, nombre Varchar (50) No NULL, City int no nulo, edad int no nulo, restricción FK_USERS_CITY__ID Clave exterior (Ciudad) Referencias Ciudades (ID) en Eliminar la actualización de la actualización RESTRINGIR)
SQL: Crear usuarios de índice_name en usuarios (nombre)
SQL: inserte en valores de ciudades (nombre) ('San Petersburgo')
SQL: Inserte en valores de ciudades (nombre) ('Munich')
SQL: Select Cities.id, Cities.Name From Cities
Ciudades: San Petersburgo, Munich
SQL: inserte en los usuarios de usuarios (nombre, ciudad, edad) ('a', 1, 5)
SQL: inserte en los valores de los usuarios (nombre, ciudad, edad, edad) ('b', 1, 27)
SQL: inserte en los usuarios de usuarios (nombre, ciudad, edad) ('C', 2, 42)
SQL: seleccione Uss.id, Uss.name, Uss.City, Uss.age de usuarios donde usuarios.city = 1users en St. Petersburg: A, B
SQL: seleccione Uss.ID, Uss.name, Uss.City, Uss.age de usuarios donde usuarios.age> = 18adults: b, cConsulte la guía de contribución antes de contribuir.
Al contribuir al proyecto expuesto, usted acepta que sus contribuciones se licenciarán bajo la licencia Apache, versión 2.0.
