Return only the columns with different values.

Question

Hi all,
I am trying to solve a seemingly trivial problem but can't seem to get any straight answer anywhere in any forum. Consider a single table with 5 columns and only two rows:
row_id           first_name         last_name        age            gender
1                    John                  doe               27             M
1                    Jane                  doe               27              F  Assume there is no primary key or any other constraint. Also assume that there are only and only two rows in this table. So I basically need a query that, in the above set of rows, would return first_name and gender, as they are the only differing columns in the two rows, and also their values. Even if i can somehow get the column names that are differing that would be enough as I can easily access the values later on. Also it is important to remember that I may not know the column names of all the columns, so basically I somehow must utilize user_tab_columns in the process.
Any help appreciated.
Edited by: 894302 on May 1, 2013 10:35 AM

Answer 1

Hi,
894302 wrote:
There is nothing wrong with it. Here you have added all the columns in the decode statement as you already know all the column names. What if there is a table whose column names are unknown i.e I can pass the table as a parameter to a procedure and I would need to loop through all the columns and then perform this operation.Table- and column names must be hard-coded into the query. If you want to figure out what the columns are at run time, given only hte table name, then you need dynamic SQL.
All the column names are in the data dictionary view all_tab_columns. You can easily loop through them to build exactly as many lines like
DECODE (a.row_id,     b.row_id,     NULL, 'row_id,')     ||as you need in the SELECT clause. The FROM clause is dynamic, too: it has the variable table name in 2 places.
But i am not sure if it worth the effort to do it on the database side. Probably easier to do it on the middle tier such as .NET, which where the business logic is implemented in my company.I don't know much about .NET, so I can't compare them
It's not very hard to do in PL/SQL (as dynamic SQL goes).
Edited by: Frank Kulash on May 1, 2013 4:39 PM
Here's a function that does the dynamic SQL:
CREATE OR REPLACE FUNCTION  different_columns
(  in_table_name  IN  VARCHAR2
,  in_owner_name  IN  VARCHAR2     DEFAULT USER
RETURN VARCHAR2
IS
    return_str     VARCHAR2 (4000);
    sql_str     VARCHAR2 (1000);
BEGIN
    sql_str := 'SELECT  RTRIM ( ';
    FOR  c  IN ( SELECT    column_name
                      ,        ROW_NUMBER () OVER (ORDER BY  column_id  DESC)  AS r_n
                      FROM        all_tab_columns
           WHERE        owner     = in_owner_name
           AND        table_name     = in_table_name
           ORDER BY  column_id
    LOOP
        sql_str := sql_str || '                DECODE (a.'
                     || c.column_name
                  || ', b.'
                  || c.column_name
                  || ', NULL, '''
                  || c.column_name
                  || ', '')';
     IF  c.r_n > 1
     THEN
         sql_str := sql_str || ' ||';
     END IF;
     sql_str := sql_str || CHR (10);
    END LOOP;
    sql_str := sql_str || '              , '', '''     || CHR (10)
                            || '              )'          || CHR (10)
                 || 'FROM  "' || in_owner_name
                 || '"."' || in_table_name
                 || '" a'                    || CHR (10)
                 || 'JOIN  "' || in_owner_name
                 || '"."' || in_table_name
                 || '" b ON a.ROWID < b.ROWID';
    -- dbms_output.put_line (sql_str);     -- for debugging
    EXECUTE IMMEDIATE   sql_str  INTO  return_str;
    RETURN  return_str;
END  different_columns;
SHOW ERRORSYou can call it in SQL like this:
SELECT     different_columns ('RHIT_TABLE_X')  AS dc
FROM     dual
;Using PL/SQL, we might not need RTRIM, at least not in the query. I'll leave that as an exercise.