操屁眼的视频在线免费看,日本在线综合一区二区,久久在线观看免费视频,欧美日韩精品久久综

很多開源技術都可以在Java下實現以數據庫為核心的業務邏輯，其中JOOQ的計算能力比強，可移植性比強，受到越來越多的關注。 SPL是新晉的數據計算語言，同樣在計算能力和可移植性方面優勢突出。下面對二者進行多方面的比較，從中找出開發效率更高的數據業務邏輯開發技術。JOOQ商業版主要支持了商業數據庫和存儲過程，不在此次討論范圍。

語言特征 編程風格

JOOQ支持完整的面向對象的編程風格，可以將多個對象（方法）組合起來，形成類似SQL的語法邏輯。JOOQ可以使用Java的表達式、函數調用接口和流程控制語法，理論上也支持面向函數和面向過程，但這些表達式\語法沒有為JOOQ的結構化數據對象（）而設計，使用時還不夠方便。

SPL支持面向對象、面向函數、面向過程的編程風格，并進行大幅簡化。SPL有對象的概念，可以用點號訪問屬性并進行多步驟計算，但沒有繼承重載這些內容。SPL的表達式比SQL更加簡單易用，函數調用接口和流程控制語法專為結構化數據對象（序表）而設計，使用更加方便。

運行模式

JOOQ是編譯執行的Java代碼，性能高一些，靈活性較差。但JOOQ本身沒有計算能力，執行后只生成SQL語句，再交由數據庫計算并返回結果，實際性能并不高，有些業務邏輯需要反復讀寫數據庫，性能就更差了。SPL是解釋型語言，編碼更靈活，相同代碼性能會差一點。但是，SPL有不依賴數據庫的獨立計算能力，無需反復讀寫數據庫，內置大量時間復雜度更低的基礎運算，計算性能經常能超過編譯型語言。

外部類庫

JOOQ可以引入其他任意的第三方Java類庫，用來彌補自身的短板，比如利用增加自己的獨立計算能力，但這些類庫沒有為結構化數據對象而設計，提供的功能比較有限。SPL內置專業的數據處理函數，提供了大量開發效率更高、時間復雜度更低的基本運算，通常不需要外部Java類庫，特殊情況可在自定義函數中調用。

IDE和調試

兩者都有圖形化IDE和完整的調試功能。JOOQ使用Java IDE，好處是更通用，缺點是沒有為數據處理做優化，無法方便地觀察結構化數據對象。SPL的IDE專為數據處理而設計，結構化數據對象呈現為表格形式，觀察更加方便。

學習難度

JOOQ需要學習三種語法，SQL、通用Java、JOOQ。其中，SQL的語言能力要高于一般水平，才能轉化為JOOQ語法；開發時主要使用JOOQ語法，難度不高，但轉化過程較復雜；通用Java的語言能力可以低于一般水平。SPL的目標是簡化Java甚至SQL的編碼，無論入門學習還是深入開發，難度都不高。但涉及到高性能計算時需要學習較多特有的算法，難度也會提高。

代碼量

SQL擅長結構化數據計算，語法較簡練，代碼量較低，但為了把SQL翻譯成JOOQ，需要引入很多函數，存在過度封裝的現象，實際代碼量較大。JOOQ的流程控制要借助Java語法，但Java語法沒有為結構化數據對象而設計，代碼量也不低。

SPL的表達能力強于SQL，遠強于JOOQ，可用更低的代碼量實現結構化數據計算，SPL的流程處理語句專為結構化數據對象而設計，代碼量低于Java。

結構化數據對象

結構化數據對象用于將數據庫表對象化，是數據處理和業務邏輯開發的基礎，專業的結構化數據對象可以方便地與數據庫交換數據，支持豐富的計算函數，并簡化流程處理的難度。

定義

JOOQ的結構化數據對象由記錄和記錄集合組成。記錄對象的種類很多，第一類是對象，適合字段的數量、類型、名字都是動態生成的情況，雖然很靈活但面向對象的程度較低，用法比較麻煩，比如要通過(M)來獲得第M個字段。第二類是[N]對象，N從1到22，比如，適合字段類型和字段數量已知但不超過22個，而字段名是動態生成的情況，[N]靈活性差些但面向對象的程度稍高，用法方便些，比如可以通過取得第M個字段。第三類記錄對象由JOOQ的代碼工具根據庫表結構生成，有幾個表就有幾個對象，字段的數量、類型、名字都和庫表字段嚴格對應，比如、，這種記錄對象不靈活但面向對象的程度很高，用法也很方便，可以直接通過字段名取字段。第三類對應庫表，可稱之為固定數據結構的記錄對象，前兩類通常來自對庫表的查詢計算，可稱之為動態數據結構的記錄對象。這三類比較常用，還有些不常用的記錄對象，比如用戶自定義記錄類型UDT，這里就不展開說了。JOOQ的記錄對象種類繁多，用法差異較大，增加了開發的難度，這主要因為業務邏輯存在大量動態數據結構，而Java是編譯型語言，只擅長表達固定數據結構，如果硬要表達動態數據結構，就只能設計復雜的接口規則，或者根據字段數量預定義大量對象。

