SAP HANA Housekeeping der technischen Tabellen

Beim Housekeeping geht es um die Optimierung der Datenhaltung. Wenn Sie sich Gedanken zur Performance Ihres SAP-Systems machen, dann sollten Sie dabei auch das stetig wachsende Datenvolumen in Betracht ziehen. Je mehr Daten sich in Ihrem System befinden, desto mehr wird die Performance in verschiedenen Bereichen beeinflusst. Deshalb empfehlen wir, regelmäßig die Archivierung oder Löschung bestimmter Daten vorzunehmen. Zur Optimierung des Datenvolumens können verschiedene Szenarien betrachtet werden:

Performance S/4 HANA

Das Housekeeping in SAP HANA ist ein wesentlicher Bestandteil der Verwaltung und Optimierung der Datenbank, um eine hohe Performance sicherzustellen. Es bezieht sich auf die verschiedenen Aufgaben, die durchgeführt werden, um nicht mehr benötigte Daten zu entfernen oder zu archivieren, die System- und Anwendungslogs zu bereinigen und den Datenbanküberlauf zu verhindern. Hier sind einige wichtige Aspekte, wie Housekeeping die Performance von SAP HANA verbessern kann:

Datenarchivierung	Durch das Archivieren alter Daten, die nicht regelmäßig abgefragt werden, kann die Datenmenge in der Hauptdatenbank reduziert werden. Dies führt zu schnelleren Abfragezeiten und kann auch die Zeit für Backups sowie die Wiederherstellungsdauer im Falle eines Ausfalls verkürzen. Zudem ermöglicht es effizientere Reorganisationen und Wartungen.
Löschung veralteter Daten	Regelmäßiges Löschen von veralteten oder irrelevanten Daten kann helfen, die Datenbankgröße zu kontrollieren. Dies reduziert den Speicherbedarf und die Belastung der Datenbank, was wiederum zu einer Verbesserung der Abfrageperformance führt und die Belastung der Hardware reduziert.
Bereinigung von Log-Dateien	SAP HANA generiert eine Vielzahl von Log-Dateien, die wertvolle Informationen für Debugging und Monitoring bieten, aber mit der Zeit anwachsen können. Die regelmäßige Bereinigung dieser Logs verhindert, dass die Dateisysteme voll laufen und die Datenbankperformance beeinträchtigen.
Partitionierung und Reorganisation	Das regelmäßige Überprüfen und Anpassen der Tabellenpartitionierung kann die Datenverteilung optimieren und die Abfrageeffizienz erhöhen. Ebenso kann die Reorganisation von Indizes und Tabellen helfen, Fragmentierungen zu reduzieren, was zu schnelleren Zugriffszeiten führt.

HANA Datenbankmigration

Bei einer Datenbankmigration, zum Beispiel von Oracle zu SAP HANA, spielt das Housekeeping eine wichtige Rolle, um die Effizienz der Migration zu steigern und die Dauer der Offline-Phase zu minimieren. Der Database Migration Option (DMO) Prozess von SAP, der für solche Migrationen oft verwendet wird, profitiert erheblich von vorbereitenden Maßnahmen im Bereich des Datenbank-Housekeepings. Hier sind die Hauptgründe und Vorgehensweisen für das Housekeeping im Kontext einer Migration:

Reduzierung der Datenmenge	Durch das Housekeeping werden unnötige oder veraltete Daten entfernt, was direkt die Menge der zu migrierenden Daten reduziert. Weniger Daten bedeuten schnelleres Übertragen während der Migration und eine kürzere Dauer der Offline-Phase, die für den finalen Wechsel zur HANA-Datenbank erforderlich ist.
Verbesserung der Datenstruktur	Vor der Migration kann das Reorganisieren der Datenbankstrukturen, wie das Neu-Anlegen von Indizes oder das Umstrukturieren von Tabellen und Views, die Performance der neuen HANA-Datenbank optimieren. Solche Maßnahmen erleichtern die Migration, da sie dazu beitragen, dass die Daten in einer für HANA optimierten Form vorliegen.
Durchführung vor dem finalen Sizing-Report	Es wird empfohlen, das Housekeeping vor dem finalen Lauf des Reports /sdf/hdb_sizing durchzuführen. Dieser Report analysiert die Größe der bestehenden Datenbank und schätzt die erforderliche Größe und Ressourcen für die SAP HANA-Datenbank. Durch das Housekeeping werden die Daten, die analysiert werden müssen, reduziert, was zu einer genaueren und oft geringeren Schätzung der benötigten HANA-Ressourcen führt. vgl. https://me.sap.com/notes/1872170

Kostenoptimierung durch HANA data volume management

Das Housekeeping der SAP technischen Tabellen ist ein entscheidender Faktor, um die Total Cost of Ownership (TCO) einer SAP HANA Landschaft zu optimieren, insbesondere in einem hochverfügbaren Betriebsumfeld. Durch sorgfältiges Management und regelmäßige Wartung dieser Tabellen können erhebliche Kosten eingespart werden, vor allem durch Reduzierung des benötigten Speicherplatzes und Optimierung der Systemleistung. Hier sind spezifische Wege, wie das Housekeeping die TCO beeinflussen kann:

