[JAVA] Erste Schritte mit dem Doma-Criteria API Cheet Sheet

Hinweis

Dieser Spickzettel ist für die ** Kriterien-API für Java ** vorgesehen. Die Kotlin-Version des Spickzettel finden Sie unter Einführung in das Doma-Kotlin-Kriterien-API-Cheet Sheet.

Annahme

Die Version von Doma ist 2.43.0. Eine Übersicht über die Kriterien-API finden Sie unter Einführung in Doma. Die von mir verwendete Java-Version ist 8.

Angenommen, die Entitätsklassen "Mitarbeiter" und "Abteilung" sind definiert.

Außerdem wird davon ausgegangen, dass folgende Variablen definiert sind.

Entityql entityql = new Entityql(config);
Nativesql nativeSql = new NativeSql(config);

Employee_ e = new Employee_();
Department_ d = new Department_();

Das Beispiel SQL kann von dem abweichen, was tatsächlich generiert wird.

Prinzip der ordnungsgemäßen Verwendung von Entityql und NativeSql

Bei Verwendung von Entityql

Bei Verwendung von NativeSql

Suche

Suche alle

List<Employee> list = entityql.from(e).fetch();
// select * from employee t0_

1 Suche

Gibt null zurück, wenn es nicht existiert.

Employee employee = entityql.from(e).where(c -> c.eq(e.id, 1)).fetchOne();
// select * from employee t0_ where t0_.id = ?

Gibt Optional.empty () zurück, wenn es nicht existiert.

Optional<Employee> employee = entityql.from(e).where(c -> c.eq(e.id, 1)).fetchOptional();
// select * from employee t0_ where t0_.id = ?

Stream-Suche

Verarbeiten Sie große Datenmengen nacheinander, ohne den Speicher zu belasten.

String names = nativeSql.from(e).mapStream(stream -> 
  stream.map(Employee::getName).collect(Collectors.joining(","))
);
// select * from employee t0_

Suche sammeln

Stream-Suchverknüpfung.

Map<Integer, List<Employee>> map = nativeSql.from(e).collect(Collectors.groupingBy(Employee::getDepartmentId));
// select * from employee t0_

Das Obige entspricht dem folgenden Code.

Map<Integer, List<Employee>> map = nativeSql.from(e).mapStream(stream -> 
  stream.collect(Collectors.groupingBy(Employee::getDepartmentId))
);
// select * from employee t0_

Projektion

Gibt das Ergebnis als Tapple-Klasse zurück.

List<Tuple2<String, Integer>> list = nativeSql.from(e).select(e.name, e.age).fetch();
// select t0_.name, t0_.age from employee t0_

Gibt das Ergebnis als Entitätsklasse zurück. Der Primärschlüssel ist immer in der SELECT-Klausel enthalten und wird auch in der Entität festgelegt.

List<Employee> list = entityql.from(e).selectTo(e, e.name, e.age).fetch();
// select t0_.id, t0_.name, t0_.age from employee t0_

Sortieren

List<Employee> list = entityql.from(e).orderBy(c -> {
  c.asc(e.name);
  c.desc(e.age);
}).fetch();
// select * from employee t0_ order by t0_.name asc, t0_.age desc

Doppelte Zeilen ausschließen

List<String> list = nativeSql.from(e).distinct().select(e.name).fetch();
// select distinct t0_.name from employee t0_

Limit/Offset

List<Employee> list = entityql.from(e).limit(10).offset(3).fetch();
// select * from employee t0_ limit 10 offset 3

Pessimistisches Schloss

List<Employee> list = entityql.from(e).forUpdate().fetch();
// select * from employee t0_ for update

Anhäufung

Als Aggregatfunktionen können Sie "avg", "count", "countDistinct", "max", "min" und "sum" verwenden, die in "org.seasar.doma.jdbc.criteria.expression.Expressions" definiert sind. ..

Integer integer = nativeSql.from(e).select(Expressions.sum(e.age)).fetchOne();
// select sum(t0_.age) from employee t0_

Aggregation nach Gruppen

List<Tuple2<Integer, Long>> list = nativeSql.from(e).groupBy(e.departmentId).select(e.departmentId, Expressions.count()).fetch();
// select t0_.department_id, count(*) from employee t0_ group by t0_.department_id

Wenn die Methode "groupBy" nicht aufgerufen wird, wird die für die GROUP BY-Klausel erforderliche Spalte aus der in der Methode "select" angegebenen Eigenschaft abgeleitet und automatisch zugewiesen. Daher generiert der folgende Code SQL, das dem oben genannten entspricht.

