sql limit 子句

功能編程允許使用通用語言進行準聲明性編程 。 通過使用功能強大的流暢API（例如Java 8的Stream API ）或jOOλ的順序Stream擴展Seq或更復雜的庫（例如javaslang或functionaljava） ，我們可以以一種非常簡潔的方式來表示數(shù)據轉換算法。 比較相同算法的Mario Fusco的命令式和功能式版本 ：

勢在必行–功能分離pic.twitter.com/G2cC6iBkDJ

— Mario Fusco（@mariofusco） 2015年3月1日

使用此類API，函數(shù)式編程肯定感覺就像是真正的聲明式編程。

最流行的真正的聲明式編程語言是SQL。 當聯(lián)接兩個表時，您不會告訴RDBMS如何實現(xiàn)該聯(lián)接。 它可以自行決定在完整查詢和所有可用元信息的上下文中，嵌套循環(huán)，合并聯(lián)接，哈希聯(lián)接或某種其他算法是否最合適。 這非常強大，因為對簡單連接有效的性能假設可能對復雜的連接不再有效，在復雜的連接上，其他算法的性能要優(yōu)于原始算法。 通過這種抽象，您可以輕松地在30秒內修改查詢，而不必擔心諸如算法或性能之類的底層細節(jié)。

當一個API允許您將兩者結合起來（例如jOOQ和Streams ）時，您將獲得兩個世界的精華-這些世界并沒有太大的不同。

在以下各節(jié)中，我們將比較常見SQL構造與使用Streams和jOOλ用Java 8編寫的等效表達式，以防Stream API沒有提供足夠的功能 。

元組

為了本文的方便，我們將假定SQL行/記錄在Java中具有等效的表示形式。 為此，我們將使用jOOλ的Tuple類型 ，該類型實質上是：

public class Tuple2<T1, T2> {public final T1 v1;public final T2 v2;public Tuple2(T1 v1, T2 v2) {this.v1 = v1;this.v2 = v2;} }

…以及很多有用的頭，例如“ Comparable Tuple等。

請注意，在此示例和所有后續(xù)示例中，我們假定以下導入。

import static org.jooq.lambda.Seq.*; import static org.jooq.lambda.tuple.Tuple.*;import java.util.*; import java.util.function.*; import java.util.stream.*;import org.jooq.lambda.*;

與SQL行很像，元組是“基于值”的類型 ，這意味著它實際上沒有標識。 兩個元組(1, 'A')和(1, 'A')可以被視為完全等效。 從游戲中刪除身份使具有不變數(shù)據結構SQL和函數(shù)式編程極為優(yōu)雅。

FROM = of（），stream（）等

在SQL中， FROM子句在邏輯上（但不是在語法上）位于所有其他子句之前。 它用于從至少一個表（可能是多個連接的表）生成一組元組。 例如，單表FROM子句可以簡單地映射到Stream.of() ，也可以映射到其他任何簡單地生成流的方法：

SQL

SELECT * FROM (VALUES(1, 1),(2, 2) ) t(v1, v2)

屈服

+----+----+ | v1 | v2 | +----+----+ | 1 | 1 | | 2 | 2 | +----+----+

Java

Stream.of(tuple(1, 1),tuple(2, 2) ).forEach(System.out::println);

屈服

(1, 1) (2, 2)

交叉聯(lián)接= flatMap（）

從多個表中進行選擇已經更加有趣。 在SQL中合并兩個表的最簡單方法是通過表列表或使用CROSS JOIN生成笛卡爾積。 以下兩個是等效SQL語句：

SQL

-- Table list syntax SELECT * FROM (VALUES( 1 ), ( 2 )) t1(v1), (VALUES('A'), ('B')) t2(v2)-- CROSS JOIN syntax SELECT * FROM (VALUES( 1 ), ( 2 )) t1(v1) CROSS JOIN (VALUES('A'), ('B')) t2(v2)

屈服

+----+----+ | v1 | v2 | +----+----+ | 1 | A | | 1 | B | | 2 | A | | 2 | B | +----+----+