Reduzierung des Speicherbedarfs	Technische Tabellen in SAP HANA, die für das Logging, die Zwischenspeicherung von Daten oder als Teil des Betriebsablaufs dienen, können im Laufe der Zeit erheblich anwachsen, insbesondere in Systemen, die über viele Jahre hinweg aktiv sind. Durch regelmäßiges Bereinigen dieser Tabellen lässt sich der Speicherbedarf signifikant reduzieren. Beispielsweise könnten alte Log-Daten oder nicht mehr benötigte temporäre Daten entfernt werden, was direkt zu einer Reduzierung der benötigten Speicherkapazität führt.
Verringerung der Lizenzkosten	SAP HANA Lizenzkosten basieren oft auf dem Volumen der genutzten Daten und der allokierten Ressourcen wie CPU und RAM. Durch das Reduzieren der Datenmenge in den technischen Tabellen können die direkten Kosten für die Lizenzierung verringert werden. Weniger Daten zu verwalten bedeutet auch oft, dass weniger leistungsfähige (und somit günstigere) Server ausreichend sind.
Effizienzsteigerung bei Backups	Backups sind ein kritischer Bestandteil des hochverfügbaren Betriebs, aber sie sind auch zeit- und ressourcenintensiv. Durch das Verringern der Datenmenge in technischen Tabellen können die für Backups benötigten Zeiten und Speicheranforderungen reduziert werden. Dies führt nicht nur zu direkten Einsparungen bei den Speicherkosten, sondern auch zu einer verbesserten Verfügbarkeit während Backup-Fenstern.
Senkung der Betriebskosten	Mit weniger Daten in den technischen Tabellen sinkt auch der Aufwand für das Datenmanagement und die Systemüberwachung. Dies kann zu niedrigeren Betriebskosten führen, da weniger Zeit für die Verwaltung des Systems aufgewendet werden muss und eventuell weniger Personal benötigt wird.
Verbesserung der Hochverfügbarkeit	In einer hochverfügbaren Umgebung ist es entscheidend, dass das System schnell wiederherstellbar ist. Große Mengen unnötiger Daten können die Wiederherstellungszeit nach einem Ausfall verlängern. Durch das Minimieren dieser Daten kann die Downtime verkürzt und somit die Serviceverfügbarkeit verbessert werden, was indirekt zu einer Senkung der mit Ausfallzeiten verbundenen Kosten führt.

Identifizieren Sie das Potential Ihrer SAP Systemlandschaft

Das beigefügte SQL Script, welches aus der SAP HANA SQL statement collection abgeleitet ist, wurde für die direkte Identifizierung des Housekeeping Potentials parametrisiert.

Glossar des SQL Outputs:

