System administration
    List of utilities
    Administrator's Guide
      The database server
        Overview of database server configuration and administration
          Database server concepts
          Environment configuration
          Database server configuration
            Storage space creation and management
            Automatic performance tuning
            Feature configuration
            Connectivity configuration
            Limit session resources
            Automate startup and shutdown on UNIX
            Automate startup on Windows
          Database server maintenance tasks
        Client/server communication
          Client/server architecture
            Network protocol
            Network programming interface
            Windows network domain
            Database server connections
            Supporting multiplexed connections
          Connections that the database server supports
          Local connections
            Shared-memory connections (UNIX)
            Stream-pipe connections (UNIX and Linux)
            Named-pipe connections (Windows)
            Local-loopback connections
          Communication support services
          Connectivity files
            Network-configuration files
              TCP/IP connectivity files
                Client and server actions when a TCP/IP connection is opened
              Multiple TCP/IP ports
            Network security files
              Trusted-host information
              Trusted-user information
              The netrc information
                User impersonation
            The sqlhosts file and the SQLHOSTS registry key
              Creating the sqlhosts file with a text editor
              Setting up the SQLHOSTS registry key with Setnet32 (Windows)
          The sqlhosts information
            IANA standard service names and port numbers in the sqlhosts.std file
            sqlhosts connectivity information
              sqlhosts file and SQLHOSTS registry key options
            Group information
              Creating a group in the sqlhosts file
            Alternatives for TCP/IP connections
          Informix support for IPv6 addresses
          Configuration parameters related to connectivity
            Connection information set in the DBSERVERNAME configuration parameter
            Connection information set in the DBSERVERALIASES configuration parameter
            Connection information set in the LIMITNUMSESSIONS configuration parameter
            Connection information set in the NETTYPE configuration parameter
            Name service maximum retention time set in the NS_CACHE configuration parameter
            Connection information set in the NUMFDSERVERS configuration parameter
            Connection information set in the HA_ALIAS configuration parameter
          Environment variables for network connections
          Automatically terminating idle connections
          Distributed Relational Database Architecture (DRDA) communications
            Overview of DRDA
            Configuring connectivity between Informix and HCL Data Server clients
            Allocating poll threads for an interface/protocol combination with the NETTYPE configuration parameter
            Specify the size of the DRDA communication buffer with the DRDA_COMMBUFFSIZE configuration parameter
            The DRDAEXEC thread and queries from clients
            SQL and supported and unsupported data types
            Display DRDA connection information
            Display DRDA session information
          Examples of client/server configurations
            A network connection
            Multiple connection types
            Accessing multiple database servers
          HCL Informix MaxConnect
        Database server initialization
          Initialization process
          Database server operating modes
            Users permitted to change modes
            Changing database server operating modes
              Specifying administration mode users
      Disk, memory, and process management
        Virtual processors and threads
          Virtual processors
            Advantages of virtual processors
              Shared processing
              Save memory and resources
              Parallel processing
              Add and drop virtual processors in online mode
              Bind virtual processors to CPUs
          How virtual processors service threads
            Control structures
            Context switching
              Ready queues
              Sleep queues
              Wait queues
          Virtual processor classes
            CPU virtual processors
              Determine the number of CPU virtual processors needed
              Run on a multiprocessor computer
              Run on a single-processor computer
              Add and drop CPU virtual processors in online mode
              Prevent priority aging
              Processor affinity
                Set processor affinity with the VPCLASS configuration parameter
            User-defined classes of virtual processors
              Determine the number of user-defined virtual processors needed
              User-defined virtual processors
              Specify user-defined virtual processors
              Assign a UDR to a user-defined virtual-processor class
              Add and drop user-defined virtual processors in online mode
            Tenant virtual processor class
            Java virtual processors
            Disk I/O virtual processors
              I/O priorities
              Logical-log I/O
              Physical-log I/O
              Asynchronous I/O
                Kernel-asynchronous I/O
                AIO virtual processors
            Network virtual processors
              Specifying Network Connections
              Run poll threads on CPU or network virtual processors
              Specify the number of networking virtual processors
              Specify listen and poll threads for the client/server connection
              Fast polling
              Multiple listen threads
                Add listen threads
                Add a network-interface card
                Dynamically starting, stopping, or restarting a listen thread
            Communications support module virtual processor
            Encrypt virtual processors
            Audit virtual processor
            Miscellaneous virtual processor
            Basic text search virtual processors
            MQ messaging virtual processor
            Web feature service virtual processor
            XML virtual processor
        Manage virtual processors
          Set virtual-processor configuration parameters
          Start and stop virtual processors
            Add virtual processors in online mode
              Add virtual processors in online mode with onmode
              Add network virtual processors
            Drop CPU and user-defined virtual processors
          Monitor virtual processors
            Monitor virtual processors with command-line utilities
              The onstat -g ath command
              The onstat -g glo command
              The onstat -g ioq command
              The onstat -g rea command
            Monitor virtual processors with SMI tables
        Shared memory
          Shared memory
          Shared-memory use
            Shared-memory allocation
            Shared-memory size
            Action to take if SHMTOTAL is exceeded
          Processes that attach to shared memory
            How a client attaches to the communications portion (UNIX)
            How utilities attach to shared memory
            How virtual processors attach to shared memory
              Obtain key values for shared-memory segments
              Specify where to attach the first shared-memory segment
              Attach additional shared-memory segments
              Define the shared-memory lower-boundary address
          Resident portion of shared memory
            Shared-memory header
            Logical-log buffer
            Physical-log buffer
            High-Availability Data-Replication buffer
            Lock table
          Buffer pool portion of shared memory
          Virtual portion of shared memory
            Management of the virtual portion of shared memory
              Size of the virtual portion of shared memory
            Components of the virtual portion of shared memory
              Shared-memory internal tables
                Buffer table
                Chunk table
                Dbspace table
                Page-cleaner table
                Tblspace table
                Transaction table
                User table
              Big buffers
              Session data
              Thread data
            Data-distribution cache
              Dictionary cache
              SQL statement cache
              Sort memory
              SPL routine and the UDR cache
              Global pool
          Communications portion of shared memory (UNIX)
          Virtual-extension portion of shared memory
          Concurrency control
            Shared-memory mutexes
            Shared-memory buffer locks
              Types of buffer locks
                Share lock
                Exclusive lock
          Database server thread access to shared buffers
            FIFO/LRU queues
              Components of LRU queue
              Pages in least-recently used order
              LRU queues and buffer-pool management
              Number of LRU queues to configure
              Number of cleaners to allocate
              Number of pages added to the MLRU queues
              End of MLRU cleaning
            Read-ahead operations
            Database server thread access to buffer pages
          Flush data to disk
            Flush buffer-pool buffers
            Flush before-images first
            Flush the physical-log buffer
            Synchronize buffer flushing
            Types of writes during flushing
              Foreground write
              LRU write
              Chunk write
            Flush the logical-log buffer
              After a transaction is prepared or terminated in a database with unbuffered logging
              When a session that uses nonlogging databases or unbuffered logging terminates
              When a checkpoint occurs
              When a page is modified that does not require a before-image in the physical-log file
          Buffer large-object data
            Write simple large objects
              Blobpages and shared memory
              Creation of simple large objects
              Creation of blobpage buffers
            Access smart large objects
          Memory use on 64-bit platforms
        Manage shared memory
          Set operating-system shared-memory configuration parameters
            Maximum shared-memory segment size
              Using more than two gigabytes of memory (Windows)
              Maximum number of shared-memory identifiers (UNIX)
            Semaphores (UNIX)
          Set database server shared-memory configuration parameters
          Set SQL statement cache parameters
          Set up shared memory
          Turn residency on or off for resident shared memory
            Turn residency on or off in online mode
            Turn residency on or off when restarting the database server
          Add a segment to the virtual portion of shared memory
          Reserve memory for critical activities
          Configure the server response when memory is critically low
            Scenario for maintaining a targeted amount of memory
          Monitor shared memory
            Monitor shared-memory segments
            Monitor the shared-memory profile and latches
              Command-line utilities to monitor shared memory and latches
              SMI tables
            Monitor buffers
          Deleting shared memory segments after a server failure
        Data storage
            Disk allocation for chunks
              Disk access on Windows
              Unbuffered or buffered disk access on UNIX
            Extendable chunks
            Partitions and offsets
            Control of where simple large object data is stored
            Root dbspace
            Temporary dbspaces
            Advantages of using sbspaces
            Sbspaces and Enterprise Replication
            Metadata, user data, and reserved area
            Control of where smart large object data is stored
            Storage characteristics of sbspaces
              Extent sizes for sbspaces
              Average smart-large-object size
              Buffering mode
              Last-access time
              Lock mode
            Levels of inheritance for sbspace characteristics
            More information about sbspaces
            Temporary sbspaces
              Comparison of temporary and standard sbspaces
              Temporary smart large objects
            Damaged tables
          Table types for Informix
            Standard permanent tables
            RAW tables
            Temp tables
            Properties of table types
              Loading of data into a table
              Fast recovery of table types
              Backup and restore of RAW tables
            Temporary tables
              Temporary tables that you create
                Where user-created temporary tables are stored
              Temporary tables that the database server creates
                Where database server-created temporary tables are stored
            Maximum number of tblspaces in a table
            Table and index tblspaces
            Extent interleaving
          Table fragmentation and data storage
          Amount of disk space needed to store data
            Size of the root dbspace
            Amount of space that databases require
          The storage pool
          Disk-layout guidelines
            Dbspace and chunk guidelines
            Table-location guidelines
          Sample disk layouts
          Logical-volume manager
        Manage disk space
          Allocate disk space
            Specify an offset
              Specify an offset for the initial chunk of root dbspace
              Specify an offset for additional chunks
              Use offsets to create multiple chunks
            Allocating cooked file spaces on UNIX
            Allocating raw disk space on UNIX
            Create symbolic links to raw devices (UNIX)
            Allocating NTFS file space on Windows
            Allocating raw disk space on Windows
          Specify names for storage spaces and chunks
            Specify the maximum size of chunks
            Specify the maximum number of chunks and storage spaces
            Back up after you change the physical schema
          Monitor storage spaces
          Manage dbspaces
            Creating a dbspace that uses the default page size
              Specifying the first and next extent sizes for the tblspace tblspace
            Creating a dbspace with a non-default page size
            Improving the performance of cooked-file dbspaces by using direct I/O
            Storing multiple named fragments in a single dbspace
            Creating a temporary dbspace
            What to do if you run out of disk space
            Adding a chunk to a dbspace or blobspace
            Rename dbspaces
              Additional actions that may be required after you rename a dbspace
            Managing automatic location and fragmentation
          Manage blobspaces
            Creating a blobspace
            Prepare blobspaces to store TEXT and BYTE data
            Determine blobpage size
              Determine database server page size
              Obtain blobspace storage statistics
          Manage sbspaces
            Creating an sbspace
            Size sbspace metadata
            Adding a chunk to an sbspace
            Alter storage characteristics of smart large objects
            Creating a temporary sbspace
          Manage the plogspace
          Automatic space management
            Creating and managing storage pool entries
            Marking a chunk as extendable or not extendable
            Modifying the sizes of an extendable storage space
            Changing the threshold and wait time for the automatic addition of more space
            Configuring the frequency of the monitor low storage task
            Manually expanding a space or extending an extendable chunk
            Example of minimally configuring for and testing the automatic addition of more space
            Example of configuring for the automatic addition of more space
          Drop a chunk
            Verify whether a chunk is empty
            Drop a chunk from a dbspace with onspaces
            Drop a chunk from a blobspace
            Drop a chunk from an sbspace with onspaces
              The -f (force) option
              Delete smart large objects without any pointers
          Drop a storage space
            Preparation for dropping a storage space
            Drop a mirrored storage space
            Drop a storage space with onspaces
            Back up after dropping a storage space
          Creating a space or chunk from the storage pool
          Returning empty space to the storage pool
          Manage extspaces
            Create an extspace
            Drop an extspace
          Skip inaccessible fragments
            The DATASKIP configuration parameter
            The dataskip feature of onspaces
            Use onstat to check dataskip status
            The SQL statement SET DATASKIP
            Effect of the dataskip feature on transactions
            Determine when to use dataskip
              Determine when to skip selected fragments
              Determine when to skip all fragments
            Monitor fragmentation use
          Display databases
            SMI tables
          Monitor disk usage
            Monitor chunks
              The onstat -d utility
              The onstat -d update option
              The onstat -D option
              Monitor chunk I/O activity with the onstat -g iof command
              The oncheck -pr command
              The oncheck -pe command
              SMI tables
            Monitor tblspaces and extents
              SMI tables
            Monitor simple large objects in a blobspace
              Determine blobpage fullness with oncheck -pB
              Monitor blobspace usage with oncheck -pe
              Monitor simple large objects in a dbspace with oncheck -pT
            Monitor sbspaces
              The onstat -d option
              The oncheck -ce and oncheck -pe options
              The oncheck -cs option
              The oncheck -ps option
              Monitoring the metadata and user-data areas
            Creating a tenant database
            Managing tenant databases
            Restoring a tenant database to a point in time
          Storage optimization
            Storage optimization methods
            Scheduling data optimization
            Example: Optimizing data storage on demand
            Partition defragmentation