在交叉聯(lián)接（或笛卡爾乘積）中，將t1中的每個值與t2每個值組合在一起，總共產生size(t1) * size(t2)行。

Java

在使用Java 8的Stream函數(shù)編程時， Stream.flatMap()方法對應于SQL CROSS JOIN如以下示例所示：

List<Integer> s1 = Stream.of(1, 2); Supplier<Stream<String>> s2 = ()->Stream.of("A", "B");s1.flatMap(v1 -> s2.get().map(v2 -> tuple(v1, v2))).forEach(System.out::println);

屈服

(1, A) (1, B) (2, A) (2, B)

請注意我們必須將第二個流包裝在Supplier因為流只能被使用一次 ，但是上述算法實際上實現(xiàn)了嵌套循環(huán)，將流s2所有元素與流s1每個元素組合在一起。 另一種選擇是不使用流而是使用列表（為簡單起見，我們將在隨后的示例中進行操作）：

List<Integer> s1 = Arrays.asList(1, 2); List<String> s2 = Arrays.asList("A", "B");s1.stream().flatMap(v1 -> s2.stream().map(v2 -> tuple(v1, v2))).forEach(System.out::println);

實際上， CROSS JOIN可以在SQL和Java中輕松鏈接：

SQL

-- Table list syntax SELECT * FROM (VALUES( 1 ), ( 2 )) t1(v1), (VALUES('A'), ('B')) t2(v2), (VALUES('X'), ('Y')) t3(v3)-- CROSS JOIN syntax SELECT * FROM (VALUES( 1 ), ( 2 )) t1(v1) CROSS JOIN (VALUES('A'), ('B')) t2(v2) CROSS JOIN (VALUES('X'), ('Y')) t3(v3)

屈服

+----+----+----+ | v1 | v2 | v3 | +----+----+----+ | 1 | A | X | | 1 | A | Y | | 1 | B | X | | 1 | B | Y | | 2 | A | X | | 2 | A | Y | | 2 | B | X | | 2 | B | Y | +----+----+----+

Java

List<Integer> s1 = Arrays.asList(1, 2); List<String> s2 = Arrays.asList("A", "B"); List<String> s3 = Arrays.asList("X", "Y");s1.stream().flatMap(v1 -> s2.stream().map(v2 -> tuple(v1, v2))).flatMap(v12-> s3.stream().map(v3 -> tuple(v12.v1, v12.v2, v3))).forEach(System.out::println);

屈服

(1, A, X) (1, A, Y) (1, B, X) (1, B, Y) (2, A, X) (2, A, Y) (2, B, X) (2, B, Y)

注意我們如何從第一個CROSS JOIN操作中顯式取消嵌套元組，以在第二個操作中形成“扁平”元組。 當然，這是可選的。

Java與jOOλ的crossJoin（）

我們jOOQ開發(fā)人員，我們是一個非常注重SQL的人員，因此為上述用例添加一個crossJoin()便捷方法是很自然的。 因此，我們的三重交叉聯(lián)接可以這樣寫：

Seq<Integer> s1 = Seq.of(1, 2); Seq<String> s2 = Seq.of("A", "B"); Seq<String> s3 = Seq.of("X", "Y");s1.crossJoin(s2).crossJoin(s3).forEach(System.out::println);

屈服

((1, A), X) ((1, A), Y) ((1, B), X) ((1, B), Y) ((2, A), X) ((2, A), Y) ((2, B), X) ((2, B), Y)

在這種情況下，我們并沒有嵌套在第一個交叉聯(lián)接中產生的元組。 僅從關系的角度來看，這都不重要。 嵌套元組與平面元組相同。 在SQL中，我們只是看不到嵌套。 當然，我們仍然可以通過添加一個附加的映射來嵌套：

Seq<Integer> s1 = Seq.of(1, 2); Seq<String> s2 = Seq.of("A", "B"); Seq<String> s3 = Seq.of("X", "Y");s1.crossJoin(s2).crossJoin(s3).map(t -> tuple(t.v1.v1, t.v1.v2, t.v2)).forEach(System.out::println);

