Merge pull request #27 from domaframework/feat/query-dsl

Use QueryDsl instead of Entityql and NativeSql

Author: nakamura-to

docs/criteria-api.rst

@@ -14,11 +14,6 @@ Introduction
     DSLs explained here. 
     The Query DSL is a new, unified interface that combines both Entityql and NativeSql DSLs.
 
-.. note::
-
-    In Kotlin environment, use Kotlin specific DSLs instead of the following DSLs.
-    See :ref:`kotlin-specific-criteria-api`.
-
 There are two kinds of DSLs in the Criteria API:
 
 * The Entityql DSL

docs/faq.rst

@@ -129,7 +129,7 @@ There are two ways:
 * The SQL Templates.
 * The Criteria API.
 
-See :doc:`sql` and :doc:`criteria-api` for detail information.
+See :doc:`sql` and :doc:`query-dsl` for detail information.
 
 Does Doma support fetching relationships like one-to-one or one-to-many?
 ----------------------------------------------------------------------------------------
@@ -138,7 +138,7 @@ Yes.
 
 Doma provides the Criteria API to map database relationships to Java entities.
 
-See :ref:`criteria_associate` for detail information.
+See :ref:`query_dsl_associate` for detail information.
 
 Does Doma provide a JDBC connection pooling feature?
 ----------------------------------------------------

docs/getting-started.rst

@@ -94,12 +94,12 @@ To execute a SELECT query and retrieve Java object results, follow this example:
 
   public Employee selectById(Integer id) {
     var e = new Employee_();
-    return entityql.from(e).where(c -> c.eq(e.id, id)).fetchOne();
+    return queryDsl.from(e).where(c -> c.eq(e.id, id)).fetchOne();
   }
 
 You'll use a metamodel class, like ``Employee_`` for ``Employee``, which is auto-generated through annotation processing. 
 
-The ``entityql`` instance from the ``Entityql`` class serves as the Criteria API's starting point. 
+The ``queryDsl`` instance from the ``QueryDsl`` class serves as the Criteria API's starting point. 
 
 The above code generates the following SQL statement:
 
@@ -116,7 +116,7 @@ To issue a DELETE statement, write as follows:
 
   public void delete(Employee employee) {
     var e = new Employee_();
-    entityql.delete(e, employee).execute();
+    queryDsl.delete(e).single(employee).execute();
   }
 
 INSERT
@@ -128,7 +128,7 @@ To issue an INSERT statement, write as follows:
 
   public void insert(Employee employee) {
     var e = new Employee_();
-    entityql.insert(e, employee).execute();
+    queryDsl.insert(e).single(employee).execute();
   }
 
 UPDATE
@@ -140,7 +140,7 @@ To issue an UPDATE statement, write as follows:
 
   public void update(Employee employee) {
     var e = new Employee_();
-    entityql.update(e, employee).execute();
+    queryDsl.update(e).single(employee).execute();
   }
 
 DAO style

docs/kotlin-support.rst

@@ -100,38 +100,16 @@ Kotlin specific Criteria API
 
     Prefer the Kotlin specific Criteria API to DAO interfaces.
 
-Doma provides Kotlin specific Criteria API, ``KEntityql`` and ``KNativeSql`` DSLs.
-They are very similar with the ``Entityql`` and ``NativeSql`` DSLs, which are described in :doc:`criteria-api`.
-The biggest feature of the ``KEntityql`` and ``KNativeSql`` DSLs is simplicity.
-
-For example, when you use ``KEntityql``, you have to accept a lambda parameter in a WHERE expression as follows:
-
-.. code-block:: kotlin
-
-    val entityql = Entityql(config)
-    val e = Employee_()
-
-    val list = entityql
-        .from(e)
-        .where { c ->
-            c.eq(e.departmentId, 2)
-            c.isNotNull(e.managerId)
-            c.or {
-                c.gt(e.salary, Salary("1000"))
-                c.lt(e.salary, Salary("2000"))
-            }
-        }
-        .fetch()
-
-The lambda parameter ``c`` is a bit annoying.
-On the other hand, when you use ``KEntityql``, the parameter is gone.
+Doma provides ``KQueryDsl``, a Criteria API specifically for Kotlin.
+It is very similar with the ``QueryDsl``, which is described in :doc:`query-dsl`.
+The biggest feature of the ``KQueryDsl`` is simplicity.
 
 .. code-block:: kotlin
 
-    val entityql = KEntityql(config)
+    val queryDsl = KQueryDsl(config)
     val e = Employee_()
 
-    val list = entityql
+    val list = queryDsl
         .from(e)
         .where {
             eq(e.departmentId, 2)
@@ -143,9 +121,9 @@ On the other hand, when you use ``KEntityql``, the parameter is gone.
         }
         .fetch()
 
-You can see a lot of sample code `here <https://github.com/domaframework/doma-it/tree/master/kotlin/src/test/kotlin/org/seasar/doma/it/criteria>`_.
+You can see mode sample code `here <https://github.com/domaframework/kotlin-sample>`_.
 
-The ``KEntityql`` and ``KNativeSql`` DSLs are included in doma-kotlin.jar.
+The ``KQueryDsl`` is included in the doma-kotlin module.
 Note that you should depend on doma-kotlin instead of doma-core in your build script.
 You can write build.gradle.kts as follows: