Seeking to arrange columns in a table via sql but retain all of the other columns - sql

Question

All,
I'm working on an AS400 and using IBM's SQL400 DB2 SQL. I have a table with 100 columns (i.e. fields) and I need to arrange the table such that several of the columns are arranged from left to right but the remaining columns can follow the arranged columns. For example-
MyDataTable
LastName1 SSN2 FirstName3 Address4 Sales5 FirstVisit6 TimeofVisit7 +93 more columns
I need to arrange the columns/fields to look as follow-
FirstName3 LastName1 SSN2 FirstVisit6 TimeofVisit7 Address4 Sales5 Remaining 93 columns
I'm not interested in GROUP BY or ORDER by as I don't want the data sorted within the column/field but I want to arrange the columns themselves . Additionally I'm trying to avoid running SELECT of 100+ columns/fields. In essence -I have a handful of columns/fields I need to place left to right in a table and I want the remaining fields to be listed in there original place. What is the most efficient way to achieve this in SQL?

Answer 1

I question the need for this, there's usually an opportunity to re-order the columns before presentation in the UI layer.
Unless you're just dealing with ad-hoc queries/extracts. But even there, the Run SQL Scripts component of IBM ACS will allow you to drag & drop the columns into a new order while looking at the results.
In any case, if you're ok with duplicated columns, then #smoore4's suggestion of just selecting the ones you're interested in and then all of them is the quickest solution.
SELECT t.LastName1, t.SSN2, t.FirstName3, t.Address4, t.Sales5,
t.FirstVisit6, t.TimeofVisit7, t.*
FROM MyDataTable t
Otherwise you are going to need to list the columns in the order you want. In order to save some typing, take a look at the QSYS2.SYSCOLUMNS table
select system_column_name concat ', '
from qsys2.syscolumns syscolumns
where system_table_name = 'MYTABLE'
and system_table_schema='MYLIB'
You can copy & paste the list of columns and reordered them for use in your original statement.
Lastly, note that SELECT * is generally a bad idea in any kind of production code. You may find the SQL statements I posted in this answer of some use for building lists of columns.

Answer 2

To avoid having to type all the columns in a large table, I use a DB2 function named listagg(). It looks like this:
select listagg(column_name, ', ') within group (order by ordinal_position)
from qsys2.syscolumns
where table_schema = 'library name'
and table_name = 'table name'
Just make sure you type your library and table names in all upper case. It will give you a comma separated string of column names. If the string is longer than 4000 characters (which can happen if your table has a lot of fields) then you can tell the function to return a larger field by casting the column larger like this:
select listagg(cast(column_name as varchar(8000)), ', ') within group (order by ordinal_position)
from qsys2.syscolumns
where table_schema = 'library name'
and table_name = 'table name'
This will produce a varchar(8000) result field. You can safely cast it all the way up to 32740, but if you do that, there can be no other columns on the row since the max row length without large objects is 32740.
Note: this is the SQL column name. To get the 10 character system name, you want to use trim(system_column_name) instead of column_name. The trim is important here as system column name is defined as char(10) vs. varchar(128), and will include trailing spaces unless they are trimmed off.

Answer 3