再次屈服

(1, A, X) (1, A, Y) (1, B, X) (1, B, Y) (2, A, X) (2, A, Y) (2, B, X) (2, B, Y)

（您可能已經注意到map()對應于SELECT ，稍后我們將再次看到）

內部聯(lián)接= flatMap（）與filter（）

SQL INNER JOIN本質上只是SQL CROSS JOIN語法糖，其謂詞可減少CROSS JOIN后的元組集。 在SQL中，以下兩種內部聯(lián)接方式是等效的：

SQL

-- Table list syntax SELECT * FROM (VALUES(1), (2)) t1(v1), (VALUES(1), (3)) t2(v2) WHERE t1.v1 = t2.v2-- INNER JOIN syntax SELECT * FROM (VALUES(1), (2)) t1(v1) INNER JOIN (VALUES(1), (3)) t2(v2) ON t1.v1 = t2.v2

屈服

+----+----+ | v1 | v2 | +----+----+ | 1 | 1 | +----+----+

（請注意，關鍵字INNER是可選的）。

因此，“ t1的值2和“ t2 ”中的值3被“扔掉”，因為它們會產生聯(lián)接謂詞為true的任何行。

可以很容易地表達相同的內容，而在Java中則更詳細

Java（低效率的解決方案！）

List<Integer> s1 = Arrays.asList(1, 2); List<Integer> s2 = Arrays.asList(1, 3);s1.stream().flatMap(v1 -> s2.stream().map(v2 -> tuple(v1, v2))).filter(t -> Objects.equals(t.v1, t.v2)).forEach(System.out::println);

以上正確產生

(1, 1)

但是要注意，在生產笛卡爾積之后，您將獲得此結果，這是每個DBA的噩夢！ 如本文開頭所述，與聲明式編程不同，在函數(shù)式編程中，您指示程序嚴格執(zhí)行指定的操作順序。 換一種說法：

在函數(shù)式編程中， 您可以定義查詢的確切“執(zhí)行計劃” 。

在聲明式編程中， 優(yōu)化器可能會重組您的“程序”

沒有優(yōu)化器可以將上述方法轉換為效率更高的方法：

Java（效率更高）

List<Integer> s1 = Arrays.asList(1, 2); List<Integer> s2 = Arrays.asList(1, 3);s1.stream().flatMap(v1 -> s2.stream().filter(v2 -> Objects.equals(v1, v2)).map(v2 -> tuple(v1, v2))).forEach(System.out::println);

以上還產生

(1, 1)

請注意，聯(lián)接謂詞如何從“外部”流轉移到“內部”流，這是通過傳遞給flatMap()的函數(shù)產生的。

Java（最佳）

如前所述，函數(shù)式編程不一定允許您根據對實際數(shù)據的了解來重寫算法。 上面介紹的用于聯(lián)接的實現(xiàn)始終實現(xiàn)從第一個流到第二個流的嵌套循環(huán)聯(lián)接。 如果您加入了兩個以上的流，或者第二個流非常大，則此方法效率極低。 復雜的RDBMS絕不會像這樣盲目地應用嵌套循環(huán)聯(lián)接，而要在實際數(shù)據上考慮約束，索引和直方圖。

不過，深入探討該主題將超出本文的范圍。

Java與jOOλ的innerJoin（）

再次，由于我們在jOOQ上的工作的啟發(fā)，我們還為上述用例添加了innerJoin()便捷方法：

Seq<Integer> s1 = Seq.of(1, 2); Seq<Integer> s2 = Seq.of(1, 3);s1.innerJoin(s2, (t, u) -> Objects.equals(t, u)).forEach(System.out::println);

屈服

(1, 1)

…因為畢竟，當連接兩個流時，唯一真正有趣的操作是join Predicate 。 所有其他內容（平面映射等）都只是樣板。

