2. 程式人生 > 其它 >MybatisPlus多條件查詢並分頁

MybatisPlus多條件查詢並分頁

阿新 • • 發佈：2021-02-02

基於塊置亂的影象加密演算法及其存在的問題

宣告：這是我的個人筆記，旨在記錄實驗過程和實驗問題，不具有太多的參考性，但是也會逐漸修改和完善。

加密演算法使用的影象如下，也可以去USC-SIPI影象資料庫 自己下載各種測試影象。
房屋明文

塊置亂加密演算法matlab實現

% 基於塊加擾的影象加密函式
% 輸入明文P，測試金鑰K
% 輸出密文C
function C = BlockScram_EnAlgorithm(I,K)
  
    %% 明文8×8分塊 或 16×16分塊等
%     Bx=4;
%     Bx=8;
%     Bx=16;
     Bx=64;
      
    %先把影象補成行數和列數均為8的倍數的矩陣
    [m0,n0,~] = size(I);    %計算影象P的尺寸
    m1=Bx-mod(m0,Bx);         %計算需要增加的行數
        if m1==Bx
            m1=0;
        end
    n1=Bx-mod(n0,Bx);         %計算需要增加的列數
        if n1==Bx
            n1=0;
        end   
    m=m0+m1;
    n=n0+n1;
    P=zeros(m,n,3);          %矩陣P1行數和列數均為8的倍數
    P(1:m0,1:n0,:)=I;
    
    %明文分塊
    Block=zeros(Bx,Bx,3,m/Bx,n/Bx);%5維陣列，以8×8×3大小的陣列作為5維陣列的元素
    for i=1:m/Bx
        for j=1:n/Bx
            Block(:,:,:,i,j)=P((i-1)*Bx+1:i*Bx,(j-1)*Bx+1:j*Bx,:);
        end
    end
    
    %5D陣列Block轉成3D影象矩陣P2
    P1=zeros(m,n,3);
    for i=1:m/Bx
        for j=1:n/Bx
            P1((i-1)*Bx+1:i*Bx,(j-1)*Bx+1:j*Bx,:)=Block(:,:,:,i,j);
        end
    end
    
    figure;imshow(uint8(P1));title('分塊後的明文')
    save 分塊後的明文.mat P1

    %% 使用金鑰產生偽隨機序列
    
    S_Len=m*n/(Bx*Bx);              %序列長度，這裡各個偽隨機序列的長度一樣，故統一用S_Len表示序列長度
    
    rng(K(1));                      %控制隨機數生成器，隨機數生成器randi()的種子設定為0
    S1=randi([1,m*n/(Bx*Bx)],1,S_Len);  %返回一個由介於1和m*n/64之間的偽隨機整陣列成的1×S_Len陣列

    rng(K(2));                      %控制隨機數生成器，隨機數生成器randi()的種子設定為1
    S2=randi([0,5],1,S_Len);       %返回一個由介於0和5之間的偽隨機整陣列成的1×S_Len陣列

    rng(K(3));
    S3=randi([0,1],1,S_Len);

    rng(K(4));
    S4=randi([0,5],1,S_Len);
    
    %% 加密程式1，塊置亂加密
    
    %Block的子塊根據隨機序列S1置亂
    for i=1:m*n/(Bx*Bx)  
        t=Block(:,:,:,i);
        Block(:,:,:,i)=Block(:,:,:,S1(i));
        Block(:,:,:,S1(i))=t;
    end
    
    
    %% 加密程式2，塊旋轉和反轉加密
    for i=1:m/Bx
        for j=1:n/Bx
            % 若S2(i*j)==0，則不旋轉塊，即不做操作
            switch S2(i*j)
                case 1              %順時針旋轉90°
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-l,k,:,i,j);
                            Block(Bx+1-l,k,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=Block(l,Bx+1-k,:,i,j);
                            Block(l,Bx+1-k,:,i,j)=t;
                        end
                    end
                    
                case 2              %順時針旋轉180°
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=t1;

                            t2=Block(k,l+Bx/2,:,i,j);
                            Block(k,l+Bx/2,:,i,j)=Block(Bx+1-k,Bx/2+1-l,:,i,j);
                            Block(Bx+1-k,Bx/2+1-l,:,i,j)=t2;
                        end
                    end
                    
                case 3              %順時針旋轉270°
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(l,Bx+1-k,:,i,j);
                            Block(l,Bx+1-k,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=Block(Bx+1-l,k,:,i,j);
                            Block(Bx+1-l,k,:,i,j)=t;
                        end
                    end
                    
                case 4              %水平翻轉
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(k,Bx+1-l,:,i,j);
                            Block(k,Bx+1-l,:,i,j)=t1;

                            t2=Block(Bx/2+k,l,:,i,j);
                            Block(Bx/2+k,l,:,i,j)=Block(Bx/2+k,Bx+1-l,:,i,j);
                            Block(Bx/2+k,Bx+1-l,:,i,j)=t2;
                        end
                    end
                    
                case 5              %垂直翻轉
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-k,l,:,i,j);
                            Block(Bx+1-k,l,:,i,j)=t1;

                            t2=Block(k,Bx/2+l,:,i,j);
                            Block(k,Bx/2+l,:,i,j)=Block(Bx+1-k,Bx/2+l,:,i,j);
                            Block(Bx+1-k,Bx/2+l,:,i,j)=t2;
                        end
                    end
                    
                otherwise 
                    
            end 
        end
    end
    
    
    %% 加密程式3，負-正變換
    
    %A=repmat(255,Bx,Bx,3);
    for i=1:m/Bx
        for j=1:n/Bx
           if S3(i*j)==1
               %Block(:,:,:,i,j)=bitxor(Block(:,:,:,i,j),A);
               Block(:,:,:,i,j)=255-Block(:,:,:,i,j);
           end
        end
    end
    

    %% 加密程式4，置亂顏色分量
    for i=1:m/Bx
        for j=1:n/Bx
            switch S4(i*j)
                case 1      %RGB->RBG，顏色分量按RBG排布，第2個顏色分量與第3個顏色分量相互交換，使用異或操作進行資料變換，
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                case 2      %RGB->GRB,顏色分量按GRB排布，第1個顏色分量與第2個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    
                case 3      %RGB->BGR,顏色分量按BGR排布，第1個顏色分量與第3個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    
                case 4      %RGB->BGR->BRG,顏色分量按BRG排布，分兩步進行，首先第1個顏色分量與第3個顏色分量相互交換，再第2個顏色分量與第3個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                case 5      %RGB->GRB->GBR,顏色分量按GBR排布，分兩步進行，首先第1個顏色分量與第2個顏色分量相互交換，再第2個顏色分量與第3個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                otherwise
                    Block(:,:,:,i,j)=Block(:,:,:,i,j);      %不做處理
            end
        end
    end
    
    %% 密文
    for i=1:m/Bx
        for j=1:n/Bx
            C((i-1)*Bx+1:i*Bx,(j-1)*Bx+1:j*Bx,:)=Block(:,:,:,i,j);
        end
    end
    
end

加密效果

在這裡插入圖片描述
密文以無失真壓縮方式儲存，則解密不會不出現任何問題，但是如果密文使用.jpg格式儲存，即：

imwrite(uint8(C1),'房屋密文.jpg');

則會出現問題，後面會說

塊置亂解密演算法

% 基於塊加擾的影象解密函式
% 輸入密文C，測試金鑰K
% 輸出明文D

function D = BlockScram_DeAlgorithm(C,K)
    
%     Bx=4;
%     Bx=8;   %以8×8分塊
%     Bx=16;  %以16×16分塊
    Bx=64;
    
    %% 使用金鑰產生偽隨機序列
    [m,n,~] = size(C);              %計算影象P的尺寸
    
    S_Len=m*n/(Bx*Bx);              %序列長度，這裡各個偽隨機序列的長度一樣，故統一用S_Len表示序列長度
    
    rng(K(1));                      %控制隨機數生成器，隨機數生成器randi()的種子設定為0
    S1=randi([1,m*n/(Bx*Bx)],1,S_Len);  %返回一個由介於1和m*n/64之間的偽隨機整陣列成的1×S_Len陣列

    rng(K(2));                      %控制隨機數生成器，隨機數生成器randi()的種子設定為1
    S2=randi([0,5],1,S_Len);       %返回一個由介於0和5之間的偽隨機整陣列成的1×S_Len陣列

    rng(K(3));
    S3=randi([0,1],1,S_Len);

    rng(K(4));
    S4=randi([0,5],1,S_Len);
    
    %% 密文8×8分塊 或 16×16分塊
    
    Block=zeros(Bx,Bx,3,m/Bx,n/Bx);%5維陣列，以8×8×3大小的陣列作為5維陣列的元素
    for i=1:m/Bx
        for j=1:n/Bx
            Block(:,:,:,i,j)=C((i-1)*Bx+1:i*Bx,(j-1)*Bx+1:j*Bx,:);
        end
    end
    
    
    %% 解密程式1，置亂顏色分量解密
    for i=1:m/Bx
        for j=1:n/Bx
            switch S4(i*j)
                case 1      %RBG->RGB，第2個顏色分量與第3個顏色分量相互交換，使用異或操作進行資料變換，
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                case 2      %GRB->RGB,第1個顏色分量與第2個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    
                case 3      %BGR->RGB,第1個顏色分量與第3個顏色分量相互交換
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    
                case 4      %BRG->BGR->RGB,分兩步進行，首先第2個顏色分量與第3個顏色分量相互交換，再第1個顏色分量與第3個顏色分量相互交換
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,3,i,j));
                    
                case 5      %GBR->GRB->RGB,分兩步進行，首先第2個顏色分量與第3個顏色分量相互交換，再第1個顏色分量與第2個顏色分量相互交換
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,3,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,2,i,j),Block(:,:,3,i,j));
                    
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,2,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    Block(:,:,1,i,j)=bitxor(Block(:,:,1,i,j),Block(:,:,2,i,j));
                    
                otherwise
                    Block(:,:,:,i,j)=Block(:,:,:,i,j);      %不做處理
            end
        end
    end
    
    
    %% 解密程式2，負-正變換的解密
    for i=1:m/Bx
        for j=1:n/Bx
           if S3(i*j)==1
               %Block(:,:,:,i,j)=bitxor(Block(:,:,:,i,j),A);
               Block(:,:,:,i,j)=255-Block(:,:,:,i,j);
           end
        end
    end
    
    
    %% 解密程式3，塊旋轉和翻轉的解密
    for i=1:m/Bx
        for j=1:n/Bx
            % 若S2(i*j)==0，則不旋轉塊，即不做操作
            switch S2(i*j)
                case 1              %逆時針旋轉90°
                    for k=1:Bx/2       
                        for l=1:Bx/2
                            t=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(l,Bx+1-k,:,i,j);
                            Block(l,Bx+1-k,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=Block(Bx+1-l,k,:,i,j);
                            Block(Bx+1-l,k,:,i,j)=t;
                        end
                    end
                    
                case 2              %順時針旋轉180°
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=t1;

                            t2=Block(k,l+Bx/2,:,i,j);
                            Block(k,l+Bx/2,:,i,j)=Block(Bx+1-k,Bx/2+1-l,:,i,j);
                            Block(Bx+1-k,Bx/2+1-l,:,i,j)=t2;
                        end
                    end
                    
                case 3              %順時針旋轉90°
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-l,k,:,i,j);
                            Block(Bx+1-l,k,:,i,j)=Block(Bx+1-k,Bx+1-l,:,i,j);
                            Block(Bx+1-k,Bx+1-l,:,i,j)=Block(l,Bx+1-k,:,i,j);
                            Block(l,Bx+1-k,:,i,j)=t;
                        end
                    end
                    
                case 4
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(k,Bx+1-l,:,i,j);
                            Block(k,Bx+1-l,:,i,j)=t1;

                            t2=Block(Bx/2+k,l,:,i,j);
                            Block(Bx/2+k,l,:,i,j)=Block(Bx/2+k,Bx+1-l,:,i,j);
                            Block(Bx/2+k,Bx+1-l,:,i,j)=t2;
                        end
                    end
                    
                case 5
                    for k=1:Bx/2
                        for l=1:Bx/2
                            t1=Block(k,l,:,i,j);
                            Block(k,l,:,i,j)=Block(Bx+1-k,l,:,i,j);
                            Block(Bx+1-k,l,:,i,j)=t1;

                            t2=Block(k,Bx/2+l,:,i,j);
                            Block(k,Bx/2+l,:,i,j)=Block(Bx+1-k,Bx/2+l,:,i,j);
                            Block(Bx+1-k,Bx/2+l,:,i,j)=t2;
                        end
                    end
                otherwise             
            end 
        end
    end

    
    %% 解密程式4，塊置亂解密
    for i=m*n/(Bx*Bx):-1:1  
        t=Block(:,:,:,S1(i));
        Block(:,:,:,S1(i))=Block(:,:,:,i);
        Block(:,:,:,i)=t;
    end
    
    D=zeros(m,n,3);
    for i=1:m/Bx
        for j=1:n/Bx
            D((i-1)*Bx+1:i*Bx,(j-1)*Bx+1:j*Bx,:)=Block(:,:,:,i,j);
        end
    end
    
