Exposed下载 - Exposed源代码下载

Exposed

其他源码

0.56.0

下载

裸露的徽标

欢迎来到Kotlin的ORM框架。

暴露是Kotlin语言JDBC驱动程序顶部的轻量级SQL库。暴露有两个数据库访问的口味：Typesafe SQL包装DSL和轻型数据访问对象（DAO）。

曝光后，您有两个数据库访问的选项：包装DSL和一个轻巧的DAO。我们的官方吉祥物是墨西哥鱼，它以其出色的模仿能力而闻名，它使其能够无缝地融合到任何环境中。与我们的吉祥物类似，暴露的可用于模仿各种数据库引擎，这可以帮助您构建应用程序而无需对任何特定数据库引擎的依赖性，并在几乎没有更改或没有更改的情况下切换它们。

支持的数据库

H2（版本2.x; 1.x版本已弃用，并将在以后的版本中删除）
（也是使用PGJDBC-NG JDBC驱动程序的PostgreSQL）

依赖性

Maven Central配置

Maven Central存储库可用暴露的释放。您可以在构建脚本中声明此存储库，如下所示：

Gradle Groovy和Kotlin DSL

警告：您可能需要将Kotlin JVM目标设置为8，并且在使用Spring到17时，才能正常工作：

存储库{//在0.30.1 // 0.30.1之前的版本不可用的nowmavencentral（）
}

小牛

Maven中央存储库默认是针对Maven用户启用的。

裸露的模块

Exposed由以下模块组成：

裸露核 - 基本模块，其中包含两个DSL API以及映射
裸露的克里普特 - 提供其他列类型，以将加密数据存储在DB中，并在客户端编码/解码
裸露的dao -dao api
基于Java8 Time API
暴露-JDBC-基于Java JDBC API的运输级别实现
暴露 - 院士 - 基于Jodatime库的日期时间扩展
暴露 - JSON -JSON和JSONB数据类型扩展
曝光 - kotlin-datetime-基于kotlinx-datetime的日期时间扩展
暴露金钱 - 从“ Javax.money：Money-api”支持Monetaryamount的扩展名
裸露的 - 弹簧启动器 - 弹簧靴的起动器，可将暴露为ORM而不是冬眠

<依赖项>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露核心</artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于crypt </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于dao </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于java time </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露-JDBC </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于Jodatime </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露 -  json </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于kotlin-datetime </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露货币</artifactid>
        <版本> 0.56.0 </version>
    </dependency>
    <依赖项>
        <groupId> org.jetbrains.parped </groupId>
        <Artifactid>暴露于spring-boot-starter </artifactid>
        <版本> 0.56.0 </version>
    </dependency>
</依赖项>

Gradle Groovy