List<Tuple2<Integer, Long>> list = nativeSql.from(e).select(e.departmentId, Expressions.count()).fetch();
// select t0_.department_id, count(*) from employee t0_ group by t0_.department_id

Eingrenzen der aggregierten Ergebnisse für jede Gruppe

//Ermitteln Sie die Anzahl der Mitarbeiter in jeder Abteilung für Abteilungen mit mehr als 3 Mitarbeitern
List<Tuple2<Long, String>> list =
  nativeSql
    .from(e)
    .innerJoin(d, on -> on.eq(e.departmentId, d.id))
    .having(c -> c.gt(Expressions.count(), 3L))
    .select(Expressions.count(), d.name)
    .fetch();
// select count(*), t1_.name from employee t0_ inner join department t1_ on (t0_.department_id = t1_.id) group by t1_.name having count(*) > 3

Beitreten

Innere Verbindung

Es wird nur eine innere Verbindung hergestellt.

List<Employee> list = entityql.from(e).innerJoin(d, on -> on.eq(e.departmentId, d.id)).fetch();
// select t0_.* from employee t0_ inner join department t1_ on (t0_.department_id = t1_.id)

Inner verbinden und verwandte Entitäten erhalten.

List<Employee> list = entityql.from(e).innerJoin(d, on -> on.eq(e.departmentId, d.id)).associate(e, d, (employee, department) {
  employee.setDepartment(department);
  department.getEmployees().add(employee);
}).fetch();
// select * from employee t0_ inner join department t1_ on (t0_.department_id = t1_.id)

Äußere Verbindung

Es wird nur eine äußere Verknüpfung durchgeführt.

List<Employee> list = entityql.from(e).leftJoin(d, on -> on.eq(e.departmentId, d.id)).fetch();
// select t0_.* from employee t0_ left outer join department t1_ on (t0_.department_id = t1_.id)

Äußerer Beitritt und auch verwandte Entitäten.

List<Employee> list = entityql.from(e). leftJoin(d, on -> on.eq(e.departmentId, d.id)).associate(e, d, (employee, department) {
  employee.setDepartment(department);
  department.getEmployees().add(employee);
}).fetch();
// select * from employee t0_ left outer join department t1_ on (t0_.department_id = t1_.id)

Selbstbindung

Sie können dieselben Tabellen mit verschiedenen Instanzen desselben Metamodells verknüpfen (selbst verknüpfen).

Employee_ m = new Employee_();

List<Employee> list = entityql.from(e).leftJoin(m, on -> on.eq(e.managerId, m.id)).fetch();
// select t0_.* from employee t0_ left outer join employee t1_ on (t0_.manager_id = t1_.id)

Sie können auch verwandte Entitäten abrufen.

Employee_ m = new Employee_();

List<Employee> list = entityql.from(e).leftJoin(m, on -> on.eq(e.managerId, m.id)).associate(e, m, (employee, manager) {
  employee.setManager(manager);
}).fetch();
// select * from employee t0_ left outer join employee t1_ on (t0_.manager_id = t1_.id)

UNION

List<Tuple2<Integer, String>> list =
  nativeSql
    .from(e)
    .select(e.id, e.name)
    .union(nativeSql.from(d).select(d.id, d.name))
    .fetch();
// select t0_.id, t0_.name from employee t0_ union select t0_.id, t0_.name from department t0_

Geben Sie zum Sortieren die Zielspalte nach Index an. Index beginnt bei 1.

List<Tuple2<Integer, String>> list =
  nativeSql
    .from(e)
    .select(e.id, e.name)
    .union(nativeSql.from(d).select(d.id, d.name))
    .orderBy(c -> c.asc(2))
    .fetch();
// (select t0_.id, t0_.name from employee t0_) union (select t0_.id, t0_.name from department t0_) order by 2 asc

Sie können auch UNION ALL.

List<Tuple2<Integer, String>> list =
  nativeSql
    .from(e)
    .select(e.id, e.name)
    .unionAll(nativeSql.from(d).select(d.id, d.name))
    .fetch();
// select t0_.id, t0_.name from employee t0_ union all select t0_.id, t0_.name from department t0_

hinzufügen

1 hinzugefügt

Employee employee = ...;
entityql.insert(e, employee).execute();
// insert into employee (id, name, age, version) values (?, ?, ?, ?)

Charge hinzufügen

List<Employee> employees = ...;
entityql.insert(e, employees).execute();
// insert into employee (id, name, age, version) values (?, ?, ?, ?)

Suchergebnisse hinzufügen

Mehrere Elemente zu einer anderen Tabelle mit derselben Datenstruktur hinzugefügt.

