Oracle工作纪要5

最新推荐文章于 2018-11-16 13:48:14 发布
最新推荐文章于 2018-11-16 13:48:14 发布
阅读量368 收藏
点赞数
分类专栏： Orcale
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。
本文链接：https://blog.csdn.net/milijiangjun/article/details/83902081
版权 
CREATE OR REPLACE PACKAGE WS_CHECKUSER_TABLE IS

  -- Author  : ADMINISTRATOR
  -- Created : 2018/11/7 09:22:42
  --视图1 视图2 结果状态 用户名称1  用户名称2
  --创建存储过程 查询用户的所有表的差集 目前定位 syscd 和base
  --USER_CHECK_LEFT  VARCHAR2,  USER_CHECK_RIGHT VARCHAR2  暂时不需要
  TYPE PUBLICK_USER_TABLES_LEFT IS REF CURSOR;
  TYPE PUBLICK_USER_TABLES_RIGHT IS REF CURSOR;
  TYPE PUBLICK_USER_TABLES_SAME IS REF CURSOR;
  TYPE PUBLICK_ATTRIBUTE_TABLES IS REF CURSOR;
  ---查询单个表的差异
  ---根据输入的表，进行表的对比对比出来表的差异
  ---返回2个查询的结果集
  ---表的名称，表的库前缀和表查询的类别。
  
  PROCEDURE TWOCOMPARISONS(P_CUR                OUT BASE_CONSTANT.T_CUR,
                           P_CUR2               OUT PUBLICK_ATTRIBUTE_TABLES,
                           RESULTMESSAGE      OUT VARCHAR2,
                           TABLENAMECHECK_LEFT VARCHAR2,
                           TABLENAMECHECK_RIGHT VARCHAR2, 
                           TABLENAMECHECK_LEFT_P VARCHAR2,
                           TABLENAMECHECK_RIGHT_P VARCHAR2,
                           P_QUERY_TYPE         NUMBER DEFAULT 0);  
  ---查询表的名称
  ---left 查询 syscd 下有base 下没有的表名称
  ---right查询 base  下有syscd下没有的表名称
  ---CENTER   syscd 下和base 下都有的表名称    
  ---不传参            
  PROCEDURE USER_TABLE_COMPARISONS(P_CUR_LEFT    OUT PUBLICK_USER_TABLES_LEFT,
                                   P_CUR_RIGHT   OUT PUBLICK_USER_TABLES_RIGHT,
                                   P_CUR_CENTER  OUT PUBLICK_USER_TABLES_SAME,
                                   RESULTMESSAGE OUT VARCHAR2);
  ---查询准备进阶版本 半完成状态 
  PROCEDURE USER_TABLE_COLUMN_COMPARISONS(P_CUR_LEFT  OUT PUBLICK_USER_TABLES_LEFT,
                                          P_CUR_RIGHT OUT PUBLICK_USER_TABLES_RIGHT);
  --查询syscd下和base下所有公共表的数据的差异sql语句组合表集
  --传入参数为GENERATION_ID 和CD_SET  必须
  --返回结果集为表TABLEID(序号),TABLENAME（表名称）,TABLESQL（对应的sql语句，2个表没有相同列名称 则为空）,
  ---TABLESTART（语句状态 true：有共同列，有语句，false ；没有公共列，没有语句）
  ---准备进阶的目标，查询出来差异结果是否有数量，然后进行判断是否需要进行显示出来
  PROCEDURE USER_TABLE_COLUMN__SQL( 
                                   GENERATION_ID IN NUMBER    ,
                                   CD_SET IN NUMBER   ,     
                                   P_CUR_DB OUT PUBLICK_USER_TABLES_RIGHT);
                                   
  
                                  
END WS_CHECKUSER_TABLE;

 

