JarCasting
JarCasting JarCasting

jOOQ Test Kotlin

jOOQ effectively combines complex SQL, typesafety, source code generation, active records, stored procedures, advanced data types, and Java in a fluent, intuitive DSL.

License

License
Categories

Categories

Kotlin Languages jOOQ Data Databases
GroupId

GroupId

org.jooq
ArtifactId

ArtifactId

jooq-test-kotlin
Last Version

Last Version

3.12.4
Release Date

Release Date
Type

Type

jar
Description

Description

jOOQ Test Kotlin
jOOQ effectively combines complex SQL, typesafety, source code generation, active records, stored procedures, advanced data types, and Java in a fluent, intuitive DSL.

Download jooq-test-kotlin

Filename Size
jooq-test-kotlin-3.12.4.pom
jooq-test-kotlin-3.12.4.jar 23 KB
jooq-test-kotlin-3.12.4-sources.jar 15 KB
jooq-test-kotlin-3.12.4-javadoc.jar 204 KB
Browse

How to add to project

<!-- https://jarcasting.com/artifacts/org.jooq/jooq-test-kotlin/ -->
<dependency>
    <groupId>org.jooq</groupId>
    <artifactId>jooq-test-kotlin</artifactId>
    <version>3.12.4</version>
</dependency>
// https://jarcasting.com/artifacts/org.jooq/jooq-test-kotlin/
implementation 'org.jooq:jooq-test-kotlin:3.12.4'
// https://jarcasting.com/artifacts/org.jooq/jooq-test-kotlin/
implementation ("org.jooq:jooq-test-kotlin:3.12.4")
'org.jooq:jooq-test-kotlin:jar:3.12.4'
<dependency org="org.jooq" name="jooq-test-kotlin" rev="3.12.4">
  <artifact name="jooq-test-kotlin" type="jar" />
</dependency>
@Grapes(
@Grab(group='org.jooq', module='jooq-test-kotlin', version='3.12.4')
)
libraryDependencies += "org.jooq" % "jooq-test-kotlin" % "3.12.4"
[org.jooq/jooq-test-kotlin "3.12.4"]

Dependencies

compile (8)

Group / Artifact Type Version
org.jetbrains.kotlin : kotlin-stdlib-jdk8 jar 1.3.41
org.jetbrains.kotlin : kotlin-reflect jar 1.3.41
org.jooq : jooq jar 3.12.4
org.jooq : jooq-meta jar 3.12.4
org.jooq : jooq-meta-extensions jar 3.12.4
org.jooq : jooq-codegen jar 3.12.4
org.jooq : jooq-test jar 3.12.4
com.h2database : h2 jar 1.4.199

test (1)

Group / Artifact Type Version
junit : junit jar 4.12

Project Modules

There are no modules declared in this project.

jOOQ's reason for being - compared to JPA

Java and SQL have come a long way. SQL is an "ancient", yet established and well-understood technology. Java is a legacy too, although its platform JVM allows for many new and contemporary languages built on top of it. Yet, after all these years, libraries dealing with the interface between SQL and Java have come and gone, leaving JPA to be a standard that is accepted only with doubts, short of any surviving options.

So far, there had been only few database abstraction frameworks or libraries, that truly respected SQL as a first class citizen among languages. Most frameworks, including the industry standards JPA, EJB, Hibernate, JDO, Criteria Query, and many others try to hide SQL itself, minimising its scope to things called JPQL, HQL, JDOQL and various other inferior query languages

jOOQ has come to fill this gap.

jOOQ's reason of being - compared to LINQ

Other platforms incorporate ideas such as LINQ (with LINQ-to-SQL), or Scala's SLICK, or also Java's QueryDSL to better integrate querying as a concept into their respective language. By querying, they understand querying of arbitrary targets, such as SQL, XML, Collections and other heterogeneous data stores. jOOQ claims that this is going the wrong way too.

In more advanced querying use-cases (more than simple CRUD and the occasional JOIN), people will want to profit from the expressivity of SQL. Due to the relational nature of SQL, this is quite different from what object-oriented and partially functional languages such as C#, Scala, or Java can offer.

It is very hard to formally express and validate joins and the ad-hoc table expression types they create. It gets even harder when you want support for more advanced table expressions, such as pivot tables, unnested cursors, or just arbitrary projections from derived tables. With a very strong object-oriented typing model, these features will probably stay out of scope.

In essence, the decision of creating an API that looks like SQL or one that looks like C#, Scala, Java is a definite decision in favour of one or the other platform. While it will be easier to evolve SLICK in similar ways as LINQ (or QueryDSL in the Java world), SQL feature scope that clearly communicates its underlying intent will be very hard to add, later on (e.g. how would you model Oracle's partitioned outer join syntax? How would you model ANSI/ISO SQL:1999 grouping sets? How can you support scalar subquery caching? etc...).

jOOQ has come to fill this gap.

jOOQ is different

SQL was never meant to be abstracted. To be confined in the narrow boundaries of heavy mappers, hiding the beauty and simplicity of relational data. SQL was never meant to be object-oriented. SQL was never meant to be anything other than... SQL!

For more details please visit jooq.org.

Follow jOOQ on Twitter and the jOOQ blog.

org.jooq

jOOQ Object Oriented Querying

Versions

Version
3.12.4