Department_ da = new Department_("DEPARTMENT_ARCHIVE");

nativeSql.insert(da).select(c -> c.from(d).where(cc -> cc.in(d.id, Arrays.asList(1, 2)))).execute();
// insert into department_archive (id, name, version) select t0_.id, t0_.name, t0_.version from department t0_ where t0_.id in (1, 2)

aktualisieren

1 Update

Employee employee = ...;
entityql.update(e, employee).execute();
// update employee set name = ?, age = ?, version = ? + 1 where id = ? and version = ?

Batch-Update

List<Employee> employees = ...;
entityql.update(e, employees).execute();
// update employee set name = ?, age = ?, version = ? + 1 where id = ? and version = ?

Mehrere Elemente wurden aktualisiert, die bestimmten Bedingungen entsprechen

nativeSql
  .update(e)
  .set(c -> c.value(e.departmentId, 3))
  .where(
    c -> {
      c.eq(e.managerId, 3);
      c.lt(e.age, 30);
    })
    .execute();
// update employee t0_ set department_id = ? where t0_.manager_id = ? and t0_.age < ?

Aktualisiert mit dem Berechnungsergebnis in SQL

nativeSql
  .update(e)
  .set(c -> {
    c.value(e.name, Expressions.concat("[", Expressions.concat(e.name, "]")));
    c.value(e.age, Expressions.add(e.age, 1));
  })
  .where(c -> c.eq(e.id, 1))
  .execute();
// update employee t0_ set name = concat(?, concat(t0_.name, ?)), age = (t0_.age + ?) where t0_.id = ?

Löschen

Löschen 1

Employee employee = ...;
entityql.delete(e, employee).execute();
// delete from employee where id = ? and version = ?

Batch löschen

List<Employee> employees = ...;
entityql.delete(e, employees).execute();
// delete from employee where id = ? and version = ?

Löschen Sie mehrere Elemente, die bestimmten Bedingungen entsprechen

nativeSql.delete(e).where(c -> c.ge(e.age, 50)).execute();
// delete from employee t0_ where t0_.age >= ?

Suchbedingungen, die in der WHERE-Klausel angegeben werden können

Vergleichsberechnung

=