end

存在問題

如果我們以.jpg格式儲存密文，再使用解密演算法解密密文，將會得到下面的解密影象
解密影象
我們可以看到解密影象存在網格噪聲，表現出塊和塊之間的分割感。這種現象稱為塊效應。由於JPEG本身的特性（JPEG以塊進行壓縮、量化會丟失高頻係數），JPEG對連續色調的影象有很好的壓縮和解壓縮效果，但對於塊置亂後的影象（非連續色調影象）並不友好，重構出來的影象會有明顯的分割感。
下面這張是解密影象與明文的差值影象（稍微放大了差值）
在這裡插入圖片描述

小結

基於空域的影象加密方案，包括基於畫素和基於塊，這些方案得到的密文都不適合使用.jpg格式儲存密文，會出現解密效果不理想或者解密失敗的情況
解密不理想
或
解密影象存在明顯的塊偽影

其他

1、目前很多影象加密演算法沒有對密文的儲存格式進行討論，他們的方案預設使用無失真壓縮儲存影象，然後進行傳輸分發，因此他們怎麼實現加密都可以，畢竟資料都能完全恢復，只要保證影象安全性即可。

2、為了減少密文資料大小，我選擇有失真壓縮影象作為影象加密的一個方向，旨在對影象本身進行加密，使加密的影象經過有失真壓縮後仍然能較好的重構出明文。
3、為什麼我要強調說只對影象本身進行加密，這是因為這樣有利於密文的分發。只對影象本身加密具有兩個優勢：能以影象形式分發；容易判斷是否是密文。