You are looking to rearrange the columns in a table?
here is an SQL function named alterTable_addColumn_likeColumn that will add a column to a table that has the same data definition as a column in a reference table. The purpose being you can use this function in a select from syscolumns SQL statement to add all the columns from the table you want to rearrange to a new table.
The alterTable_addColumn_likeColumn SQL function:
/* add a column to a table with the same data defn as the like */
/* column. */
CREATE OR REPLACE function alterTable_addColumn_likeColumn(
inSchema char(10),
inTableName char(80),
inColumnName char(80),
inLikeSchema char(10),
inLikeTable char(80),
inLIkeColumn char(80))
returns char(80)
language sql
specific core0066f
MODIFIES SQL DATA
SET OPTION datfmt = *ISO, DLYPRP = *YES, DBGVIEW = *SOURCE,
USRPRF = *OWNER, DYNUSRPRF = *OWNER
BEGIN
DECLARE VMSG CHAR(80) ;
DECLARE VCMDSTR CHAR(256) ;
declare vSqlCode decimal(5,0) default 0 ;
declare vSqlState char(5) default ' ' ;
declare vErrText char(256) default ' ' ;
declare sqlCode int default 0 ;
declare SqlState char(5) default ' ' ;
declare vDataType char(10) default ' ' ;
declare vLength decimal(5,0) default 0 ;
declare vDprc decimal(1,0) default 0 ;
declare vNullable char(1) default ' ' ;
declare vHasDefault char(1) default ' ' ;
declare vColumnDefault char(80) default ' ' ;
declare vColumnHeading char(80) default ' ' ;
declare vStmt char(2000) default ' ' ;
declare dataDefn varchar(80) default ' ' ;
declare vNotNull varchar(80) default '' ;
declare vDataDefn varchar(80) default '' ;
declare vDefault varchar(256) default '' ;
declare errmsg char(256) default ' ' ;
DECLARE CONTINUE HANDLER FOR SQLEXCEPTION
begin
SET vSqlCode = SQLCODE ;
SET vSqlState = SQLstate ;
get diagnostics exception 1 vErrText = message_text ;
end ;
/* check for add column already exist. */
select a.length
into vLength
from qsys2/syscolumns a
where a.table_schema = inSchema and a.table_name = inTableName
and a.column_name = inColumnName ;
if sqlcode = 0 then
return trim(inColumnName) || ' exists' ;
end if ;
/* read data defn of like column. */
select a.data_type,
decimal(a.length,5,0) length,
decimal(coalesce(numeric_scale,0),3,0) dprc,
a.is_nullable, a.has_default,
char(a.column_default,50) column_default, a.column_heading
into vDataType, vLength, vDprc,
vNullable, vHasDefault,
vColumnDefault, vColumnHeading
from qsys2/syscolumns a
where a.table_schema = inLikeSchema and a.table_name = inLikeTable
and a.column_name = inLikeColumn ;
/* data defn of the column. */
if vDataType = 'CHAR' or vDataType = 'VARCHAR' then
set vDataDefn = trim(vDataType) || '(' || trim(char(vLength)) || ')' ;
elseif vDataType in ('DATE','TIME','TIMESTAMP') then
set vDataDefn = trim(vDataType) ;
else
set vDataDefn = trim(vDataType) || '(' || trim(char(vLength)) ||
',' || trim(char(vDprc)) || ')' ;
end if;
/* is nullable. */
if vNullable = 'N' then
set vNotNull = 'not null ' ;
else
set vNotNull = '' ;
end if ;
/* default value. */
if vHasDefault = 'Y' then
set vDefault = 'default ' || trim(vColumnDefault) ;
end if ;
set vStmt = 'alter table ' || trim(inSchema) || '/' ||
trim(inTableName) || ' ' ||
'add column ' || trim(inColumnName) || ' ' ||
vDataDefn || ' ' || vNotNull ||
' ' || vDefault ;
prepare s1 from vStmt ;
execute s1 ;
return trim(inColumnName) || ' added' ;
END
to use the function, start with a new table:
create table qgpl/steve18 (
CREATETIME timestamp default current_timestamp )
run the select * from syscolumns query. Specify the alterTable_addColumn_likeColumn function as one of the select columns. This runs the function against every row selected from the SYSCOLUMNS table. The end result is to have columns added to the definition of the target table.
select char(a.column_name,20) colname, a.data_type,
decimal(a.length,5,0) length,
decimal(coalesce(numeric_scale,0),3,0) dprc,
a.system_column_name,
altertable_addColumn_likeColumn( 'QGPL','STEVE18',
a.column_name, a.table_schema, a.table_name,
a.column_name) addcol
from qsys2/syscolumns a
where a.table_schema = 'MYLIB' and a.table_name = 'CUSMS'