且构网

分享程序员开发的那些事...
且构网 - 分享程序员编程开发的那些事

使用存储过程实现进销存系统中的先进先出算法(3)——Oracle9i版

更新时间:2021-12-27 17:55:33

 本文是我在前一篇文章提到的关于先进先出存储过程,针对Oracle 9i 的修改版,基本思路一致,只是修改了关键字使用方法。
        有关数据库和存储过程的设计,请参阅使用存储过程实现进销存系统中的先进先出 算法(1)——数据库与存储过程设计

         使用Sql Server 前往

       点击下载Oracle 9i 存储过程  下载

 


  1.   ------------------------------------------------    
  2.   ----------Author nileader----------23-------------    
  3.   ----------Date 2010/04/24-----------------------    
  4.   ------------------------------------------------  
  5.   CREATE OR REPLACE PROCEDURE pro_ProductSM(  
  6.         SorM IN char--表征当前业务是进货还是出售 S--进货 M--出售  
  7.         pId  IN productsm.pid%type, --表征操作的商品id  
  8.                                               
  9.         marketPrice IN nvarchar2, --如果当前的业务是M,那么这个参数有效, 表示这次出售的价格    
  10.         marketNum   IN nvarchar2, --如果当前的业务是M,那么这个参数有效,表示这次出售的数量    
  11.                                               
  12.         stockPrice IN nvarchar2, --如果当前的业务是S,那么这个参数有效,表示这次进货的成本单价    
  13.         stockNum   IN nvarchar2 --如果当前的业务是S,那么这个参数有效,表示这次进货的数量  
  14. IS 
  15. BEGIN 
  16.   --定义变量  
  17.   DECLARE 
  18.     stockNo   int-- 当前可以进货的仓库编号   仓库最大6个  
  19.     marketNo  int-- 当前可以出售的仓库编号   仓库最大6个    
  20.     updateSQL nvarchar2(200); -- 一个待构造的sql update 语句   
  21.     numx      nvarchar2(10); --要更新的num号  
  22.     costx     nvarchar2(10); --要更新的cost号  
  23.     --   各个仓库现在的数量  
  24.     num1     numeric(6); --第1个仓库当前的数量  
  25.     num2     numeric(6); --第2个仓库当前的数量  
  26.     num3     numeric(6); --第3个仓库当前的数量  
  27.     num4     numeric(6); --第4个仓库当前的数量  
  28.     num5     numeric(6); --第5个仓库当前的数量  
  29.     num6     numeric(6); --第6个仓库当前的数量  
  30.     totalNum numeric(7); --现在所有仓库中的数量和  
  31.     
  32.     cost1 numeric(5, 2); --第1个仓库当前的成本  
  33.     cost2 numeric(5, 2); --第2个仓库当前的成本  
  34.     cost3 numeric(5, 2); --第3个仓库当前的成本  
  35.     cost4 numeric(5, 2); --第4个仓库当前的成本  
  36.     cost5 numeric(5, 2); --第5个仓库当前的成本  
  37.     cost6 numeric(5, 2); --第6个仓库当前的成本  
  38.     
  39.     flag int--是否完成交易,1表示完成,0表示没有完成,  
  40.     --这个标识用来表示在一个一个仓库卖的过程中,  
  41.     --是否可以满足需求,终止此次交易  
  42.     thisWant numeric(6); -- 现在还要的需求    
  43.     thisNum  numeric(6); -- 现在所在的仓库有多少货  
  44.     thisCost numeric(5, 2); -- 现在所在的仓库的成本  
  45.     
  46.     money numeric(5, 2); --  盈利  
  47.     
  48.  ---------   选择操作业务  进货还是出售 S--进货 M--出售  ---------  
  49.     
  50.     -----------------------以下是进货操作------------------  
  51.   BEGIN 
  52.     --0  
  53.     IF SorM = 'S' THEN 
  54.       --2  
  55.       BEGIN 
  56.         --1  
  57.         
  58.         --让用户知道自己在干什么    
  59.         DBMS_OUTPUT.PUT_LINE('INFO:You will buy somethings-------price is' ||  
  60.                              stockPrice || '---nums is ' || stockNum ||  
  61.                              '---pid is ' || pId);  
  62.         --取出当前可以进货的编号  
  63.         SELECT stockNo, marketNo  
  64.           INTO stockNo, marketNo  
  65.           FROM ProductSM  
  66.          WHERE pId = pId;  
  67.         --判断是否可以继续进货  
  68.         IF stockNo >= 7 THEN 
  69.           --3          --不能继续进货了  
  70.           DBMS_OUTPUT.PUT_LINE('All storages have full, can not buy!');  
  71.           --还能继续进货      1 <= stockNo <=6  
  72.         ELSE 
  73.           BEGIN 
  74.             --4  
  75.             DBMS_OUTPUT.PUT_LINE('INFO:BEGIN UPDATE THE DB WHERE PID IS' || pId);  
  76.             
  77.             -- --构造出要更新的num和cost字段, 拼装成sql语句---  
  78.             numx  := 'num' || TO_CHAR(stockNo);  
  79.             costx := 'cost' || stockNo;  
  80.             
  81.             updateSQL := 'UPDATE ProductSM SET ' || numx || '=' || stockNum || ', ' ||  
  82.                          costx || '=' || stockPrice ||  
  83.                          ', stockNo=stockNo+1 WHERE pId=' || pId;  
  84.             EXECUTE IMMEDIATE TO_CHAR(updateSQL);  
  85.             --  如果之前所有的仓库都是空的,那么marketNo=0,  
  86.             --  即没有指向任何可以出售的仓库,那么现在要让他指向第一个仓库  
  87.             IF marketNo = 0 THEN 
  88.               --5  
  89.               BEGIN 
  90.                 updateSQL := 'UPDATE ProductSM SET marketNo = 1 WHERE pId =' || pId;  
  91.                 EXECUTE IMMEDIATE TO_CHAR(updateSQL);  
  92.                 
  93.               END;  
  94.             END IF; --5         
  95.             --让用户知道自己完成了什么工作  
  96.             DBMS_OUTPUT.PUT_LINE('INFO:You buy something successfully!!' 
  97.                                  ||'-------------stockPrice is' ||  
  98.                                  stockPrice || ',---pid is ' || pId ||  
  99.                                  '----stockNum is' || stockNum);  
  100.             
  101.           END--4  
  102.           
  103.         END IF; --3  
  104.         
  105.       END--1  
  106.       
  107.       ----------------------------------以上是进货操作----------------------------  
  108.       -----------------------------------以下是出售操作----------------------------  
  109.       
  110.     ELSIF SorM = 'M' THEN 
  111.       --6  
  112.       BEGIN 
  113.         --7  
  114.         --让用户知道自己在干什么    
  115.         DBMS_OUTPUT.PUT_LINE('INFO:You will sell somethings-------price is' ||  
  116.                              marketPrice || '---nums is ' || marketNum ||  
  117.                              '---pid is ' || pId);  
  118.         -- 如果marketNo 大于stockNo 终止  
  119.         --取出当前可以出售的编号和进货编号      
  120.         SELECT stockNo, marketNo  
  121.           INTO stockNo, marketNo  
  122.           FROM ProductSM  
  123.          WHERE pId = pId;  
  124.         
  125.         IF marketNo > stockNo THEN 
  126.           --10  
  127.           BEGIN 
  128.             DBMS_OUTPUT.PUT_LINE('出售编号大于进货编号,怎么可能?我得去仓库看看了。');  
  129.           END;  
  130.         ELSE 
  131.           BEGIN 
  132.             --11  
  133.             --仓库概况  
  134.             DBMS_OUTPUT.PUT_LINE('Storages INFO:----stockNo is' ||  
  135.                                  TO_CHAR(stockNo) || ' -------marketNo is' ||  
  136.                                  TO_CHAR(marketNo));  
  137.             --   统计出现在所有的库存量,用来检测这次出售交易是否超过了所有仓库的供给量  
  138.             SELECT num1,  
  139.                    cost1,  
  140.                    num2,  
  141.                    cost2,  
  142.                    num3,  
  143.                    cost3,  
  144.                    num4,  
  145.                    cost4,  
  146.                    num5,  
  147.                    cost5,  
  148.                    num6,  
  149.                    cost6  
  150.               INTO num1,  
  151.                    cost1,  
  152.                    num2,  
  153.                    cost2,  
  154.                    num3,  
  155.                    cost3,  
  156.                    num4,  
  157.                    cost4,  
  158.                    num5,  
  159.                    cost5,  
  160.                    num6,  
  161.                    cost6  
  162.               FROM ProductSM  
  163.              WHERE pId = pId;  
  164.             
  165.             totalNum := num1 + num2 + num3 + num4 + num5 + num6;  
  166.             
  167.             --如果现在的所有数量都不能满足你的要求,那就只好说再见了  
  168.             IF totalNum < marketNum THEN 
  169.               --12  
  170.               DBMS_OUTPUT.PUT_LINE('不好意思,你的需求过大,交易失败');  
  171.               
  172.             ELSE 
  173.               BEGIN 
  174.                 --13  
  175.                 --取出当前可以出售的编号  
  176.                 SELECT marketNo  
  177.                   INTO marketNo  
  178.                   FROM ProductSM  
  179.                  WHERE pId = pId;  
  180.                 -- 从当前可以出售的开始,即@marketNo开始一个一个卖,直到满足marketNum需求  
  181.                 flag     := 0;  
  182.                 thisWant := marketNum;  
  183.                 
  184.                 WHILE flag = 0 LOOP  
  185.                   --14  
  186.                   --取出当前可以进货的编号  
  187.                   SELECT marketNo  
  188.                     INTO marketNo  
  189.                     FROM ProductSM  
  190.                    WHERE pId = pId;  
  191.                   
  192.                   IF marketNo = 1 THEN 
  193.                     --15  
  194.                     BEGIN 
  195.                       thisNum  := num1;  
  196.                       thisCost := cost1;  
  197.                       numx     := 'num1';  
  198.                       costx    := 'cost1';  
  199.                     END;  
  200.                   ELSIF marketNo = 2 THEN 
  201.                     BEGIN 
  202.                       thisNum  := num2;  
  203.                       thisCost := cost2;  
  204.                       numx     := 'num2';  
  205.                       costx    := 'cost2';  
  206.                     END;  
  207.                   ELSIF marketNo = 3 THEN 
  208.                     BEGIN 
  209.                       thisNum  := num3;  
  210.                       thisCost := cost3;  
  211.                       numx     := 'num3';  
  212.                       costx    := 'cost3';  
  213.                     END;  
  214.                   ELSIF marketNo = 4 THEN 
  215.                     BEGIN 
  216.                       thisNum  := num4;  
  217.                       thisCost := cost4;  
  218.                       numx     := 'num4';  
  219.                       costx    := 'cost4';  
  220.                     END;  
  221.                   ELSIF marketNo = 5 THEN 
  222.                     BEGIN 
  223.                       thisNum  := num5;  
  224.                       thisCost := cost5;  
  225.                       numx     := 'num5';  
  226.                       costx    := 'cost5';  
  227.                     END;  
  228.                   ELSIF marketNo = 6 THEN 
  229.                     BEGIN 
  230.                       thisNum  := num6;  
  231.                       thisCost := cost6;  
  232.                       numx     := 'num6';  
  233.                       costx    := 'cost6';  
  234.                     END;  
  235.                   END IF; --15  
  236.                   
  237.                   --判断这个仓库是否可以满足这个交易的需求  
  238.                   --如果这个仓库比需求大,那么出售marketNum件商品就ok了  
  239.                   IF thisWant < thisNum THEN 
  240.                     --17  
  241.                     BEGIN 
  242.                       --18  
  243.                       DBMS_OUTPUT.PUT_LINE('INFO:you sell something-------marketPrice is  ' ||  
  244.                                            marketPrice || ' ----cost is' ||  
  245.                                            TO_CHAR(thisCost) ||  
  246.                                            '----pid is' || pId ||  
  247.                                            '------num is' ||  
  248.                                            TO_CHAR(thisWant));  
  249.                       -- 算一下赚了多少钱  
  250.                       money := (marketPrice - thisCost) * thisWant;  
  251.                       DBMS_OUTPUT.PUT_LINE('money you gain is:' ||  
  252.                                            TO_CHAR(money));  
  253.                       --更新数据库中的仓库信息  
  254.                       updateSQL := 'UPDATE ProductSM SET ' || numx || '=' ||  
  255.                                    TO_CHAR(numx) || '-' ||  
  256.                                    TO_CHAR(thisWant) || ' WHERE pId=' || pId;  
  257.                       EXECUTE IMMEDIATE TO_CHAR(updateSQL);  
  258.                       --做一些收尾工作  
  259.                       thisWant := 0; --都满足需求了,肯定置为0了  
  260.                       flag     := 1; --表示已经完成了  
  261.                       
  262.                     END--18  
  263.                   ELSIF thisWant = thisNum THEN 
  264.                     --20  
  265.                     BEGIN 
  266.                       --21  
  267.                       
  268.                       DBMS_OUTPUT.PUT_LINE('INFO:you sell something-------marketPrice is  ' ||  
  269.                                            marketPrice || ' ----cost is' ||  
  270.                                            TO_CHAR(thisCost) ||  
  271.                                            '----pid is' || pId ||  
  272.                                            '------num is' ||  
  273.                                            TO_CHAR(thisWant));  
  274.                       -- 算一下赚了多少钱  
  275.                       money := (marketPrice - thisCost) * thisWant;  
  276.                       DBMS_OUTPUT.PUT_LINE('money you gain is:' ||  
  277.                                            TO_CHAR(money));  
  278.                       --更新数据库中的仓库信息  
  279.                       updateSQL := 'UPDATE ProductSM SET marketNo = marketNo + 1,' || numx +  
  280.                                    '=0,' || costx || '=0 WHERE pId=' || pId;  
  281.                       EXECUTE IMMEDIATE TO_CHAR(updateSQL);  
  282.                       --做一些收尾工作  
  283.                       thisWant := 0; --都满足需求了,肯定置为0了  
  284.                       flag     := 1; --表示已经完成了  
  285.                       
  286.                     END--21  
  287.                     
  288.                   ELSE 
  289.                     --23  
  290.                     BEGIN 
  291.                       --22  
  292.                       
  293.                       DBMS_OUTPUT.PUT_LINE('INFO:you sell something-------marketPrice is  ' ||  
  294.                                            marketPrice || ' ----cost is' ||  
  295.                                            TO_CHAR(thisCost) ||  
  296.                                            '----pid is' || pId ||  
  297.                                            '------num is' ||  
  298.                                            TO_CHAR(thisNum));  
  299.                       -- 算一下赚了多少钱  
  300.                       money := (marketPrice - thisCost) * thisNum;  
  301.                       DBMS_OUTPUT.PUT_LINE('money you gain is:' ||  
  302.                                            TO_CHAR(money));  
  303.                       --更新数据库中的仓库信息  
  304.                       updateSQL := 'UPDATE ProductSM SET marketNo = marketNo + 1,' || numx +  
  305.                                    '=0,' || costx + '=0 WHERE pId=' || pId;  
  306.                       EXECUTE IMMEDIATE TO_CHAR(updateSQL);  
  307.                       
  308.                       --做一些收尾工作  
  309.                       thisWant := thisWant - thisNum;  
  310.                       
  311.                     END--22  
  312.                     
  313.                   END IF; --17  
  314.                   
  315.                 END LOOP; --14  
  316.                 
  317.               END--13  
  318.             END IF; --12  
  319.             
  320.           END--11  
  321.         END IF; --10  
  322.         
  323.       END--7  
  324.     END IF; --2  
  325.     
  326.   END--0  
  327.  
  328. END

 本文转自 nileader 51CTO博客,原文链接:http://blog.51cto.com/nileader/304396,如需转载请自行联系原作者