JOOQ記錄集合的種類相對較少，常用的有原生對象，及其父類，有時候也會用。

SPL的結構化數據對象同樣由記錄（）和記錄集合（序表）組成。SPL的記錄對象只有一種，主要因為SPL是解釋型語言，動態數據結構和固定數據結構表達起來同樣方便，接口都很簡單，沒必要分成多個。此外，記錄對象與單記錄集合雖然本質不同，但業務意義相似，用起來容易混淆。SPL是解釋型語言，可以通過靈活的接口使兩者的外部用法保持一致，從而進一步提高易用性。相反，JOOQ是編譯型語言，很難設計出這種靈活的接口，只能提供兩類不同的接口，分別用來處理記錄對象和單記錄集合。

讀數據庫

JOOQ讀取外部數據庫表，生成固定記錄集合：

java.sql.Connection conn = DriverManager.getConnection(url, userName, password);
DSLContext context = DSL.using(conn, SQLDialect.MYSQL);
Result R1=context.select().from(ORDERS).fetchInto(ORDERS);

查詢外部數據庫表，生成動態記錄集合：

Result>R2=context.select(ORDERS.SELLERID,ORDERS.CLIENT,ORDERS.AMOUNT).from(ORDERS).fetch();

動態記錄集合的后續用法稍顯麻煩，但可以兼容固定記錄集合，下面文章中主要用動態記錄集合。

SPL讀取或查詢外部數據庫表，生成序表：

SPL不分固定記錄集合或動態記錄集合，生成方法一致，后續用法相同。

寫數據庫

將處理后的結構化數據對象持久化保存到數據庫，JOOQ提供了三種函數，分別是、、。修改記錄r，再更新到數據庫：

r.setValue(ORDERS.AMOUNT,r.getValue(ORDERS.AMOUNT).doubleValue()+100);
r.update();

上面是單條記錄的更新。要注意的是，數據庫表必須有主鍵，自動生成的記錄類才會繼承，只有繼承的記錄類才支持函數。

批量寫入數據庫是數據業務邏輯常見的場景，JOOQ也能實現。批量修改記錄集合T，并更新到數據庫：

R1.forEach(r->{r.setValue(ORDERS.AMOUNT,r.getValue(ORDERS.AMOUNT).doubleValue()+100);});
R1.forEach(r->{r.update();});

上面代碼循環記錄集合，手工更新每一條記錄，從而實現對整體集合的更新。可以看到，JOOQ通過硬寫代碼實現批量寫入，沒有進行封裝，很多時候不方便。如果一批記錄既有修改又有新增還有刪除，就必須區分三類記錄，再用不同的函數循環寫入，常見的辦法是繼承記錄類，新加一個“標識”屬性予以區分，或者保存一個未修改的原始記錄集合T，將修改后的集合NT與原始集合進行手工比對。無論哪種方法，手工實現的過程都很麻煩。

SPL對數據庫的寫入進行了封裝，只用一個函數就實現單條和批量記錄的新增、修改、刪除，且支持混合更新。比如：原序表為T，經過增刪改一系列處理后的序表為NT,將變化結果持久化到數據庫的表：

conn.update(NT:T,orders)

訪問字段

JOOQ讀取單條記錄的字段：

R1.get(0).getClient();
R1.get(0).get(ORDERS.CLIENT);

上面代碼體現了JOOQ的核心優勢：支持純粹的面向對象的字段訪問方式，不摻雜字符串、數字常量，或其他非Java的表達式，代碼風格高度統一。遺憾之處在于，上面代碼只適用于固定結構化數據對象。如果是查詢計算生成的動態記錄對象，就只能使用字符串字段名或數字序號訪問字段：

R2.get(0).get("Client");
R2.get(0).get(1);

動態記錄對象更加普遍，上面的字段訪問方式不算純粹的面向對象，代碼風格不一致，不支持自動補全，編寫時普遍麻煩。

SPL支持純粹的面向對象的字段訪問方式，不分固定或動態，編寫時普遍方便：

T(1).Client

當然也支持字符串字段名或數字序號訪問字段：