依赖项{
    实施'org.jetbrains.exposed：expaped-core：0.56.0'implementation'org.jetbrains.exped：expaped-crypt:0.56.0.56.0'impletation'org.jetbrains.jetbrains.exposed：exposed-exped-dao：0.56.0'implementation'implementation'''implementation'''' org.jetbrains.exposed：exped-jdbc:0.56.0'
    实施'org.jetbrains.exped：exped-jodatime:0.56.0'///orimplementation'org.jetbrains.exposed：Exposed-java time:0.56.0'//orimplementation'org.jetbrains'org.jetbrains.exposed：Expaped-kotsosed-kotlin--kotlin--kotlin--kotlin--日期：0.56.0'
    实现'org.jetbrains.exposed：exped-json:0.56.0'implementation'org.jetbrains.exposed：Expausped-money:0.56.0'implementation'org.jetbrains.jetbrains.exposed：Spart-Spart-Spring-boot-boot-Starter：0.56。 0'}

Gradle Kotlin DSL

在build.gradle.kts中：

 val暴露：串联项目的字符串
依赖项{
    实现（“ org.jetbrains.exped：公开核：
    实现（“ org.jetbrains.exped：公开crypt：brypt：bressposedversion”）
    实现（“ org.jetbrains.exped：exped-dao：qublexposedversion”）
    实现（“ org.jetbrains.exped：expaped-jdbc：jdbc：qublexposedversion”）

        实现（“ org.jetbrains.exped：expaped-jodatime:$ exposedversion”）// orimplementation（“ org.jetbrains.exposed：exposed-java time：$ exposedversion''）// orimplementation（org.jetbrains.jetbrains.exposed：exposed：expposed -kotlin-datetime：$ exposedversion”）

        实现（“ org.jetbrains.exped：expaused-json:json：qublesposedversion”）
    实现（“ org.jetbrains.exped：公开 - 货币：
    实现（“ org.jetbrains.exped：expaped-spring-boot-starter：qublexposedversion”）
}

和gradle.properties

exposedVersion=0.56.0

样品

查看样品以快速启动。

链接

目前，可用于Maven/Gradle构建。检查Maven Central并开始阅读，以了解设置暴露的洞察力。

有关更多信息，请访问以下链接：

文档和示例和文档
有助于暴露
迁移指南
破坏变化和任何迁移细节
松弛频道
问题跟踪器

提交问题

请注意，我们正在远离GitHub问题，以报告错误和功能。请记录YouTrack上的任何新请求。您必须登录以查看和日志问题，否则您将获得404。

社区

你有疑问吗？请随时请求邀请Kotlinlang Slack，并在我们的#POCT频道加入项目对话。

拉请求

我们积极欢迎您的拉力请求。但是，将您的工作与现有问题联系起来是首选。

分叉存储库，并从Main创建您的分支。
将您的分支命名为描述您正在做的工作的东西。 IE添加了新的东西。
如果您添加了应该测试的代码，请添加测试并确保测试套件通过。
确保您解决任何棉绒警告。
如果您使现有代码更好，请在您的公关描述中告诉我们。

有关更多详细信息，请参见贡献指南。

例子

SQL DSL

导入org.jetbrains.spard.sql。 id“，10）val名称：列<string> = varchar（“名称”，长度= 50）val CityId：列<int？> =（integer（“ city_id”）参考cities.id）.nullable（）overtride val primarykey = primarykey = primarykey（id，names =“ pk_user_id”）// name name s extional} objional} object object object object object object cities：table（table）（table） ）{val id：column <int> = integer（“ id”）。 50）覆盖val primary = primarykey（id，name =“ pk_cities_id”）
} fun main（）{database.connect（“ jdbc：h2：mem：test”，driver =“ org.h2.driver”，用户=“ root”，password =“”）

    交易 {
        addlogger（stdoutsqllogger）schemautils.create（城市，用户）val saintpetersburgid = cities.insert {
            它[name] =“圣彼得堡”}获取城市。
            it [name] =“慕尼黑”}获取城市。
            it.update（name，stringLiteral（“ prague”）.trim（）。子字符串（1，2））
        } [cities.id] val praguename = cities.Selectall（）。其中{cities.id eq pragueid} .single（）[cities .oname] println（“ pragueName = $ pragueName = $ pragueName”）userer.insert.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] =慕尼黑
        } users.insert {
            it [id] =“ Alex” it [name] =“ Alex” it [users.cityid] = null} users.insert {
            it [id] =“ smth” it [name] =“ shotse” it [users.cityid] = null} users.update（{users.id eq'alex'}）{
            IT [name] =“ Alexey”} users.deletewhere {users.name suke like“％thing'} println（“所有城市：”）（cities in cities in cities in corit.Selectall（））{println（“ $ {$ {city [city [cities cities。 id]}：$ {city [cities.name]}”）
        } println（“手动加入：”）

                （用户Innerjoin Cities）
            .SELECT（users.name，cities.name）
            。在哪里 {
                （users.id.eq（“ andrey”）或users.name.eq（“ sergey”）andusers.id.eq（“ sergey”）和users.cityid.eq（cities.id）
            } .foreach {println（“ $ {it [users.name]}}生活在$ {it [cities.name]}”）
             } println（“加入外键：”）

        （用户Innerjoin Cities）
            .SELECT（users.name，users.cityid，cities.name）
            。
            。
                 } else {println（“ $ {it [users.name]}
                 }
             } println（“功能和组：”）

        （（城市Innerjoins用户）
            选择（cities.name，users.id.count（））
            .groupby（cities.name）
            。 ）
                } else {println（“没有人生活在$ cityname中”）
                }
            } schemautils.drop（用户，城市）
    }
}

生成的SQL：

    SQL：创建表（如果不存在）（ID int auto_increment，name varchar（50）而不是null，约束pk_cities_id primary键（id））
    SQL：创建表如果不存在（ID VARCHAR（10），name varChar（50）不是null，city_id int null，约束pk_user_id primary键（id），约束FK_USERS_CITY_CITY_ID_ID_ID foreferial efirter（city_id）在更新限制中）
    SQL：插入城市（名称）价值观（'St. Petersburg'）
    SQL：插入城市（名称）值（'慕尼黑'）
    SQL：插入城市（名称）值（substring（trim（'rague'），1，2））
    sql：select cities.id，cities.name。来自cities.id = 3praguename = pr的城市
    SQL：插入用户（id，name，city_id）值（'andrey'，'andrey'，1）
    SQL：插入用户（id，name，city_id）值（'Sergey'，'Sergey'，2）
    SQL：插入用户（id，name，city_id）值（'eugene'，'eugene'，2）
    SQL：插入用户（id，name，city_id）values（'Alex'，'Alex'，null）
    SQL：插入用户（id，name，city_id）values（'smth'，'sosings'，null）
    sql：更新用户设置名称='lexey'where users.id ='alex'sql：从用户中删除用户。
    SQL：Select Cities.ID，城市。来自城市的名称1：St. Petersburg2：Munich3：PR
    手册加入：
    sql：select users.name，cities.name来自用户内在cities.id = user.city_id where（（users.id ='andrey'））或（users.name ='sergey'））和（users.id.id ='Sergey'）和（user.city_id = cities.id）
    Sergey用外国钥匙居住在慕尼黑：
    sql：选择user.name，user.city_id，cities.name。来自用户内在的城市上的城市。
    安德烈住在圣彼得堡
    功能和组：
    SQL：Select Cities.Name，Count（user.ID）来自Cities Inner in cities.id = users.city_id group by cities.name1 user（s）live（s） ）在慕尼黑
    SQL：如果存在用户，则DROV表
    SQL：如果存在城市

道

导入org.jetbrains.exposed.dao。 .transactions.transactionObject用户：Intidtable（）{val name = varchar（“ name”，50）.index（）val City =参考（“城市”，城市）val age = integer（“ age”）
}对象城市：intidtable（）{val name = varchar（“名称”，50）
} class用户（id：entityId <int>）：意向（id）{companion object：intentityClass <user>（用户）用户var name by User.namevar City by city city referendeon用户。用户cityvar age.age.age。
} class City（ID：ENTITYID <int>）：意图（ID）{companion object：intentityClass <City>（城市）var by cities.nameval用户用户推荐用户users.nameval用户。
} fun main（）{database.connect（“ jdbc：h2：mem：test”，driver =“ org.h2.driver”，用户=“ root”，password =“”）

    交易 {
        addlogger（stdoutsqllogger）schemautils.create（城市，用户）val stpete = city.new {
            name =“圣彼得堡”}瓦尔·慕尼黑=城市。
            name =“慕尼黑”} user.new {
            name =“ a” a = stpete
            年龄= 5} user.new {
            name =“ b” city = stpete
            年龄= 27} user.new {
            名称=“ C”城市=慕尼黑
            age = 42} println（“ coities：$ {city.all（）。introsostring {it.name}}”）println（“ $ {stpete.name}中的用户：$ {stpete.users.jointostring {it.name} }”）println（“成人：$ {user.find {users.age greatereq 18} .jointostring {it.name}}”）
    }
}

生成的SQL：

    SQL：创建表格（如果不存在）（ID int auto_increment主键，name varchar（50）不是null）
    SQL：创建表如果不存在（ID int auto_increment primary键，name varchar（50）不是null，city int int int int not null，age int not null，限制fk_users_city__id forefertion foreferions forefrence foreference coreforences coreforess cories（id）delete delete限制更新的限制限制）
    SQL：在用户（名称）上创建index user_name
    SQL：插入城市（名称）价值观（'St. Petersburg'）
    SQL：插入城市（名称）值（'慕尼黑'）
    SQL：选择Cities.ID，城市。
    城市：慕尼黑圣彼得堡
    SQL：插入用户（名称，城市，年龄）值（'a'，1，5）
    SQL：插入用户（名称，城市，年龄）值（'B'，1，27）
    SQL：插入用户（名称，城市，年龄）值（'C'，2，42）
    sql：选择用户。
    sql：select users.id，user.name，user.city，users。从用户中的用户。