• SCHEMA_NAME: Schema name
• TABLE_NAME: Table name
• COMPONENT: ABAP component
• S: Table store (‚R‘ for row store, ‚C‘ for column store)
• L: Load state (‚Y‘ -> loaded, ‚P‘ -> partially loaded, ‚N‘ -> not loaded)
• T: ‚X‘ if table belongs to the class of technical tables described in SAP Note 2388483
• U: ‚X‘ if at least one unique index exists for the table
• P: ‚X‘ if paged attributes are used
• COLS: Number of table columns
• RECORDS: Number of table records
• DISK_GB: Total size on disk (GB, table + indexes + LOBs)
• MEM_GB: Total current size in memory (GB, table + indexes + cached LOBs)
• PARTS: Number of table partitions (0 if table is not partitioned)
• TAB_MEM_GB: Memory size of table (GB)
• INDEXES: Number of indexes on the table (//)
• IND_MEM_GB: Memory size of indexes (GB)
• LOBS: Type and number of LOB columns of the table (‚M‘ for in memory LOBs, ‚H‘ for hybrid LOBs, ‚T‘ for text LOBs, ‚V‘ for various column LOB types)
• LOB_DISK_GB: Total disk size of all table LOB segments (GB)
• LOB_MEM_GB: Total LOB page cache size of all table LOB segments (GB)
• SHAR_GB: Shared memory size (GB)
• HEAP_GB: Heap memory size (GB)
• PERS_GB: Persistent memory size (GB)
• PAGE_MEM_GB: Paged attribute memory, e.g. NSE buffer cache content (GB)
• PAGE_DISK_GB: Paged attribute size on disk (GB)
• POS: Position of table in top list
• HOST: Host name (‚various‘ in case of partitions on multiple hosts)
• MAX_MEM_GB: Total potential maximum size in memory (GB, table + indexes + cached LOBs), LOB caching is considered as static
• MEM_PCT: Total current size in memory (% of overall memory size)
• CUM_PCT: Cumulated total current size in memory percentage of the largest tables

WITH
BASIS_INFO AS
( SELECT                                       /* Modification section */
    '%' SCHEMA_NAME,
    '%' TABLE_NAME,
    '%' STORE,                             /* ROW, COLUMN, % */
    ' ' ONLY_PAGED_TABLES,
    'X' ONLY_TECHNICAL_TABLES,
    ' ' ONLY_TABLES_WITH_NSE_RECOMMENDATION,
    512 MIN_TABLE_DISK_SIZE_MB,
    'TOTAL_DISK' ORDER_BY,                    /* CURRENT_MEM, INDEX_MEM, LOB_DISK, LOB_MEM, MAX_MEM, PAGE_MEM, PAGE_DISK, RECORDS, TABLE_MEM, TOTAL_DISK  */
    100 RESULT_ROWS
  FROM
    DUMMY
),
TECHNICAL_TABLES AS
( SELECT
    CASE WHEN LOCATE(SCHEMA_TABLE_NAME, '.') = 0 THEN '%'               ELSE SUBSTR(SCHEMA_TABLE_NAME, 1, LOCATE(SCHEMA_TABLE_NAME, '.') - 1) END SCHEMA_NAME,
    CASE WHEN LOCATE(SCHEMA_TABLE_NAME, '.') = 0 THEN SCHEMA_TABLE_NAME ELSE SUBSTR(SCHEMA_TABLE_NAME, LOCATE(SCHEMA_TABLE_NAME, '.') + 1) END TABLE_NAME
  FROM
  ( SELECT
      SUBSTR(B.TECHNICAL_TABLES, LOCATE(B.TECHNICAL_TABLES, ',', 1, O.ROWNO) + 1, LOCATE(B.TECHNICAL_TABLES, ',', 1, O.ROWNO + 1) - LOCATE(B.TECHNICAL_TABLES, ',', 1, O.ROWNO) - 1) SCHEMA_TABLE_NAME
    FROM
    ( SELECT TOP 1000 ROW_NUMBER() OVER () ROWNO FROM OBJECTS ) O,
    ( SELECT
        '%~~OLD,$BPC$HC$%,$BPC$TMP%,/1CPMB/%,/AIF/ALERT_IDX,/AIF/BGRFC_BUFF,/AIF/CDATA,/AIF/CDATAF,/AIF/MMSG_VARS,/AIF/PERS_QMSG,/AIF/PERS_XML,/AIF/QRFC_I_QIN,/AIF/QRFC_I_SDAT,' || 
        '/AIF/QRFC_I_UNIT,/AIF/QRFC_O_QOUT,/AIF/QRFC_O_SDAT,/AIF/QRFC_O_UNIT,/AIF/REP_MSG_CNT,/AIF/T_MMSG_IDX,/AIF/TRFC_I_DEST,/AIF/TRFC_I_SDAT,/AIF/TRFC_I_UNIT,' ||
        '/AIF/TRFC_O_DEST,/AIF/TRFC_O_SDAT,/AIF/TRFC_O_UNIT,/AIF/TRFCQDATA,/AIF/TRFCQIN,/AIF/TRFCQOUT,/AIF/TRFCQSTATE,/AIF/XRFC_TEMP,' ||
        '/BI0/0%,/BIC/000APR%,/BI_/A%00,/BI_/A%1,/BI_/A%2,/BI_/A%3,/BI_/B%,/BI_/E%,/BI_/F%,/BI0/E0CCM%,/BI_/H%,/BI_/I%,/BI_/J%,/BI_/K%,' ||
        '/CGS/T_REPORTXML,/IWBEP/SU_ERRLOG,/IWFND/L_MET_COL,/IWFND/L_MET_DAT,/IWFND/SU_ERRLOG,/IWFND/SU_STATS,/IWFND/SU_TPLOAD,' ||
        '/SAPAPO/LISLOG,/SAPAPO/LISMAP,/SAPTRX/AOTREF,/SAPTRX/APPTALOG,/SAPTRX/EH_TASK,/SCMTMS/D_MSGREG,/SCMTMS/RES_POS,' ||
        '/SDF/CSSIZING,/SDF/HDBSIZING,/SDF/HDBTABSIZES,/SDF/IFR_TRFCQIN,/SDF/IFR_TRFCQOU,/SDF/INDX,/SDF/MON,/SDF/RSSIZING,/SDF/SMON_CLUST,/SDF/SMON_WPINFO,' ||
        '/SDF/ZQLMD,/SSF/ATAB,/SLO/BCKNEW_CLU,/SLO/MYBACKUP_CL,/SSF/PTAB,/TXINTF/TRACE,/UIF/LREP%,/UIM/UILOG,/UISM/FAT,/VERTEX/LOGDM,/VERTEX/LOGDM_C,/VERTEX/SICXML,0BW:BIA:%,' ||
        '0BW:CRM:%,ABTREE,APQD,AQLDB,ARDB_STAT0,ARDB_STAT1,ARDB_STAT2,ARFCLOG,ARFCRSTATE,ARFCSDATA,' ||
        'ARFCSSTATE,BALC,BALDAT,BALHDR,BALHDRP,BALM,BALMP,BAL_INDX,BBPCONT,BBP_TRANSXSTRING,BCST_CAM,BCST_SR,BC_MSG,' ||
        'BC_BPEM_BL_%,BC_BPEM_EL_%,BC_MSG_AUDIT,BC_MSG_DUP_CHECK,BC_MSG_LOG,BC_MSG_VERSION,' ||
        'BC_SLD_CHANGELOG,BDCP,BDCP2,BDCPS,BTCEVTHISTORY,BTCJOBEPP,BTCJSTAT,CCMLOG,CCMLOGD,CCMOBJKEYS,CCMOBJLST,CCMSESSION,CCQUEUE,CCQUEUESLICE,CCTABCONTSLDATA,' ||
        'CDHDR,CDPOS,CDPOS_STR,CDPOS_UID,CE_SCENARIOS_,' ||
        'CNV_PE_TPM_CLU,CNV_PE_TPM_CLU_T,COIX_DATA40,COUNT_CA_DETAIL,COUNT_CA_ERR_MSG,COUNT_CA_HEADER,COUNT_CA_ITEM,COUNT_CA_PRODUCT,' ||
        'CRM_ICI_TRACES,CROSS,CS_AUDIT_LOG_,D010TAB,D010INC,DB2DB02%,DB6CONV_,DBMSGORA,DBTABLOG,DBTABPRT,DDLOG,DDPRS,DFKKDOUBTD_RET_W,' ||
        'DFKKDOUBTD_W,DOKCLU,DMC_INDXCL,DRFD_OBJ_REP_STA,DRFD_SERVOUT_LOG,DRVLOG_HEADER,DRVLOG_ITEM,DRVLOG_FIELDVAL,DRVLOG_TRAIL,' ||
        'DSVASREPODOCS,DSVASRESULTSATTR,DSVASRESULTSCHK,DSVASRESULTSGEN,DSVASRESULTSSEL,DSVASREPODOCS,' ||
        'DSVASSESSADMIN,DYNPLOAD,DYNPSOURCE,E2EREP_MAPPING,ECLOG_CALL,ECLOG_DATA,ECLOG_EXEC,ECLOG_EXT,ECLOG_HEAD,ECLOG_RESTAB,' ||
        'ECLOG_SCNT,ECLOG_SCR,ECLOG_SEL,ECLOG_XDAT,EDI30C,EDI40,EDID4,EDIDC,EDIDOC,EDIDS,' ||
        'ENHLOG,ESH_EX_CPOINTER,FSBP_CNS_IMAGE,FTPT_LOG_GDS,GRACROLEPRMVL,GRACSODREPDATA,GRACSODREPINDEX,' ||
        'GRACSODREPSTATUS,GRACUSERPRMVL,GTB_CD_DATA,GTB_CD_DATA2,GTB_CD_KEY,GVD_BGPROCESS,' ||
        'GVD_BUFF_POOL_ST,GVD_CURR_BLKSRV,GVD_DATABASE,GVD_DATAFILE,GVD_DATAGUARD_ST,GVD_DB_CACHE_ADV,' ||
        'GVD_ENQUEUE_STAT,GVD_FILESTAT,GVD_INSTANCE,GVD_LATCH,GVD_LATCHCHILDS,GVD_LATCHHOLDER,GVD_LATCHNAME,' ||
        'GVD_LATCH_MISSES,GVD_LATCH_PARENT,GVD_LIBRARYCACHE,GVD_LOCK,GVD_LOCKED_OBJEC,GVD_LOCK_ACTIVTY,' ||
        'GVD_LOGFILE,GVD_MANGD_STANBY,GVD_OBJECT_DEPEN,GVD_PARAMETER,GVD_PARAMETER2,GVD_PGASTAT,GVD_PGA_TARGET_A,' ||
        'GVD_PGA_TARGET_H,GVD_PROCESS,GVD_PX_SESSION,GVD_ROWCACHE,GVD_SEGMENT_STAT,GVD_SEGSTAT,GVD_SERVERLIST,' ||
        'GVD_SESSION,GVD_SESSION_EVT,GVD_SESSION_WAIT,GVD_SESSTAT,GVD_SESS_IO,GVD_SGA,GVD_SGACURRRESIZ,' ||
        'GVD_SGADYNCOMP,GVD_SGADYNFREE,GVD_SGARESIZEOPS,GVD_SGASTAT,GVD_SHAR_P_ADV,GVD_SPPARAMETER,GVD_SQL,' ||
        'GVD_SQLAREA,GVD_SQLTEXT,GVD_SQL_WA_ACTIV,GVD_SQL_WA_HISTO,GVD_SQL_WORKAREA,GVD_SYSSTAT,GVD_SYSTEM_EVENT,' ||
        'GVD_TEMPFILE,GVD_UNDOSTAT,GVD_WAITSTAT,GVD_WPTOTALINFO,IBIN,IBINVALUES,IDOCREL,INDX,' ||
        'INIFILE_CONTENT_HISTORY_,JBDCPHDR2,JBDCPPOS2,JOB_LOG,LMDB_P_CHANGELOG,MATCH_TRACING_,MCT_STORAGE,MCT_STORAGE_BCK,' ||
        'MDMFDBEVENT,MDMFDBID,MDMFDBPR,MERGED_TRACES_FOR_COCKPIT,NRIVSHADOW,OBJECT_HISTORY,ODQDATA,ODQDATA_C,ODQDATA_F,ODTD_ER, ODTD_ER_ATT_BIN,ORA_SNAPSHOT,ORA_SQLC_DATA,ORA_SQLC_HEAD,' ||
        'PERF_%_PERF_ANALYSIS%,P_EXPLAIN_CALL_PLANS_,POC_D_EVTQ,POC_D_EVTQ_PREBO,POC_D_EVTQ_CNTXT,POWL_RESULT,' ||
        'PPARFC,QRFC_I_EXE_STATE,QRFC_I_QIN,QRFC_I_QIN_LOCK,QRFC_I_SDATA,QRFC_I_QIN_TOP,QRFC_I_UNIT,QRFC_I_UNIT_LOCK,' ||
        'QRFCLOG,QRFCTRACE,REMOTE_SOURCE_OBJECTS_,REMOTE_SOURCE_OBJECT_DESCRIPTIONS_,REPOLOAD,' ||
        'REPOSRC,RSAU_BUF_DATA,RSAU_LOG,RSBATCHCTRL,RSBATCHCTRL_PAR,RSBATCHDATA,RSBATCHHEADER,RSBATCHPROT,' ||
        'RSBATCHSTACK,RSBERRORLOG,RSBKDATA,RSBKDATAINFO,RSBKDATAPAKID,RSBKDATAPAKSEL,RSBKSELECT,RSBMLOGPAR,' ||
        'RSBMLOGPAR_DTP,RSBMNODES,RSBMONMESS,RSBMONMESS_DTP,RSBMREQ_DTP,RSBTERRORLOG,RSBTERRORCHANGED,RSCRTDONE,RSDDSTATAGGR,RSDDSTATAGGRDEF,' ||
        'RSDDSTATCOND,RSDDSTATDELE,RSDDSTATDM,RSDDSTATDTP,RSDDSTATEVDATA,RSDDSTATHEADER,RSDDSTATINFO,RSDDSTATLOGGING,' ||
        'RSDELDONE,RSDRDLOGHEADER,RSDRDLOGPOSITION,RSECHIE_CL,RSECLOG,RSECSESSION_CL,' ||
        'RSECTXT_CL,RSECUSERAUTH_CL,RSECVAL_CL,RSERRORHEAD,RSERRORLOG,' ||
        'RSHIEDONE,RSICPROT,RSIXWWW,RSLDTDONE,RSMONFACT,RSMONICTAB,RSMONIPTAB,RSMONMESS,RSMONRQTAB,RSODSACTUPDTYPE,' ||
        'RSOTLOGOHISTORY,RSPCINSTANCE,RSPCINSTANCET,RSPCPROCESSLOG,' ||
        'RSPMADMIN,RSPMDATAPID,RSPMDATATARGET,RSPMDTASELECTION,RSPMFILTERCMD,' ||
        'RSPMHKDATAPID,RSPMHKLOG,RSPMHKPROCESS,RSPMHKREQUEST,RSPMHKREQUESTPRP,RSPMHKREQSTATHST,RSPMHKSELECTION,RSPMHKXREF,' ||
        'RSPMLOG,RSPMPROCESS,RSPMPROCESSDTAV,RSPMPROCESSTYPE,' ||
        'RSPMPROCESSTYPET,RSPMREQSTATHIST,RSPMREQUEST,RSPMREQUESTPROP,RSPMSTATICEVENT,RSPMSTORAGESTAT,RSPMTRACE,RSPMVARIANT,RSPMXREF,' ||
        'RSR_CACHE_DATA_B,RSR_CACHE_DATA_C,RSR_CACHE_DBS_BL,RSR_CACHE_FFB,RSR_CACHE_QUERY,RSR_CACHE_STATS,' ||
        'RSR_CACHE_VARSHB,RSSELDONE,RSSTATMANREQMAP,RSSTATMANREQMDEL,RSTCPDONE,RSTT_CALLSTACK,RSUICDONE,RSWR_DATA,' ||
        'RSZCALC,RSZCEL,RSZCOMPIC,RSZELTATTR,RSZELTDIR,RSZELTPRIO,RSZELTPROP,RSZELTTXT,RSZELTXREF,RSZGLOBV,RSZRANGE,' ||
        'RSZWBOOKMARK,RSZWITEM,RSZWOBJ,RSZWVIEW,SALRT,SALRTCNT,sap.bc.ina.fileloader.db::INA_FILELOADER.LOG,SACONT01,SASACONT1,' ||
        'SBOI_DTRC_DETAIL,SBOI_DTRC_HEADER,SBCMCONT1,SCMON_DATA,SCR_ABAP_AST,SCR_ABAP_SCAN,SCR_ABAP_SYMB,SCR_ABAP_SYMB_SL,' ||
        'SDBAD,SDBAH,SE16N_CD_DATA,SE16N_CD_KEY,SEC_CONTEXT_BLKD,SICFRECORDER,SMD_HASH_TABLE,SMO8FTCFG,' ||
        'SMO8FTSTP,SMO8_DLIST,SMO8_TMDAT,SMO8_TMSG,SMW0REL,SMW3_BDOC,SMW3_BDOC1,SMW3_BDOC2,SMW3_BDOC4,SMW3_BDOC5,' ||
        'SMW3_BDOC6,SMW3_BDOC7,SMW3_BDOCQ,SMWT_TRC,SNAP,SOC3,SOC3N,SOFFCONT1,SOOD,SOOS,SPAF_ERR_LOG_MSG,SPAF_ERR_MSGSQLMD,SRRELROLES,SRRELROLES,' ||
        'SRTM_SUB,SRT_CDTC,SRT_MMASTER,SRT_MONILOG_DATA,SRT_MVERSIONS,SRT_RTC_DATA,SRT_RTC_DATA_RT,SRT_RTC_DT_RT,SRT_SEQ_HDR_STAT,' ||
        'SRT_SEQ_REORG,SRT_UTIL_ERRLOG,SRT_UTIL_TRCFUNC,SRT_UTIL_TRCPERF,SRT_UTIL_TRCPLOA,SSCOOKIE,STATISTICS_ALERTS,' ||
        'STATISTICS_ALERTS_BASE,SUAUTHVALTRC,SWELOG,SWELTS,SWEQCONT,SWEQUEUE,SWFGPROLEINST,SWFRCNTXML,' ||
        'SWFREVTCNT,SWFREVTLOG,SWFREVTPOQ,SWFRXICNT,SWFRXIHDR,SWFRXIPRC,SWF_TRC_CONT,SWNCM%,SWN_NOTIF,SWN_NOTIFTSTMP,SWN_SENDLOG,SWPNODE,SWPNODELOG,' ||
        'SWPSTEPLOG,SWP_HEADER,SWP_NODEWI,SWWCNTP0,SWWCNTPADD,SWWEI,SWWLOGHIST,SWWLOGPARA,SWWUSERWI,SWWWIDEADL,' ||
        'SWWWIHEAD,SWWWIRET,SWW_CONT,SWW_CONTOB,SWW_WI2OBJ,SWW_WIREGISTRY,SWZAI,SWZAIENTRY,SWZAIRET,SXMSCLUP,SXMSCLUP2,SXMSCLUR,SXMSCLUR2,' || 
        'SXMSPFRAWD,SXMSPFRAWH,SXMSPHIST,SXMSPHIST2,SXMSPEMAST,SXMSPEMAS2,SXMSPMAST,SXMSPMAST2,' ||
        'SXMSPVERS,SXMSPVERS2,SXMSPERROR,SXMSPERRO2,T811E,T811ED,T811ED2,TAAN_DATA,' ||
        'TAAN_FLDS,TAAN_HEAD,TABLE_GROUPS_,TASK_EXECUTIONS,TBTCO,TBTCJOBLOG%,TBTCP,TBTCS,TBTC_TASK,TEAMI_LOG_DATA,TEAMI_LOG_MSG,TPRI_PAR,' ||
        'TRANS_TOKEN_HISTORY,TRFCQDATA,TRFCQIN,TRFCQOUT,TRFCQSTATE,TRFC_I_DEST,' ||
        'TRFC_I_ERR_STATE,TRFC_I_EXE_STATE,TRFC_I_SDATA,TRFC_I_UNIT,TRFC_I_UNIT_LOCK,/TRP/RES_TRKLOG,TSPEVDEV,TSPEVJOB,TST01,' ||
        'TST03,TXMILOGRAW,UASE16N_CD_DATA,UASE16N_CD_KEY,UJ0_STAT_DTL,UJ0_STAT_HDR,UJF_DOC,UJF_DOC_CLUSTER,UPC_STATISTIC,UPC_STATISTIC2,' ||
        'UPC_STATISTIC3,USOB_AUTHVALTRC,VBDATA,VBERROR,VBHDR,VBMOD,VDCHGPTR,WBCROSSGT,WBCROSSI,WRH$_ACTIVE_SESSION_HISTORY,' ||
        'WRI$_OPTSTAT_HISTGRM_HISTORY,WRI$_OPTSTAT_HISTHEAD_HISTORY,WRI$_OPTSTAT_IND_HISTORY,WRI$_OPTSTAT_TAB_HISTORY,WWWDATA,' ||
        'XI_AF_MSG,XI_AF_MSG_AUDIT,ZARIX%,ZBI_Z%,_SYS_STATISTICS.GLOBAL%,_SYS_STATISTICS.HOST%,_SYS_STATISTICS.TEL%,' TECHNICAL_TABLES
     FROM
       DUMMY
    ) B
  )
  WHERE
    SCHEMA_TABLE_NAME != ''
),
TABLES_HELPER AS
( SELECT
    T.SCHEMA_NAME,
    T.TABLE_NAME,
    DF.PS_POSID COMPONENT,
    T.HOST,
    T.STORE,
    T.RECORD_COUNT RECORDS,
    T.TABLE_MEM_MB,
    T.LOADED,
    T.HEAP_MEM_MB,
    T.PERS_MEM_MB,
    T.MAX_MEM_MB,
    T.PAGE_MEM_MB,
    IFNULL(CPS.PAGE_DISK_MB, 0) PAGE_DISK_MB,
    TP.TOTAL_DISK_MB,
    TC.NUM_COLUMNS,
    TC.PAGED_COLUMNS,
    IFNULL( ( SELECT MAX(MAP(LOAD_UNIT, 'PAGE', 1, 0)) PAGED_PARTITIONS FROM M_TABLE_PARTITIONS TP WHERE TP.SCHEMA_NAME = T.SCHEMA_NAME AND TP.TABLE_NAME = T.TABLE_NAME ), 0 ) PAGED_PARTITIONS,
    GREATEST(0, IFNULL(I.UNIQUE_INDEXES, 0)) UNIQUE_INDEXES,
    GREATEST(0, IFNULL(I.INDEXES, 0)) INDEXES,
    GREATEST(0, IFNULL(IM.CONCATS, 0)) CONCATS,
    GREATEST(0, IFNULL(IM.IMPLICIT_INDEXES, 0)) IMPLICIT_INDEXES,
    GREATEST(0, IFNULL(IC.MULTI_COLUMN_INDEXES, 0)) MULTI_COLUMN_INDEXES,
    ( SELECT COUNT(*) FROM FULLTEXT_INDEXES F WHERE F.SCHEMA_NAME = T.SCHEMA_NAME AND F.TABLE_NAME = T.TABLE_NAME ) FULLTEXT_INDEXES,
    IFNULL(IM.INDEX_MEM_MB, 0) INDEX_MEM_MB,
    IFNULL(IM.RS_INDEX_MEM_MB, 0) RS_INDEX_MEM_MB,
    IFNULL(L.LOB_INFO, '') LOB_INFO,
    IFNULL(LS.LOB_DISK_MB, 0) LOB_DISK_MB,
    IFNULL(LS.LOB_MEM_MB, 0) LOB_MEM_MB,
    IFNULL(P.PARTITIONS, 1) PARTITIONS,
    IFNULL(TT.TECHNICAL_TABLE, '') TECHNICAL_TABLE
  FROM
    BASIS_INFO BI INNER JOIN
    ( SELECT
        'COLUMN' STORE,
        SCHEMA_NAME, 
        TABLE_NAME, 
        MAP(MIN(HOST), MAX(HOST), MIN(HOST), 'various') HOST, 
        MAP(MAX(LOADED), 'NO', 'N', 'FULL', 'Y', 'PARTIALLY', 'P') LOADED,
        SUM(RECORD_COUNT) RECORD_COUNT,
        SUM(MEMORY_SIZE_IN_TOTAL + PERSISTENT_MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 TABLE_MEM_MB,
        SUM(MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 HEAP_MEM_MB,
        SUM(PERSISTENT_MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 PERS_MEM_MB,
        SUM(ESTIMATED_MAX_MEMORY_SIZE_IN_TOTAL) / 1024 / 1024 MAX_MEM_MB,
        SUM(MEMORY_SIZE_IN_PAGE_LOADABLE_MAIN) / 1024 / 1024 PAGE_MEM_MB
      FROM
        M_CS_TABLES
      GROUP BY 
        SCHEMA_NAME, 
        TABLE_NAME
      HAVING
        SUM(RECORD_COUNT) >= 100
      UNION
      ( SELECT
          'ROW' STORE,
          SCHEMA_NAME, 
          TABLE_NAME, 
          MAP(MIN(HOST), MAX(HOST), MIN(HOST), 'various') HOST, 
          'Y' LOADED,
          SUM(RECORD_COUNT) RECORD_COUNT,
          SUM(USED_FIXED_PART_SIZE + USED_VARIABLE_PART_SIZE) / 1024 / 1024 TABLE_MEM_MB,
          0 HEAP_MEM_MB,
          0 PERS_MEM_MB,
          0 MAX_MEM_MB,
          0 PAGE_MEM_MB
        FROM
          M_RS_TABLES 
        GROUP BY 
          SCHEMA_NAME, 
          TABLE_NAME
        HAVING
          SUM(USED_FIXED_PART_SIZE + USED_VARIABLE_PART_SIZE) >= 1024 * 1024
      )
    ) T ON
      T.SCHEMA_NAME LIKE BI.SCHEMA_NAME AND
      T.TABLE_NAME LIKE BI.TABLE_NAME AND
      T.STORE LIKE BI.STORE INNER JOIN
    ( SELECT
        TC.SCHEMA_NAME,
        TC.TABLE_NAME,
        COUNT(*) NUM_COLUMNS,
        SUM(MAP(T.LOAD_UNIT, 'PAGE', 1, MAP(TC.LOAD_UNIT, 'PAGE', 1, 0))) PAGED_COLUMNS
      FROM
        TABLES T,
        TABLE_COLUMNS TC
      WHERE
        T.SCHEMA_NAME = TC.SCHEMA_NAME AND
        T.TABLE_NAME = TC.TABLE_NAME
      GROUP BY
        TC.SCHEMA_NAME,
        TC.TABLE_NAME
    ) TC ON
    TC.SCHEMA_NAME = T.SCHEMA_NAME AND
    TC.TABLE_NAME = T.TABLE_NAME INNER JOIN
    ( SELECT
        TP.SCHEMA_NAME,
        TP.TABLE_NAME,
        SUM(TP.DISK_SIZE) / 1024 / 1024 TOTAL_DISK_MB
      FROM
        BASIS_INFO BI,
        M_TABLE_PERSISTENCE_STATISTICS TP
      WHERE
        ( BI.MIN_TABLE_DISK_SIZE_MB = -1 OR TP.DISK_SIZE / 1024 / 1024 >= BI.MIN_TABLE_DISK_SIZE_MB )
      GROUP BY
        TP.SCHEMA_NAME,
        TP.TABLE_NAME
      HAVING
        SUM(TP.DISK_SIZE) >= 1024 * 1024
    ) TP ON
      TP.SCHEMA_NAME = T.SCHEMA_NAME AND
      TP.TABLE_NAME = T.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        SUM(MAIN_PHYSICAL_SIZE_IN_PAGE_LOADABLE) / 1024 / 1024 PAGE_DISK_MB
      FROM
        M_CS_COLUMNS_PERSISTENCE
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) CPS ON
      CPS.SCHEMA_NAME = TP.SCHEMA_NAME AND
      CPS.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        IFNULL(SUM
        ( CASE INTERNAL_ATTRIBUTE_TYPE
            WHEN 'TREX_UDIV'         THEN 0                                                                    /* technical necessity, completely treated as "table" */
            WHEN 'ROWID'             THEN 0                                                                    /* technical necessity, completely treated as "table" */
            WHEN 'VALID_FROM'        THEN 0                                                                    /* technical necessity, completely treated as "table" */
            WHEN 'VALID_TO'          THEN 0                                                                    /* technical necessity, completely treated as "table" */
            WHEN 'TEXT'              THEN MEMORY_SIZE_IN_TOTAL + PERSISTENT_MEMORY_SIZE_IN_TOTAL               /* both concat attribute and index on it treated as "index" */
            WHEN 'TREX_EXTERNAL_KEY' THEN MEMORY_SIZE_IN_TOTAL + PERSISTENT_MEMORY_SIZE_IN_TOTAL               /* both concat attribute and index on it treated as "index" */
            WHEN 'UNKNOWN'           THEN MEMORY_SIZE_IN_TOTAL + PERSISTENT_MEMORY_SIZE_IN_TOTAL               /* both concat attribute and index on it treated as "index" */
            WHEN 'CONCAT_ATTRIBUTE'  THEN MEMORY_SIZE_IN_TOTAL + PERSISTENT_MEMORY_SIZE_IN_TOTAL               /* both concat attribute and index on it treated as "index" */
            ELSE MAIN_MEMORY_SIZE_IN_INDEX + MAIN_PERSISTENT_MEMORY_SIZE_IN_INDEX + DELTA_MEMORY_SIZE_IN_INDEX /* index structures on single columns treated as "index" */
          END
        ), 0) / 1024 / 1024 INDEX_MEM_MB,
        SUM(CASE WHEN PART_ID <= 1 AND INTERNAL_ATTRIBUTE_TYPE IN ( 'CONCAT_ATTRIBUTE', 'TREX_EXTERNAL_KEY') THEN 1 ELSE 0 END) CONCATS,
        COUNT(DISTINCT(CASE WHEN INDEX_TYPE != 'NONE' AND INTERNAL_ATTRIBUTE_TYPE IS NULL THEN COLUMN_NAME ELSE NULL END)) IMPLICIT_INDEXES,
        0 RS_INDEX_MEM_MB
      FROM
        M_CS_ALL_COLUMNS
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
      UNION ALL
      SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        SUM(INDEX_SIZE) / 1024 / 1024 INDEX_MEM_MB,
        0 CONCATS,
        0 IMPLICIT_INDEXES,
        SUM(INDEX_SIZE) / 1024 / 1024 RS_INDEX_MEM_MB
      FROM
        M_RS_INDEXES
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) IM ON
      IM.SCHEMA_NAME = TP.SCHEMA_NAME AND
      IM.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        CASE WHEN MIN(CS_DATA_TYPE_NAME) = MAX(CS_DATA_TYPE_NAME) THEN IFNULL(MAX(MAP(CS_DATA_TYPE_NAME, 'ST_MEMORY_LOB', 'M', 'LOB', 'H', 
          'ST_DISK_LOB', 'D', 'TEXT', 'T', 'U')), '') ELSE 'V' END || COUNT(*) LOB_INFO
      FROM 
        TABLE_COLUMNS
      WHERE 
        DATA_TYPE_NAME IN ( 'BLOB', 'CLOB', 'NCLOB', 'TEXT' )
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) L ON
      L.SCHEMA_NAME = TP.SCHEMA_NAME AND
      L.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        SUM(CASE WHEN INDEX_TYPE LIKE '%UNIQUE%' OR CONSTRAINT LIKE '%UNIQUE%' OR CONSTRAINT = 'PRIMARY KEY' THEN 1 ELSE 0 END) UNIQUE_INDEXES,
        COUNT(*) INDEXES
      FROM
        INDEXES
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) I ON
      I.SCHEMA_NAME = TP.SCHEMA_NAME AND
      I.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        COUNT(*) MULTI_COLUMN_INDEXES
      FROM
        INDEX_COLUMNS
      WHERE
        POSITION = 2
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) IC ON
      IC.SCHEMA_NAME = TP.SCHEMA_NAME AND
      IC.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        COUNT(*) PARTITIONS
      FROM
        M_CS_PARTITIONS
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) P ON
      P.SCHEMA_NAME = TP.SCHEMA_NAME AND
      P.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        SUM(DISK_SIZE) / 1024 / 1024 LOB_DISK_MB,
        SUM(MEMORY_SIZE) / 1024 / 1024 LOB_MEM_MB
      FROM
        M_TABLE_LOB_STATISTICS
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) LS ON
      LS.SCHEMA_NAME = TP.SCHEMA_NAME AND
      LS.TABLE_NAME = TP.TABLE_NAME LEFT OUTER JOIN
    ( SELECT
        SCHEMA_NAME,
        TABLE_NAME,
        'X' TECHNICAL_TABLE
      FROM
        TECHNICAL_TABLES
      GROUP BY
        SCHEMA_NAME,
        TABLE_NAME
    ) TT ON
      TP.SCHEMA_NAME LIKE TT.SCHEMA_NAME AND
      TP.TABLE_NAME LIKE TT.TABLE_NAME LEFT OUTER JOIN
    TADIR TA ON
      TA.PGMID = 'R3TR' AND
      TA.OBJECT IN ('TABL', 'SQLT') AND
      TA.OBJ_NAME = T.TABLE_NAME LEFT OUTER JOIN
    TDEVC TD ON
      TD.DEVCLASS = TA.DEVCLASS LEFT OUTER JOIN
    DF14L DF ON
      TD.COMPONENT = DF.FCTR_ID
)
SELECT
  SCHEMA_NAME,
  TABLE_NAME,
  COMPONENT,
  S,                                        /* 'C' --> column store, 'R' --> row store */
  LOADED L,                                 /* 'Y' --> fully loaded, 'P' --> partially loaded, 'N' --> not loaded */
  TECHNICAL_TABLE T,                        /* 'X' if table belongs to list of technical tables (SAP Note 2388483) */
  U,                                        /* 'X' if unique index exists for table */
  MAP(PAGED, 0, ' ', 'X') P,        /* 'X' if paged attributes exist (SAP Note 1871386) */
  LPAD(NUM_COLUMNS, 4) COLS,
  LPAD(RECORDS, 12) RECORDS,
  LPAD(TO_DECIMAL(TOTAL_DISK_MB / 1024, 10, 2), 7) DISK_GB,
  LPAD(TO_DECIMAL(TOTAL_MEM_MB / 1024, 10, 2), 7) MEM_GB,
  LPAD(PARTITIONS, 5) "PARTS",
  LPAD(TO_DECIMAL(TABLE_MEM_MB / 1024, 10, 2), 10) TAB_MEM_GB,
  INDEXES,
  LPAD(TO_DECIMAL(INDEX_MEM_MB / 1024, 10, 2), 10) IND_MEM_GB,
  LPAD(LOB_INFO, 4) LOBS,
  LPAD(TO_DECIMAL(LOB_DISK_MB / 1024, 10, 2), 11) LOB_DISK_GB,
  LPAD(TO_DECIMAL(LOB_MEM_MB / 1024, 10, 2), 10) LOB_MEM_GB,
  LPAD(TO_DECIMAL(SHARED_MEM_MB / 1024, 10, 2), 7) SHAR_GB,
  LPAD(TO_DECIMAL(HEAP_MEM_MB / 1024, 10, 2), 7) HEAP_GB,
  LPAD(TO_DECIMAL(PERS_MEM_MB / 1024, 10, 2), 7) PERS_GB,
  LPAD(TO_DECIMAL(PAGE_MEM_MB / 1024, 10, 2), 11) PAGE_MEM_GB,
  LPAD(TO_DECIMAL(PAGE_DISK_MB / 1024, 10, 2), 12) PAGE_DISK_GB,
  LPAD(ROW_NUM, 3) POS,
  HOST,
  LPAD(TO_DECIMAL(MAX_TOTAL_MEM_MB / 1024, 10, 2), 10) MAX_MEM_GB,
  LPAD(TO_DECIMAL(MEM_PCT, 9, 2), 7) MEM_PCT,
  LPAD(TO_DECIMAL(SUM(MEM_PCT) OVER (ORDER BY ROW_NUM), 5, 2), 7) CUM_PCT