CREATE OR REPLACE PACKAGE BODY WS_CHECKUSER_TABLE IS
-------------存储过程查询单个表的
 PROCEDURE TWOCOMPARISONS(P_CUR              OUT BASE_CONSTANT.T_CUR,
                           P_CUR2             OUT PUBLICK_ATTRIBUTE_TABLES,  
                           RESULTMESSAGE OUT  VARCHAR2,               
                           TABLENAMECHECK_LEFT VARCHAR2,
                           TABLENAMECHECK_RIGHT VARCHAR2, 
                           TABLENAMECHECK_LEFT_P VARCHAR2,
                           TABLENAMECHECK_RIGHT_P VARCHAR2,
                           P_QUERY_TYPE       NUMBER DEFAULT 0 
                           ) AS  
                           TWO_COUNT NUMBER;
                           ONE_COLUMN VARCHAR2(3999);
                          
                           SELECT_TYPE_ZERO   VARCHAR2(3999);      
                           SELECT_TYPE_ONE   VARCHAR2(3999);
                           SELECT_TYPE_TWO   VARCHAR2(3999);
                           
                         
  BEGIN 
        --******************************-- 
        
        --******************************--
                       
        ---查询两表的公共列                 
        SELECT COUNT(*) INTO TWO_COUNT FROM(
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  TABLENAMECHECK_LEFT） tb1 
        INTERSECT
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  TABLENAMECHECK_RIGHT） tb2 );
        ---查询两表的公共列
        IF TWO_COUNT <= 0 THEN
          --标识没有相同的列直接不查询 返回空的结果集
          P_CUR:= NULL;
        ELSE 
           --标识有相同的直 分条件判断
             --查询公共的列部分
             SELECT WMSYS.WM_CONCAT(COLUMN_NAME) INTO ONE_COLUMN FROM (
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = TABLENAMECHECK_LEFT） tb1 
              INTERSECT 
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = TABLENAMECHECK_RIGHT） tb2 
              ) ;
             --查询公共的列部分
          SELECT_TYPE_ONE :=   'SELECT '|| ONE_COLUMN ||' FROM '||TABLENAMECHECK_LEFT_P||'.'||TABLENAMECHECK_LEFT||' MINUS SELECT  '|| ONE_COLUMN ||' FROM '||TABLENAMECHECK_RIGHT_P||'.'||TABLENAMECHECK_RIGHT;
          SELECT_TYPE_TWO :=   'SELECT '|| ONE_COLUMN ||' FROM '||TABLENAMECHECK_RIGHT_P||'.'||TABLENAMECHECK_RIGHT||' MINUS SELECT  '|| ONE_COLUMN ||' FROM '||TABLENAMECHECK_LEFT_P||'.'||TABLENAMECHECK_LEFT;
        
          IF P_QUERY_TYPE = 0 THEN 
           OPEN P_CUR FOR
             SELECT * FROM USER_TABLES;
        
          ELSIF P_QUERY_TYPE = 1 THEN
            -----1-----------
            OPEN P_CUR FOR
             SELECT_TYPE_ONE ;
              RESULTMESSAGE:= '查询成功';
             -----1-----------                                                               
          ELSIF P_QUERY_TYPE = 2 THEN
            OPEN P_CUR FOR
              SELECT_TYPE_TWO ;
              RESULTMESSAGE:= '查询成功';
          
          ELSE
               P_CUR :=NULL;
               RESULTMESSAGE:= '查询失败';
            
          END IF;
           --标识有相同的直 分条件判断
        END IF;
            --******************************--
        
         
           
   
  END TWOCOMPARISONS;