相關推薦

MybatisPlus多條件查詢並分頁

技術標籤：mybatismysql 需求 輸入任意欄位進行查詢，如果欄位為空，則忽略該欄位，並分頁輸出。

Spring Boot Jpa 多條件查詢+排序+分頁

　　事情有點多，於是快一個月沒寫東西了，今天補上上次說的。 　　JPA是Java Persistence API的簡稱，中文名Java持久層API，是JDK 5.0註解或XML描述物件－關係表的對映關係，並將執行期的實體物件持久化到資料庫中。

81商品專案（多條件查詢和分頁功能，更新）

分析： 點商品管理後就需要分頁action管理了 這時候是空的查詢條件。 意思是所有時候的展示都是多條件查詢時候的，只不過有時候查詢條件為空。

條件查詢和分頁

建立查詢條件的實體類 和分頁類 條件實體類 package com.oracle.domain; public class Conditon {

jpa條件查詢與分頁條件查詢

首先JpaSpecificationExecutor這個介面的過載的findAll方法，Specification 用於拼接條件Pageable分頁引數，Sort排序引數。簡單記錄分頁查詢實現方式

springboot2.2.6 elasticsearch 6.8.7 多條件查詢、高亮顯示、分頁

最近做了一個爬蟲專案，需要把資料存入ES中，在網上找資料的過程中挺辛苦的，大部分文章上來就是貼程式碼，沒有講springboot和es之間版本關係，而本身ES更新真的是快，坑是真的多（自我學習能力不強，見諒），很多方

ssm框架實現多條件查詢分頁(模擬百度演算法)

首先需求分析 1、 如果資料足夠多那先預設先生成十頁 否則就生成你的總頁數這麼多頁

條件查詢_JSP多條件查詢分頁

技術標籤：條件查詢 DAO資料訪問 package dao;​import java.sql.SQLException;import java.util.ArrayList;import java.util.List;import org.apache.commons.dbutils.QueryRunner;import org.apache.commo

小書MybatisPlus第4篇-表格分頁與下拉分頁查詢

本文為mybatis系列檔案的第4篇，前三篇請訪問下面的網址。 小書MybatisPlus第1篇-整合SpringBoot快速開始增刪改查

MyBatis-Plus多表聯合查詢並且分頁(3表聯合)

這3張表的關係是模型表Model ===> 訓練表Training ===》應用表Application（大概的邏輯是：選擇應用，然後訓練，然後成為模型）

最簡單的MyBatis Plus的多表聯接、分頁查詢實現方法

一、前言 最近在加強 ITAEM 團隊的一個 app 專案——學生教師學習交流平臺 人員組成：安卓 + 前端 + 後臺

【Springboot】MybatisPlus配置+自動程式碼生成+分頁查詢

技術標籤：後端# springboot資料庫javamybatismysql 一、MyBatis配置（mybatis-plus-boot-starter）

pandas在多表查詢並輸出行資料到不同sheet頁

import pandas as pdimport pathlibfrom openpyxl import load_workbookoriginal_file = r\'school_and_country_table.csv\'originaltable = pd.read_csv(original_file)originadata = originaltable.loc[:, \'scho

Spring data jpa 的使用與詳解（二）：複雜動態查詢及分頁，排序

上一篇介紹了spring data jpa在spring boot中的基本搭建和整合，以及較為簡單的查詢，這一篇來說spring data jpa中如何實現較為複雜的查詢及分頁，排序。

mybatis collection 多條件查詢的實現方法

mybatis collection 多條件查詢的實現方法 前言： 業務需要通過mybatis 查詢返回巢狀集合，嫌多次查詢太麻煩，用自帶的高階查詢解決問題，下邊是程式碼，已測試通過。

Qt sqlite多條件查詢插入QTableWidget表格(記錄備份以防忘記，新手！)

 StatData.h #pragma once /* 注意： 使用QChartView提升為QChart 新增標頭檔案#include <QChart>，

列表查詢後分頁邏輯

一、你需要先建立一個bean物件（也就是page物件） 創建出你需要的屬性比如在我的專案中我需要用到的：有當前的頁碼currentPage

.Net Core如何對MongoDB執行多條件查詢

以前專案基本上全部使用MySQL資料庫,最近專案排期空出了一點時間leader決定把日誌模組遷移到插入/查詢效能更好的MongoDB上. 多條件查詢的寫法著實費了些功夫,撰文記錄一下.

利用python對mysql表做全域性模糊搜尋並分頁例項

在寫django專案的時候，有的資料沒有使用模型管理（資料表是動態新增的），所以要直接使用mysql。前端請求資料的時候可能會指定這幾個引數：要請求的頁號，頁大小，以及檢索條件。

python Mysql 多條件查詢

做專案時，遇到一場景，前端至少傳入一個引數，最多傳入四個引數，根據單引數或者組合引數，從資料庫篩選資料。