T(1).field(2)
T(1).field("Client")

SPL在面向對象方面更加純粹，風格更統一，編寫代碼更加方便。此外，SPL提供了很多JOOQ不支持的便利功能：默認字段名，可以用點號直接訪問，比如取第2個字段：T(1).#2；取多個字段，返回集合的集合：T.([,])

有序訪問

有序訪問是業務邏輯開發的難點之一，JOOQ的記錄集合繼承自Java的有序集合，具備一定的有序訪問能力，支持按下標取記錄和按區間取記錄：

R.get(3)
R.subList(3,5); 

再進一步的功能，就需要硬編碼實現了，比如后3條：

Collections.reverse(R);
R.subList(0,3);

至于按位置集合取記錄、步進取記錄等功能，硬編碼就更麻煩了。

SPL序表同樣是有序集合，提供了順序相關的基本功能，比如按下標取、按區間取：

T(3)
T.to(3,5)

序表是專業的結構化數據對象，許多順序相關的高級功能JOOQ 沒有支持，序表則直接提供了，比如按倒數序號取記錄，可以直接用負號表示：

T.m(-3)                         //倒數第3條
T.m(to(-3,-5))                      //倒數區間

再比如按位置集合取記錄、步進取記錄：

T.m(1,3,5,7:10)                     //序號是1、3、5、7-10的記錄
T.m(-1,-3,-5)                       //倒數第1，3，5條
T.step(2,1)                     //每2條取第1條（等價于奇數位置）

結構化數據計算

結構化數據計算能力是數據業務邏輯的核心功能，下面從簡單到復雜選取幾個常見題目，比較JOOQ和SPL的計算代碼。

改名

//等價的SQL
select SellerID eid,Amount amt from Orders
//JOOQ
context.select(ORDERS.SELLERID.as("eid"),ORDERS.AMOUNT.as("amt")).from(ORDERS).fetch()
//SPL
Orders.new(SellerID:EID, Amount:amt)

JOOQ的語法邏輯與SQL基本一致，可以達到用面向對象的方式模擬SQL的目的，這是JOOQ的重要優點。相應的也有缺點，JOOQ的一項運算需要多個函數的組合才能實現，每個函數都有自己的參數和語法規則，學習和編寫難度較大。此外，很多函數里的字段名必須附帶表名，即使單表計算也是如此，這說明JOOQ的語法不夠專業，還有很大的改進空間。

SPL直接用面向對象的語法實現計算，一項運算對應一個函數，引用字段不必附帶表名，語法更專業，代碼更簡短。

條件查詢

//等價的SQL
select * from Orders where 
    ((SellerID=2 and Amount<3000) or (SellerID=3 and Amount>=2000 and Amount<5000)) 
    and
    year(OrderDate)>2010
//JOOQ
context.select().from(ORDERS)
.where(
    ((ORDERS.SELLERID.equal(2).and(ORDERS.AMOUNT.lessThan(3000.0)))
    .or((ORDERS.SELLERID.equal(3).and(ORDERS.AMOUNT.greaterOrEqual(2000.0).and(ORDERS.AMOUNT.lessThan(5000.0))))))
    .and(year(ORDERS.ORDERDATE).greaterThan(2012)))
.fetch();
//SPL
Orders.select(
    ((SellerID==2 && Amount<3000) || (SellerID==3 && Amount>=2000 && Amount<5000)) 
    &&
    year(OrderDate)>2010)

SQL的條件表達式本身足夠簡單，JOOQ雖然在模擬SQL，但對條件表達式進行了過度封裝，函數數量過多，多層括號難閱讀，遠不如SQL好理解。SPL用一個函數實現條件查詢，條件表達式簡短易讀。

分組匯總

//等價的SQL：
select Client, extract(year from OrderDate) y,count(1) cnt
from Orders
group by Client, extract(year from OrderDate)
having amt<20000
//JOOQ
context.select(ORDERS.CLIENT,year(ORDERS.ORDERDATE).as("y"),sum(ORDERS.AMOUNT).as("amt"),count(one()).as("cnt"))
.from(ORDERS)
.groupBy(ORDERS.CLIENT,year(ORDERS.ORDERDATE))

.having(field("amt").lessThan(20000)).fetch();
//SPL
Orders.groups(Client,year(OrderDate):y;sum(Amount):amt,count(1):cnt)
.select(amt<20000)

為了模擬SQL，JOOQ使用了很多函數，規則很復雜，導致代碼過長。SPL直接用面向對象的語法，規則簡單，代碼更短。

