运用存储进程完成进销存系统中的先进先出算法(3)——Oracle9i版51CTO博客 - AG环亚娱乐

运用存储进程完成进销存系统中的先进先出算法(3)——Oracle9i版51CTO博客

2019年03月09日15时29分29秒 | 作者: 晗日 | 标签: 库房,进程,当时 | 浏览: 2105

        本文是我在前一篇文章说到的关于先进先出存储进程,针对Oracle 9i 的修改版,基本思路共同,仅仅修改了关键字运用方法。
        有关数据库和存储进程的规划,请参阅运用存储进程完结进销存系统中的先进先出 算法(1)——数据库与存储进程规划

         运用Sql Server? 前往。

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

 

  1.       
  2.   Author nileader23-    
  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; 

 

 

附件:http://down.51cto.com/data/2355654
版权声明
本文来源于网络,版权归原作者所有,其内容与观点不代表AG环亚娱乐立场。转载文章仅为传播更有价值的信息,如采编人员采编有误或者版权原因,请与我们联系,我们核实后立即修改或删除。

猜您喜欢的文章