v$sysstat names

For definiitions check : https://sites.google.com/site/oraclemonitor/oracle-statistics-defined-11-2

Collected with:

10g was on LINIX, and 11.2 on windows

 create table statnames as select i.version, m.name
from  V$statname m,
      (select version from v$instance where rownum < 2 ) i

insert into  statnames  (
select i.version, m.name
from  V$statname@LINUX m,
      (select version from v$instance@LINUX where rownum < 2 ) i

with statv as (
   select a.version v1, b.version v2,b.name
         ( select version,name
          from statnames
          where version='' ) b,
         ( select version,name
          from statnames
          where version='') a
   where a.name=b.name(+)
   select a.version, b.version,b.name
         ( select version,name
          from statnames
          where version='' ) b,
         ( select version,name
          from statnames
          where version='') a
   where a.name(+)=b.name
select * from statv order by name;
SQL> /

V1                V2                NAME
----------------- ----------------- ----------------------------------------------------------------
                Batched IO (bound) vector count
                Batched IO (full) vector count
                Batched IO (space) vector count
                Batched IO block miss count
                Batched IO buffer defrag count
                Batched IO double miss count
                Batched IO same unit count
                Batched IO single block count
                Batched IO slow jump count
                Batched IO vector block count
                Batched IO vector read count
                Batched IO zero block count
                Block Cleanout Optim referenced
                CC Analyze CUs Decompressed
                CC Analyzer Calls
                CC Archive CUs Compressed
                CC Archive CUs Decompressed
                CC CU Row Pieces Compressed
                CC CUs Compressed
                CC CUs Decompressed
                CC Check CUs Decompressed
                CC Columns Decompressed
                CC Compressed Length Compressed
                CC Compressed Length Decompressed
                CC DML CUs Decompressed
                CC Decompressed Length Compressed
                CC Decompressed Length Decompressed
                CC Dump CUs Decompressed
                CC Pieces Buffered for Decompression
                CC Query High CUs Compressed
                CC Query High CUs Decompressed
                CC Query Low CUs Compressed
                CC Query Low CUs Decompressed
                CC Rowid CUs Decompressed
                CC Rows Compressed
                CC Rows Not Compressed
                CC Scan CUs Decompressed
                CC Total Columns for Decompression
                CC Total Pieces for Decompression
                CC Total Rows for Decompression
                CC Turbo Scan CUs Decompressed        CCursor + sql area evicted        CPU used by this session        CPU used when call started        CR blocks created        Cached Commit SCN referenced
                Clusterwide global transactions
                Clusterwide global transactions spanning RAC nodes        Commit SCN cached        DB time        DBWR checkpoint buffers written        DBWR checkpoints        DBWR fusion writes        DBWR lru scans        DBWR object drop buffers written        DBWR parallel query checkpoint buffers written        DBWR revisited being-written buffer        DBWR tablespace checkpoint buffers written        DBWR thread checkpoint buffers written        DBWR transaction table writes        DBWR undo block writes        DDL statements parallelized        DFO trees parallelized        DML statements parallelized
                DX/BB enqueue lock background get time
                DX/BB enqueue lock background gets
                DX/BB enqueue lock foreground requests
                DX/BB enqueue lock foreground wait time
                Effective IO time
                Forwarded 2PC commands across RAC nodes
                GTX processes spawned by autotune
                GTX processes stopped by autotune
                HSC Compressed Segment Block Changes
                HSC Heap Segment Block Changes
                HSC IDL Compressed Blocks
                HSC OLTP Compressed Blocks
                HSC OLTP Compression skipped rows
                HSC OLTP Drop Column
                HSC OLTP Non Compressible Blocks
                HSC OLTP Space Saving
                HSC OLTP compression block checked
                HSC OLTP inline compression
                HSC OLTP negative compression
                HSC OLTP positive compression
                HSC OLTP recursive compression
                Heap Segment Array Inserts
                Heap Segment Array Updates        IMU CR rollbacks        IMU Flushes        IMU Redo allocation size        IMU bind flushes        IMU commits        IMU contention        IMU ktichg flush        IMU mbu flush        IMU pool not allocated        IMU recursive-transaction flush        IMU undo allocation size        IMU undo retention flush        IMU- failed to get a private strand        IPC CPU used by this session
                LOB table id lookup cache misses        Misses for writing mapping
                No. of Decrypt ops
                No. of Encrypt ops
                No. of Namespaces Created
                No. of Principal Cache Misses
                No. of Principal Invalidations
                No. of Roles Enabled or Disabled
                No. of User Callbacks Executed
                No. of XS Sessions Attached
                No. of XS Sessions Created
                Number of read IOs issued
                OS CPU Qt wait time        OTC commit optimization attempts        OTC commit optimization failure - setup        OTC commit optimization hits        PX local messages recv'd        PX local messages sent        PX remote messages recv'd        PX remote messages sent        Parallel operations downgraded 1 to 25 pct        Parallel operations downgraded 25 to 50 pct        Parallel operations downgraded 50 to 75 pct        Parallel operations downgraded 75 to 99 pct        Parallel operations downgraded to serial        Parallel operations not downgraded        RowCR - resume        RowCR - row contention        RowCR attempts        RowCR hits        SMON posted for dropping temp segment        SMON posted for instance recovery        SMON posted for txn recovery for other instances        SMON posted for undo segment recovery        SMON posted for undo segment shrink        SQL*Net roundtrips to/from client        SQL*Net roundtrips to/from dblink
                TBS Extension: bytes extended
                TBS Extension: files extended
                TBS Extension: tasks created
                TBS Extension: tasks executed        Workload Capture: dbtime        Workload Capture: errors        Workload Capture: size (in bytes) of recording        Workload Capture: unreplayable user calls        Workload Capture: unsupported user calls        Workload Capture: user calls        Workload Capture: user calls flushed        Workload Capture: user logins        Workload Capture: user txns
                Workload Replay: dbtime
                Workload Replay: deadlocks resolved
                Workload Replay: network time
                Workload Replay: think time
                Workload Replay: time gain
                Workload Replay: time loss
                Workload Replay: user calls        active txn count during cleanout        application wait time        auto extends on undo tablespace        background checkpoints completed        background checkpoints started        background timeouts        branch node splits        buffer is not pinned count        buffer is pinned count        bytes received via SQL*Net from client        bytes received via SQL*Net from dblink        bytes sent via SQL*Net to client        bytes sent via SQL*Net to dblink
                bytes via SQL*Net vector from client
                bytes via SQL*Net vector from dblink
                bytes via SQL*Net vector to client
                bytes via SQL*Net vector to dblink        calls to get snapshot scn: kcmgss        calls to kcmgas        calls to kcmgcs        calls to kcmgrs
                cell CUs processed for compressed
                cell CUs processed for uncompressed
                cell CUs sent compressed
                cell CUs sent head piece
                cell CUs sent uncompressed
                cell IO uncompressed bytes
                cell blocks helped by commit cache
                cell blocks helped by minscn optimization
                cell blocks processed by cache layer
                cell blocks processed by data layer
                cell blocks processed by index layer
                cell blocks processed by txn layer
                cell blocks skipped due to chained rows
                cell commit cache queries
                cell flash cache read hits
                cell index scans
                cell num smart IO sessions in rdbms block IO due to big payload
                cell num smart IO sessions in rdbms block IO due to user
                cell num smart IO sessions using passthru mode due to cellsrv
                cell num smart IO sessions using passthru mode due to timezone
                cell num smart IO sessions using passthru mode due to user
                cell num smart file creation sessions using rdbms block IO mode
                cell physical IO bytes eligible for predicate offload
                cell physical IO bytes saved by storage index
                cell physical IO bytes saved during optimized RMAN file restore
                cell physical IO bytes saved during optimized file creation
                cell physical IO interconnect bytes
                cell physical IO interconnect bytes returned by smart scan
                cell scans
                cell session smart scan efficiency
                cell simulated physical IO bytes eligible for predicate offload
                cell simulated physical IO bytes returned by predicate offload
                cell simulated session smart scan efficiency
                cell smart IO session cache hard misses
                cell smart IO session cache hits
                cell smart IO session cache hwm
                cell smart IO session cache lookups
                cell smart IO session cache soft misses
                cell transactions found in commit cache        change write time        cleanout - number of ktugct calls        cleanouts and rollbacks - consistent read gets        cleanouts only - consistent read gets        cluster key scan block gets        cluster key scans        cluster wait time        cold recycle reads        commit batch performed        commit batch requested        commit batch/immediate performed        commit batch/immediate requested        commit cleanout failures: block lost        commit cleanout failures: buffer being written        commit cleanout failures: callback failure        commit cleanout failures: cannot pin        commit cleanout failures: hot backup in progress        commit cleanout failures: write disabled        commit cleanouts        commit cleanouts successfully completed        commit immediate performed        commit immediate requested        commit nowait performed        commit nowait requested        commit txn count during cleanout        commit wait performed        commit wait requested        commit wait/nowait performed        commit wait/nowait requested        concurrency wait time        consistent changes        consistent gets        consistent gets - examination        consistent gets direct        consistent gets from cache
                consistent gets from cache (fastpath)        current blocks converted for CR        cursor authentications        data blocks consistent reads - undo records applied        db block changes        db block gets        db block gets direct        db block gets from cache
                db block gets from cache (fastpath)
                db corrupt blocks detected
                db corrupt blocks recovered        deferred (CURRENT) block cleanout applications        deferred CUR cleanouts (index blocks)        dirty buffers inspected        doubling up with imu segment        drop segment calls in space pressure        enqueue conversions        enqueue deadlocks        enqueue releases        enqueue requests        enqueue timeouts        enqueue waits        exchange deadlocks        execute count        failed probes on index block reclamation
                file io service time
                file io wait time
                flash cache eviction: aged out
                flash cache eviction: buffer pinned
                flash cache eviction: invalidated
                flash cache insert skip: DBWR overloaded
                flash cache insert skip: corrupt
                flash cache insert skip: exists
                flash cache insert skip: modification
                flash cache insert skip: not current
                flash cache insert skip: not useful
                flash cache inserts
                flashback log write bytes        flashback log writes        frame signature mismatch        free buffer inspected        free buffer requested        gc CPU used by this session
                gc blocks compressed        gc blocks corrupt        gc blocks lost        gc claim blocks lost        gc cr block build time        gc cr block flush time
                gc cr block read wait time        gc cr block receive time        gc cr block send time        gc cr blocks received        gc cr blocks served        gc current block flush time        gc current block pin time        gc current block receive time        gc current block send time        gc current blocks received        gc current blocks served
                gc kbytes saved
                gc kbytes sent        gc local grants
                gc reader bypass grants        gc remote grants        gcs messages sent        ges messages sent        global enqueue CPU used by this session        global enqueue get time        global enqueue gets async        global enqueue gets sync        global enqueue releases        global undo segment hints helped        global undo segment hints were stale        heap block compress        hot buffers moved to head of LRU        immediate (CR) block cleanout applications        immediate (CURRENT) block cleanout applications        immediate CR cleanouts (index blocks)        index crx upgrade (found)        index crx upgrade (positioned)        index crx upgrade (prefetch)        index fast full scans (direct read)        index fast full scans (full)        index fast full scans (rowid ranges)        index fetch by key
                index reclamation/extension switch        index scans kdiixs1        java call heap collected bytes        java call heap collected count        java call heap gc count        java call heap live object count        java call heap live object count max        java call heap live size        java call heap live size max        java call heap object count        java call heap object count max        java call heap total size        java call heap total size max        java call heap used size        java call heap used size max        java session heap collected bytes        java session heap collected count        java session heap gc count        java session heap live object count        java session heap live object count max        java session heap live size        java session heap live size max        java session heap object count        java session heap object count max        java session heap used size        java session heap used size max        leaf node 90-10 splits        leaf node splits        lob reads        lob writes        lob writes unaligned        local undo segment hints helped        local undo segment hints were stale        logons cumulative        logons current
                max cf enq hold time        messages received        messages sent
                min active SCN optimization applied on CR        native hash arithmetic execute        native hash arithmetic fail        no buffer to keep pinned count        no work - consistent read gets
                non-idle wait count
                non-idle wait time        number of map misses        number of map operations        opened cursors cumulative        opened cursors current
                parse count (describe)        parse count (failures)        parse count (hard)        parse count (total)        parse time cpu        parse time elapsed        physical read IO requests        physical read bytes
                physical read flash cache hits
                physical read requests optimized        physical read total IO requests        physical read total bytes        physical read total multi block requests        physical reads        physical reads cache        physical reads cache prefetch        physical reads direct        physical reads direct (lob)        physical reads direct temporary tablespace        physical reads for flashback new        physical reads prefetch warmup        physical reads retry corrupt        physical write IO requests        physical write bytes        physical write total IO requests        physical write total bytes        physical write total multi block requests        physical writes        physical writes direct        physical writes direct (lob)        physical writes direct temporary tablespace        physical writes from cache        physical writes non checkpoint        pinned buffers inspected
                pinned cursors current        prefetch clients - 16k        prefetch clients - 2k        prefetch clients - 32k        prefetch clients - 4k        prefetch clients - 8k        prefetch clients - default        prefetch clients - keep        prefetch clients - recycle        prefetch warmup blocks aged out before use        prefetch warmup blocks flushed out before use        prefetched blocks aged out before use        process last non-idle time        queries parallelized        queue flush        queue ocp pages        queue position update        queue qno pages        queue single row        queue splits        queue update without cp update        recovery array read time        recovery array reads
                recovery block gets from cache        recovery blocks read
                recovery blocks read for lost write detection
                recovery blocks skipped lost write checks        recursive aborts on index block reclamation        recursive calls        recursive cpu usage
                recursive system API invocations
                redo blocks checksummed by FG (exclusive)
                redo blocks checksummed by LGWR        redo blocks read for recovery        redo blocks written        redo buffer allocation retries        redo entries
                redo entries for lost write detection
                redo k-bytes read (memory)
                redo k-bytes read (memory) by LNS
                redo k-bytes read for recovery
                redo k-bytes read for terminal recovery
                redo k-bytes read total
                redo k-bytes read total by LNS        redo log space requests        redo log space wait time        redo ordering marks        redo size
                redo size for direct writes
                redo size for lost write detection        redo subscn max counts        redo synch time        redo synch writes        redo wastage
                redo write broadcast ack count
                redo write broadcast ack time        redo write time        redo writes
                remote Oradebug requests        rollback changes - undo records applied        rollbacks only - consistent read gets
                root node splits        rows fetched via callback
                scheduler wait time
                securefile add dedupd lob to set
                securefile allocation bytes
                securefile allocation chunks
                securefile bytes cleartext
                securefile bytes deduplicated
                securefile bytes encrypted
                securefile bytes non-transformed
                securefile compressed bytes
                securefile create dedup set
                securefile dedup callback oper final
                securefile dedup fits inline
                securefile dedup flush too low
                securefile dedup hash collision
                securefile dedup prefix hash match
                securefile destroy dedup set
                securefile direct read bytes
                securefile direct read ops
                securefile direct write bytes
                securefile direct write ops
                securefile inode ioreap time
                securefile inode read time
                securefile inode write time
                securefile number of flushes
                securefile number of non-transformed flushes
                securefile reject deduplication
                securefile rmv from dedup set
                securefile uncompressed bytes
                segemnt dispenser load empty
                segment cfs allocations
                segment chunks allocation from disepnser
                segment dispenser allocations
                segment dispenser load tasks
                segment prealloc bytes
                segment prealloc ops
                segment prealloc tasks
                segment prealloc time (ms)
                segment prealloc ufs2cfs bytes
                segment total chunk allocation        serializable aborts        session connect time        session cursor cache count        session cursor cache hits        session logical reads        session pga memory        session pga memory max        session stored procedure space        session uga memory        session uga memory max        shared hash latch upgrades - no wait        shared hash latch upgrades - wait
                shared io pool buffer get failure
                shared io pool buffer get success        sorts (disk)        sorts (memory)        sorts (rows)        space was found by tune down        space was not found by tune down
                spare statistic 1
                spare statistic 2
                spare statistic 3
                spare statistic 4        sql area evicted        sql area purged        steps of tune down ret. in space pressure        summed dirty queue length        switch current to new buffer        table fetch by rowid        table fetch continued row        table scan blocks gotten        table scan rows gotten        table scans (cache partitions)        table scans (direct read)        table scans (long tables)        table scans (rowid ranges)        table scans (short tables)
                temp space allocated (bytes)
                total cf enq hold time
                total number of cf enq holders        total number of slots        total number of times SMON posted        total number of undo segments dropped        transaction lock background get time        transaction lock background gets        transaction lock foreground requests        transaction lock foreground wait time        transaction rollbacks        transaction tables consistent read rollbacks        transaction tables consistent reads - undo records applied        tune down retentions in space pressure        undo change vector size        undo segment header was pinned        user I/O wait time        user calls        user commits        user rollbacks        workarea executions - multipass        workarea executions - onepass        workarea executions - optimal        workarea memory allocated        write clones created for recovery        write clones created in background        write clones created in foreground

589 rows selected.

SQL> spool off