前面都是較簡單計算，類似的計算還包括排序、去重、關聯、集合交并差等計算，這里不再一一列舉，總的來說，JOOQ進行簡單計算時比SQL和SPL代碼長，很多時候不易理解，開發效率較低。

各組前3名

//等價的SQL
select * from (select *, row_number() over (partition by Client order by Amount) rn from Orders) T where rn<=3
//JOOQ
WindowDefinition CA = name("CA").as(partitionBy(ORDERS.CLIENT).orderBy(ORDERS.AMOUNT));
context.select().from(select(ORDERS.ORDERID,ORDERS.CLIENT,ORDERS.SELLERID,ORDERS.AMOUNT,ORDERS.ORDERDATE,rowNumber().over(CA).as("rn")).from(ORDERS).window(CA) ).where(field("rn").lessOrEqual(3)).fetch();
//SPL
Orders.group(Client).(~.top(3;Amount)).conj()

這道題目稍有難度，JOOQ雖然模擬出了SQL，但使用了很多函數，代碼長度遠超SQL，語法也越來越不像SQL，編寫理解更加困難。SPL先對客戶分組，再求各組（即~）的前3名，最后合并各組計算結果，不僅代碼更簡短，且更易理解。

JOOQ使用了窗口函數，只適合特定版本的數據庫，比如，不能通用于其他版本的數據庫，要想在下實現同樣的計算，代碼改動非常麻煩。SPL有獨立計算能力，代碼可通用于任何數據庫。

某支股票最大連續上漲天數

JOOQ：

WindowDefinition woDay1 = name("woDay").as(orderBy(APPL.DAY));
TableT0=table(select(APPL.DAY.as("DAY"),when(APPL.PRICE.greaterThan(lag(APPL.PRICE).over(woDay1)),0).otherwise(1).as("risingflag")).from(APPL).window(woDay1)).as("T0");
WindowDefinition woDay2 = name("woDay1").as(orderBy(T0.field("DAY")));
TableT1=table(select(sum(T0.field("risingflag").cast(java.math.BigDecimal.class)).over(woDay2).as("norisingdays")).from(T0).window(woDay2)).as("T1");
TableT2=table(select(count(one()).as("continuousdays")).from(T1).groupBy(T1.field("norisingdays"))).as("T2");
Result result=context.select(max(T2.field("continuousdays"))).from(T2).fetch();

這個問題難度較高，需要綜合運用多種簡單計算。JOOQ很難直接表達連續上漲的概念，只能使用技巧變相實現，即通過累計不漲天數來計算連續上漲天數。具體是，先按時間順序給每條記錄打漲跌標記，如果下跌，則標為1，如果上漲，則標為0；再按時間順序累計每條記錄的不漲天數，只有當前記錄下跌時，這個數字才會變大，如果當前記錄上漲，則這個數字不變；再按不漲天數分組，求各組記錄數，顯然，連續下跌的一批記錄的不同，每條記錄都會分到不同的組，該組計數為1，這個值不是解題目標，而連續上漲的一批記錄的相同，可以分到同一組，該組計數即連續上漲的天數，這個值是解題目標；最后用max函數求出最大的連續上漲天數。

JOOQ的編程過程是先寫SQL，再翻譯成JOOQ，對于簡單計算來說，SQL比較好寫，翻譯也不會太難，但對于本題這種綜合性計算來說，計算邏輯的技巧性比較強，SQL不好寫，翻譯的難度更大。此外，JOOQ表面上是方便調試的Java，但本質卻是SQL，和SQL一樣難以調試，這又為將來的維護工作埋下了大坑。

SPL代碼簡單多了：

APPL.sort(day).group@i(price

T.select@1(Amount>1000)

T.select@b(Amount>1000)

Orders.select@1b(Amount>1000)

join(Orders:o,SellerId ; Employees:e,EId)

Orders.forEach(r->{
    Double amount=r.getValue(ORDERS.AMOUNT);
    if (amount>10000) {
        r.setValue(ORDERS.BONUS), amount * 0.05);
    }else if(amount>=5000 && amount<10000){
        r.setValue(ORDERS.BONUS),amount*0.03);
    }else if(amount>=2000 && amount<5000){
        r.setValue(ORDERS.BONUS),amount*0.02);
    }
});

Orders.(Bonus=if(Amount>10000,Amount*0.05,
    if(Amount>5000 && Amount<10000, Amount*0.03,
    if(Amount>=2000 && Amount<5000, Amount*0.02)
)))

Class.forName("com.esproc.jdbc.InternalDriver");
Connection connection =DriverManager.getConnection("jdbc:esproc:local://");
Statement statement = connection.createStatement();
ResultSet result = statement.executeQuery("call genBonus()");