LEFT OUTER JOIN = flatMap（），帶有filter（）和“ default”

SQL的OUTER JOIN工作方式與INNER JOIN ，不同之處在于，如果JOIN謂詞對成對的元組產生false ，則會生成其他“默認”行。 就集合論/關系代數(shù)而言 ，可以表示為：

或使用SQL風格的方言：

R LEFT OUTER JOIN S ::=R INNER JOIN S UNION ((R EXCEPT (SELECT R.* FROM R INNER JOIN S))CROSS JOIN(null, null, ..., null) )

這只是意味著左外側接合時S到R會有在結果至少一行中的每一行R與可能的空值S 。

相反地，當右外接合 S到R會有在結果中的每一行的至少一行S ，與可能的空值R

最后，當完全外部接合 S到R會有在結果中的每一行的至少一行R與可能為空值S 和用于在每行S具有用于可能為空值R

讓我們看一下LEFT OUTER JOIN ，它是SQL中最常用的。

SQL

-- Table list, Oracle syntax (don't use this!) SELECT * FROM (SELECT 1 v1 FROM DUALUNION ALL SELECT 2 v1 FROM DUAL) t1, (SELECT 1 v2 FROM DUALUNION ALLSELECT 3 v2 FROM DUAL) t2 WHERE t1.v1 = t2.v2 (+)-- OUTER JOIN syntax SELECT * FROM (VALUES(1), (2)) t1(v1) LEFT OUTER JOIN (VALUES(1), (3)) t2(v2) ON t1.v1 = t2.v2

屈服

+----+------+ | v1 | v2 | +----+------+ | 1 | 1 | | 2 | null | +----+------+

（請注意，關鍵字OUTER是可選的）。

Java

不幸的是，如果流為空，JDK的Stream API不能為我們提供一種簡單的方法來從流中產生“至少”一個值。 我們可能正在編寫實用程序函數(shù)，如Stack Overflow上的Stuart Marks所述 ：

static <T> Stream<T> defaultIfEmpty(Stream<T> stream, Supplier<T> supplier) {Iterator<T> iterator = stream.iterator();if (iterator.hasNext()) {return StreamSupport.stream(Spliterators.spliteratorUnknownSize(iterator, 0), false);} else {return Stream.of(supplier.get());} }

或者，我們只使用jOOλ的Seq.onEmpty()

List<Integer> s1 = Arrays.asList(1, 2); List<Integer> s2 = Arrays.asList(1, 3);seq(s1) .flatMap(v1 -> seq(s2).filter(v2 -> Objects.equals(v1, v2)).onEmpty(null).map(v2 -> tuple(v1, v2))) .forEach(System.out::println);

（注意，我們在流中添加null 。這可能并不總是一個好主意。我們將在以后的博客文章中對此進行跟進）

以上還產生

(1, 1) (2, null)

如何讀取隱式左外部聯(lián)接？

• 我們將從左側流s1獲取每個值v1
• 對于每個這樣的值v1 ，我們將右流s2平面化以生成元組(v1, v2) （笛卡爾乘積，交叉聯(lián)接）
• 我們將對每個這樣的元組(v1, v2)應用連接謂詞
• 如果join謂詞對任何值v2不留下任何元組，我們將生成一個包含左流v1的值和null的單個元組

帶有jOOλ的Java

為了方便起見，jOOλ還支持leftOuterJoin() ，其工作原理如上所述：

Seq<Integer> s1 = Seq.of(1, 2); Seq<Integer> s2 = Seq.of(1, 3);s1.leftOuterJoin(s2, (t, u) -> Objects.equals(t, u)).forEach(System.out::println);

屈服

(1, 1) (2, null)

右外連接=左外連接反向

通常， RIGHT OUTER JOIN只是前一個LEFT OUTER JOIN的逆。 rightOuterJoin()的jOOλ實現(xiàn)如下所示：

default <U> Seq<Tuple2<T, U>> rightOuterJoin(Stream<U> other, BiPredicate<T, U> predicate) {return seq(other).leftOuterJoin(this, (u, t) -> predicate.test(t, u)).map(t -> tuple(t.v2, t.v1)); }

如您所見， RIGHT OUTER JOIN反轉了LEFT OUTER JOIN的結果，就是這樣。 例如：

Seq<Integer> s1 = Seq.of(1, 2); Seq<Integer> s2 = Seq.of(1, 3);s1.rightOuterJoin(s2, (t, u) -> Objects.equals(t, u)).forEach(System.out::println);

屈服

(1, 1) (null, 3)

在哪里= filter（）

最簡單的映射可能是SQL的WHERE子句在Stream API中具有完全等效的內容： Stream.filter() 。

SQL

SELECT * FROM (VALUES(1), (2), (3)) t(v) WHERE v % 2 = 0

屈服

+---+ | v | +---+ | 2 | +---+

Java

Stream<Integer> s = Stream.of(1, 2, 3);s.filter(v -> v % 2 == 0).forEach(System.out::println);

屈服

2

通常， filter()和Stream API的有趣之處在于，該操作可以在調用鏈中的任何位置應用，這與WHERE子句不同， WHERE子句被限制在FROM子句之后–即使SQL的JOIN .. ON或HAVING子句在語義上相似。

GROUP BY = collect（）

最不直接的映射是GROUP BY與Stream.collect() 。

首先， 要完全理解 SQL的GROUP BY可能有些棘手 。 它實際上是FROM子句的一部分，它將FROM .. JOIN .. WHERE生成的元組集轉換為元組組，其中每個組都有一個關聯(lián)的可聚合元組集，可以在HAVING ， SELECT和ORDER BY子句。 當您使用諸如GROUPING SETS類的OLAP功能時，事情變得更加有趣，它可以根據幾種分組組合來復制元組。

在大多數(shù)不支持ARRAY或MULTISET SQL實現(xiàn)中，可聚合的元組在SELECT中不可用（即嵌套集合）。 在這里， Stream API的功能集非常出色。 另一方面， Stream API只能將值作為終端操作進行分組，其中在SQL中， GROUP BY是純粹以聲明方式（因此是惰性地）應用的。 如果不需要，執(zhí)行計劃者可以選擇根本不執(zhí)行GROUP BY 。 例如：

SELECT * FROM some_table WHERE EXISTS (SELECT x, sum(y)FROM other_tableGROUP BY x )

上面的查詢在語義上等同于

SELECT * FROM some_table WHERE EXISTS (SELECT 1FROM other_table )

子查詢中的分組是不必要的。 可能有人從其他位置將子查詢復制粘貼到該子查詢中，或者將查詢整體進行了重構。 在Java中，使用Stream API，總是執(zhí)行每個操作。

為了簡單起見，我們將堅持最簡單的示例

沒有GROUP BY的匯總

一種特殊情況是當我們不指定任何GROUP BY子句時。 在這種情況下，我們可以在FROM子句的所有列上指定聚合，從而始終只生成一條記錄。 例如：

SQL

SELECT sum(v) FROM (VALUES(1), (2), (3)) t(v)

屈服

+-----+ | sum | +-----+ | 6 | +-----+

Java

Stream<Integer> s = Stream.of(1, 2, 3);int sum = s.collect(Collectors.summingInt(i -> i)); System.out.println(sum);

屈服

6

使用GROUP BY進行匯總

如前所述，在SQL中更常見的聚合情況是指定一個顯式的GROUP BY子句。 例如，我們可能要按偶數(shù)和奇數(shù)分組：

SQL

SELECT v % 2, count(v), sum(v) FROM (VALUES(1), (2), (3)) t(v) GROUP BY v % 2

屈服

+-------+-------+-----+ | v % 2 | count | sum | +-------+-------+-----+ | 0 | 1 | 2 | | 1 | 2 | 4 | +-------+-------+-----+

Java

幸運的是，對于這個簡單的分組/收集用例，JDK提供了一個稱為Collectors.groupingBy()的實用程序方法，該方法生成一個收集器，該收集器生成Map<K, List<V>>類型，如下所示：

Stream<Integer> s = Stream.of(1, 2, 3);Map<Integer, List<Integer>> map = s.collect(Collectors.groupingBy(v -> v % 2) );System.out.println(map);

屈服

{0=[2], 1=[1, 3]}

這當然會照顧到分組。 現(xiàn)在，我們要為每個組生成聚合。 有點尷尬的JDK方法是：

Stream<Integer> s = Stream.of(1, 2, 3);Map<Integer, IntSummaryStatistics> map = s.collect(Collectors.groupingBy(v -> v % 2,Collectors.summarizingInt(i -> i)) );System.out.println(map);

我們現(xiàn)在將獲得：

{0=IntSummaryStatistics{count=1, sum=2, min=2, average=2.000000, max=2},1=IntSummaryStatistics{count=2, sum=4, min=1, average=2.000000, max=3}}

如您所見， count()和sum()值是根據上述內容計算出來的。

更復雜的GROUP BY

當使用Java 8的Stream API進行多個聚合時，您將很快被迫與自己實現(xiàn)復雜的收集器和累加器的低級API進行角力。 這是乏味且不必要的。 考慮以下SQL語句：

SQL

CREATE TABLE t (w INT,x INT,y INT,z INT );SELECTz, w, MIN(x), MAX(x), AVG(x), MIN(y), MAX(y), AVG(y) FROM t GROUP BY z, w;

我們希望一口氣：

• 按幾個值分組
• 從多個值匯總

Java

在上一篇文章中，我們已經詳細解釋了如何使用jOOλ中的便捷API通過 Seq.groupBy()

class A {final int w;final int x;final int y;final int z;A(int w, int x, int y, int z) {this.w = w;this.x = x;this.y = y;this.z = z;} }Map<Tuple2<Integer, Integer>, Tuple2<IntSummaryStatistics, IntSummaryStatistics> > map = Seq.of(new A(1, 1, 1, 1),new A(1, 2, 3, 1),new A(9, 8, 6, 4),new A(9, 9, 7, 4),new A(2, 3, 4, 5),new A(2, 4, 4, 5),new A(2, 5, 5, 5))// Seq.groupBy() is just short for // Stream.collect(Collectors.groupingBy(...)) .groupBy(a -> tuple(a.z, a.w),// ... because once you have tuples, // why not add tuple-collectors?Tuple.collectors(Collectors.summarizingInt(a -> a.x),Collectors.summarizingInt(a -> a.y)) );System.out.println(map);

以上收益

{(1, 1)=(IntSummaryStatistics{count=2, sum=3, min=1, average=1.500000, max=2},IntSummaryStatistics{count=2, sum=4, min=1, average=2.000000, max=3}),(4, 9)=(IntSummaryStatistics{count=2, sum=17, min=8, average=8.500000, max=9},IntSummaryStatistics{count=2, sum=13, min=6, average=6.500000, max=7}),(5, 2)=(IntSummaryStatistics{count=3, sum=12, min=3, average=4.000000, max=5},IntSummaryStatistics{count=3, sum=13, min=4, average=4.333333, max=5})}

有關更多詳細信息， 請在此處閱讀全文 。

請注意，使用Stream.collect()或Seq.groupBy()如何實現(xiàn)隱式SELECT子句，不再需要通過map()獲得（見下文）。

再次= filter（）

如前所述，使用Stream API并沒有真正不同的方式來應用謂詞，只有Stream.filter() 。 在SQL中， HAVING是一個“特殊”謂詞子句，在語法上位于GROUP BY子句之后。 例如：

SQL

SELECT v % 2, count(v) FROM (VALUES(1), (2), (3)) t(v) GROUP BY v % 2 HAVING count(v) > 1

屈服

+-------+-------+ | v % 2 | count | +-------+-------+ | 1 | 2 | +-------+-------+

Java

不幸的是，正如我們之前所看到的， collect()是Stream API中的終端操作，這意味著它急切地生成Map ，而不是將Stream<T>轉換為Stream<K, Stream<V> ，在復雜的Stream組合更好。 這意味著我們要在收集后立即執(zhí)行的任何操作都必須在從輸出Map生成的新流上實施：

Stream<Integer> s = Stream.of(1, 2, 3);s.collect(Collectors.groupingBy(v -> v % 2,Collectors.summarizingInt(i -> i))).entrySet().stream().filter(e -> e.getValue().getCount() > 1).forEach(System.out::println);

屈服

1=IntSummaryStatistics{count=2, sum=4, min=1, average=2.000000, max=3}

如您所見，應用的類型轉換為：

• Map<Integer, IntSummaryStatistics>
• Set<Entry<Integer, IntSummaryStatistics>>
• Stream<Entry<Integer, IntSummaryStatistics>>

選擇= map（）

SQL中的SELECT子句不過是一個元組轉換函數(shù)，該函數(shù)采用FROM子句產生的元組的笛卡爾積，并將其轉換為新的元組表達式，然后將其饋送到客戶端或某些更高級別的查詢（如果有）這是一個嵌套的SELECT。 插圖：

從輸出

+------+------+------+------+------+ | T1.A | T1.B | T1.C | T2.A | T2.D | +------+------+------+------+------+ | 1 | A | a | 1 | X | | 1 | B | b | 1 | Y | | 2 | C | c | 2 | X | | 2 | D | d | 2 | Y | +------+------+------+------+------+

應用選擇

SELECT t1.a, t1.c, t1.b || t1.d+------+------+--------------+ | T1.A | T1.C | T1.B || T1.D | +------+------+--------------+ | 1 | a | AX | | 1 | b | BY | | 2 | c | CX | | 2 | d | DY | +------+------+--------------+

使用Java 8 Streams，可以使用Stream.map()非常簡單地實現(xiàn)SELECT ，正如我們在前面的示例中已經看到的那樣，其中我們使用map()取消了元組的嵌套。 以下示例在功能上等效：

SQL

SELECT t.v1 * 3, t.v2 + 5 FROM (VALUES(1, 1),(2, 2) ) t(v1, v2)

屈服

+----+----+ | c1 | c2 | +----+----+ | 3 | 6 | | 6 | 7 | +----+----+

Java

Stream.of(tuple(1, 1),tuple(2, 2) ).map(t -> tuple(t.v1 * 3, t.v2 + 5)).forEach(System.out::println);

屈服

(3, 6) (6, 7)

DISTINCT = distinct（）

該DISTINCT可以與被提供的關鍵字SELECT從句簡單地移除它們已經被產生之后立即重復元組SELECT子句。 插圖：

從輸出

+------+------+------+------+------+ | T1.A | T1.B | T1.C | T2.A | T2.D | +------+------+------+------+------+ | 1 | A | a | 1 | X | | 1 | B | b | 1 | Y | | 2 | C | c | 2 | X | | 2 | D | d | 2 | Y | +------+------+------+------+------+

應用SELECT DISTINCT

SELECT DISTINCT t1.a+------+ | T1.A | +------+ | 1 | | 2 | +------+

使用Java 8 Streams，可以在Stream.distinct()之后Stream.map()使用Stream.distinct()來非常簡單地實現(xiàn)SELECT DISTINCT 。 以下示例在功能上等效：

SQL

SELECT DISTINCT t.v1 * 3, t.v2 + 5 FROM (VALUES(1, 1),(2, 2),(2, 2) ) t(v1, v2)

屈服

+----+----+ | c1 | c2 | +----+----+ | 3 | 6 | | 6 | 7 | +----+----+

Java

Stream.of(tuple(1, 1),tuple(2, 2),tuple(2, 2) ).map(t -> tuple(t.v1 * 3, t.v2 + 5)).distinct().forEach(System.out::println);

屈服

(3, 6) (6, 7)

UNION ALL = concat（）

設置操作在SQL和使用Stream API中都非常強大。 UNION ALL操作映射到Stream.concat() ，如下所示：

SQL

SELECT * FROM (VALUES(1), (2)) t(v) UNION ALL SELECT * FROM (VALUES(1), (3)) t(v)

屈服

+---+ | v | +---+ | 1 | | 2 | | 1 | | 3 | +---+

Java

Stream<Integer> s1 = Stream.of(1, 2); Stream<Integer> s2 = Stream.of(1, 3);Stream.concat(s1, s2).forEach(System.out::println);

屈服

1 2 1 3

Java（使用jOOλ）

不幸的是， concat()僅作為static方法存在于Stream ，而使用Seq.concat()時， Seq.concat()也存在于實例上。

Seq<Integer> s1 = Seq.of(1, 2); Seq<Integer> s2 = Seq.of(1, 3);s1.concat(s2).forEach(System.out::println);

UNION = concat（）和distinct（）

在SQL中，定義UNION以通過UNION ALL將兩個集合連接起來后刪除重復項。 以下兩個語句是等效的：

SELECT * FROM t UNION SELECT * FROM u;-- equivalentSELECT DISTINCT * FROM (SELECT * FROM tUNION ALLSELECT * FROM u );

讓我們付諸行動：

SQL

SELECT * FROM (VALUES(1), (2)) t(v) UNION SELECT * FROM (VALUES(1), (3)) t(v)

屈服

+---+ | v | +---+ | 1 | | 2 | | 3 | +---+

Java

Stream<Integer> s1 = Stream.of(1, 2); Stream<Integer> s2 = Stream.of(1, 3);Stream.concat(s1, s2).distinct().forEach(System.out::println);

ORDER BY = sorted（）

ORDER BY映射很簡單

SQL

SELECT * FROM (VALUES(1), (4), (3)) t(v) ORDER BY v

屈服

+---+ | v | +---+ | 1 | | 3 | | 4 | +---+

Java

Stream<Integer> s = Stream.of(1, 4, 3);s.sorted().forEach(System.out::println);

屈服

1 3 4

LIMIT = limit（）

LIMIT映射更加簡單

SQL

SELECT * FROM (VALUES(1), (4), (3)) t(v) LIMIT 2

屈服

+---+ | v | +---+ | 1 | | 4 | +---+

Java

Stream<Integer> s = Stream.of(1, 4, 3);s.limit(2).forEach(System.out::println);

屈服

1 4

偏移= skip（）

OFFSET映射也很簡單

SQL

SELECT * FROM (VALUES(1), (4), (3)) t(v) OFFSET 1

屈服

+---+ | v | +---+ | 4 | | 3 | +---+

Java

Stream<Integer> s = Stream.of(1, 4, 3);s.skip(1).forEach(System.out::println);

屈服

4 3

結論

在上面的文章中，我們已經看到了幾乎所有有用SQL SELECT查詢子句，以及如何將它們映射到Java 8 Stream API或jOOλ的Seq API，以防Stream無法提供足夠的功能。

本文表明，SQL的聲明性世界與Java 8的功能性世界沒有太大不同。 SQL子句可以組成即席查詢，就像Stream方法可以用來組成功能轉換管道一樣。 但是有根本的區(qū)別。

盡管SQL確實是聲明性的，但是函數(shù)式編程還是很有啟發(fā)性的。 Stream API不會基于約束，索引，直方圖和有關要轉換的數(shù)據的其他元信息來做出優(yōu)化決策。 使用Stream API就像在SQL中使用所有可能的優(yōu)化提示一樣，以強制SQL引擎選擇一個特定的執(zhí)行計劃而不是另一個。 但是，盡管SQL是更高級別的算法抽象，但是Stream API可能允許您實現(xiàn)更多可自定義的算法。

翻譯自: https://www.javacodegeeks.com/2015/08/common-sql-clauses-and-their-equivalents-in-java-8-streams.html

sql limit 子句

總結

以上是生活随笔為你收集整理的sql limit 子句_Java 8流中的常见SQL子句及其等效项的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。