FROM
( SELECT
    T.SCHEMA_NAME,
    T.TABLE_NAME,
    T.COMPONENT,
    T.HOST,
    T.TECHNICAL_TABLE,
    CASE WHEN UNIQUE_INDEXES = 0 THEN ' ' ELSE 'X' END U,
    MAP(T.STORE, 'COLUMN', 'C', 'ROW', 'R') S,
    MAP(T.STORE, 'COLUMN', 0, T.TABLE_MEM_MB) SHARED_MEM_MB,
    MAP(T.STORE, 'COLUMN', T.HEAP_MEM_MB, T.RS_INDEX_MEM_MB) + T.LOB_MEM_MB HEAP_MEM_MB,
    T.PERS_MEM_MB,
    T.NUM_COLUMNS,
    MAP(T.PAGED_COLUMNS, 0, T.PAGED_PARTITIONS, T.PAGED_COLUMNS) PAGED,
    T.RECORDS,
    T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB + T.LOB_MEM_MB TOTAL_MEM_MB,
    IFNULL(T.MAX_MEM_MB, T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB) + T.LOB_MEM_MB MAX_TOTAL_MEM_MB,
    T.TABLE_MEM_MB - T.INDEX_MEM_MB + T.RS_INDEX_MEM_MB TABLE_MEM_MB,
    T.PAGE_MEM_MB,
    T.PAGE_DISK_MB,
    T.LOADED,
    T.TOTAL_DISK_MB,
    CASE 
      WHEN SUM(T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB) OVER () * 100 = 0 THEN 0 
      ELSE (T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB) / SUM(T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB) OVER () * 100
    END MEM_PCT,
    T.PARTITIONS,
    T.INDEXES || '/' || MAP(T.STORE, 'ROW', 0, GREATEST(0, T.CONCATS - T.MULTI_COLUMN_INDEXES)) || '/' || MAP(T.STORE, 'ROW', 0, T.IMPLICIT_INDEXES - (T.INDEXES - T.MULTI_COLUMN_INDEXES - T.FULLTEXT_INDEXES)) INDEXES,
    T.INDEX_MEM_MB,
    T.LOB_INFO,
    T.LOB_MEM_MB,
    T.LOB_DISK_MB,
    ROW_NUMBER () OVER ( ORDER BY MAP ( BI.ORDER_BY,
      'TOTAL_DISK',  T.TOTAL_DISK_MB, 
      'CURRENT_MEM', T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB + T.LOB_MEM_MB, 
      'MAX_MEM',     IFNULL(T.MAX_MEM_MB, T.TABLE_MEM_MB + T.RS_INDEX_MEM_MB) + T.LOB_MEM_MB,
      'TABLE_MEM',   T.TABLE_MEM_MB - T.INDEX_MEM_MB + T.RS_INDEX_MEM_MB, 
      'INDEX_MEM',   T.INDEX_MEM_MB,
      'LOB_DISK',    T.LOB_DISK_MB,
      'LOB_MEM',     T.LOB_MEM_MB,
      'PAGE_MEM',    T.PAGE_MEM_MB,
      'PAGE_DISK',   T.PAGE_DISK_MB,
      'RECORDS',     T.RECORDS ) 
      DESC, T.SCHEMA_NAME, T.TABLE_NAME ) ROW_NUM,
    BI.RESULT_ROWS,
    BI.ORDER_BY
  FROM
    BASIS_INFO BI,
    TABLES_HELPER T
  WHERE
    ( BI.ONLY_TECHNICAL_TABLES = ' ' OR T.TECHNICAL_TABLE = 'X' ) AND
    ( BI.ONLY_TABLES_WITH_NSE_RECOMMENDATION = ' ' OR T.TABLE_NAME IN ( 'BALDAT', 'CDPOS', 'EDID4' ) ) AND
    ( BI.ONLY_PAGED_TABLES = ' ' OR MAP(T.PAGED_COLUMNS, 0, T.PAGED_PARTITIONS, T.PAGED_COLUMNS) > 0 )
)
WHERE
  ( RESULT_ROWS = -1 OR ROW_NUM <= RESULT_ROWS )
ORDER BY
  ROW_NUM
WITH HINT ( IGNORE_PLAN_CACHE );