-------------存储过程查询单个表的
  ---left 以syscd为主 查找的差集 syscd 有的 base 没有 right 以syscd为主 查找的差集  base 有的 syscd  没有 。center 为2个用户 共有的表
  PROCEDURE USER_TABLE_COMPARISONS(P_CUR_LEFT    OUT PUBLICK_USER_TABLES_LEFT,
                                   P_CUR_RIGHT   OUT PUBLICK_USER_TABLES_RIGHT,
                                   P_CUR_CENTER  OUT PUBLICK_USER_TABLES_SAME,
                                   RESULTMESSAGE OUT VARCHAR2) AS
    ---USER_TABLE_COMPARISONS逻辑开始---
    P_CUR_LEFT_SQL  VARCHAR2(3999);
    P_CUR_RIGHT_SQL VARCHAR2(3999);
    P_CUR_SAME_SQL  VARCHAR2(3999);
  
  BEGIN
    -------------***-------------
  
    P_CUR_LEFT_SQL := 'SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_SYSCD'' AND t.TABLE_NAME LIKE ''S%'' ORDER BY  t.TABLE_NAME ) SYSCD_TABLE
                        MINUS 
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_BASE'' AND t.TABLE_NAME LIKE ''B%''  ORDER BY  t.TABLE_NAME)BASE_TABLE';
  
    P_CUR_RIGHT_SQL := 'SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_BASE'' AND t.TABLE_NAME LIKE ''B%''  ORDER BY  t.TABLE_NAME)BASE_TABLE 
                        MINUS
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_SYSCD'' AND t.TABLE_NAME LIKE ''S%'' ORDER BY  t.TABLE_NAME ) SYSCD_TABLE';
  
    P_CUR_SAME_SQL := 'SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_SYSCD'' AND t.TABLE_NAME LIKE ''S%'' ORDER BY  t.TABLE_NAME ) SYSCD_TABLE
                        INTERSECT
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) FROM  all_tables t WHERE  owner=''EMASS_BASE'' AND t.TABLE_NAME LIKE ''B%''  ORDER BY  t.TABLE_NAME)BASE_TABLE';
  
    OPEN P_CUR_LEFT FOR P_CUR_LEFT_SQL;
    RESULTMESSAGE := '查询出LEFT数据';
    DBMS_OUTPUT.PUT_LINE( '查询出LEFT数据');  
    OPEN P_CUR_RIGHT FOR P_CUR_RIGHT_SQL;
    RESULTMESSAGE := '查询出LEFT数据,查询出RIGHT数据';
    DBMS_OUTPUT.PUT_LINE( '查询出LEFT数据,查询出RIGHT数据');  
    OPEN P_CUR_CENTER FOR P_CUR_SAME_SQL;
    RESULTMESSAGE := '查询出LEFT数据,查询出RIGHT数据,查询出共有数据';
    DBMS_OUTPUT.PUT_LINE( '查询出LEFT数据,查询出RIGHT数据,查询出共有数据');  
  
  END USER_TABLE_COMPARISONS;

  -------------***-------------
  ---USER_TABLE_COMPARISONS逻辑结束---
  ---USER_TABLE_COLUMN_COMPARISONS---
  PROCEDURE USER_TABLE_COLUMN_COMPARISONS(
                                   P_CUR_LEFT    OUT PUBLICK_USER_TABLES_LEFT,
                                   P_CUR_RIGHT   OUT PUBLICK_USER_TABLES_RIGHT
                                   ) AS
     INDEXS NUMBER(38) DEFAULT 0 ;
     USER_TABLE_NAME_LEFT VARCHAR2(100);
     USER_TABLE_NAME_RIGHT VARCHAR2(100);  
     
     USER_TABLE_NAME_Q_LEFT VARCHAR2(100);
     USER_TABLE_NAME_Q_RIGHT VARCHAR2(100);  
     TWINS_COUNT NUMBER;
     TWINS_TABLEORCOLUMN_COUNT NUMBER;
     TWINS_START VARCHAR2(100);
     TWINS_COLUMN VARCHAR2(3999);
     TWINS_SELECT_WHERE  VARCHAR2(3999);
     P_CUR_LEFT_SQL_COUNT  NUMBER;
     P_CUR_RIGHT_SQL_COUNT NUMBER;
     P_CUR_LEFT_SQL  VARCHAR2(3999);
     P_CUR_RIGHT_SQL VARCHAR2(3999);
     ---声明查询sy下和base下的具有相同的表数据 查询 all_tables表在最高权限用户下
     CURSOR  C_EMP IS 
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) TABLENAME FROM  all_tables t WHERE  owner='EMASS_SYSCD' AND t.TABLE_NAME LIKE 'S%' ORDER BY  t.TABLE_NAME ) SYSCD_TABLE
                        INTERSECT
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) TABLENAME FROM  all_tables t WHERE  owner='EMASS_BASE' AND t.TABLE_NAME LIKE 'B%'  ORDER BY  t.TABLE_NAME)BASE_TABLE;
                    
     C_ROW C_EMP%ROWTYPE;   
     ---声明查询sy下和base下的具有相同的表数据 查询 all_tables表在最高权限用户下
     
  BEGIN
    
    ---循环相同的表开始
    FOR C_ROW IN C_EMP LOOP  
    INDEXS :=INDEXS+1;
    --DBMS_OUTPUT.PUT_LINE(INDEXS ||  C_ROW.TABLENAME || '--' );  
    --DBMS_OUTPUT.PUT_LINE(INDEXS);  
    ---循环体内的逻辑处理
    USER_TABLE_NAME_LEFT := 'S_'||C_ROW.TABLENAME;--组合标准查询表名
    USER_TABLE_NAME_RIGHT := 'B_'||C_ROW.TABLENAME;--组合标准查询表名
    USER_TABLE_NAME_Q_LEFT := 'EMASS_SYSCD.S_'||C_ROW.TABLENAME;--组合标准查询表名
    USER_TABLE_NAME_Q_RIGHT := 'EMASS_BASE.B_'||C_ROW.TABLENAME;--组合标准查询表名
    ---0.先根据表名查询出来公共的列个数
    SELECT COUNT(*) INTO TWINS_COUNT FROM(
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_LEFT） tb1 
        INTERSECT
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_RIGHT） tb2 
        );
      IF TWINS_COUNT = 0 THEN   DBMS_OUTPUT.PUT_LINE('索引'|| INDEXS||'表名'||C_ROW.TABLENAME ||'没有公共列');  TWINS_START :='FALSE';     
      ELSE TWINS_START :='TRUE'; 
      END IF;  
    
      IF TWINS_START = 'TRUE' THEN
        ---1.查询出来公共的表的列
         SELECT WMSYS.WM_CONCAT(COLUMN_NAME) INTO TWINS_COLUMN FROM (
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_LEFT） tb1 
              INTERSECT 
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_RIGHT） tb2 
          ) ;
          
          
          ---1.2 查询出来公共的表的列的查询条件
           /*  SELECT WMSYS.WM_CONCAT('''||COLUMN_NAME||''') INTO TWINS_SELECT_WHERE FROM (
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_LEFT） tb1 
              INTERSECT 
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_RIGHT） tb2 
              ) ;*/
          
         --2.根据公共的列进行判断 判断列名和类型是否一致
        /*SELECT COUNT(*) INTO TWINS_TABLEORCOLUMN_COUNT FROM(
        SELECT * FROM( SELECT  COLUMN_NAME, DATA_TYPE  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_LEFT） tb1 
        MINUS
        SELECT * FROM( SELECT  COLUMN_NAME, DATA_TYPE  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_RIGHT） tb2 
        ) ;*/
        
        ---这里如果直接大于0 的话，就跳出
         /*SELECT COUNT(*)   FROM(
        SELECT * FROM( SELECT  COLUMN_NAME, DATA_TYPE  FROM ALL_TAB_COLS WHERE TABLE_NAME =   'S_APPORTIONMENT_CONDITION'
           AND  COLUMN_NAME IN('CONDITION_INDEX','DESTINATION_PARTICIPANT_ID','PRODUCT_TYPE','SOURCE_PARTICIPANT_ID','UD_SUBTYPE','UD_TYPE')
         ） tb1 
        MINUS
        SELECT * FROM( SELECT  COLUMN_NAME, DATA_TYPE  FROM ALL_TAB_COLS WHERE TABLE_NAME =   'B_APPORTIONMENT_CONDITION'
         AND  COLUMN_NAME IN('CONDITION_INDEX','DESTINATION_PARTICIPANT_ID','PRODUCT_TYPE','SOURCE_PARTICIPANT_ID','UD_SUBTYPE','UD_TYPE')
        ） tb2 
        ) ;*/
        
        
        ---
          P_CUR_LEFT_SQL :=
           ' 
           SELECT  '||TWINS_COLUMN||' FROM ( 
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_SYSCD.'||USER_TABLE_NAME_LEFT||' t WHERE t.GENERATION_ID = 21 AND t.CD_SET = 25
           ORDER BY   '||TWINS_COLUMN||'
           ) t
           MINUS 
           SELECT  '||TWINS_COLUMN||' FROM (
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_BASE.'||USER_TABLE_NAME_RIGHT||' t
           ORDER BY   '||TWINS_COLUMN||') t;';
           
          P_CUR_RIGHT_SQL :=
             ' 
             SELECT  '||TWINS_COLUMN||' FROM (
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_BASE.'||USER_TABLE_NAME_RIGHT||' t
           ORDER BY   '||TWINS_COLUMN||') t
            MINUS  
           SELECT  '||TWINS_COLUMN||' FROM ( 
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_SYSCD.'||USER_TABLE_NAME_LEFT||' t WHERE t.GENERATION_ID = 21 AND t.CD_SET = 25
           ORDER BY   '||TWINS_COLUMN||'
           ) t; ';
          DBMS_OUTPUT.PUT_LINE('这个是第'||INDEXS); 
          IF INDEXS = 1 THEN
              DBMS_OUTPUT.PUT_LINE('这个是第'||P_CUR_LEFT_SQL); 
               DBMS_OUTPUT.PUT_LINE('这个是第'||P_CUR_RIGHT_SQL); 
          END IF ;
          --   DBMS_OUTPUT.PUT_LINE(P_CUR_LEFT_SQL); 
          
           --  DBMS_OUTPUT.PUT_LINE(P_CUR_RIGHT_SQL); 
         
          ---这里如果直接大于0 的话，就跳出
      /*  IF TWINS_TABLEORCOLUMN_COUNT != TWINS_COUNT THEN
           DBMS_OUTPUT.PUT_LINE('索引'|| INDEXS||'表名'||C_ROW.TABLENAME ||'列名的数据类型不同'); 
        ELSIF TWINS_TABLEORCOLUMN_COUNT <=0 THEN 
            DBMS_OUTPUT.PUT_LINE('索引'|| INDEXS||'表名'||C_ROW.TABLENAME ||'数据类型不一致'); 
        ELSE   
        --3.在这里是列名和列名数据类型都一样。在这里进行查询差集,返出差集的结果
         DBMS_OUTPUT.PUT_LINE('--'); 
         \*   OPEN P_CUR_LEFT FOR P_CUR_LEFT_SQL;
            OPEN P_CUR_RIGHT FOR P_CUR_RIGHT_SQL;*\
         -- SELECT COUNT(*) INTO P_CUR_LEFT_SQL_COUNT FROM P_CUR_LEFT; 
         --3.
        END IF; */
         ---2.进行查询相关的差集
      END IF;                          
   
    
    ---循环体内的逻辑处理
    END LOOP;  
    ---循环相同的表结束
    DBMS_OUTPUT.PUT_LINE(INDEXS);  
  END USER_TABLE_COLUMN_COMPARISONS;
  ---USER_TABLE_COLUMN_COMPARISONS---
  
  ---USER_TABLE_COLUMN_COMPARISONS---
  PROCEDURE USER_TABLE_COLUMN__SQL(
                                   GENERATION_ID IN NUMBER    ,
                                   CD_SET IN NUMBER    ,                   
                                   P_CUR_DB   OUT PUBLICK_USER_TABLES_RIGHT
                                   ) AS
     INDEXS NUMBER(38) DEFAULT 0 ;
     USER_TABLE_NAME_LEFT VARCHAR2(100);
     USER_TABLE_NAME_RIGHT VARCHAR2(100);  
     TWINS_LEFT_COUNT NUMBER;
     TWINS_RIGHT_COUNT NUMBER;
     TWINS_COUNT NUMBER;
    
     TWINS_START VARCHAR2(100);
     TWINS_COLUMN VARCHAR2(3999);
   
     P_CUR_LEFT_SQL  VARCHAR2(3999);
     P_CUR_RIGHT_SQL VARCHAR2(3999);
     ---临时表的数据
     OUT_TABLE_DB_SQL  VARCHAR2(3999);
     OUT_INDERT_SQL VARCHAR2(3999);
     OUT_TABLE_DB_START VARCHAR2(100);
     ---声明查询sy下和base下的具有相同的表数据 查询 all_tables表在最高权限用户下
     CURSOR  C_EMP IS 
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) TABLENAME FROM  all_tables t WHERE  owner='EMASS_SYSCD' AND t.TABLE_NAME LIKE 'S%' ORDER BY  t.TABLE_NAME ) SYSCD_TABLE
                        INTERSECT
                        SELECT * FROM (SELECT SUBSTR(t.TABLE_NAME,3) TABLENAME FROM  all_tables t WHERE  owner='EMASS_BASE' AND t.TABLE_NAME LIKE 'B%'  ORDER BY  t.TABLE_NAME)BASE_TABLE;
                    
     C_ROW C_EMP%ROWTYPE;   
     ---声明查询sy下和base下的具有相同的表数据 查询 all_tables表在最高权限用户下
     
  BEGIN
    ---创建存储表 逻辑部分
     SELECT  COUNT(*) INTO OUT_TABLE_DB_START  FROM  user_tables WHERE  table_name = 'OUT_TABLE_DB';
     IF OUT_TABLE_DB_START <= 0 THEN 
 /*只存在第一次创建的时候用*/
  OUT_TABLE_DB_SQL :='CREATE GLOBAL TEMPORARY TABLE  OUT_TABLE_DB  (
       TABLEID NUMBER,
       TABLENAME VARCHAR2(500),
       TABLESQL VARCHAR2(3999),
       TABLESTART VARCHAR2(100)
    ) ON COMMIT PRESERVE ROWS ';
  EXECUTE IMMEDIATE OUT_TABLE_DB_SQL; 
  /*ELSE 
    OUT_TABLE_DB_SQL := 'DELETE FROM OUT_TABLE_DB';
    EXECUTE IMMEDIATE OUT_TABLE_DB_SQL; */
  END IF; 
    ---创建存储表 逻辑部分
    
    ---循环相同的表开始
    FOR C_ROW IN C_EMP LOOP  
    INDEXS :=INDEXS+1;
    --DBMS_OUTPUT.PUT_LINE(INDEXS ||  C_ROW.TABLENAME || '--' );  
    --DBMS_OUTPUT.PUT_LINE(INDEXS);  
    ---循环体内的逻辑处理
    USER_TABLE_NAME_LEFT := 'S_'||C_ROW.TABLENAME;--组合标准查询表名
    USER_TABLE_NAME_RIGHT := 'B_'||C_ROW.TABLENAME;--组合标准查询表名
 
    ---0.先根据表名查询出来公共的列个数
    SELECT COUNT(*) INTO TWINS_COUNT FROM(
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_LEFT） tb1 
        INTERSECT
        SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME =  USER_TABLE_NAME_RIGHT） tb2 
        );
      IF TWINS_COUNT = 0 THEN   
        DBMS_OUTPUT.PUT_LINE('索引'|| INDEXS||'表名'||C_ROW.TABLENAME ||'没有公共列'); 
           OUT_INDERT_SQL :='INSERT INTO OUT_TABLE_DB(TABLEID,TABLENAME,TABLESQL,TABLESTART) VALUES('||INDEXS||','''||USER_TABLE_NAME_LEFT||''','''',''FALSE'')';
            EXECUTE IMMEDIATE OUT_INDERT_SQL;
             OUT_INDERT_SQL :='INSERT INTO OUT_TABLE_DB(TABLEID,TABLENAME,TABLESQL,TABLESTART) VALUES('||INDEXS||','''||USER_TABLE_NAME_RIGHT||''','''',''FALSE'')';
            EXECUTE IMMEDIATE OUT_INDERT_SQL;
         TWINS_START :='FALSE';     
      ELSE TWINS_START :='TRUE'; 
      END IF;  
    
      IF TWINS_START = 'TRUE' THEN
        ---1.查询出来公共的表的列 例如：  t.GENERATION_ID = 21 AND t.CD_SET = 25
         SELECT WMSYS.WM_CONCAT(COLUMN_NAME) INTO TWINS_COLUMN FROM (
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_LEFT） tb1 
              INTERSECT 
              SELECT * FROM( SELECT  COLUMN_NAME  FROM ALL_TAB_COLS WHERE TABLE_NAME = USER_TABLE_NAME_RIGHT） tb2 
          ) ; 
          P_CUR_LEFT_SQL :=  'SELECT  '||TWINS_COLUMN||' FROM ( 
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_SYSCD.'||USER_TABLE_NAME_LEFT||' t WHERE t.GENERATION_ID = '||GENERATION_ID||' AND t.CD_SET =  '||CD_SET||'
           ORDER BY   '||TWINS_COLUMN||'
           ) t
           MINUS 
           SELECT  '||TWINS_COLUMN||' FROM (
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_BASE.'||USER_TABLE_NAME_RIGHT||' t
           ORDER BY   '||TWINS_COLUMN||') t;';
           
          P_CUR_RIGHT_SQL :=  'SELECT  '||TWINS_COLUMN||' FROM (
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_BASE.'||USER_TABLE_NAME_RIGHT||' t
           ORDER BY   '||TWINS_COLUMN||') t
           MINUS  
           SELECT  '||TWINS_COLUMN||' FROM ( 
           SELECT   '||TWINS_COLUMN||'
           FROM EMASS_SYSCD.'||USER_TABLE_NAME_LEFT||' t WHERE t.GENERATION_ID =  '||GENERATION_ID||' AND t.CD_SET =  '||CD_SET||'
           ORDER BY   '||TWINS_COLUMN||'
           ) t; ';
           
            OUT_INDERT_SQL :='INSERT INTO OUT_TABLE_DB(TABLEID,TABLENAME,TABLESQL,TABLESTART) VALUES('||INDEXS||','''||USER_TABLE_NAME_LEFT||''','''||P_CUR_LEFT_SQL||''',''TRUE'')';
            EXECUTE IMMEDIATE OUT_INDERT_SQL;
             OUT_INDERT_SQL :='INSERT INTO OUT_TABLE_DB(TABLEID,TABLENAME,TABLESQL,TABLESTART) VALUES('||INDEXS||','''||USER_TABLE_NAME_RIGHT||''','''||P_CUR_RIGHT_SQL||''',''TRUE'')';
            EXECUTE IMMEDIATE OUT_INDERT_SQL;
            --- 这个是
        
         
            
          DBMS_OUTPUT.PUT_LINE('这个是第'||INDEXS);  
      END IF;                          
   
    
    ---循环体内的逻辑处理
    END LOOP;  
    ---循环相同的表结束
    ---进行查处数据放到游标中
    OUT_INDERT_SQL :='SELECT * FROM OUT_TABLE_DB';
    OPEN P_CUR_DB FOR 
    OUT_INDERT_SQL;
   
    ---进行查处数据放到游标中
    DBMS_OUTPUT.PUT_LINE(INDEXS);  
  END USER_TABLE_COLUMN__SQL;
  ---USER_TABLE_COLUMN_COMPARISONS---
  
END WS_CHECKUSER_TABLE;

 

milijiangjun
关注
  • 0
    点赞
  • 踩
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
专栏目录
oracle 拆分以点号和逗号分隔的字符串为多列?
milijiangjun的博客
11-06 5202
最近遇到一个问题，需要把一个带有,的字符串拆分成多列。通过查询资料，这个操作需要使用以下2个关键知识： 1. REGEXP_SUBSTR函数 这个函数的作用是正则分隔字符串，用法为 function REGEXP_SUBSTR(String, pattern, position, occurrence, modifier) __srcstr     ：需要进行正则处理的字符串 __pa...
XXXX沟通会议纪要.pdf
08-08
3. 数据库服务器：内网IP：XXXXXXXXX，CPU：E5530 2.4G，内16G，数据库类型版本：Oracle 10G（客户反馈备份报错，想升级到11G），数据库备份文件大小为66.6G。 4. 第三方应用：用友门户：内网IP：XXXXXXXXXX，门户...
2017-03-18金麦斯特业务培训及讨论纪要1
08-08
5. **接口验证**：金麦斯特使用SOAPUI来验证EMPI患者接入接口的准确性，甲方负责验收，确保接口无误后再进行开发。 6. **数据库兼容性**：在主数据演示时遇到的报错是因为Oracle语法未改为SQL Server。甲方测试团队...
BBS系统【包含全部业务】
12-10
接下来，**会议纪要**记录了团队讨论和决策的过程，确保所有成员对项目的方向和进展有共识。 **原型设计**是将需求转化为可视化模型的过程，这可能包括线框图、流程图等，帮助设计者和开发者理解功能布局和用户体验...
erp实施手册
12-25
一、 ERP实施成功的关键 1. “一把手工程” 2. 全员动员+培训 3. 数据准备 ...四、 会议纪要 五、 企业需求分析调查 六、 调研计划 七、 实施计划 八、 培训计划 九、 岗位培训和考核 十. 附件
会议流程管理信息系统
05-23
通过分析企业会议的信息管理需求，根据会议信息的业务流程，从会议发布到会议总结、形成会议纪要、进行存档等过程，有效利用网络实现现代无纸化办公。数据库为Oracle，采用JSP+Bean的方式。-Through the analysis of...
PLSQL导出建表语句
milijiangjun的博客
09-18 4611
在表上面单机右键，查看，右下角有个查看SQL导出来就可以了
Oracle创建存储过程
milijiangjun的博客
11-06 3397
1.首先登陆plsql 最好是权限最高的用户 2.进行找到packages  3.在上面右键进行创建操作 4.在第一个里面进行编写表头第二个里面进行编写表的主题部分 然后点击右上角的执行或者f8 如果成功的话，会显示成 如果失败了的话，自行检查语法...
oracle查询一张表中的所有列及其列的数据类型
milijiangjun的博客
11-06 2926
---- 根据表名称进行查找列 SELECT table_name, column_name, data_type FROM all_tab_cols WHERE table_name = 'BASE_ORG' ;
Oracle 中关于字符串的拼接问题
milijiangjun的博客
11-07 1091
一般情况下用|| 就可以。 但是在特殊的情况下，你需要进行 进行赋值操作  例如： 在这里，你就需要进行2个引号赋值了。而在特殊的语句中需要把‘’ 加上输出出来，这个时候需要这样操作 这样就可以在数据库用到的地方进行设置和使用相关的。...
Oracle存储过程001
milijiangjun的博客
11-16 369
包含值的声明循环 添加数据创建表 临时表  CREATE OR REPLACE PACKAGE WS_CHECKUSER_TABLE IS -- Author : ADMINISTRATOR -- Created : 2018/11/7 09:22:42 --视图1 视图2 结果状态 用户名称1 用户名称2 --创建存储过程 查询用户的所有表的差集 目前定位 syscd ...
Oracle工作纪要4
milijiangjun的博客
11-09 365
创建存储过程实现oracle 下syscd 和base 用户的相同的表的差集结果的sql语句结果集。 完结版本在第3个 包头： CREATE OR REPLACE PACKAGE WS_CHECKUSER_TABLE IS -- Author : ADMINISTRATOR -- Created : 2018/11/7 09:22:42 --视图1 视图2 结果状态 用户名...
Oracle工作纪要3
milijiangjun的博客
11-07 351
创建存储过程 查询 出两个oracle 指定用户下所指定 表的公共列的差集 包头部分： create or replace package WS_Check_Comparisons is --添加组织， type PUBLICK_ATTRIBUTE_TABLES is REF CURSOR; PROCEDURE TWOCOMPARISONS( ...
Oracle纪要1
milijiangjun的博客
11-07 331
存储过程的创建 在Packages 上面进行右键创建 在Name处输入存储过程的名称 创建出来的如图 左边包头右边包体 我们可以在包头里编写存储过程的名称和参数。在包体里面编写逻辑 这样 存储过程的框架就搭建了出来。可以在包头里面声明游标...
Oracle工作纪要2
milijiangjun的博客
11-07 318
编写存储过程，使用游标，进行查询出ORACLE 数据中 syscd用户和base用户下所有的表并查处差集和相同数据。 登录plsql ws 用户，最高权限用户，然后在Packages 上面右键新建 输入包体名称创建包体 包头信息 创建存储过程的名称 时间 游标： CREATE OR REPLACE PACKAGE WS_CHECKUSER_TABLE IS -- Author : ...
b051银行客户管理系统-springboot+vue+elementui.zip（可运行源码+sql文件+文档）
07-23
系统根据B/S，即所谓的电脑浏览器/网络服务器方式，运用Java技术性，挑选MySQL作为后台系统。系统主要包含对客服聊天管理、字典表管理、公告信息管理、金融工具管理、金融工具收藏管理、金融工具银行卡管理、借款管理、理财产品管理、理财产品收藏管理、理财产品银行卡管理、理财银行卡信息管理、银行卡管理、存款管理、银行卡记录管理、取款管理、转账管理、用户管理、员工管理等功能模块。 文中重点介绍了银行管理的专业技术发展背景和发展状况，随后遵照软件传统式研发流程，最先挑选适用思维和语言软件开发平台，依据需求分析报告模块和设计数据库结构，再根据系统功能模块的设计制作系统功能模块图、流程表和E-R图。随后设计架构以及编写代码，并实现系统能模块。最终基本完成系统检测和功能测试。结果显示，该系统能够实现所需要的作用，工作状态没有明显缺陷。 系统登录功能是程序必不可少的功能，在登录页面必填的数据有两项，一项就是账号，另一项数据就是密码，当管理员正确填写并提交这二者数据之后，管理员就可以进入系统后台功能操作区。进入银行卡列表，管理员可以进行查看列表、模糊搜索以及相关维护等操作。用户进入系统可以查看公告和模糊搜索公告信息、也可以进行公告维护操作。理财产品管理页面，管理员可以进行查看列表、模糊搜索以及相关维护等操作。产品类型管理页面，此页面提供给管理员的功能有：新增产品类型,修改产品类型,删除产品类型。
测反应，简易测反应速度的小工具
07-23
测反应速度 点击开始 观察到显示框颜色发生改变 迅速点击结束 测出显示框颜色发生改变到结束按钮被触发所用时间 对于视觉刺激，成年人的平均反应时间大约在0.2-0.25秒之间
sdxl-vae.safetensors
最新发布
07-23
sdxl的vae，可放在comfyui\models\vae下。
Oracle移植工作台：SQLServer到Oracle数据库无缝迁移指南
Oracle移植工作台是一个专为简化从第三方数据库系统，如Microsoft SQL Server，迁移到Oracle数据库（如Oracle 9i和后续版本）而设计的工具。这个文档主要关注如何利用该工具来迁移SQL Server 2000中的HR数据库到...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值