entityql.from(e).where(c -> c.eq(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age = ?

<>

entityql.from(e).where(c -> c.ne(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age <> ?

entityql.from(e).where(c -> c.gt(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age > ?

=

entityql.from(e).where(c -> c.ge(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age >= ?

<

entityql.from(e).where(c -> c.lt(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age < ?

<=

entityql.from(e).where(c -> c.le(e.age, 20)).fetch();
// select * from employee t0_ where t0_.age <= ?

IS NULL

entityql.from(e).where(c -> c.isNull(e.age)).fetch();
// select * from employee t0_ where t0_.age is null

IS NOT NULL

entityql.from(e).where(c -> c.isNotNull(e.age)).fetch();
// select * from employee t0_ where t0_.age is not null

= Oder IST NULL

Generieren = wenn age nicht null ist.

entityql.from(e).where(c -> c.eqOrIsNull(e.age, age)).fetch();
// select * from employee t0_ where t0_.age = ?

Generiere IS NULL, wenn age null ist.

entityql.from(e).where(c -> c.eqOrIsNull(e.age, age)).fetch();
// select * from employee t0_ where t0_.age is null

<> Oder IST NICHT NULL

Generieren Sie <>, wenn age nicht null ist.

entityql.from(e).where(c -> c.neOrIsNotNull(e.age, age)).fetch();
// select * from employee t0_ where t0_.age <> ?

Generieren IST NICHT NULL, wenn age null ist.

entityql.from(e).where(c -> c.neOrIsNotNull(e.age, age)).fetch();
// select * from employee t0_ where t0_.age is not null

LIKE

Ein LIKE-Prädikat, das nichts verarbeitet.

entityql.from(e).where(c -> c.like(e.name, "A%")).fetch();
// select * from employee t0_ where t0_.name like ?
// select * from employee t0_ where t0_.name like 'A%' (Gebundenes SQL)

LIKE Prädikat für Präfixübereinstimmung. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.like(e.name, "A%", LikeOption.prefix())).fetch();
// select * from employee t0_ where t0_.name like ? escape '$'
// select * from employee t0_ where t0_.name like 'A$%%' escape '$'　(Gebundenes SQL)

WIE Prädikat für Zwischenmatch. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.like(e.name, "A%", LikeOption.infix())).fetch();
// select * from employee t0_ where t0_.name like ? escape '$'
// select * from employee t0_ where t0_.name like '%A$%%' escape '$' (Gebundenes SQL)

LIKE Prädikat für Suffix-Match. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.like(e.name, "A%", LikeOption.suffix())).fetch();
// select * from employee t0_ where t0_.name like ? escape '$'
// select * from employee t0_ where t0_.name like '%A$%' escape '$' (Gebundenes SQL)

NOT LIKE

NICHT WIE Prädikat ohne Verarbeitung.

entityql.from(e).where(c -> c.notLike(e.name, "A%")).fetch();
// select * from employee t0_ where t0_.name not like ?
// select * from employee t0_ where t0_.name not like 'A%' (Gebundenes SQL)

NICHT WIE Prädikat für Präfixübereinstimmung. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.notLike(e.name, "A%", LikeOption.prefix())).fetch();
// select * from employee t0_ where t0_.name not like ? escape '$'
// select * from employee t0_ where t0_.name not like 'A$%%' escape '$' (Gebundenes SQL)

NICHT WIE Prädikat für Zwischenmatch. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.notLike(e.name, "A%", LikeOption.infix())).fetch();
// select * from employee t0_ where t0_.name not like ? escape '$'
// select * from employee t0_ where t0_.name not like '%A$%%' escape '$' (Gebundenes SQL)

NICHT WIE Prädikat für Suffix-Übereinstimmung. Platzhalter werden entkommen.

entityql.from(e).where(c -> c.notLike(e.name, "A%", LikeOption.suffix())).fetch();
// select * from employee t0_ where t0_.name not like ? escape '$'
// select * from employee t0_ where t0_.name not like '%A$%' escape '$' (Gebundenes SQL)

BETWEEN

entityql.from(e).where(c -> c.between(e.age, 20, 30)).fetch();
// select * from employee t0_ where t0_.age between ? and ?

IN

Ein einfaches IN-Prädikat.

entityql.from(e).where(c -> c.in(e.age, Arrays.asList(10, 20))).fetch();
// select * from employee t0_ where t0_.age in (?, ?)

IN Prädikat mit Tapple.

entityql.from(e).where(c -> c.in(new Tuple2(e.age, e.salary), Arrays.asList(new Tuple2(10, 1000), new Tuple2(20, 2000)))).fetch();
// select * from employee t0_ where (t0_.age, t0_.salary) in ((?, ?), (?, ?))

IN-Prädikat mit Unterabfrage.

entityql.from(e).where(c -> c.in(e.departmentId, c.from(d).select(d.id))).fetch();
// select * from employee t0_ where t0_.department_id in (select t1_.id from department t1_)

NOT IN

Ein einfaches NOT IN-Prädikat.

entityql.from(e).where(c -> c.notIn(e.age, Arrays.asList(10, 20))).fetch();
// select * from employee t0_ where t0_.age not in (?, ?)

NICHT IN Prädikat mit Tapple.

entityql.from(e).where(c -> c.notIn(new Tuple2(e.age, e.salary), Arrays.asList(new Tuple2(10, 1000), new Tuple2(20, 2000)))).fetch();
// select * from employee t0_ where (t0_.age, t0_.salary) not in ((?, ?), (?, ?))

NOT IN Prädikat mit Unterabfrage.

entityql.from(e).where(c -> c.notIn(e.departmentId, c.from(d).select(d.id))).fetch();
// select * from employee t0_ where t0_.department_id not in (select t1_.id from department t1_)

EXISTS

entityql.from(e).where(c -> c.exists(c.from(d).where(c2 -> c2.eq(e.departmentId, d.id))).fetch();
// select * from employee t0_ where exists (select * from department t1_ where t0_.deparment_id = t1_.id)

Logische Operation

AND

entityql.from(e).where(c -> {
  c.eq(e.age, 20);
  c.ge(e.salary, 100000);
  c.lt(e.salary, 200000);
}).fetch();
// select * from employee t0_ where t0_.age = ? and t0_.salary >= ? and t0_.salary < ?

OR

entityql.from(e).where(c -> {
  c.eq(e.age, 20);
  c.or(() -> {
    c.ge(e.salary, 100000);
    c.lt(e.salary, 200000);
  });
}).fetch();
// select * from employee t0_ where t0_.age = ? or (t0_.salary >= ? and t0_.salary < ?)

NOT

entityql.from(e).where(c -> {
  c.eq(e.age, 20);
  c.not(() -> {
    c.ge(e.salary, 100000);
    c.lt(e.salary, 200000);
  });
}).fetch();
// select * from employee t0_ where t0_.age = ? and not (t0_.salary >= ? and t0_.salary < ?)

Ausdrücke für Spalten

wörtlich

Betten Sie den Wert unverändert in SQL ein, ohne Bindungsvariablen zu verwenden. Es werden nur die Typen unterstützt, die von der "litera" -Methode von "org.seasar.doma.jdbc.criteria.expression.Expressions" akzeptiert werden.

List<Employee> list = entityql.from(e).where(c -> c.eq(e.id, Expressions.literal(10))).fetch();
// select * from employee t0_ where t0_.id = 10

Arithmetik

Für arithmetische Operationen können Sie "add", "sub", "mul", "div", "mod" usw. verwenden, die in "org.seasar.doma.jdbc.criteria.expression.Expressions" definiert sind.

List<String> list = nativeSql.from(e).select(Expressions.add(e.age, 10)).fetch();
// select (t0_.age + ?) from employee t0_

String-Funktion

Zu den String-Funktionen gehören "concat", "lower", "superior", "trim", "ltrim" und "rtrim", die in "org.seasar.doma.jdbc.criteria.expression.Expressions" definiert sind. Kann verwendet werden.

List<String> list = nativeSql.from(e).select(Expressions.lower(e.name)).fetch();
// select lower(t0_.name) from employee t0_

CASE-Ausdruck

List<Tuple2<String, String>> list =
  nativeSql
    .from(e)
    .select(
      e.name,
      Expressions.when(
        c -> {
          c.lt(e.age, Expressions.literal(10), Expressions.literal("A"));
          c.lt(e.age, Expressions.literal(20), Expressions.literal("B"));
          c.lt(e.age, Expressions.literal(30), Expressions.literal("C"));
      },
      Expressions.literal("D")))
      .fetch();
// select t0_.name, case when t0_.age < 10 then 'A' when t0_.age < 20 then 'B' when t0_.age < 30 then 'C' else 'D' end from EMPLOYEE t0_

Recommended Posts

Erste Schritte mit dem Doma-Criteria API Cheet Sheet
Erste Schritte mit DBUnit
Erste Schritte mit Ruby
Erste Schritte mit Swift
Erste Schritte mit Doma-Transaktionen
Erste Schritte mit der Doma-Projektion mit der Criteira-API
Erste Schritte mit Doma-Using Joins mit der Criteira-API
Erste Schritte mit Doma-Einführung in die Kriterien-API
Erste Schritte mit der Verarbeitung von Doma-Annotationen
Erste Schritte mit Java Collection
Java Stream API Spickzettel
Erste Schritte mit JSP & Servlet
Erste Schritte mit Java Basics
Erste Schritte mit Spring Boot
Erste Schritte mit Ruby-Modulen
Erste Schritte mit Doma-Dynamic Erstellen von WHERE-Klauseln mit der Kriterien-API
Erste Schritte mit Reactive Streams und der JDK 9 Flow API
Erste Schritte mit Java_Kapitel 5_Praktische Übungen 5_4
[Google Cloud] Erste Schritte mit Docker
Erste Schritte mit Docker mit VS-Code
Erste Schritte mit Ruby für Java-Ingenieure
Erste Schritte mit Docker für Mac (Installation)
Einführung in den Parametrisierungstest in JUnit
Einführung in Java ab 0 Teil 1
Erste Schritte mit Ratpack (4) -Routing & Static Content
Beginnen Sie mit der Funktionsweise von JVM GC
Erste Schritte mit dem Language Server Protocol mit LSP4J
Erste Schritte mit dem Erstellen von Ressourcenpaketen mit ListResoueceBundle
Erste Schritte mit Java_Kapitel 8_Über "Instanzen" und "Klassen"
Java Spickzettel
Links & Memos für den Einstieg in Java (für mich)
JMeter Spickzettel
Erste Schritte mit Java 1 Ähnliche Dinge zusammenstellen
Erste Schritte mit Kotlin zum Senden an Java-Entwickler
Kotlin Spickzettel
[Docker Spickzettel]
Ich habe versucht, mit Gradle auf Heroku zu beginnen
Erste Schritte mit Java-Programmen mit Visual Studio Code
Erste Schritte mit älteren Java-Ingenieuren (Stream + Lambda)
Mockito + PowerMock Spickzettel
Kompatibel mit Android 10 (API 29)
Eclipse Sammlungen Cheet Sheet
Schienen Tutorial Cheet Sheet
Spring Boot2 Spickzettel
SCSS Notation Spickzettel
Beginnen Sie mit Gradle
Docker Befehl Spickzettel
Erste Schritte mit Java und Erstellen eines Ascii Doc-Editors mit JavaFX
Jetzt ist es an der Zeit, mit der Stream-API zu beginnen
Erste Schritte mit der Git Hub Container Registry anstelle von Docker Hub