Order By Columns in a Row

Question

Hi,
I'm struggling to solve a problem. I want to sort the values of fields in each row.
RDBMS : 11.2.0.3
CREATE TABLE test_order
  (a NUMBER, b NUMBER ,c NUMBER ,d NUMBER
REM INSERTING into test_order
Insert into "test_order" (A,B,C,D) values ('18','29','14','21');
Insert into "test_order" (A,B,C,D) values ('40','11','29','12');
Insert into "test_order" (A,B,C,D) values ('22','20','19','24');
select * from test_order
         A          B          C          D
        18         29         14         21
        40         11         29         12
        22         20         19         24 I'm trying get result in order as shown below DOES NOT matter column name.
Each row ordered by its own columns.
         A          B          C          D
        14         18         21         29
        11         12         29         40
        19         20         22         24 Note: my real table have more than one million records.
Any helps is welcome.

Answer 1

Seeing as Frank is also having fun with this, and I'm bored watching a data pump import ticking over partition by partition, I thought about creating a SQL data type called TSortedNumbers - allowing you to create/store a set of numbers as a sorted list, and providing a method for returning a specific item in the set.
As PL/SQL code needs to be used to override the default constructor, I decided to use a PL/SQL quicksort on the number list - as oppose to an expensive context switch to SQL to have SQL doing the sort for you. No idea what (if any) performance improvements there are using a PL/SQL quicksort.
However, this does demonstrate the really kewl and awesome functionality Oracle provides by enabling one to define custom SQL types.
// TNumbers is an array/collection of numbers
SQL> create or replace type TNumbers as table of number;
  2  /
Type created.
// package Lib, implements the well-known Quick Sort algorithm - and sorts an
// array of numbers, where the array is of data type TNumbers
SQL> create or replace package Lib is
  2          procedure QuickSort( array in out nocopy TNumbers );
  3  end;
  4  /
Package created.
SQL>
SQL> create or replace package body Lib is
  2          procedure SwapPivots( array in out nocopy TNumbers, pivot1 number, pivot2 number ) is
  3                  pivotValue      number;
  4          begin
  5                  pivotValue := array(pivot1);
  6                  array(pivot1) := array(pivot2);
  7                  array(pivot2) := pivotValue;
  8          end;
  9
10          procedure  Partition( array in out nocopy TNumbers, left number, right number, pivotIndex number, storeIndex out number ) is
11                  pivotValue      number;
12          begin
13                  pivotValue := array(pivotIndex);
14                  SwapPivots( array, pivotIndex, right );
15                  storeIndex := left;
16                  for i in left..right - 1 loop
17                          if array(i) < pivotValue then
18                                  SwapPivots( array, i, storeIndex );
19                                  storeIndex := storeIndex + 1;
20                          end if;
21                  end loop;
22                  SwapPivots( array, storeIndex, right );
23          end;
24
25          procedure QuickSort( array in out nocopy TNumbers, left number, right number ) is
26                  pivotIndex      number;
27                  pivotNewIndex   number;
28          begin
29                  if left < right then
30                          pivotIndex := trunc( DBMS_RANDOM.value( left, right ) );
31
32                          Partition( array, left, right, pivotIndex, pivotNewIndex );
33                          QuickSort( array, left, pivotNewIndex-1 );
34                          QuickSort( array, pivotNewIndex+1, right );
35                  end if;
36          end;
37
38          procedure QuickSort( array in out nocopy TNumbers ) is
39          begin
40                   QuickSort( array, 1, array.Count );
41          end;
42
43  end;
44  /
Package body created.
// We define a a custom SQL data type that contains a single property called n,
// where n is of type TNumber.
// The default constructor for this type is: TSortedNumbers ( <array-of-numbers )
// We create a custom constructor with the same signature, in order to override
// the default constructor.
SQL> create or replace type TSortedNumbers is object(
  2          n       TNumbers,
  3
  4          constructor function TSortedNumbers(n TNumbers) return self as result,
  5          member function Get(i integer) return number
  6  );
  7  /
Type created.
// Using our custom constructor, we accept the array-of-numbers parameter,
// assign it to our  TSortedNumbers property n, and quick sort our property so
// that the array-of-numbers is in ascending values.
// We also provide a method called Get(), that allows the caller to get a value
// from our sorted array, by index number.
SQL> create or replace type body TSortedNumbers as
  2          constructor function TSortedNumbers(n TNumbers) return self as result is
  3          begin
  4                  self.n := n;
  5                  Lib.QuickSort(self.n);
  6                  return;
  7          end;
  8
  9          member function Get(i integer) return number is
10          begin
11                  return( self.n(i) );
12          end;
13
14  end;
15  /
Type body created.
// Create sample table and populate it with data
SQL> create table testtab( a number, b number, c number, d number );
Table created.
SQL>
SQL> insert into testtab (A,B,C,D) values ('18','29','14','21');
1 row created.
SQL> insert into testtab (A,B,C,D) values ('40','11','29','12');
1 row created.
SQL> insert into testtab (A,B,C,D) values ('22','20','19','24');
1 row created.
// To create an array of numbers, we use the TNumbers() data type. Its
// constructor  is TNumbers( num1, num2, .., numn ). We pass the columns of
// the rows as parameters into this constructor and it creates an array of our
// column values. As we now have an array-of-numbers, we can instantiate a
// TSortedNumbers object. Its constructor required an array-of-numbers
// parameter. Which is what we have created using our row's columns.
// As the TSortedNumbers object contains a sorted array-of-numbers of our
// columns, we can display the numbers in the array using the Get() method
// and index position in the array of the number we want to display.
SQL> with results as(
  2  select
  3          rownum,
  4          t.*,
  5          TSortedNumbers( TNumbers(a,b,c,d) ) as NUMBER_SET
  6  from       testtab t
  7  )
  8  select
  9          r.number_set.Get(1)     as "1",
10          r.number_set.Get(2)     as "2",
11          r.number_set.Get(3)     as "3",
12          r.number_set.Get(4)     as "4"
13  from       results r
14  /
         1          2          3          4
        14         18         21         29
        11         12         29         40
        19         20         22         24
SQL>
Edited by: Billy  Verreynne  on Apr 13, 2013 6:04 PM. (Added comments to example)