Administering
  System administration
    List of utilities
    Administrator's Guide
      What's new in administration for Informix, Version 12.10
      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
            Database server monitoring
              UNIX operating-system tools
              Windows administrative utilities
        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 IBM 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
            Threads
            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
            Stacks
            Queues
              Ready queues
              Sleep queues
              Wait queues
            Mutexes
          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
                Stacks
                Heaps
            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
          Chunks
            Disk allocation for chunks
              Disk access on Windows
              Unbuffered or buffered disk access on UNIX
            Extendable chunks
            Partitions and offsets
          Pages
          Blobpages
          Sbpages
          Extents
          Dbspaces
            Control of where simple large object data is stored
            Root dbspace
            Temporary dbspaces
          Blobspaces
          Sbspaces
            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
              Logging
            Levels of inheritance for sbspace characteristics
            More information about sbspaces
            Temporary sbspaces
              Comparison of temporary and standard sbspaces
              Temporary smart large objects
          Plogspace
          Extspaces
          Databases
          Tables
            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
          Tblspaces
            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
          Multitenancy
            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
            Compression
              Data that you can compress
              Data that you cannot compress
              B-tree index compression
              Compression ratio estimates
              Compression dictionaries
              Tools for moving compressed data
              BLOBspace Blob Compression
              Methods for viewing compression information
          Load data into a table
        Moving data with external tables
          External tables
          Defining external tables
          Map columns to other columns
          Load data from and unload to a named pipe
            Loading data with named pipes
            FIFO virtual processors
            Unloading data with named pipes
            Copying data from one instance to another using the PIPE option
          Monitor the load or unload operations
            Monitor frequent load and unload operations
            Monitor FIFO virtual processors
          External tables in high-availability cluster environments
          System catalog entries for external tables
          Performance considerations when using external tables
          Manage errors from external table load and unload operations
            Reject files
            External table error messages
            Recoverability of table types for external tables
      Logging and log administration
        Logging
          Database server processes that require logging
          Transaction logging
          Logging of SQL statements and database server activity
            Activity that is always logged
            Activity logged for databases with transaction logging
            Activity that is not logged
          Database-logging status
            Unbuffered transaction logging
            Buffered transaction logging
            ANSI-compliant transaction logging
            No database logging
            Databases with different log-buffering status
            Database logging in an X/Open DTP environment
          Settings or changes for logging status or mode
        Manage the database-logging mode
          Change the database-logging mode
          Modify the database-logging mode with ondblog
            Change the buffering mode with ondblog
            Cancel a logging mode change with ondblog
            End logging with ondblog
            Make a database ANSI compliant with ondblog
            Changing the logging mode of an ANSI-compliant database
          Modify the database logging mode with ontape
            Turn on transaction logging with ontape
            End logging with ontape
            Change buffering mode with ontape
            Make a database ANSI compliant with ontape
          Modify the table-logging mode
            Alter a table to turn off logging
            Alter a table to turn on logging
            Disable logging on temporary tables
          Monitor transactions
          Monitor the logging mode of a database
            Monitor the logging mode with SMI tables
        Logical log
          What is the logical log?
          Location of logical-log files
          Identification of logical-log files
          Status flags of logical-log files
          Size of the logical-log file
            Number of logical-log files
            Performance considerations
          Dynamic log allocation
          Freeing of logical-log files
            Action if the next logical-log file is not free
            Action if the next log file contains the last checkpoint
          Log blobspaces and simple large objects
            Switch log files to activate blobspaces
            Back up log files to free blobpages
            Back up blobspaces after inserting or deleting TEXT and BYTE data
          Log sbspaces and smart large objects
            Sbspace logging
              Logging for smart large objects
              Logging for updated smart large objects
              Turn logging on or off for an sbspace
            Smart-large-object log records
            Prevent long transactions when logging smart-large-object data
          Logging process
            Dbspace logging
            Blobspace logging
        Manage logical-log files
          Estimate the size and number of log files
            Estimate the log size when logging smart large objects
            Estimate the number of logical-log files
          Back up logical-log files
            Backing up blobspaces
            Back up sbspaces
          Switch to the next logical-log file
          Free a logical-log file
            Delete a log file with status D
            Free a log file with status U
            Freeing a log file with status U-B or F
            Freeing a log file with status U-C or U-C-L
            Free a log file with status U-B-L
          Monitor logging activity
            Monitor the logical log for fullness
              The onstat -l command
              The oncheck -pr command
            Monitor temporary logical logs
            SMI tables
            Monitor log-backup status
          Allocate logical log files
            Dynamically add a logical-log file to prevent transaction blocking
              Size and number of dynamically added log files
              Location of dynamically added logical log files
              Monitor events for dynamically added logs
            Dynamically add logical logs for performance
            Adding logical-log files manually
          Dropping logical-log files
          Change the size of logical-log files
          Move logical-log files
          Display logical-log records
          Controlling long transactions
        Physical logging, checkpoints, and fast recovery
          Critical sections
          Physical logging
            Fast recovery use of physically-logged pages
            Backup use of physically-logged pages
            Database server activity that is physically logged
              Physical recovery messages
              Physical logging and simple large objects
              Physical logging and smart large objects
          Size and location of the physical log
            Strategy for estimating the size of the physical log
            Physical-log overflow when transaction logging is turned off
          Checkpoints
            LRU values for flushing a buffer pool between checkpoints
            Checkpoints during backup
          Fast recovery
            Need for fast recovery
            Situations when fast recovery is initiated
              Fast recovery and buffered logging
              Possible physical log overflow during fast recovery
              Fast recovery and no logging
            Fast recovery after a checkpoint
              The server returns to the last-checkpoint state
              The server locates the checkpoint record in the logical log
              The server rolls forward logical-log records
              The server rolls back uncommitted transactions
        Manage the physical log
          Change the physical-log location and size
          Monitor physical and logical-logging activity
          Monitor checkpoint information
            Turn checkpoint tuning on or off
            Force a checkpoint
            Server-provided checkpoint statistics
            SMI tables
          Turn automatic LRU tuning on or off
      Fault tolerance
        Mirroring
          Mirroring
            Benefits of mirroring
            Costs of mirroring
            Consequences of not mirroring
            Data to mirror
            Alternatives to mirroring
              Logical volume managers
              Hardware mirroring
              External backup and restore
          Mirroring process
            Creation of a mirror chunk
            Mirror status flags
            Recovery
            Actions during processing
              Disk writes to mirror chunks
              Disk reads from mirror chunks
              Detection of media failures
              Chunk recovery
            Result of stopping mirroring
            Structure of a mirror chunk
        Using mirroring
          Preparing to mirror data
          Enable the MIRROR configuration parameter
          Allocate disk space for mirrored data
            Link chunks (UNIX)
            Relink a chunk to a device after a disk failure
          Using mirroring
            Mirroring the root dbspace during initialization
            Change the mirror status
          Manage mirroring
            Start mirroring for unmirrored storage spaces
              Start mirroring for unmirrored dbspaces using onspaces
            Start mirroring for new storage spaces
              Start mirroring for new spaces using onspaces
            Add mirror chunks
              Add mirror chunks using onspaces
            Swap mirror chunk
            Take down a mirror chunk
              Take down mirror chunks using onspaces
            Recover a mirror chunk
              Recover a mirror chunk using onspaces
            End mirroring
              End mirroring using onspaces
        Consistency checking
          Perform periodic consistency checking
            Verify consistency
              Validate system catalog tables
              Validate data pages
              Validate extents
              Validate indexes
              Validate logical logs
              Validate reserved pages
              Validate metadata
            Monitor for data inconsistency
              Read assertion failures in the message log and dump files
              Validate table and tblspace data
            Retain consistent level-0 backups
          Deal with corruption
            Find symptoms of corruption
            Fix index corruption
            Fix I/O errors on a chunk
          Collect diagnostic information
          Disable I/O errors
          Monitor the database server for disabling I/O errors
            The message log to monitor disabling I/O errors
            Event alarms to monitor disabling I/O errors
            No bad-sector mapping
      High availability and scalability
        Strategies for high availability and scalability
          Components supporting high availability and scalability
            Advantages of data replication
              Clustering versus mirroring
              Clustering versus two-phase commit
              Type of data replicated in clusters
              Primary and secondary database servers
          Transparent scaling and workload balancing strategies
          High availability strategies
        High-availability cluster configuration
          Plan for a high-availability cluster
          Configuring clusters
            Hardware and operating-system requirements for clusters
            Database and data requirements for clusters
            Database server configuration requirements for clusters
              Database server version
              Storage space and chunk configuration
              Non-default page sizes in an HDR environment
              Mirroring
              Physical-log configuration
              Dbspace and logical-log tape backup devices
              Logical-log configuration
              High-availability cluster configuration parameters
              Cluster transaction coordination
            Configuring secure connections for high-availability clusters
          Starting HDR for the First Time
            Decrease setup time using the ontape STDIO feature
          Remote standalone secondary servers
            Comparison of RS secondary servers and HDR secondary servers
            Index page logging
              How index page logging works
              Enable or disable index page logging
              View index page logging statistics
            Starting an RS secondary server for the first time
              Decrease setup time through an alternative backup method
            Converting an offline primary server to an RS secondary server
            Delayed application of log records
              Specifying the log staging directory
              Delay application of log records on an RS secondary server
              Stop the application of log records
            Flow control for remote standalone secondary servers
          Shared disk secondary servers
            SD secondary server
            Disk requirements for SD secondary servers
            Setting up a shared disk secondary server
            Obtain SD secondary server statistics
            Promote an SD secondary server to a primary server
            Convert a primary server to a standard server
            SD secondary server security
            Flow control for shared-disk secondary servers
        Cluster administration
          How data replication works
            How data initially replicates
            Replication of primary-server data to secondary servers
              Fully synchronous mode for HDR replication
              Nearly synchronous mode for HDR replication
              Asynchronous mode for HDR replication
              Lost-and-found transactions
            Data replication configuration examples
              Remote standalone secondary configuration examples
              Shared disk secondary configuration examples
              Enterprise Replication as part of the recoverable group
              High-availability clusters with Enterprise Replication configuration example
              Example of a complex failover recovery strategy
            Troubleshooting high-availability cluster environments
            Design data replication group clients
              Use of temporary dbspaces for sorting and temporary tables
          Performing basic administration tasks
            Changing the configuration parameters for an HDR replication pair
            Back up storage spaces and logical-log files
            Changing the logging mode of databases
            Add and drop chunks and storage spaces
            Renaming chunks
            Saving chunk status on the secondary database server
            Use and change mirroring of chunks
            Manage the physical log
            Manage the logical log
            Manage virtual processors
            Manage shared memory
            Configure SMX connections
            Replicate an index to an HDR secondary database server
            Encrypting data traffic between HDR database servers
            Adjust LRU flushing and automatic tuning in HDR server pairs
            Cloning a primary server
              Creating a clone of a primary server
            Database updates on secondary servers
              Isolation levels on secondary servers
                Set lock mode
              Transient types on high-availability cluster secondary servers
              Row versioning
            Backup and restore with high-availability clusters
            Change the database server mode
            Changing the database server type
            Prevent blocking checkpoints on HDR servers
              View statistics for nonblocking checkpoints on HDR servers
            Monitor HDR status
              Command-line utilities
                The onstat -g dri option
                The oncheck -pr option
              SMI tables
          Obtain RS secondary server statistics
          Remove an RS secondary server
          RS secondary server security
            Create or change a password on an RS secondary server
          Transaction completion during cluster failover
            Configuring the server so that transactions complete after failover
        Connection management through the Connection Manager
          Configuring connection management
            Creating Connection Manager configuration files
              Parameters and format of the Connection Manager configuration file
                CMALARMPROGRAM Connection Manager configuration parameter
                CM_TIMEOUT Connection Manager configuration parameter
                CLUSTER Connection Manager configuration parameter
                DEBUG Connection Manager configuration parameter
                EVENT_TIMEOUT Connection Manager configuration parameter
                FOC Connection Manager configuration parameter
                GRID Connection Manager configuration parameter
                INFORMIXSERVER Connection Manager configuration parameter
                LOCAL_IP Connection Manager configuration parameter
                LOG Connection Manager configuration parameter
                LOGFILE Connection Manager configuration parameter
                MACRO Connection Manager configuration parameter
                NAME Connection Manager configuration parameter
                REPLSET Connection Manager configuration parameter
                SECONDARY_EVENT_TIMEOUT Connection Manager configuration parameter
                SERVERSET Connection Manager configuration parameter
                SLA Connection Manager configuration parameter
                SQLHOSTS Connection Manager configuration parameter
                SSL_LABEL Connection Manager configuration parameter
              Modifying Connection Manager configuration files
              Converting older formats of the Connection Manager configuration file to the current format
            Configuring environments and setting configuration parameters for connection management
            Defining sqlhosts information for connection management
              Defining sqlhosts information for connection management of high-availability clusters
              sqlhosts for HA clusters that use secure ports
              sqlhosts for HA clusters that use DRDA
              sqlhosts for HA clusters that use DRDA and secure ports
              sqlhosts for grids and replicate sets
              sqlhosts for grids and replicate sets that use secure ports
              sqlhosts for HA replication systems
              sqlhosts for HA replication systems that use secure ports
              sqlhosts for server sets
            Creating a password file for connecting to database servers on untrusted networks
              Modifying encrypted password information
            Starting Connection Managers on UNIX and Linux
            Starting Connection Managers on Windows
            Stopping connection management
          Monitoring and troubleshooting connection management
          Strategies for increasing availability with Connection Managers
          Configuration examples for connection management
            Example of configuring connection management for a high-availability cluster
            Example of configuring connection management for a grid or replicate set
            Example of configuring connection management for a high-availability replication system
            Example: Configuring connection management for untrusted networks
            Example: Configuring for prioritizing connections and network monitoring
            Example: Configuring for an SSL connection
              Configuring a CM to connect to Oninit using SSL
              Configuring a client to connect to a CM using SSL
        Cluster failover, redirection, and restoration
          Failover configuration for high-availability clusters
            Failover with ISV cluster management software
            I/O fencing for shared file systems
            Cluster failures
              Automatic switchover
              Automatic switchover without a reliable network
              Manual switchover
              Connecting offline servers to the new primary server
          Redirection and connectivity for data-replication clients
            Redirecting clients automatically with the DBPATH environment variable
              How the DBPATH redirection method works
            Redirecting clients with the connectivity information
              Changing client connectivity information
              Connecting to the database server
              Automatic redirection with server groups
            Redirecting clients with the INFORMIXSERVER environment variable
            Redirecting clients with application code
            Comparison of redirection methods
          Recover HDR and RS clusters after failure
            Recovering a cluster after critical data is damaged
            Restarting HDR or RS clusters after a network failure
            Restarting HDR or RS clusters if the secondary server fails
            Recovering an HDR cluster after the secondary server became the primary server
            Restart if the primary server fails
          Recovering a shared-disk cluster after data is damaged
          Recovering an SD cluster after the secondary server became the primary server
      Distributed data
        Multiphase commit protocols
          Transaction managers
            TP/XA Library with a transaction manager
            Microsoft Transaction Server (MTS/XA)
            Informix transaction support for XA-compliant, external data sources
            XA in high-availability clusters
            Loosely-coupled and tightly-coupled modes
          Two-phase commit protocol
            When the two-phase commit protocol is used
            Two-phase commit concepts
            Phases of the two-phase commit protocol
              Precommit phase
              Postdecision phase
            How the two-phase commit protocol handles failures
              Types of failures that automatic recovery handles
              Administrator's role in automatic recovery
              Automatic-recovery mechanisms for coordinator failure
              Automatic-recovery mechanisms for participant failure
            Presumed-end optimization
          Independent actions
            Situations that initiate independent action
            Possible results of independent action
              Independent actions that allow transactions to complete successfully
              Independent actions that result in an error condition
              Independent actions that result in heuristic decisions
            The heuristic rollback scenario
              Conditions that result in a heuristic rollback
                Condition 1: Logical log fills to a high-watermark
                Condition 2: System administrator executes onmode -z
              Results of a heuristic rollback
                Situation 1: Coordinator issues a commit and all participants report heuristic rollbacks
                Situation 2: Coordinator issued a commit; one participant commits and one reports a heuristic rollback
            The heuristic end-transaction scenario
              When to perform a heuristic end transaction
              How to use onmode -Z
              Action when the transaction is ended heuristically
            Monitor a global transaction
          Two-phase commit protocol errors
          Two-phase commit and logical-log records
            Logical-log records when the transaction commits
            Logical-log records written during a heuristic rollback
            Logical-log records written after a heuristic end transaction
          Configuration parameters used in two-phase commits
            Function of the DEADLOCK_TIMEOUT parameter
            Function of the TXTIMEOUT parameter
          Heterogeneous commit protocol
            Gateways that can participate in a heterogeneous commit transaction
            Enable and disable of heterogeneous commit
            How heterogeneous commit works
              Precommit phase
              Gateway commit phase
              Heterogeneous commit optimization
            Implications of a failed heterogeneous commit
              Database server coordinator failure
              Participant failure
              Interpretation of heterogeneous commit error messages
                Application attempts to update multiple gateway participants
                Failed attempt to commit distributed transaction using heterogeneous commit
        Manually recovering from failed two-phase commit
          Determine if manual recovery is required
            Determine if a transaction was implemented inconsistently
              Global transaction ended prematurely
              Heuristic end transaction
              Heuristic rollback
            Determine if the distributed database contains inconsistent data
              Obtaining information from the logical log
              Obtain the global transaction identifier
            Decide if action is needed to correct the situation
          Example of manual recovery
      Overview of automatic monitoring and corrective actions
        The Scheduler
          Scheduler tables
          Built-in tasks and sensors
          Creating a task
          Creating a sensor
          Actions for task and sensors
          Creating a group
          Creating a threshold
          Creating an alert
          Monitor the scheduler
          Modifying the scheduler
        Remote administration with the SQL administration API
          SQL administration API admin() and task() functions
          Viewing SQL administration API history
            Controlling the size of the command_history table
        Query drill-down
          Specifying startup SQL tracing information by using the SQLTRACE configuration parameter
          Disable SQL tracing globally or for a session
          Enable SQL tracing
          Enable global SQL tracing for a session
      HCL Informix server licensing
        FlexNet Licensing Overview
        Licensing configuration
        Operational considerations
        FlexNet Operations portal
        The REST interface
        Security
          Local License Server
        Informix Warehouse Accelerator
    Administrator's Reference
      What's New in Administrator's Reference for Informix database server, Version 12.10
      Configuring and monitoring Informix
        Database configuration parameters
          onconfig file
            Modifying the onconfig file
            Displaying the settings in the onconfig file
          onconfig Portal: Configuration parameters by functional category
          ADMIN_MODE_USERS configuration parameter
          ADMIN_USER_MODE_WITH_DBSA configuration parameter
          ALARMPROGRAM configuration parameter
          ALLOW_NEWLINE configuration parameter
          ALRM_ALL_EVENTS configuration parameter
          AUTO_AIOVPS configuration parameter
          AUTO_CKPTS configuration parameter
          AUTO_LLOG configuration parameter
          AUTO_TUNE_SERVER_SIZE configuration parameter
          AUTO_LRU_TUNING configuration parameter
          AUTO_READAHEAD configuration parameter
          AUTO_REPREPARE configuration parameter
          AUTO_STAT_MODE configuration parameter
          AUTO_TUNE configuration parameter
          AUTOLOCATE configuration parameter
          BATCHEDREAD_INDEX configuration parameter
          BATCHEDREAD_TABLE configuration parameter
          BLOCKTIMEOUT configuration parameter
          BTSCANNER Configuration Parameter
          BUFFERPOOL configuration parameter
          CHECKALLDOMAINSFORUSER configuration parameter
          CKPTINTVL configuration parameter
          CLEANERS configuration parameter
          CLUSTER_TXN_SCOPE configuration parameter
          CONSOLE configuration parameter
          CONVERSION_GUARD configuration parameter
          DATASKIP Configuration Parameter
          DBCREATE_PERMISSION configuration parameter
          DB_LIBRARY_PATH configuration parameter
          DBSERVERALIASES configuration parameter
          DBSERVERNAME configuration parameter
          DBSPACETEMP configuration parameter
            Use Hash Join Overflow and DBSPACETEMP
          DD_HASHMAX configuration parameter
          DD_HASHSIZE configuration parameter
          DEADLOCK_TIMEOUT configuration parameter
          DEF_TABLE_LOCKMODE configuration parameter
          DEFAULTESCCHAR configuration parameter
          DELAY_APPLY Configuration Parameter
          DIRECT_IO configuration parameter (UNIX)
          DIRECTIVES configuration parameter
          DISABLE_B162428_XA_FIX configuration parameter
          DISK_ENCRYPTION configuration parameter
          DRDA_COMMBUFFSIZE configuration parameter
          DRAUTO configuration parameter
          DRIDXAUTO configuration parameter
          DRINTERVAL configuration parameter
          DRLOSTFOUND configuration parameter
          DRTIMEOUT configuration parameter
          DS_HASHSIZE configuration parameter
          DS_MAX_QUERIES configuration parameter
          DS_MAX_SCANS configuration parameter
          DS_NONPDQ_QUERY_MEM configuration parameter
          DS_POOLSIZE configuration parameter
          DS_TOTAL_MEMORY configuration parameter
            Algorithm for DS_TOTAL_MEMORY
          DUMPCNT configuration parameter (UNIX)
          DUMPCORE configuration parameter (UNIX)
          DUMPDIR configuration parameter
          DUMPGCORE configuration parameter (UNIX)
          DUMPSHMEM configuration parameter (UNIX)
          DYNAMIC_LOGS configuration parameter
          EILSEQ_COMPAT_MODE configuration parameter
          ENABLE_SNAPSHOT_COPY configuration parameter
          ENCRYPT_CIPHERS configuration parameter
          ENCRYPT_HDR configuration parameter
          ENCRYPT_MAC configuration parameter
          ENCRYPT_MACFILE configuration parameter
          ENCRYPT_SMX configuration parameter
          ENCRYPT_SWITCH configuration parameter
          EXPLAIN_STAT configuration parameter
          EXT_DIRECTIVES configuration parameter
          EXTSHMADD configuration parameter
          FAILOVER_CALLBACK configuration parameter
          FAILOVER_TX_TIMEOUT configuration parameter
          FASTPOLL configuration parameter
          FILLFACTOR configuration parameter
          FULL_DISK_INIT configuration parameter
          GSKIT_VERSION configuration parameter
          HA_ALIAS configuration parameter
          HA_FOC_ORDER configuration parameter
          HDR_TXN_SCOPE configuration parameter
          HETERO_COMMIT configuration parameter
          IFX_EXTEND_ROLE configuration parameter
          IFX_FOLDVIEW configuration parameter
          IFX_XA_UNIQUEXID_IN_DATABASE configuration parameter
          INFORMIXCONRETRY configuration parameter
          INFORMIXCONTIME configuration parameter
          LICENSE_SERVER configuration parameter
          LICENSE_TIMING configuration parameter
          LIMITNUMSESSIONS configuration parameter
          LISTEN_TIMEOUT configuration parameter
          LOCKS configuration parameter
          LOGBUFF configuration parameter
          LOGBUF_INTVL configuration parameter
          LOGFILES configuration parameter
          LOG_INDEX_BUILDS configuration parameter
          LOG_STAGING_DIR configuration parameter
          LOGSIZE configuration parameter
          LOW_MEMORY_MGR configuration parameter
          LOW_MEMORY_RESERVE configuration parameter
          LTXEHWM configuration parameter
          LTXHWM configuration parameter
          MAX_FILL_DATA_PAGES configuration parameter
          MAX_INCOMPLETE_CONNECTIONS configuration parameter
          MAX_PDQPRIORITY configuration parameter
          MIRROR configuration parameter
          MIRROROFFSET configuration parameter
          MIRRORPATH configuration parameter
          MSG_DATE configuration parameter
          MSGPATH configuration parameter
          MULTIPROCESSOR configuration parameter
          NET_IO_TIMEOUT_ALARM configuration parameter
          NETTYPE configuration parameter
          NS_CACHE configuration parameter
          NUMFDSERVERS configuration parameter
          OFF_RECVRY_THREADS configuration parameter
          ON_RECVRY_THREADS configuration parameter
          ONDBSPACEDOWN configuration parameter
            Database Server Behavior When ONDBSPACEDOWN Does Not Apply
          ONLIDX_MAXMEM configuration parameter
          OPTCOMPIND configuration parameter
          OPT_GOAL configuration parameter
          PC_HASHSIZE configuration parameter
          PC_POOLSIZE configuration parameter
          PHYSBUFF configuration parameter
          PHYSFILE configuration parameter
          PLOG_OVERFLOW_PATH configuration parameter
          PLCY_HASHSIZE configuration parameter
          PLCY_POOLSIZE configuration parameter
          PN_STAGEBLOB_THRESHOLD configuration parameter
          PRELOAD_DLL_FILE configuration parameter
          QSTATS configuration parameter
          REMOTE_SERVER_CFG configuration parameter
          REMOTE_USERS_CFG configuration parameter
          RESIDENT configuration parameter
          RESTARTABLE_RESTORE configuration parameter
          RESTORE_POINT_DIR configuration parameter
          ROOTNAME configuration parameter
          ROOTOFFSET configuration parameter
          ROOTPATH configuration parameter
          ROOTSIZE configuration parameter
          RSS_FLOW_CONTROL configuration parameter
          RTO_SERVER_RESTART configuration parameter
          S6_USE_REMOTE_SERVER_CFG configuration parameter
          SB_CHECK_FOR_TEMP configuration parameter
          SBSPACENAME configuration parameter
          SBSPACETEMP configuration parameter
          SDS_ALTERNATE configuration parameter
          SDS_ENABLE configuration parameter
          SDS_FLOW_CONTROL configuration parameter
          SDS_LOGCHECK configuration parameter
          SDS_PAGING configuration parameter
          SDS_TEMPDBS configuration parameter
          SDS_TIMEOUT configuration parameter
          SECURITY_LOCALCONNECTION configuration parameter
          SEQ_CACHE_SIZE configuration parameter
          SERVERNUM configuration parameter
          SESSION_LIMIT_LOCKS configuration parameter
          SESSION_LIMIT_LOGSPACE configuration parameter
          SESSION_LIMIT_MEMORY configuration parameter
          SESSION_LIMIT_TEMPSPACE configuration parameter
          SESSION_LIMIT_TXN_TIME configuration parameter
          SHMADD configuration parameter
          SHMBASE configuration parameter
          SHMNOACCESS configuration parameter
          SHMTOTAL configuration parameter
          SHMVIRT_ALLOCSEG configuration parameter
          SHMVIRTSIZE configuration parameter
          SINGLE_CPU_VP configuration parameter
            VPCLASS Values and the SINGLE_CPU_VP Configuration Parameter
          SMX_COMPRESS configuration parameter
          SMX_NUMPIPES configuration parameter
          SMX_PING_INTERVAL configuration parameter
          SMX_PING_RETRY configuration parameter
          SP_AUTOEXPAND configuration parameter
          SP_THRESHOLD configuration parameter
          SP_WAITTIME configuration parameter
          SQL_LOGICAL_CHAR configuration parameter
          SQLTRACE configuration parameter
          SSL_KEYSTORE_LABEL configuration parameter
          STACKSIZE configuration parameter
          STATCHANGE configuration parameter
          STMT_CACHE configuration parameter
          STMT_CACHE_HITS configuration parameter
          STMT_CACHE_NOLIMIT configuration parameter
          STMT_CACHE_NUMPOOL configuration parameter
          STMT_CACHE_SIZE configuration parameter
          STOP_APPLY configuration parameter
          STORAGE_FULL_ALARM configuration parameter
          SYSALARMPROGRAM configuration parameter
          SYSSBSPACENAME configuration parameter
          TBLSPACE_STATS configuration parameter
          TBLTBLFIRST configuration parameter
          TBLTBLNEXT configuration parameter
          TEMPTAB_NOLOG configuration parameter
          TENANT_LIMIT_CONNECTIONS configuration parameter
          TENANT_LIMIT_MEMORY configuration parameter
          TENANT_LIMIT_SPACE configuration parameter
          TLS_VERSION configuration parameter
          TXTIMEOUT configuration parameter
          UNSECURE_ONSTAT configuration parameter
          UPDATABLE_SECONDARY configuration parameter
          USELASTCOMMITTED configuration parameter
          USEOSTIME configuration parameter
          USERMAPPING configuration parameter (UNIX, Linux)
          USRC_HASHSIZE configuration parameter
          USRC_POOLSIZE configuration parameter
          USTLOW_SAMPLE configuration parameter
          VP_MEMORY_CACHE_KB configuration parameter
          VPCLASS configuration parameter
          WSTATS configuration parameter
        The sysmaster database
          The sysmaster Database
            The buildsmi Script
            The bldutil.sh Script
          The System-Monitoring Interface
            Understanding the SMI Tables
            Accessing SMI tables
              SELECT statements
              Triggers and Event Alarms
              SPL and SMI Tables
              Locking and SMI Tables
          The System-Monitoring Interface Tables
            The sysutils Tables
            sysadtinfo
            sysaudit
            syschkio
            syscheckpoint
            syschunks
            sysckptinfo
            syscluster
            syscmsm
            syscmsmsla
            syscmsmtab
            syscmsmunit
            syscompdicts_full
            sysconfig
            sysdatabases
            sysdbslocale
            sysdbspaces
            sysdri
            sysdual
            sysenv
            sysenvses
            sysextents
            sysextspaces
            sysfeatures
            sysha_lagtime Table
            sysha_type
            sysha_workload
            sysipl
            syslocks
            syslogs
            syslogfil table
            sysmgminfo
            sysnetclienttype
            sysnetglobal
            sysnetworkio table
            sysonlinelog
            sysprofile
            sysproxyagents
            sysproxydistributors
            sysproxysessions table
            sysproxytxnops table
            sysproxytxns table
            sysptnhdr
            sysptprof table
            sysrepevtreg table
            sysrepstats table
              User interface for sysrepstats and sysrepevtreg tables
            sysrsslog
            sysscblst
            syssesappinfo
            syssesprof
            syssessions
            syssmx
            syssmxses
            syssqexplain table
            syssqltrace
            syssqltrace_hvar
            syssqltrace_info
            syssqltrace_iter
            syssrcrss
            syssrcsds
            systabnames
            systhreads
            systrgrss
            systrgsds
            sysvpprof
            The SMI Tables Map
            Information from onstat in the SMI Tables
        The sysadmin Database
          The Scheduler tables
            The ph_task Table
            The ph_run Table
            The ph_group Table
            The ph_alert Table
            The ph_threshold Table
          The results tables
          The command_history table
          The storagepool table
          The tenant table
        Disk Structures and Storage
          Dbspace Structure and Storage
            Structure of the Root Dbspace
            Reserved Pages
            Structure of a Regular Dbspace
              Structure of an Additional Dbspace Chunk
              Structure of a Mirror Chunk
            Structure of the Chunk Free-List Page
            Structure of the Tblspace Tblspace
              Tblspace tblspace entries
              Tblspace Numbers
            Structure of the Database Tblspace
              Database Tblspace Entries
            Structure and Allocation of an Extent
              Extent Structure
                Extent size
                Page Types Within a Table Extent
                Page Types Within an Index Extent
              Next-Extent Allocation
                Next-Extent Size
                Extent size doubling
                Lack of Contiguous Space
                Merge of Extents for the Same Table
            Structure and Storage of a Dbspace Page
              Rows in Nonfragmented Tables
                Definition of Rowid
                Use of Rowids
              Rows in Fragmented Tables
                Access to Data in Fragmented Tables with Rowid
              Recommendations on Use of Rowid
              Data-Row Format and Storage
                Storage of Row
                Location of Rows
                Page Compression
            Structure of Fragmented Tables
            Structure of B-Tree Index Pages
              Definition of B-tree terms
              Logical Storage of Indexes
                Creation of Root and Leaf Nodes
                Creation of branch nodes
                Duplicate Key Values
                Key-Value Locking
                Adjacent Key Locking
                Freed Index Pages
                Filling Indexes
                Calculating the Length of Index Items
              Functional Indexes
            Structure of R-Tree Index Pages
          Storage of Simple Large Objects
            Structure of a Blobspace
            Structure of a Dbspace Blobpage
            Simple-Large-Object Storage and the Descriptor
              Creation of Simple Large Objects
              Deletion or Insertion of Simple Large Objects
              Size Limits for Simple Large Objects
            Blobspace Page Types
            Structure of a Blobspace Blobpage
          Sbspace Structure
            Structure of the metadata area
            Sbpage Structure
          Time Stamps
          Database and Table Creation: What Happens on Disk
            Database Creation
              Disk-Space Allocation for System Catalog Tables
              Tracking of System Catalog Tables
            Table Creation
              Disk-Space Allocation
              Entry in the Tblspace Tblspace
              Entries in the System Catalog Tables
              Creation of a Temporary Table
        Interpreting Logical-Log Records
          About Logical-Log Records
            Transactions That Drop a Table or Index
            Transactions That Are Rolled Back
            Checkpoints with Active Transactions
            Distributed Transactions
          Logical-Log Record Structure
            Logical-Log Record Header
            Logical-log record types and additional columns
            Log Record Types for Smart Large Objects
      Administrative Utilities
        Overview of Utilities
          Obtaining utility version information
          Setting local environment variables for utilities (UNIX)
        The finderr utility
        The genoncfg Utility
        The oncheck Utility
          oncheck Check-and-Repair
            What Does Each Option Do?
            Using the -y Option to Perform Repairs
            Repairing Indexes in Sbspaces and External Spaces
            Locking and oncheck
          oncheck utility syntax
          oncheck -cc and-pc: Check system catalog tables
          oncheck -cd and oncheck -cD commands: Check pages
          oncheck -ce, -pe: Check the chunk-free list
          oncheck -ci and -cI: Check index node links
          oncheck -cr and -cR: Check reserved pages
          oncheck -cs, -cS, -ps, -pS: Check and display sbspaces
          oncheck -pB: Display blobspace statistics
          oncheck -pd and pD: Display rows in hexadecimal format
          oncheck -pk, -pK, -pl, -pL: Display index information
          oncheck -pp and -pP: Display the contents of a logical page
          oncheck -pr and pR: Display reserved-page information
          oncheck -pt and -pT: Display tblspaces for a Table or Fragment
          Turn On Locking with -x
          Send Special Arguments to the Access Method with -u
          Return Codes on Exit
        The onclean utility
          The onshutdown script
        The oncmsm utility
        The onconfig_diff utility
        The ondblog utility
        The oninit utility
          The -FILE option
          Return codes for the oninit utility
        The onlog utility
        The onmode utility
          onmode command syntax
          onmode -a: Add a shared-memory segment
          onmode -BC: Allow large chunk mode
          onmode -c: Force a checkpoint
          onmode -C: Control the B-tree scanner
          onmode -cache surrogates: Cache the allowed.surrogates file
          onmode -d: Set data-replication types
          onmode -d: Set High Availability server characteristics
          onmode -d command: Replicate an index with data-replication
          onmode -D, -M, -Q, -S: Change decision-support parameters
          onmode -e: Change usage of the SQL statement cache
          onmode -F: Free unused memory segments
          onmode -I: Control diagnostics collection
          onmode -k, -m, -s, -u, -j: Change database server mode
            Taking the Database Server to Offline Mode with the -k Option
            Bringing the Database Server Online with the -m Option
            Shutting Down the Database Server Gracefully with the -s Option
            Shutting Down the Database Server Immediately with the -u Option
            Changing the Database Server to Administration Mode with the -j Option
          onmode -l: Switch the logical-log file
          onmode -n, -r: Change shared-memory residency
          onmode -O: Override ONDBSPACEDOWN WAIT mode
          onmode -p: Add or drop virtual processors
            Rules for adding and dropping virtual processors
            Monitoring poll threads with onstat
          onmode -P: Start, stop, or restart a listen thread dynamically
          onmode -R: Regenerate .infos.dbservername File
          onmode -W: Change settings for the SQL statement cache
            SQL statement cache examples
          onmode -we: Export a file that contains current configuration parameters
          onmode -wf, -wm: Dynamically change certain configuration parameters
            onmode -wm: Change LRU tuning status
          onmode -wi: Import a configuration parameter file
          onmode -Y: Dynamically change SET EXPLAIN
          onmode -z: Kill a database server session
          onmode -Z: Kill a distributed transaction
        The onparams Utility
          onparams syntax
          onparams -a -d dbspace: Add a logical-log file
          onparams -d -l lognum: Drop a logical-log file
          onparams -p: Change physical-log parameters
            Backing Up After You Change the Physical-Log Size or Location
            Changing the Size of the Physical Log and Using Non-Default Page Sizes
          onparams -b: Add a buffer pool
          Examples of onparams Commands
        The onpassword utility
        The ifxclone utility
        The onspaces utility
          onspaces syntax
          onspaces -a: Add a chunk to a dbspace or blobspace
          onspaces -a: Add a chunk to an sbspace
          onspaces -c -b: Create a blobspace
          onspaces -c -d: Create a dbspace
          onspaces -c -P: Create a plogspace
          onspaces -c -S: Create an sbspace
            Creating a Temporary Sbspace with the -t Option
            Creating an Sbspace with the -Df option
            Changing the -Df Settings
            Using the onspaces -g option
          onspaces -c -x: Create an extspace
          onspaces -ch: Change sbspace default specifications
          onspaces -cl: Clean up stray smart large objects in sbspaces
          onspaces -d: Drop a chunk in a dbspace, blobspace, or sbspace
          onspaces -d: Drop a space
          onspaces -f: Specify DATASKIP parameter
          onspaces -m: Start mirroring
            Using a File to Specify Chunk-Location Information with the -f Option
          onspaces -r: Stop mirroring
          onspaces -ren: Rename a dbspace, blobspace, sbspace, or extspace
            Renaming a dbspace, blobspace, sbspace, or extspace when Enterprise Replication is active
            Performing an Archive after Renaming a Space
          onspaces -s: Change status of a mirrored chunk
          Avoid overwriting a chunk
        The onstat utility
          onstat Utility Commands Sorted by Functional Category
          Monitor the database server status
          onstat command syntax
          onstat command: Equivalent to the onstat -pu command
          onstat - command: Print output header
          onstat -- command: Print onstat options and functions
          Running onstat Commands on a Shared Memory Dump File
          onstat -a command: Print overall status of the database server
          onstat -b command: Print buffer information for buffers in use
          onstat -B command: Prints information about used buffers
          onstat -c command: Print ONCONFIG file contents
          onstat -C command: Print B-tree scanner information
          onstat -d command: Print chunk information
          onstat -D command: Print page-read and page-write information
          onstat -f command: Print dbspace information affected by dataskip
          onstat -F command: Print counts
          onstat -g monitoring options
            onstat -g act command: Print active threads
            onstat -g afr command: Print allocated memory fragments
            onstat -g all command: Print diagnostic information
            onstat -g aqt command: Print data mart and accelerated query table information
            onstat -g arc command: Print archive status
            onstat -g ath command: Print information about all threads
            onstat -g bth and -g BTH: Print blocked and waiting threads
            onstat -g buf command: Print buffer pool profile information
            onstat -g cac command: Print information about caches
            onstat -g ckp command: Print checkpoint history and configuration recommendations
            onstat -g cfg command: Print the current values of configuration parameters
            onstat -g cluster command: Print high-availability cluster information
            onstat -g cmsm command: Print Connection Manager information
            onstat -g con command: Print condition and thread information
            onstat -g cpu: Print runtime statistics
            onstat -g dbc command: Print dbScheduler and dbWorker thread statistics
            onstat -g defragment command: Print defragment partition extents
            onstat -g dic command: Print table information
            onstat -g dis command: Print database server information
            onstat -g dll command: Print dynamic link library file list
            onstat -g dmp command: Print raw memory
            onstat -g dri command: Print high-availability data replication information
            onstat -g dsc command: Print distribution cache information
            onstat -g dsk command: Print the progress of the currently running compression operation
            onstat -g env command: Print environment variable values
            onstat -g ffr command: Print free fragments
            onstat -g glo command: Print global multithreading information
            onstat -g his command: Print SQL trace information
            onstat -g ioa command: Print combined onstat -g information
            onstat -g iob command: Print big buffer use summary
            onstat -g iof command: Print asynchronous I/O statistics
            onstat -g iog command: Print AIO global information
            onstat -g ioq command: Print I/O queue information
            onstat -g ipl command: Print index page logging status information
            onstat -g iov command: Print AIO VP statistics
            onstat -g lap command: Print light appends status information
            onstat -g laq command: Print secondary server queues
            onstat -g lmm command: Print low memory management information
            onstat -g lmx command: Print all locked mutexes
            onstat -g lsc command: Print active light scan status (deprecated)
            onstat -g mem command: Print pool memory statistics
            onstat -g mgm command: Print MGM resource information
            onstat -g nbm command: Print a block bit map
            onstat -g nsc command: Print current shared memory connection information
            onstat -g nsd command: Print poll threads shared-memory data
            onstat -g nss command: Print shared memory network connections status
            onstat -g ntd command: Print network statistics
            onstat -g ntm command: Print network mail statistics
            onstat -g ntt command: Print network user times
            onstat -g ntu command: Print network user statistics
            onstat -g opn command: Print open partitions
            onstat -g osi: Print operating system information
            onstat -g pd command: Print push data session-related information
            onstat -g pd event command: Print push data event-related information
            onstat -g pos command: Print file values
            onstat -g ppd command: Print partition compression dictionary information
            onstat -g ppf command: Print partition profiles
            onstat -g pqs command: Print operators for all SQL queries
            onstat -g prc command: Print sessions using UDR or SPL routines
            onstat -g proxy command: Print proxy distributor information
            onstat -g qst command: Print wait options for mutex and condition queues
            onstat -g rah command: Print read-ahead request statistics
            onstat -g rbm command: Print a block map of shared memory
            onstat -g rea command: Print ready threads
            onstat -g rss command: Print RS secondary server information
            onstat -g rwm command: Print read and write mutexes
            onstat -g sch command: Print VP information
            onstat -g scn command: Print scan information
            onstat -g sds command: Print SD secondary server information
            onstat -g seg command: Print shared memory segment statistics
            onstat -g ses command: Print session-related information
            onstat -g shard command: Print information about the shard definition
            onstat -g sle command: Print all sleeping threads
            onstat -g smb command: Print sbspaces information
            onstat -g smx command: Print multiplexer group information
            onstat -g spi command: Print spin locks with long spins
            onstat -g sql command: Print SQL-related session information
            onstat -g spf: Print prepared statement profiles
            onstat -g src command: Patterns in shared memory
            onstat -g ssc command: Print SQL statement occurrences
            onstat -g stk command: Print thread stack
            onstat -g stm command: Print SQL statement memory usage
            onstat -g stq command: Print queue information
            onstat -g sts command: Print stack usage for each thread
            onstat -g sym command: Print symbol table information for the oninit utility
            onstat -g tpf command: Print thread profiles
            onstat -g ufr command: Print memory pool fragments
            onstat -g vpcache command: Print CPU VP and tenant VP private memory cache statistics
            onstat -g wai command: Print wait queue thread list
            onstat -g wmx command: Print all mutexes with waiters
            onstat -g wst command: Print wait statistics for threads
          onstat -G command: Print TP/XA transaction information
          onstat -h command: Print buffer header hash chain information
          onstat -i command: Initiate interactive mode
          onstat -j command: Provide onpload status information
          onstat -k command: Print active lock information
          onstat -l command: Print physical and logical log information
          onstat -L command: Print the number of free locks
          onstat -m command: Print recent system message log information
          onstat -o command: Output shared memory contents to a file
          onstat -p command: Print profile counts
          onstat -P command: Print partition information
          onstat -r command: Repeatedly print selected statistics
          onstat -R command: Print LRU, FLRU, and MLRU queue information
          onstat -s command: Print latch information
          onstat -t and onstat -T commands: Print tblspace information
          onstat -u command: Print user activity profile
          onstat -x command: Print database server transaction information
            Determine the position of a logical-log record
            Determine the mode of a global transaction
          onstat -X command: Print thread information
          onstat -z command: Clear statistics
          Return codes on exiting the onstat utility
      SQL Administration API
        SQL Administration API Functions
          SQL Administration API Overview
            admin() and task() Function Syntax Behavior
            admin() and task() Argument Size Specifications
            admin() and task() Function Return Codes
          SQL administration API portal: Arguments by privilege groups
          add bufferpool argument: Add a buffer pool (SQL administration API)
          add chunk argument: Add a new chunk (SQL administration API)
          add log argument: Add a new logical log (SQL administration API)
          add memory argument: Increase shared memory (SQL administration API)
          add mirror argument: Add a mirror chunk (SQL administration API)
          alter chunk argument: Change chunk status to online or offline (SQL administration API)
          alter logmode argument: Change the database logging mode (SQL administration API)
          alter plog argument: Change the physical log (SQL administration API)
          archive fake argument: Perform an unrecorded backup (SQL administration API)
          autolocate database add argument: Add a dbspace to the dbspace list (SQL administration API)
          autolocate database anywhere argument: Add all dbspaces to the dbspace list (SQL administration API)
          autolocate database argument: Specify dbspaces for automatic location and fragmentation (SQL administration API)
          autolocate database off argument: Disable automatic fragmentation for a database (SQL administration API)
          autolocate database remove argument: Remove a dbspace from the dbspace list (SQL administration API)
          cdr argument: Administer Enterprise Replication (SQL administration API)
          cdr add trustedhost argument: Add trusted hosts (SQL administration API)
          cdr autoconfig serv argument: Autoconfigure connectivity and replication (SQL administration API)
          cdr list trustedhost argument: List trusted hosts (SQL administration API)
          cdr remove trustedhost argument: Remove trusted hosts (SQL administration API)
          check data argument: Check data consistency (SQL administration API)
          check extents argument: Check extent consistency (SQL administration API)
          check partition argument: Check partition consistency (SQL administration API)
          checkpoint argument: Force a checkpoint (SQL administration API)
          clean sbspace argument: Release unreferenced smart large objects (SQL administration API)
          create blobspace argument: Create a blobspace (SQL administration API)
          create blobspace from storagepool argument: Create a blobspace from the storage pool (SQL administration API)
          create chunk argument: Create a chunk (SQL administration API)
          create chunk from storagepool argument: Create a chunk from the storage pool (SQL administration API)
          create database argument: Create a database (SQL administration API)
          create dbaccessdemo argument: Create the demonstration database (SQL administration API)
          create dbspace argument: Create a dbspace (SQL administration API)
          create dbspace from storagepool argument: Create a dbspace from the storage pool (SQL administration API)
          create plogspace: Create a plogspace (SQL administration API)
          create sbspace argument: Create an sbspace (SQL administration API)
          create sbspace from storagepool argument: Create an sbspace from the storage pool (SQL administration API)
          create sbspace with accesstime argument: Create an sbspace that tracks access time (SQL administration API)
          create sbspace with log argument: Create an sbspace with transaction logging (SQL administration API)
          create tempdbspace argument: Create a temporary dbspace (SQL administration API)
          create tempdbspace from storagepool argument: Create a temporary dbspace from the storage pool (SQL administration API)
          create tempsbspace argument: Create a temporary sbspace (SQL administration API)
          create tempsbspace from storagepool argument: Create a temporary sbspace from the storage pool (SQL administration API)
          defragment argument: Dynamically defragment partition extents (SQL administration API)
          drop blobspace argument: Drop a blobspace (SQL administration API)
          drop blobspace to storagepool argument: Return space from an empty blobspace to the storage pool (SQL administration API)
          drop chunk argument: Drop a chunk (SQL administration API)
          drop chunk to storagepool argument: Return space from an empty chunk to the storage pool (SQL administration API)
          drop database argument: Drop a database (SQL administration API)
          drop dbspace argument: Drop a dbspace (SQL administration API)
          drop dbspace to storagepool argument: Return space from an empty dbspace to the storage pool (SQL administration API)
          drop log argument: Drop a logical log (SQL administration API)
          drop plogspace: Drop the plogspace (SQL administration API)
          drop sbspace argument: Drop an sbspace (SQL administration API)
          drop sbspace to storagepool argument: Return space from an empty sbspace to the storage pool (SQL administration API)
          drop tempdbspace argument: Drop a temporary dbspace (SQL administration API)
          drop tempdbspace to storagepool argument: Return space from an empty temporary dbspace to the storage pool (SQL administration API)
          drop tempsbspace to storagepool argument: Return space from an empty temporary sbspace to the storage pool (SQL administration API)
          export config argument: Export configuration parameter values (SQL administration API)
          file status argument: Display the status of a message log file (SQL administration API)
          grant admin argument: Grant privileges to run SQL administration API commands
          ha make primary argument: Change the mode of a secondary server (SQL administration API)
          ha rss argument: Create an RS secondary server (SQL administration API)
          ha rss add argument: Add an RS secondary server to a primary server (SQL administration API)
          ha rss change argument: Change the password of an RS secondary server (SQL administration API)
          ha rss delete argument: Delete an RS secondary server (SQL administration API)
          ha sds clear argument: Stop shared-disk replication (SQL administration API)
          ha sds primary argument: Convert an SD secondary server to a primary server (SQL administration API)
          ha sds set argument: Create a shared-disk primary server (SQL administration API)
          ha set idxauto argument: Replicate indexes to secondary servers (SQL administration API)
          ha set ipl argument: Log index builds on the primary server (SQL administration API)
          ha set primary argument: Define an HDR primary server (SQL administration API)
          ha set secondary argument: Define an HDR secondary server (SQL administration API)
          ha set standard argument: Convert an HDR server into a standard server (SQL administration API)
          ha set timeout argument: Change SD secondary server timeout (SQL administration API)
          import config argument: Import configuration parameter values (SQL administration API)
          index compress repack shrink arguments: Optimize the storage of B-tree indexes (SQL administration API)
          index estimate_compression argument: Estimate index compression (SQL administration API)
          master_key reset argument: Change the storage space encryption key (SQL administration API)
          message log delete argument: Delete a message log file (SQL administration API)
          message log rotate argument: Rotate the message log file (SQL administration API)
          message log truncate argument: Delete the contents of a message log file (SQL administration API)
          modify chunk extend argument: Extend the size of a chunk (SQL administration API)
          modify chunk extendable argument: Mark a chunk as extendable (SQL administration API)
          modify chunk extendable off argument: Mark a chunk as not extendable (SQL administration API)
          modify config arguments: Modify configuration parameters (SQL administration API)
          modify space expand argument: Expand the size of a space (SQL administration API)
          modify space sp_sizes argument: Modify sizes of an extendable storage space (SQL administration API)
          onbar argument: Backup the storage spaces (SQL administration API)
          onmode and a arguments: Add a shared-memory segment (SQL administration API)
          onmode and c arguments: Force a checkpoint (SQL administration API)
          onmode and C arguments: Control the B-tree scanner (SQL administration API)
          onmode and d arguments: Set data-replication types (SQL administration API)
          onmode and D arguments: Set PDQ priority (SQL administration API)
          onmode and e arguments: Change usage of the SQL statement cache (SQL administration API)
          onmode and F arguments: Free unused memory segments (SQL administration API)
          onmode and j arguments: Switch the database server to administration mode (SQL administration API)
          onmode and l arguments: Switch to the next logical log (SQL administration API)
          onmode and m arguments: Switch to multi-user mode (SQL administration API)
          onmode and M arguments: Temporarily change decision-support memory (SQL administration API)
          onmode and n arguments: Unlock resident memory (SQL administration API)
          onmode and O arguments: Mark a disabled dbspace as down (SQL administration API)
          onmode and p arguments: Add or remove virtual processors (SQL administration API)
          onmode and Q arguments: Set maximum number for decision-support queries (SQL administration API)
          onmode and r arguments: Force residency of shared memory (SQL administration API)
          onmode and S arguments: Set maximum number of decision-support scans (SQL administration API)
          onmode and W arguments: Reset statement cache attributes (SQL administration API)
          onmode and wf arguments: Permanently update a configuration parameter (SQL administration API)
          onmode and wm arguments: Temporarily update a configuration parameter (SQL administration API)
          onmode, wm, and AUTO_LRU_TUNING arguments: Change LRU tuning status (SQL administration API)
          onmode and Y arguments: Change query plan measurements for a session (SQL administration API)
          onmode and z arguments: Terminate a user session (SQL administration API)
          onmode and Z arguments: Terminate a distributed transaction (SQL administration API)
          onsmsync argument: Synchronize with the storage manager catalog (SQL administration API)
          onstat argument: Monitor the database server (SQL administration API)
          ontape archive argument: Backup the data on your database (SQL administration API)
          print error argument: Print an error message (SQL administration API)
          print file info argument: Display directory or file information (SQL administration API)
          print partition argument: Print partition information (SQL administration API)
          rename space argument: Rename a storage space (SQL administration API)
          reset config argument: Revert configuration parameter value (SQL administration API)
          reset config all argument: Revert all dynamically updatable configuration parameter values (SQL administration API)
          reset sysadmin argument: Move the sysadmin database (SQL administration API)
          restart listen argument: Stop and start a listen thread dynamically (SQL administration API)
          revoke admin argument: Revoke privileges to run SQL administration API commands
          scheduler argument: Stop or start the scheduler (SQL administration API)
          scheduler lmm enable argument: Specify automatic low memory management settings (SQL administration API)
          scheduler lmm disable argument: Stop automatic low memory management (SQL administration API)
          set chunk argument: Change the status of a chunk (SQL administration API)
          set dataskip argument: Start or stop skipping a dbspace (SQL administration API)
          set index compression argument: Change index page compression (SQL administration API)
          set onconfig memory argument: Temporarily change a configuration parameter (SQL administration API)
          set onconfig permanent argument: Permanently change a configuration parameter (SQL administration API)
          set sbspace accesstime argument: Control access time tracking (SQL administration API)
          set sbspace avg_lo_size argument: Set the average size of smart large objects (SQL administration API)
          set sbspace logging argument: Change the logging of an sbspace (SQL administration API)
          set sql tracing argument: Set global SQL tracing (SQL administration API)
          set sql tracing database argument: Change database tracing (SQL administration API)
          set sql tracing session argument: Control tracing for a session (SQL administration API)
          set sql tracing user argument: Control tracing for users (SQL administration API)
          set sql user tracing argument: Set global SQL tracing for a user session (SQL administration API)
          start json listener argument: Start the MongoDB API wire listener
          start listen argument: Start a listen thread dynamically (SQL administration API)
          start mirroring argument: Starts storage space mirroring (SQL administration API)
          stop json listener: Stop the wire listener
          stop listen argument: Stop a listen thread dynamically (SQL administration API)
          stop mirroring argument: Stops storage space mirroring (SQL administration API)
          storagepool add argument: Add a storage pool entry (SQL administration API)
          storagepool delete argument: Delete one storage pool entry (SQL administration API)
          storagepool modify argument: Modify a storage pool entry (SQL administration API)
          storagepool purge argument: Delete storage pool entries (SQL administration API)
          Table and fragment compress and uncompress operations (SQL administration API)
            table or fragment arguments: Compress data and optimize storage (SQL administration API)
            Output of the estimate compression operation (SQL administration API)
            purge compression dictionary arguments: Remove compression dictionaries (SQL administration API)
          tenant create argument: Create a tenant database (SQL Administration API)
          tenant drop argument: Drop a tenant database (SQL Administration API)
          tenant update argument: Modify tenant database properties (SQL Administration API)
      Appendixes
        Database server files
        Troubleshooting errors
          Collecting Diagnostics using onmode -I
          Creating Tracepoints
          Collecting data with the ifxcollect tool
        Event Alarms
          Using ALARMPROGRAM to Capture Events
            Setting ALRM_ALL_EVENTS
            Writing Your Own Alarm Script
            Customizing the ALARMPROGRAM Scripts
            Precautions for Foreground Operations in Alarm Scripts
            Interpreting event alarm messages
          Events in the ph_alert Table
          Event Alarm Parameters
          Event alarm IDs
            Severity 5 event alarms
          Connection Manager event alarm IDs
        Messages in the database server log
          How the Messages Are Ordered in This Chapter
            How to view these messages
            Message Categories
          Messages: A-B
            Aborting Long Transaction: tx 0xn.
            Affinitied VP mm to phys proc nn.
            Affinity not enabled for this server.
            Assert Failed: Error from SBSpace cleanup thread.
            Assert Failed: Short description of what failed Who: Description of user/session/thread running at the time Result: State of the affected database server entity Action: What action the database administrator should take See Also: DUMPDIR/af.uniqid containing more diagnostics.
            Begin re-creating indexes deferred during recovery.
            Building 'sysmaster' database requires ~mm pages of logical log. Currently there are nn pages available. Prepare to back up your logs soon.
            Building 'sysmaster' database...
          Messages: C
            Cannot Allocate Physical-log File, mm wanted, nn available.
            Cannot alter a table which has associated violations table.
            Cannot change to mode.
            Cannot Commit Partially Complete Transactions.
            Cannot create a user-defined VP class with 'SINGLE_CPU_VP' non-zero.
            Cannot create violations/diagnostics table.
            Cannot insert from the violations table to the target table.
            Cannot modify/drop a violations/diagnostics table.
            Cannot Open Dbspace nnn.
            Cannot Open Logical Log.
            Cannot Open Mirror Chunk pathname, errorno = nn.
            Cannot Open Primary Chunk pathname, errorno = nnn.
            Cannot Open Primary Chunk chunkname.
            Cannot open sysams in database name, iserrno number.
            Cannot open sysdistrib in database name, iserrno number.
            Cannot open system_table in database name, iserrno number.
            Cannot open systrigbody in database name, iserrno number.
            Cannot open systriggers in database name, iserrno number.
            Cannot open sysxtdtypes in database name, iserrno number.
            Cannot Perform Checkpoint, shut system down.
            Cannot Restore to Checkpoint.
            Cannot Rollback Incomplete Transactions.
            Cannot update pagezero.
            Cannot update syscasts in database name. Iserrno number.
            Can’t affinity VP mm to phys proc nn.
            Changing the sbspace minimum extent value: old value value1, new value value2.
            Checkpoint blocked by down space, waiting for override or shutdown.
            Checkpoint Completed: duration was n seconds.
            Checkpoint Page Write Error.
            Checkpoint Record Not Found in Logical Log.
            Chunk chunkname added to space spacename.
            Chunk chunkname dropped from space spacename.
            Chunk number nn pathname -- Offline.
            Chunk number nn pathname -- Online.
            The chunk pathname must have READ/WRITE permissions for owner and group.
            The chunk pathname must have owner-ID and group-ID set to informix.
            The chunk pathname will not fit in the space specified.
            Cleaning stray LOs in sbspace sbspacename.
            Completed re-creating indexes.
            Configuration has been grown to handle up to integer chunks.
            Configuration has been grown to handle up to integer dbslices.
            Configuration has been grown to handle up to integer dbspaces.
            Continuing Long Transaction (for COMMIT): tx 0xn.
            Could not disable priority aging: errno = number.
            Could not fork a virtual processor: errno = number.
            Create_vp: cannot allocate memory.
          Messages: D-E-F
            Dataskip is OFF for all dbspaces.
            Dataskip is ON for all dbspaces.
            Dataskip is ON for dbspaces: dbspacelist.
            Dataskip will be turned {ON|OFF} for dbspacename.
            DBSERVERALIASES exceeded the maximum limit of 32
            DBSPACETEMP internal list not initialized, using default.
            The DBspace/BLOBspace spacename is now mirrored.
            The DBspace/BLOBspace spacename is no longer mirrored.
            devname: write failed, file system is full.
            Dropping temporary tblspace 0xn, recovering nn pages.
            Dynamically allocated new shared memory segment (size nnnn).
            ERROR: NO "wait for" locks in Critical Section.
            Error building sysmaster database. See outfile.
            Error in dropping system defined type.
            Error in renaming systdist.
            Error removing sysdistrib row for tabid = tabid, colid = colid in database name. iserrno = number
            Error writing pathname errno = number.
            Error writing shmem to file filename (error). Unable to create output file filename errno=mm.Error writing filename errno=nn.
            Fail to extend physical log space.
            Fatal error initializing CWD string. Check permissions on current working directory. Group groupname must have at least execute permission on '.'.
            Fragments dbspacename1 dbspacename2 of table tablename set to non-resident.
            Forced-resident shared memory not available.
            Freed mm shared-memory segment(s) number bytes.
          Messages: G-H-I
            gcore pid; mv core.pid dir/core.pid.ABORT.
            I/O function chunk mm, pagenum nn, pagecnt aa --> errno = bb.
            I/O error, primary/mirror Chunk pathname -- Offline (sanity).
            Informix database_server Initialized - Complete Disk Initialized.
            Informix database_server Initialized - Shared Memory Initialized.
            Informix database_server Stopped.
            In-Place Alter Table. Perform EXECUTE FUNCTION sysadmin:task('table update_ipa', 'table_name','database');
            ERROR: Insufficient available disk in the root dbspace to increase the entire Configuration save area.
            Insufficient available disk in the root dbspace for the CM save area. Increase the size of the root dbspace in the ONCONFIG file and reinitialize the server.
            Internal overflow of shmid's, increase system max shared memory segment size.
          Messages: J-K-L-M
            Listener-thread err = error_number: error_message.
            Lock table overflow - user id mm session id nn.
            Logical-log File not found.
            Logical Log nn Complete.
            Logical logging vberror for type:subtype in (failed_system).
            Log Record: log = ll, pos = 0xn, type = type:subtype(snum), trans = xx
            Log record (type:subtype) at log nn, 0xn was not undone.
            Log record (type:subtype) failed, partnum pnum row rid iserrno num.
            Log record (type:subtype) in log nn, offset 0xn was not rolled back.
            Logical Recovery allocating nn worker threads thread_type.
            Logical Recovery Started.
            Maximum server connections number.
            Memory allocation error.
            Mirror Chunk chunkname added to space spacename. Perform manual recovery.
            Mixed transaction result. (pid=nn user=userid).
            mt_shm_free_pool: pool 0xn has blocks still used (id nn).
            mt_shm_init: can’t create resident/virtual segment.
            mt_shm_remove: WARNING: may not have removed all/correct segments.
          Messages: N-O-P
            Newly specified value of value for the pagesize in the configuration file does not match older value of value. Using the older value.
            Not enough main memory.
            Not enough logical-log files, Increase LOGFILES.
            The number of configured inline poll threads exceeds the number of CPU virtual processors.
            onconfig parameter parameter modified from old_value to new_value.
            oninit: Cannot have SINGLE_CPU_VP non-zero and number of CPU VPs greater than 1.
            oninit: Cannot have SINGLE_CPU_VP non-zero and user-defined VP classes.
            oninit: Fatal error in initializing ASF with 'ASF_INIT_DATA' flags asfcode = '25507'.
            Cannot alter a table which has associated violations table.
            oninit: Too many VPCLASS parameters specified.
            oninit: VPCLASS classname bad affinity specification.
            oninit: VPCLASS classname duplicate class name.
            oninit: VPCLASS classname illegal option.
            oninit: VPCLASS classname maximum number of VPs is out of the range 0-10000.
            oninit: VPCLASS classname name is too long. Maximum length is maxlength.
            oninit: VPCLASS classname number of VPs is greater than the maximum specified.
            oninit: VPCLASS classname number of VPs is out of the range 0-10000.
            onmode: VPCLASS classname name is too long. Maximum length is maxlength.
            Online Mode.
            onspaces: unable to reset dataskip.
            Open transaction detected when changing log versions.
            Out of message shared memory.
            Out of resident shared memory.
            Out of virtual shared memory.
            PANIC: Attempting to bring system down.
            Participant site database_server heuristically rolled back.
            Physical recovery complete: number pages examined, number pages restored.
            Physical recovery started at page (chunk:offset).
            Portions of partition partnum of table tablename in database dbname were not logged. This partition cannot be rolled forward.
            Possible mixed transaction result.
            Prepared participant site server_name did not respond.
            Prepared participant site server_name not responding.
          Messages: Q-R-S
            Quiescent Mode.
            Read failed. Table name, Database name, iserrno = number
            Recovery Mode.
            Recreating index: 'dbsname:"owner".tabname-idxname'.
            Rollforward of log record failed, iserrno = nn.
            Root chunk is full and no additional pages could be allocated to chunk descriptor page.
            scan_logundo: subsys ss, type tt, iserrno ee.
            Session completed abnormally. Committing tx id 0xm, flags 0xn.
            Session completed abnormally. Rolling back tx id 0xm, flags 0xn.
            semctl: errno = nn.
            semget: errno = nn.
            shmat: some_string os_errno: os_err_text.
            shmctl: errno = nn.
            shmdt: errno = nn.
            shmem sent to filename.
            shmget: some_str os_errno: key shmkey: some_string.
            Shutdown (onmode -k) or override (onmode -O).
            Shutdown Mode.
            Space spacename added.
            Space spacename dropped.
            Space spacename -- Recovery Begins(addr).
            Space spacename -- Recovery Complete(addr).
            Space spacename -- Recovery Failed(addr).
            sysmaster database built successfully.
            Successfully extend physical log space
          Messages: T-U-V
            This ddl operation is not allowed due to deferred constraints pending on this table and dependent tables.
            This type of space does not accept log files.
            TIMER VP: Could not redirect I/O in initialization, errno = nn.
            Too Many Active Transactions.
            Too many violations.
            Transaction Not Found.
            Transaction heuristically rolled back.
            Transaction table overflow - user id nn, process id nn.
            Unable to create output file filename errno = nn.
            Unable to extend nn reserved pages for purpose in root chunk.
            Unable to start SQL engine.
            Unable to open tblspace nn, iserrno = nn.
            The value of pagesize pagesize specified in the config file is not a valid pagesize. Use 2048, 4096 or 8192 as the value for PAGESIZE in the onconfig file and restart the server.
            Violations table is not started for the target table.
            Violations table reversion test completed successfully.
            Violations table reversion test failed.
            Violations table reversion test start.
            Violations tables still exist.
            Virtual processor limit exceeded.
            VPCLASS classname name is too long. Maximum length is maxlength.
            VPCLASS classname duplicate class name.
            VPCLASS classname Not enough physical procs for affinity.
          Messages: W-X-Y-Z
            WARNING: aio_wait: errno = nn.
            WARNING: Buffer pool size may cause database server to get into a locked state. Recommended minimum buffer pool size is num times maximum concurrent user threads.
            warning: Chunk time stamps are invalid.
            Warning: name_old is a deprecated onconfig parameter. Use name_new instead. See the release notes and the Informix Administrator's Reference for more information.
            Warning: name_old is a deprecated onconfig parameter. Use name_new instead.
            Warning: Unable to allocate requested big buffer of size nn.
            You are turning off smart large object logging.
          Messages: Symbols
            HH:MM:SS Informix database server Version R.VV.PPPPP Software Serial Number RDS#XYYYYYY.
            argument: invalid argument.
            function_name: cannot allocate memory.
          Conversion and reversion error messages
            Cannot revert new fragment expression for index index, tabid id.
            Cannot revert new table fragment expression for table with id id.
            The conversion of the database name has failed.
            Database name is not revertible...
            Database name: Must drop trigger (id = id_number) before attempting reversion.
            The dummy updates failed while converting database name. This may imply data corruption in the database. If so, restore the original database with the tape backup. For more information, see output_file.
            Error in slow altering a system table.
            Internal server error.
            Must drop long identifiers in table name in database name
            Must drop new database (name) before attempting reversion. Iserrno error_number
            Must drop new user defined statistics in database name, iserrno number
            The pload database contains load/unload jobs referring to long table names, column names, or database names. These jobs will not work as expected until they are redefined.
            Reversion canceled.
            There is a semi-detached index in this table, which cannot be reverted.
            WARNING: Target server version must have a certified Storage Manager installed after conversion/reversion and before bringing up server.
          Conversion and Reversion Messages for Enterprise Replication
            CDR reversion test failed; for details look in $INFORMIXDIR/etc/revtestcdr.out.
            Enterprise Replication is not ready for conversion. The Control and TRG send queues should be empty for conversion/reversion to proceed.
            Enterprise Replication should be in a stopped state for conversion/reversion to proceed.
            ...‘syscdr’ reversion failed; for details look in $INFORMIXDIR/etc/revcdr.out.
            'syscdr' conversion failed. For details, look in $INFORMIXDIR/etc/concdr.out.
            Syscdr should NOT contain new replicate sets for reversion to succeed.
            Syscdr should not contain replicates defined with the --floatieee option for reversion to succeed.
          Dynamic Log Messages
            Dynamically added log file logid to DBspace dbspace_number.
            Log file logid added to DBspace dbspace_number.
            Log file number logid has been dropped from DBspace dbspace_number.
            Log file logid has been pre-dropped.
            Pre-dropped log file number logid has been deleted from DBspace dbspace_number.
            ALERT: Because the oldest logical log (logid) contains records from an open transaction (transaction_address), the server is attempting to dynamically add a log file. But there is no space available. Please add a DBspace or chunk. Then complete the transaction as soon as possible.
            ALERT: The oldest logical log (logid) contains records from an open transaction (transaction_address). Logical logging will remain blocked until a log file is added. Add the log file with the onparams -a command, using the -i (insert) option, as in: onparams -a -d dbspace -s size -i. Then complete the transaction as soon as possible.
            Log file logid has been pre-dropped. It will be deleted from the log list and its space can be reused once you take level-0 archives of all BLOBspaces, Smart BLOBspaces and non-temporary DBspaces.
          Sbspace Metadata Messages
            Allocated number pages to Metadata from chunk number.
            Allocated number pages to Userdata from chunk number.
            Freeing reserved space from chunk number to Metadata.
            Freeing reserved space from chunk number to Userdata.
          Truncate Table Messages
            The table cannot be truncated if it has an open cursor or dirty readers.
            The table cannot be truncated. It has at least one non-empty child table with referential constraints.
        Limits in Informix
    DB-Access User's Guide
      What's new for DB-Access in IBM Informix, Version 12.10
      Getting started with DB-Access
        Requirements for the Informix server DB-Access utility
          Environment variables for DB-Access
        Requirements for the Informix Client Software Development Kit DB-Access utility
        Demonstration databases
          Creating a demonstration database
          dbaccessdemo command: Create demonstration databases
        Start DB-Access
          dbaccess command: Start DB-Access
            CONNECTION menu options
            DATABASE menu options
            QUERY-LANGUAGE menu options
            TABLE menu options
            Example: Start DB-Access for a database
            Example: Run a command file
            Example: View the Information Schema
            Example: Check for ANSI compliance
            Example: Show nonprintable characters in hexadecimal
          Run DB-Access in interactive mode without menus
            Connect to a database environment in interactive mode
      The full-screen menu interface
        The Query-language option
          SQL editor
          A system editor
          Statements that the Run option supports
          Redirect query results
          Choose an existing SQL statement
          Save the current SQL statement
          Support for SPL Routines
          What happens when errors occur
        The Database option
          List of available databases
          Retrieve nondefault locale information
          Close a database
        The Table option
          Display table information
        The Connection and Session options
          Implicit closures
      Appendixes
        How to read online help for SQL statements
        Demonstration SQL
          SQL files for the relational database model
            The alt_cat.sql command file
            The c_calls.sql command file
            The c_cat.sql command file
            The c_custom.sql command file
            The c_index.sql command file
            The c_items.sql command file
            The c_manuf.sql command file
            The c_orders.sql file
            The c_proc.sql command file
            The c_state command file
            The c_stock.sql command file
            The c_stores.sql command file
            The c_table.sql command file
            The c_trig.sql command file
            The c_type.sql command file
            The c_view1.sql command file
            The c_view2.sql command file
            The d_proc.sql command file
            The d_trig.sql command file
            The d_view.sql command file
            The del_stock.sql command file
            The ins_table.sql command file
            The sel_agg.sql command file
            The sel_all.sql command file
            The sel_group.sql command file
            The sel_join.sql command file
            The sel_ojoin1.sql command file
            The sel_ojoin2.sql command file
            The sel_ojoin3.sql command file
            The sel_ojoin4.sql command file
            The sel_order.sql command file
            The sel_sub.sql command file
            The sel_union.sql command file
            The upd_table.sql command file
          SQL files for the Dimensional Database Model
            The createdw.sql file
            The loaddw.sql file
          User-defined routines for the object-relational database model
    High-Performance Loader User's Guide
      High-Performance Loader overview
        Overview of HPL features
        The HPL data-load process
        The HPL data-unload process
        HPL loading modes
        HPL components
          The onpload utility
          The ipload utility
          The onpladm utility
          The onpload database
          Relationships among the parts of the HPL
        Environment variables needed for the HPL
          Preparing multiple onpload databases
          The PLCONFIG environment variable
          The PLOAD_SHMBASE environment variable
            Avoid shared-memory collision
            Set the PLOAD_SHMBASE environment variable
          The PLOAD_LO_PATH environment variable
          The PLOAD_SHMAT environment variable
        Architecture of the onpload utility
          The onpload utility deluxe-mode process
            Threads that the onpload utility uses
            Threads that the database server uses
          The onpload utility express-mode load process
          The onpload utility unload process
      Examples of loading and unloading jobs using the ipload utility
        Prepare to use the ipload utility
        Create a file of data
        Create a database
        The ipload utility
          Start the ipload utility
          Choose a project
          Check the ipload utility default values
            Look at the Defaults window
            Look at the Machines window
        Load Job windows
          Load Job Select window
          Load Job window
        Device-Array windows
          Device Array Selection window
          Device-Array Definition window
        Format windows
          Format Views window
          Record Formats window
          Format-Definition window
        Filter, Discard Records, and Logfile text boxes
        Map Views window
          Creating a map by using Map Views window
        Completing the Load Record Maps window
        Map-Definition window
          Associating each input item with a column of the database table
        Load Options window
        Running the ipload job
        Active Job window
        The ipload utility Generate options
          Use the information you created with the ipload example
          Preparing the Unload Job window
          Performing the unload job
      The ipload utility windows
        The ipload utility GUI or the onpladm command-line interface
          Start the ipload utility
        The ipload utility GUI
          The HPL main window
            Initial options on the HPL main window
            Options of the HPL main window
          Component-Selection windows
          Component-Definition windows
          Load Job and Unload Job windows
          Views windows
            Access views windows
            Available options in a Views window
              Search for a component in a Views window
              Expand the view in a Views window
          Selection-List windows
          Message windows
        The HPL ipload utility buttons
          The HPL ipload utility toolbar buttons
            The Browse button
            The Copy button
              Copying an existing format into a new format
            The Delete button
              Deleting an existing format
            The Notes button
              Creating a note
            The Print button
          The HPL ipload utility icon buttons
          Buttons at the bottom of the HPL ipload utility display
        The HPL online help
        The UNIX keyboard commands to move the cursor
      Define HPL projects
        HPL projects
        Project organization
        Select or create a project with the Projects window
          Defining a new project
          Selecting a project
            Selecting a project for a load or unload job
            Selecting a project to edit
      Configure the High-Performance Loader
        Configure the ipload utility
        Select a database server
          Selecting a database server
          Create the onpload database
        Modify the onpload default values
          The Defaults window
          Specifying the onpload defaults
        Selecting a driver
          The Drivers window
          Adding a custom-driver name
        Modify the machine description
          The Machines window
          Editing the description of a computer
          Adding a computer type to the Machines list
      Define device arrays
        Device arrays
        Multiple devices in a device array
        The Device-Array Selection window
          Creating a device array
          Opening an existing device array
        The Device-Array Definition window
          Adding, editing, and removing devices
            Adding devices to the device array
            Editing a device in the device array
            Deleting a device from the device array
      Define formats
        Formats
        Formats of supported datafile records
        Fixed-length records
          Creating a fixed format
            Data types allowed in a fixed format
          Editing a format
            Adding a new field description to the format
            Inserting a new field into the format
            Editing the description of a field
            Deleting a field description from the format
          Create a fixed format that uses carriage returns
          Create a fixed format that includes BYTE or TEXT data
            Inline data
            Data in a separate file
          Create a fixed format that includes Ext type or Simple LO data
            Fixed-length data
            Inline data
            Simple LO data in a separate file
        Delimited records
          Create a delimited format
            Data types allowed in a delimited format
          Create a delimited format that includes BYTE or TEXT data
          Create a delimited format with extended data types
        COBOL records
          Create a COBOL format
          Picture and usage descriptions
        Other formats
        Format options
          Modifying fixed and COBOL formats
          Modifying delimited-format options
            Testing the import of a CSV file
        Format Views window
      Define queries
        HPL queries
        Creating a query
          Using the Column Selection window
          Editing the WHERE clause
        Editing a query
        Exporting and importing queries
          Importing a query
          Exporting a query
        The Database Views window
      Define maps
        Load and unload maps
          The Map-Definition window
            The Table and Format panes
            Unassigned or multiple-assigned fields and columns
            Identical field names and column names
          Creating a load map
        Unload maps
          Creating an unload map
          Unload data by using functions
        Mapping options
          Defining the mapping options
          Set the mapping options
        Editing options
          Using the Delete button
          Using the Find button
          Using the Specs button
        Map Views window
          Seeing the load maps of a database
          Seeing selected load maps
      Define filters
        Filters
        Example of using filter
        Creating a filter
          Preparing the filter definition
        Modifying a filter
          Editing an existing filter
          Adding an item to the filter
          Inserting an item into the filter sequence
          Deleting a filter
        Filter views
        Filters with code-set conversion (GLS)
      Unload data from a database
        Unload jobs
        Components of the unload job
          Choose the database server
          Run multiple jobs
        The Unload Job windows
          Creating an unload job
          Run the unload job
            Problems during an unload job
          Specify to write to the end of the tape
          The command-line information
          Changing the unload options
          Editing an unload job
        Generate options for an unload job
      Load data to a database table
        Load jobs
        Components of the load job
          Choose the database server
          Run multiple jobs
          Prepare user privileges and the violations table
            Set user constraints
            Manage the violations and diagnostics tables
        The Load Job windows
          Creating a load job
          Run the load job
            Make a level-0 backup
            Problems during a load job
          Specify to read to the end of the tape
          The command-line information
          Changing the load options
          Editing a load job
        Generate options for a load job
      The Generate options of the ipload utility
        Overview of the ipload Generate options
        Tasks that generate load or unload components
        Generate from the Load Job window
          Generating a job from the Load Job window
        Generate from the Unload Job window
          Generating a job that uses a query
          Generating a job that unloads an entire table
        Generate from the Components menu
          The Generate window
            Generate group
            Format type group
          Generating load and unload components
          Using the No Conversion Job option
      The HPL browsing options
        Browsing options
          Preview data-file records
            Using the Record Browser window
              Reviewing data-file records in a selected format
              Searching and editing a format
              Editing a format
          Reviewing records that the conversion rejected
          Viewing the violations table
          View the status of a load job or unload job
            Viewing the log file
            Sample log file
      Manage the High-Performance Loader
        Manage modes, errors, and performance
        HPL modes
          The HPL deluxe mode
          The HPL express mode
          How the express and deluxe modes work
            Foreign-key constraints
            Comparison between an express-mode and a deluxe-mode load operation
        HPL load and unload errors
          Rejected records from the input file
          Constraint violations
          View error records
        HPL performance
          The onpload configuration parameters
          Express-mode limitations
          The onstat options for onpload
          Devices for the device array
          HPL usage tasks
            Reorganize computer configuration
            Alter the schema of a table
            Assess information for loading or unloading external data
          Settings for a no-conversion load or unload job
            Run no-conversion load jobs with tables with hidden columns
          An express-mode load with delimited ASCII
          HPL performance hints
            Choose an efficient format
            Ensure enough converter threads and VPs
            Ensure enough memory
            Ensure enough buffers of adequate size
            Increase the commit interval
        Limitation when using the Excalibur Text DataBlade Module indexes
      The onpload utility
        Overview of the onpload utility
        The onpload file name size limitations on UNIX
        Start the onpload utility
        Using the onpload utility
        The onpload utility syntax
        Set the onpload run mode with the -f option
          Type the onpload -f flags
          Interpret the onpload -d and -f options together
        Modify the size of onpload database parameters
          The onpload -i option
        Override the onpload database values
        Load data into collection data type columns
      The onpladm utility
        Overview of the onpladm utility
          The onpladm utility features
          Specification-file conventions
          Error handling
        Define onpladm utility jobs
          Create onpladm jobs
            Create conversion jobs
              Create conversion jobs by using a quick command
              Create conversion jobs by using detailed specification files
                Create a conversion-load job
                Create a conversion unload job
            Create no-conversion jobs
              Create no-conversion jobs by using a quick command
              Create no-conversion jobs by using detailed specification files
                Create a no-conversion load job
                Create a no-conversion unload job
          Modify a job by using a detailed specification file
          Describe a job
          List all jobs in a project
          Run a job
            The onpladm utility when referential constraints are on tables
          Delete a job
        Define device arrays
          Create a device array
          Modify a device array
          Describe a device array
          List project device arrays
          Deleting a device array
        Define maps
          Create maps
            Create a map by using a quick command
            Create a map with a detailed specification file
          Delete a map
          Describe a map
          Modify a map by using a detailed specification file
          List all maps in a project
        Define formats
          Create a format
          Modify a format by using a specification file
          Describe a format
          List all formats in a project
          Delete a format
        Define queries
          Creating a query
          Modify a query
          Describing a query
          List all queries in a project
          Delete a query
        Define filters
          Create a filter
          Modify a filter
          Describe a filter
          List all filters in a project
          Delete a filter
        Define projects
          Create a project
          Run all jobs in a project
          List all projects
          Delete a project
        Define machine types
          Create a machine type
          Modify a machine type
          Describe a machine
          List all existing machine types
          Delete a machine type
        Define database operations
          Create a database project
          Configure target-server attributes
            Set target-server attribute values
            List target-server defaults
      Appendixes
        The onpload database
          The defaults table in the onpload database
          The delimiters table in the onpload database
          The device table in the onpload database
          The driver table in the onpload database
          The filteritem table in the onpload database
          The filters table in the onpload database
          The formatitem table in the onpload database
          The formats table in the onpload database
          The language table in the onpload database
          The machines table in the onpload database
          The mapitem table in the onpload database
          The mapoption table in the onpload database
          The maps table in the onpload database
          The note table in the onpload database
          The project table in the onpload database
          The query table in the onpload database
          The session table in the onpload database
        High-Performance Loader configuration file
          HPL configuration parameter descriptions
          HPL configuration parameter file conventions
          The AIOBUFFERS configuration parameter
          The AIOBUFSIZE configuration parameter
          The CONVERTTHREADS configuration parameter
          The CONVERTVPS configuration parameter
          The HPLAPIVERSION configuration parameter
          The HPL_DYNAMIC_LIB_PATH configuration parameter
          The STRMBUFFERS configuration parameter
          The STRMBUFFSIZE configuration parameter
        Picture strings
          Alphanumeric pictures
          Numeric pictures
          Date pictures
        Match condition operators and characters
          Operator descriptions and examples
        Custom-conversion functions
          Custom conversion example
          The onpload conversion process
            Integrating custom conversion functions
            API functions
              The DBXget_source_value(fldname,buffer,buflen) routine
              The DBXget_dest_value(fldname,buffer,buflen) routine
              The DBXput_dest_value(fldname,buffer) routine
              The DBXget_dest_length(fldname) routine
        The onstat -j option
          Using the onstat -j option
        The HPL log-file and pop-up messages
          How HPL logfile messages are ordered
          HPL logfile message categories
          The HPL log-file messages
            Blob conversion error occurred on record record_num
            Cannot access database table table_name: SQL error error_num
            Cannot allocate shared memory
            Cannot allocate TLI memory for operating_system structure
            Cannot bind socket connection: errno= operating-system_error_num
            Cannot bind TLI connection: t_errno= t_error_num
            Cannot configure driver driver_name
            Cannot connect to message server: Socket error = UNIX_error_num
            Cannot connect to message server: TLI erro r= t_error_num, TLI event = t_event_num, errno = error_num
            Cannot connect to server_name: SQL error error_num, ISAM error error_num
            Cannot connect worker to server data stream
            Cannot disable table_name object constraints: SQL error error_num, ISAM error error_num
            Cannot disable primary-key constraint. Child-table references exist
            Cannot express load to logged table on HDR server server_name
            Cannot filter indexes for table table_name: SQL error error_num, ISAM error error_num
            Cannot find the shared library path in the plconfig file. Using the shared library from the default location library_location
            Cannot find the user-defined function user_func_name in the shared library: error error_num
            Cannot get systable info for table table_name: SQL error error_num, ISAM error error_num
            Cannot initialize shared library handling
            Cannot load code-set conversion file from file_name to file_name
            Cannot load mapping definitions
            Cannot load the shared library library_location
            Cannot locate delimiter in data file
            Cannot open
            Cannot open simple large object file: file_name, simple large object not loaded
            Cannot open database database_name: SQL error error_num, ISAM error error_num
            Cannot open file file_name: error number operating-system_error_num
            Cannot open TCP connection for server_name: errno operating-system_error_num
            Cannot perform express mode load on table with pseudo rowid
            Cannot perform express-mode load with rowsize = row_length > page_size
            Cannot read file file_name: AIO error code operating-system_error_num
            Cannot re-enable all objects: num_violations violations detected
            Cannot reorder query statement to align simple large objects or Ext Types
            Cannot reorder query statement to align blobs
            Cannot set mode of table_name objects from current_mode to final_mode mode: SQL error error_num, ISAM error error_num
            Cannot start violations table for table_name: SQL error error_num, ISAM error error_num
            Cannot stop violations table for table_name: SQL error error_num, ISAM error error_num
            Cannot unload to multiple devices when the given query cannot be executed in parallel
            Cannot write file file_name: AIO error code operating-system_error_num
            Code-set conversion overflow
            Conversion of onpload database failed due to error error_num
            Conversion of onpload database failed due to error error_num, run as user informix
            Custom conversion function function_name not found in shared library
            Discarded num_bytes null bytes from end of tape device device_name
            Environment variable variable_name expansion would overflow string
            Error accepting socket connection: errno = operating-system_error_num
            Error accessing file_name
            Error accessing format: SQL error error_num, ISAM error error_num
            Error accessing map map_name: SQL error error_num, ISAMerror error_num
            Error accessing sysmaster: SQL error error_num, ISAMerror error_num
            Error accessing table table_name: SQL error error_num, ISAM error error_num
            Error: AIO buffer size buffer_size is less than required minimum size size
            Error error_num closing current database
            Error operating-system_error_num closing file file_name
            Error error_num converting record field field_name to column column_name
            Error declaring cursor: could not get table info
            Error declaring cursor: SQL error error_num, ISAM error error_num
            Error describing unload query query_name: SQL error error_num, ISAM error error_num
            Error error_num initializing backend connection
            Error inserting into table table_name: SQL error error_num, ISAM error error_num
            Error listening for socket connection: t_errno = t_error_num errno = operating-system_error_num
            Error listening for TLI connection: t_errno = t_error_num errno = UNIX_error_num
            Error error_num on record record_num converting column column_name to record field field_name
            Error occurred on record %d reading pipe %s
            Error on close of server load session: SQL error error_num, ISAM error error_num
            Error opening cursor: SQL Error error_num
            Error preparing query: SQL error error_num
            Error preparing statement statement_name: SQL error error_num, ISAM error error_num
            Error preparing unload query query_name: SQL error error_num, ISAM error error_num
            Error error_num reading message queue
            Error operating-system_error_num reading TLI/socket connection
            Error error_num setting isolation level
            Error error_num writing message on message queue
            Error operating-system_error_num writing TLI/socket connection
            Error: Stream buffer size buffer_size is less than required minimum size size
            Exhausted all attempts to allocate shared-memory key.
            Fatal error: cannot execute pipe_name
            Fatal error: cannot load X resource
            Fatal error creating server load session: error error_num
            Fatal error getting stream buffer from server
            Fatal error in server row processing: SQL error error_num, ISAM error error_num
            File type device file file_name is not a regular (disk) file
            Got Interrupt: Shutting down
            Internal error: Cannot initialize AIO library
            Internal error: Cannot send message
            Internal error: error_num. Contact Tech Support
            Internal error: invalid message type error_num
            Internal error error_num reading queue
            Invalid count detected, might be due to abnormal BE shutdown
            Invalid code-set character: Cannot convert
            Invalid HEXASCII simple large object or extended type representation on record record_num
            Invalid HEXASCII simple large object representation in fieldname, record record_num
            Invalid project name project_name entered
            Invalid reject count detected, might be due to abnormal BE shutdown. Using last known reject count and proceeding
            Invalid session ID id_number
            Invalid tape header expecting -> tape_name
            Map map_name type is not a load map
            Method not supported by current driver
            MT cannot bind to vpid
            MT internal failure
            MT failure putting CPU online
            No insert permission on table table_name
            No mapping to simple large object field field_name
            onpload must run on the host host_name that contains the target database
            onpload terminated by signal
            Pipe type device file file_name is not a regular file
            Pload cannot reorder queries having expressions/aggregates and blobs/udts in the same select list
            Query contains unmapped simple large object column column_name: Cannot proceed
            Query for unload is not a select query.
            Record is too long to process: recnum record_num, length record_length, bufsize buffer_size
            Server interface error; expected num_input but got num_received instead
            SQL error error_num executing statement statement_name
            Simple large object or extended type conversion error occurred on record record_num
            Start record record_num is greater than number of records total_num read from input file_name
            Successfully loaded the shared library library_location
            Table table_name will be read-only until level-0 archive
            Tables with BLOBS cannot be loaded in High Performance Mode
            Tables with BLOBS or extended types cannot be loaded in Express mode
            Tables with simple large objects or extended types cannot be processed with no conversion (-fn)
            Tape header is larger than I/O buffer: tape header_length, I/O buffer_size
            Tape type device file file_name is not a character-special or block-special file
            There is no mapping to column column_name, which cannot accept null values
            Unable to load locale categories for locale locale_name: error error_num
            Unload query select item for the query_item expression needs to be assigned a name
            Write/read to/from tape until end of device
            Write to device (tape or pipe) device_name failed; no space left on device. AIO error error_num
          HPL logfile pop-up messages
            Cannot attach to server shared memory
            Cannot create shared-memory message queue: error error_num
            Cannot create shared-memory pool: errno UNIX_error_num
            Cannot initialize multithreaded library
            Cannot initialize shared memory: errno operating-system_error_num
            Cannot load X resource
            Cannot open. Enter (r)etry, (c)ontinue, (q)uit job when ready
            Cannot open log file log_file_name.
            Cannot start I/O. Enter (r)etry, (c)ontinue, (q)uit job when ready
            Fatal error: shared memory will conflict with server
            Incorrect database version. Make sure that it is upgraded properly
            Press ‘r’ when ready, ‘c’ to shutdown device or ‘q’ to quit
            Set the shared library path as an absolute path in the plconfig file
            Tables with blobs cannot be loaded in High-Performance Mode
            Write error. Enter (r)etry, (c)ontinue, (q)uit job when ready
        Custom drivers
          Add a custom driver to the onpload utility
            Adding the driver name to the onpload database
            Preparing the custom-driver code
              Preparing the file that provides the driver functionality
              Preparing the plcstdrv.c file
            Rebuilding the shared-library file
          Connect your code to onpload at run time
            Driver initialization
            Register driver functions
          An example of a custom driver
            The plcstdrv.c file
            Custom-driver code for MYDRIVER
          Available driver methods
            The PL_MTH_OPEN function
            The PL_MTH_CLOSE function
          Available API support functions
            The pl_inherit_methods(driver, methodtable) function
            The pl_set_method_function(methodtable, method, function) function
            The pl_driver_inherit(method) function
            The pl_get_recordlength() function
            The pl_set_informix_conversion(flag) function
            The pl_lock_globals() function
            The pl_reset_inherit_chain(method) function
        Run load and unload jobs on a Windows computer
          The onpladm utility on Windows
            Run the Run Job or Run Project commands
            Running onpladm on UNIX with the database server running on Windows
          Preparing jobs with the ipload utility on Windows computers
        Conversion and reversion scripts for HPL database migration
          Upgrade the High-Performance Loader onpload database
          Revert from the current onpload database
    InformixHQ Guide
      What's new in InformixHQ
      Architecture
      System Compatibility
      Getting Started
        Starting the InformixHQ Server
        Starting the InformixHQ Agent
        Logging in InformixHQ
      InformixHQ Concepts
      InformixHQ Server
        InformixHQ Server Configuration
        InformixHQ UI
          Adding Servers and Groups
          Exploring Groups
          Exploring Informix Database Servers
          Configuring Monitoring
          Configuring Alerting
          Custom Dashboards
          InformixHQ Server Settings
            Configuring Alerting Notification
            Creating Custom Reports
            Creating Custom Sensors
          User Settings
            Configuring User Alerting Notification
          Users and Permissions
      InformixHQ Agent
        InformixHQ Agent Configuration
      Frequently asked questions (FAQs) about InformixHQ
        High level architecture and functionality
        Getting Started
        Monitoring and the Repository Database
        Security
        Users and Permissions
    Performance Guide
      Performance basics
        Developing a basic approach to performance measurement and tuning
        Quick start for acceptable performance on a small database
        Performance goals
        Measurements of performance
          Throughput
            Ways to measure throughput
            Standard throughput benchmarks
          Response time
            Response time and throughput
            Response-time measurement
              Operating-system timing commands
              Operating-system tools for monitoring performance
              Timing functions within your application
          Cost per transaction
        Resource utilization and performance
          Resource utilization
          CPU utilization
          Memory utilization
          Disk utilization
        Factors that affect resource utilization
        Maintenance of good performance
      Performance monitoring and the tools you use
        Evaluate the current configuration
        Create a performance history
          The importance of a performance history
          Tools that create a performance history
            Operating-system tools
            Database server tools
              Performance information that the onstat utility displays
        Monitor performance with the OpenAdmin Tool (OAT) for Informix
        Monitor database server resources
          Monitor resources that impact CPU utilization
          Monitor memory utilization
          Monitor disk I/O utilization
            Using onstat -g to monitor I/O utilization
            Using the oncheck utility to monitor I/O utilization
        Monitor transactions
          Using the onlog utility to monitor transactions
          Using the onstat utility to monitor transactions
        Monitor sessions and queries
          Monitoring memory usage for each session
          Using the SET EXPLAIN statement
      Effect of configuration on CPU utilization
        UNIX configuration parameters that affect CPU utilization
          UNIX semaphore parameters
          UNIX file-descriptor parameters
          UNIX memory configuration parameters
        Windows configuration parameters that affect CPU utilization
        Configuration parameters and environment variables that affect CPU utilization
          Specifying virtual processor class information
            Setting the number of CPU VPs
            Disabling process priority aging for CPU VPs
            Specifying processor affinity
              Distributing computation impact
              Isolating AIO VPs from CPU VPs
              Avoiding a certain CPU
            Setting the number of AIO VPs
          Setting the MULTIPROCESSOR configuration parameter when using multiple CPU VPs
          Setting the SINGLE_CPU_VP configuration parameter when using one CPU VP
          Optimizing access methods
            Setting the value of OPTCOMPIND within a session
          Limiting PDQ resources in queries
          Limiting the performance impact of CPU-intensive queries
          Limiting the number of PDQ scan threads that can run concurrently
          Configuring poll threads
            Specifying the connection protocol
            Specifying virtual-processor classes for poll threads
            Specifying the number of connections and poll threads
            Improve connection performance and scalability
          Enabling fast polling
        Network buffer pools
          Network buffers
          Support for private network buffers
          Network buffer size
        Virtual processors and CPU utilization
          Adding virtual processors
          Monitoring virtual processors
            Using some onstat-g commands to monitor virtual processors
              Monitor virtual processors with the onstat-g glo command
              Monitor virtual processors with the onstat-g rea command
              Monitor virtual processors with the onstat-g ioq command
            Using SMI tables to monitor virtual processors
          Private memory caches
        Connections and CPU utilization
          Multiplexed connections and CPU utilization
          MaxConnect for multiple connections UNIX
      Effect of configuration on memory utilization
        Shared memory
          Resident portion of shared memory
          Virtual portion of shared memory
          Message portion of shared memory
          Buffer pool portion of shared memory
          Estimating the size of the resident portion of shared memory
          Estimating the size of the virtual portion of shared memory
          Estimating the size of the message portion of shared memory
          Configuring UNIX shared memory
          Freeing shared memory with onmode -F
        Configuration parameters that affect memory utilization
          Setting the size of the buffer pool, logical-log buffer, and physical-log buffer
            The BUFFERPOOL configuration parameter and memory utilization
            The DS_TOTAL_MEMORY configuration parameter and memory utilization
              Algorithm for determining DS_TOTAL_MEMORY
              Deriving a minimum for decision-support memory
              Deriving a working value for decision-support memory
                When the DS_TOTAL_MEMORY configuration parameter is set
                When the DS_TOTAL_MEMORY configuration parameter is not set
              Checking the derived value for decision-support memory
            The LOGBUFF configuration parameter and memory utilization
            The LOW_MEMORY_RESERVE configuration parameter and memory utilization
            The PHYSBUFF configuration parameter and memory utilization
          The LOCKS configuration parameter and memory utilization
          The RESIDENT configuration parameter and memory utilization
          The SHMADD and EXTSHMADD configuration parameters and memory utilization
          The SHMTOTAL configuration parameter and memory utilization
          The SHMVIRTSIZE configuration parameter and memory utilization
          The SHMVIRT_ALLOCSEG configuration parameter and memory utilization
          The STACKSIZE configuration parameter and memory utilization
        Configure and monitor memory caches
          Data-dictionary cache
            Data-dictionary configuration
          Data-distribution cache
            Data-distribution configuration
          Monitor and tune the SQL statement cache
            Prepared statements and the statement cache
            SQL statement cache configuration
            Number of SQL statement executions
              Monitoring the number of hits on the SQL statement cache
              Determining the number of nonshared entries in the SQL statement cache
            Monitoring and tuning the size of the SQL statement cache
              Changing the size of the SQL statement cache
              Too many single-use queries in the SQL statement cache
            Memory limit and size
            Multiple SQL statement cache pools
              Number of SQL statement cache pools
              Size of SQL statement cache pools and the current cache
            SQL statement cache information in onstat -g ssc output
        Session memory
        Data-replication buffers and memory utilization
        Memory latches
          Monitoring latches with command-line utilities
            Monitoring latches with onstat -p
            Monitoring latches with onstat -s
          Monitoring latches with SMI tables
        Encrypted values
      Effect of configuration on I/O activity
        Chunk and dbspace configuration
          Associate disk partitions with chunks
          Associate dbspaces with chunks
          Placing system catalog tables with database tables
        I/O for cooked files for dbspace chunks
          Direct I/O (UNIX)
          Direct I/O (Windows)
          Concurrent I/O (AIX only)
          Enabling the direct I/O or concurrent I/O option (UNIX)
          Confirming the use of the direct or concurrent I/O option (UNIX)
        Placement of critical data
          Consider separate disks for critical data components
          Consider mirroring for critical data components
            Consider mirroring the root dbspace
            Consider mirroring smart-large-object chunks
            Mirroring and its effect on the logical log
            Mirroring and its effect on the physical log
        Configuration parameters that affect critical data
        Configure dbspaces for temporary tables and sort files
          Creating temporary dbspaces
          Specify temporary tables in the DBSPACETEMP configuration parameter
          Override the DBSPACETEMP configuration parameter for a session
          Estimating temporary space for dbspaces and hash joins
          PSORT_NPROCS environment variable
        Configure sbspaces for temporary smart large objects
          Creating temporary sbspaces
          Specify which sbspaces to use for temporary storage
        Placement of simple large objects
          Advantage of blobspaces over dbspaces
          Blobpage size considerations
            Optimize blobspace blobpage size
            Obtain blobspace storage statistics
            Determine blobpage fullness with oncheck -pB output
              Interpreting blobpage average fullness
              Analyzing efficiency criteria with oncheck -pB output
        Factors that affect I/O for smart large objects
          Disk layout for sbspaces
          Configuration parameters that affect sbspace I/O
          onspaces options that affect sbspace I/O
            Sbspace extents
            Lightweight I/O for smart large objects
              Advantages of lightweight I/O for smart large objects
              Specifying lightweight I/O for smart large objects
            Logging
        Table I/O
          Sequential scans
          Light scans
          Unavailable data
        Configuration parameters that affect table I/O
          How DATASKIP affects table I/O
        Background I/O activities
          Configuration parameters that affect checkpoints
            RTO_SERVER_RESTART and its effect on checkpoints
              Automatic checkpoints, LRU tuning, and AIO virtual processor tuning
            CKPTINTVL and its effect on checkpoints
            LOGSIZE and LOGFILES and their effect on checkpoints
            Checkpoints and the physical log
            ONDBSPACEDOWN and its effect on checkpoints
          Configuration parameters that affect logging
            LOGBUFF and PHYSBUFF and their effect on logging
            LOGFILES and its effect on logging
              Calculating the space allocated to logical log files
            LOGSIZE and its effect on logging
              Estimating logical-log size when logging dbspaces
              Estimating the logical-log size when logging simple large objects
              Estimating the logical-log size when logging smart large objects
            DYNAMIC_LOGS and its effect on logging
            AUTO_LLOG and its effect on logging
            LTXHWM and LTXEHWM and their effect on logging
            TEMPTAB_NOLOG and its effect on logging
            SESSION_LIMIT_LOGSPACE and its effect on logging
            SESSION_LIMIT_TXN_TIME and its effect on logging
          Configuration parameters that affect page cleaning
            CLEANERS and its effect on page cleaning
            BUFFERPOOL and its effect on page cleaning
            RTO_SERVER_RESTART and its effect on page cleaning
          Configuration parameters that affect backup and restore
            ON-Bar configuration parameters
            ontape configuration parameters (UNIX)
          Configuration parameters that affect rollback and recovery
            OFF_RECVRY_THREADS and ON_RECVRY_THREADS and their effect on fast recovery
            PLOG_OVERFLOW_PATH and its effect on fast recovery
            RTO_SERVER_RESTART and its effect on fast recovery
            The LOW_MEMORY_RESERVE configuration parameter and memory utilization
          Configuration parameters that affect data replication and auditing
            Configuration parameters that affect data replication
            Configuration parameters that affect auditing
          LRU tuning
      Table performance considerations
        Placing tables on disk
          Isolating high-use tables
          Placing high-use tables on middle partitions of disks
          Using multiple disks
            Using multiple disks for a dbspace
            Using multiple disks for logical logs
            Spreading temporary tables and sort files across multiple disks
          Backup and restore considerations when placing tables on disks
          Factors affecting the performance of nonfragmented tables and table fragments
        Estimating table size
          Estimating data pages
            Estimating tables with fixed-length rows
            Estimating tables with variable-length rows
            Selecting an intermediate value for the size of the table
          Estimating pages that simple large objects occupy
            Storing simple large objects in the tblspace or a separate blobspace
            Estimating tblspace pages for simple large objects
        Managing the size of first and next extents for the tblspace tblspace
        Managing sbspaces
          Estimating pages that smart large objects occupy
            Estimating the size of the sbspace and metadata area
            Sizing the metadata area manually for a new chunk
              Example of calculating the metadata area for a new chunk
          Improving metadata I/O for smart large objects
          Monitoring sbspaces
            Monitoring sbspaces with oncheck -cS
            Monitoring sbspaces with oncheck -pe
            Monitoring sbspaces with oncheck -pS
            Monitoring sbspaces with onstat -g smb
          Changing storage characteristics of smart large objects
            Altering smart-large-object columns
        Managing extents
          Choosing table extent sizes
            Extent sizes for tables in a dbspace
            Extent sizes for table fragments
            Extent sizes for smart large objects in sbspaces
          Monitoring active tblspaces
          Monitoring the upper limit on extents and extent interleaving
            Considering the upper limit on extents
            Checking for extent interleaving
            Eliminating interleaved extents
              Reorganizing dbspaces and tables to eliminate extent interleaving
              Creating or altering an index to cluster
              Using ALTER TABLE to eliminate extent interleaving
          Reclaiming unused space within an extent
            Reclaiming space in an empty extent with ALTER INDEX
            Reclaiming space in an empty extent by unloading and re-creating or reloading a table
            Releasing space in an empty extent with ALTER FRAGMENT
          Managing extent deallocation with the TRUNCATE keyword
          Defragment partitions to merge extents
        Storing multiple table fragments in a single dbspace
        Displaying a list of table and index partitions
        Changing tables to improve performance
          Loading and unloading tables
            Advantages of logging tables
            Advantages of nonlogging tables
              Quickly loading a large standard table
              Quickly loading a new nonlogging table
          Dropping indexes for table-update efficiency
          Creating and enabling referential constraints efficiently
          Attaching or detaching fragments
          Altering a table definition
            Slow alter
            In-place alter
              Conditions for in-place alter operations
              Performance considerations for DML statements
              Performance of in-place alters for DDL operations
              Altering a column that is part of an index
            Fast alter
        Denormalize the data model to improve performance
          Shortening rows
          Expelling long strings
            Convert CHAR columns into VARCHAR columns to shorten rows (GLS)
            Convert a long string to a TEXT data type column
            Move strings to a companion table
            Build a symbol table
          Splitting wide tables
          Redundant data
            Adding redundant data
        Reduce disk space in tables with variable length rows
        Reduce disk space by compressing tables and fragments
      Indexes and index performance considerations
        Types of indexes
          B-tree indexes
            Structure of conventional index pages
          Forest of trees indexes
          R-tree indexes
          Indexes that DataBlade modules provide
        Estimating index pages
          Index extent sizes
            Formula for estimating the extent size of an attached index
            Formula for estimating the extent size of a detached index
          Estimating conventional index pages
        Managing indexes
          Space costs of indexes
          Time costs of indexes
          Unclaimed index space
          Indexes on columns
            Filtered columns in large tables
            Order-by and group-by columns
            Avoiding columns with duplicate keys
            Clustering
              Configuration parameters that affect the degree of clustering
          Nonunique indexes
        Improve query performance with a forest of trees index
          Detecting root node contention
          Creating a forest of trees index
          Disabling and enabling a forest of trees index
          Performing a range scan on a forest of trees index
          Determining if you are using a forest of trees index
          Finding the number of hashed columns and subtrees in a forest of trees index
        Creating and dropping an index in an online environment
          When you cannot create or drop indexes online
          Creating attached indexes in an online environment
          Limiting memory allocation while creating indexes online
        Improving performance for index builds
          Estimating memory needed for sorting
          Estimating temporary space for index builds
        Storing multiple index fragments in a single dbspace
        Improving performance for index checks
        Indexes on user-defined data types
          Defining indexes for user-defined data types
            B-tree secondary-access method
              Uses for a B-tree index
              Extending a generic B-tree index
            Identifying the available access methods
            User-defined secondary-access methods
              R-tree indexes
            Using a functional index
              What is a functional index?
              When is a functional index used?
              Creating a functional index
          Using an index that a DataBlade module provides
          Choosing operator classes for indexes
            Operator classes
              Strategy and support functions of a secondary access method
              Default operator classes
            Built-in B-tree operator class
              B-tree strategy functions
              B-tree support function
            Identifying the available operator classes
            User-defined operator classes
      Locking
        Locks
          Locking granularity
          Row and key locks
            Key-value locks
          Page locks
          Table locks
          Database locks
        Configuring the lock mode
        Setting the lock mode to wait
        Locks with the SELECT statement
          Isolation level
            Dirty Read isolation
            Committed Read isolation
              Ways to reduce the risk of Committed Read isolation level conflicts
            Cursor Stability isolation
            Repeatable Read isolation
          Locking nonlogging tables
          Update cursors
        Locks placed with INSERT, UPDATE, and DELETE statements
        The internal lock table
        Monitoring locks
          Configuring and managing lock usage
          Monitoring lock waits and lock errors
          Monitoring the number of free locks
          Monitoring deadlocks
          Monitoring isolation levels that sessions use
        Locks for smart large objects
          Byte-range locking
            How the database server manages byte-range locks
            Using byte-range locks
            Monitoring byte-range locks
            Setting number of locks for byte-range locking
          Lock promotion
          Dirty Read isolation level and smart large objects
      Fragmentation guidelines
        Planning a fragmentation strategy
          Fragmentation goals
            Improved query performance through fragmentation strategy
            Reduced contention between queries and transactions
            Increased data availability
            Increased granularity for backup and restore
          Examining your data and queries
          Considering physical fragmentation factors
        Distribution schemes
          Choosing a distribution scheme
          Designing an expression-based distribution scheme
          Suggestions for improving fragmentation
        Strategy for fragmenting indexes
          Attached indexes
          Detached indexes
          Restrictions on indexes for fragmented tables
        Strategy for fragmenting temporary tables
        Distribution schemes that eliminate fragments
          Fragmentation expressions for fragment elimination
          Query expressions for fragment elimination
            Range expressions in query
            Equality expressions in query
          Effectiveness of fragment elimination
            Nonoverlapping fragments on a single column
            Overlapping fragments on a single column
            Nonoverlapping fragments, multiple columns
        Improve the performance of operations that attach and detach fragments
          Improving ALTER FRAGMENT ATTACH performance
            Distribution schemes for reusing indexes
              Fragmenting the index in the same way as the table
              Fragmenting the index with the same distribution scheme as the table
              Attaching unfragmented tables together
            Ensuring no data movement when you attach a fragment
            Indexes on attached tables
              Example for situation when corresponding index does not exist
              Example for situation when index on table is not usable
          Improving ALTER FRAGMENT DETACH performance
            Fragmenting the index in the same way as the table
            Fragmenting the index using same distribution scheme as the table
          Forcing out transactions when altering table fragments
        Monitoring Fragment Use
          Monitoring fragmentation with the onstat -g ppf command
          Monitoring fragmentation with SET EXPLAIN output
      Queries and the query optimizer
        The query plan
          The access plan
          The join plan
            Nested-loop join
            Hash join
            Join order
          Example of query-plan execution
            Example of a join with column filters
            Example of a join with indexes
          Query plans that include an index self-join path
          Query plan evaluation
          Report that shows the query plan chosen by the optimizer
            The explain output file
            Query statistics section provides performance debugging information
          Sample query plan reports
            Single-table query
            Multitable query
            Key-first scan
            Query plans for subqueries
            Query plans for collection-derived tables
              Example showing how the database server completes the query
              Derived tables folded into parent queries
          XML query plans in IBM Data Studio
        Factors that affect the query plan
          Statistics held for the table and index
          Filters in the query
          Indexes for evaluating a filter
          Effect of PDQ on the query plan
          Effect of OPTCOMPIND on the query plan
            Single-table query
            Multitable query
          Effect of available memory on the query plan
        Time costs of a query
          Memory-activity costs
          Sort-time costs
          Row-reading costs
          Sequential access costs
          Nonsequential access costs
          Index lookup costs
            Reading duplicate values from an index
            Searching for NCHAR or NVARCHAR columns in an index
          In-place ALTER TABLE costs
          View costs
          Small-table costs
          Data-mismatch costs
          Encrypted-value costs
          GLS functionality costs
          Network-access costs
        Optimization when SQL is within an SPL routine
          SQL optimization
            Displaying the execution plan
            Automatic reoptimization
            Reoptimizing SPL routines
            Optimization levels for SQL in SPL routines
          Execution of an SPL routine
          SPL routine executable format stored in UDR cache
            Adjust the UDR cache
        Trigger execution
          Performance implications for triggers
            SELECT triggers on tables in a table hierarchy
            SELECT triggers and row buffering
      Optimizer directives
        What optimizer directives are
          Optimizer directives that are embedded in queries
          External optimizer directives
        Reasons to use optimizer directives
        Preparation for using directives
        Guidelines for using directives
        Types of optimizer directives that are supported in SQL statements
          Access-method directives
          Join-order directives
            Effect of join order on join plan
            Join order when you use views
          Join-method directives
          Optimization-goal directives
          Star-join directives
          EXPLAIN directives
          Example of directives that can alter a query plan
        Configuration parameters and environment variables for optimizer directives
        Optimizer directives and SPL routines
        Forcing reoptimization to avoid an index and previously prepared statement problem
        External optimizer directives
          Creating and saving external directives
          Enabling external directives
          Deleting external directives
      Parallel database query (PDQ)
        What PDQ is
        Structure of a PDQ query
        Database server operations that use PDQ
          Parallel update and delete operations
          Parallel insert operations
            Explicit inserts with SELECT...INTO TEMP statements
            Implicit inserts with INSERT INTO...SELECT statements
          Parallel index builds
          Parallel user-defined routines
          Hold cursors that use PDQ
          SQL operations that do not use PDQ
          Update statistics operations affected by PDQ
          SPL routines and triggers and PDQ
          Correlated and uncorrelated subqueries
          OUTER index joins and PDQ
          Remote tables used with PDQ
        The Memory Grant Manager
        The allocation of resources for parallel database queries
          Limiting the priority of decision-support queries
            Limiting the value of the PDQ priority
            Maximizing OLTP throughput for queries
            Conserving resources when using PDQ
            Allowing maximum use of parallel processing
            Determining the level of parallel processing
            Limits on parallel operations associated with PDQ priority
            Using SPL routines with PDQ queries
          Adjusting the amount of memory for DSS and PDQ queries
          Limiting the number of concurrent scans
          Limiting the maximum number of PDQ queries
        Managing PDQ queries
          Analyzing query plans with SET EXPLAIN output
          Influencing the choice of a query plan
          Setting the PDQ priority dynamically
          Enabling the database server to allocate PDQ memory
          User control of PDQ resources
          DBA control of resources for PDQ and DSS queries
            Controlling resources allocated to PDQ
            DBA control of resources allocated to decision-support queries
        Monitoring resources used for PDQ and DSS queries
          Using the onstat Utility
            Monitoring PDQ threads with onstat utility commands
            Monitoring resources allocated for a session running a DSS query
          Identifying parallel scans in SET EXPLAIN output
      Improving individual query performance
        Test queries using a dedicated test system
        Display the query plan
        Improve filter selectivity
          Filters with user-defined routines
          Avoid some filters
            Avoid difficult regular expressions
            Avoid noninitial substrings
          Use join filters and post-join filters
        Automatic statistics updating
          How AUS works
          AUS expiration policies
            Changing AUS expiration policies
          Viewing AUS statements
          Prioritizing databases in AUS
          Rescheduling AUS
          Disabling AUS
        Update statistics when they are not generated automatically
          Update the statistics for the number of rows
          Drop data distributions if necessary when upgrading
            Drop distributions in LOW mode without gathering statistics
          Creating data distributions
          Updating statistics for join columns
          Updating statistics for columns with user-defined data types
          Update statistics in parallel on very large databases
          Adjust the amount of memory and disk space for UPDATE STATISTICS
          Data sampling during update statistics operations
          Display data distributions
        Improve performance by adding or removing indexes
          Replace autoindexes with permanent indexes
          Use composite indexes
          Indexes for data warehouse applications
          Configure B-tree scanner information to improve transaction processing
            Alice scan mode values
            Leaf and range scan mode settings
            B-tree scanner index compression levels and transaction processing performance
            Setting the level for B-tree scanner compression of indexes
          Determine the amount of free space in an index page
        Optimizer estimates of distributed queries
          Buffer data transfers for a distributed query
          The query plan of a distributed query
        Improve sequential scans
        Enable view folding to improve query performance
        Reduce the join and sort operations
          Avoid or simplify sort operations
          Use parallel sorts
          Use temporary tables to reduce sorting scope
          Configuring memory for queries with hash joins, aggregates, and other memory-intensive elements
        Optimize user-response time for queries
          Optimization level
          Optimization goals
            Specifying the query performance goal
            Preferred query plans for user-response-time optimization
              Nested-loop joins versus hash joins
              Table scans versus index scans
              Ordering with fragmented indexes
        Optimize queries for user-defined data types
          Parallel UDRs
          Selectivity and cost functions
          User-defined statistics for UDTs
          Negator functions
        Optimize queries with the SQL statement cache
          When to use the SQL statement cache
          Using the SQL statement cache
            Enabling the SQL statement cache
            Placing statements in the cache
          Monitoring memory usage for each session
            Display all user threads and session memory usage
            Display detailed session information and memory usage
            Display information about session SQL statements
            Display information about the memory that SQL statements use in a session
          Monitoring usage of the SQL statement cache
        Monitor sessions and threads
          Monitor sessions and threads with onstat commands
            Monitor blocking threads with the onstat -g bth and onstat -g BTH commands
            Monitor threads with onstat –u output
            Monitor threads with onstat -g ath output
            Monitor threads with onstat -g act output
            Monitor threads with onstat -g cpu output
            Monitor session resources with onstat -g ses output
            Monitor session memory with onstat -g mem and onstat -g stm output
          Monitor sessions and threads with SMI tables
        Monitor transactions
          Display information about transactions
          Display information about transaction locks
          Display statistics on user sessions
          Display Statistics on Sessions Executing SQL Statements
      The onperf utility on UNIX
        Overview of the onperf utility
          Basic onperf utility functions
            Display metric values
            Save metric values to a file
            Review metric measurements
          onperf utility tools
        Requirements for running the onperf utility
        Starting the onperf utility and exiting from it
        The onperf user interface
          Graph tool
            Graph-tool title bar
            Graph-tool graph menu
            Graph-tool metrics menu
            Graph-tool view menu
            The graph-tool Configure menu and the Configuration dialog box
            Graph-tool Tools menu
            Changing the scale of metrics
            Displaying recent-history values
          Query-tree tool
          Status tool
          Activity tools
        Why you might want to use onperf
          Routine monitoring with onperf
          Diagnosing sudden performance loss
          Diagnosing performance degradation
        onperf utility metrics
          Database server metrics
          Disk-chunk metrics
          Disk-spindle metrics
          Physical-processor metrics
          Virtual-processor metrics
          Session metrics
          Tblspace metrics
          Fragment metrics
      Appendix
        Case studies and examples
          Case study of a situation in which disks are overloaded
    SNMP Subagent Guide
      SNMP concepts
        What is SNMP?
        Purpose of the SNMP
        The SNMP architecture
          SNMP network managers
          Master agents
          Subagents
          Managed components
          Management Information Bases
      Informix implementation of SNMP
        Components of the Informix implementation
        Purpose of Informix SNMP
          Event notification
          Data requests
          Traps
          Information that OnSNMP provides
        SNMP standard
        SNMP architecture
        Informix implementation of SNMP on UNIX or Linux
          The runsnmp.ksh script
          UNIX master agents
            Assuring compatibility
            Installing and configuring a master agent manually
            Starting and stopping a master agent
              Starting a master agent manually
              Stopping a master agent manually
              Making sure that a master agent is running correctly
          UNIX subagent
          UNIX server discovery process
            Preparing onsrvapd manually
            Issue the onsrvapd command
              Starting onsrvapd manually
              Making sure that onsrvapd is running correctly
            Choose an installation directory
        Informix implementation of SNMP on Windows
          Windows master agent
          Windows subagent
            Start and stop OnSNMP
            Configure OnSNMP
            Windows registry key for the OnSNMP logging level
          Windows server discovery process
            Start and stop onsrvapd
            Installing the Informix SNMP agent
        GLS and SNMP
        MIB types and objects
        Table indexing
          Numeric index values
          Alphabetical index values
        Refresh control value
        Files installed for SNMP
          Files installed on UNIX or Linux
          Files installed on Windows
      Management Information Base reference
        Application MIB
          applTable
        RDBMS MIB
          rdbmsDbInfoTable
          rdbmsDbTable
          rdbmsRelTable
          rdbmsSrvInfoTable
          rdbmsSrvLimitedResourceTable
          rdbmsSrvParamTable
          rdbmsSrvTable
          rdbmsTraps
            frdbmsStateChange trap
        Online MIB in the Informix Private MIB
          onActiveBarTable
          onActiveTableTable
          onBarTable
          onChunkTable
          onDatabaseTable
          onDbspaceTable
          onErQueueTable
          onErSiteTable
          onFragmentTable
          onLockTable
          onLogicalLogTable
          onPhysicalLogTable
          onServerTable
          onSessionTable
          onSqlHostTable
          onTableTable
  Backup and restore
    Backup and Restore Guide
      What's New in the Backup and Restore Guide, Version 12.10
      Overview of backup and restore
        Backup and restore concepts
          Recovery system
            Backup systems
            Backup levels
            Logical-log backup
              Manual and continuous logical-log backups
              Log salvage
              Save logical-log backups
            Restore systems
              Physical and logical restores
              Warm, cold, and mixed restores
              Continuous log restore
          Comparison of the ON-Bar and ontape utilities
        Plan for backup and restore
          Plan a recovery strategy
            Types of data loss
            Determine failure severity
            Data use determines your backup schedule
            Schedule backups
            Security requirements for label-based access control
          Plan a backup system for a production database server
            Evaluate hardware and memory resources
            Evaluate backup and restore time
            Evaluate logging and transaction activity
            Compress row data
            Transform data with external programs
      ON-Bar backup and restore system
        Overview of the ON-Bar backup and restore system
          ON-Bar components
            Backup Services API (XBSA)
            ON-Bar catalog tables
            ixbar file: ON-Bar emergency boot file
            bar_act.log file: ON-Bar activity log
            ON-Bar script
        Configure the storage manager and ON-Bar
          Configure a storage manager
            Storage-manager definitions in the sm_versions file
            Configuring TSM
              Editing the TSM client options files
                Editing the TSM client user options file
                Editing the TSM client system options file
              Assigning a TSM management class for a backup
              Setting the HCL Informix Interface for TSM environment variables
              Registering with the TSM server
              Initializing the HCL Informix Interface for TSM password
              Updating the storage-manager definition in the sm_versions file for TSM
              Configuring ON-Bar for optional TSM features
            Configuring a third-party storage manager
          Validating your storage manager
          Configuring ON-Bar
            ON-Bar security
          Verifying the configuration of ON-Bar and your storage manager
          Files that ON-Bar and storage managers use
        Back up with ON-Bar
          Preparing to back up data
            Administrative files to back up
          onbar -b syntax: Backing up
            List of storage spaces in a file
            Backing up blobspaces
          onbar -m syntax: Monitoring recent ON-Bar activity
          Viewing a list of registered backups
          onbar -P syntax: Printing backed-up logical logs
          onbar -v syntax: Verifying backups
            Temporary space for backup verification
            Verification failures
              Diagnosing why a backup failed verification
              Verifying an expired backup
              Restoring when a backup is missing data
        Restore data with ON-Bar
          Pre-restore checklist
            Storage space status and required actions
          Storage device availability
          onbar -r syntax: Restoring data
            Avoid salvaging logical logs
            Performing a cold restore
            Configuring a continuous log restore by using ON-Bar
            Restoring data by using a mixed restore
              Strategies for using a mixed restore
            Recreating chunk files during a restore
              Restoring when using cooked chunks
              Restoring when using raw chunks
            Reinitializing the database server and restoring data
          Replacing disks during a restore
            Renaming a chunk to a nonexistent device
          Restoring to a different computer
          onbar -RESTART syntax: Restarting a failed restore
          Resolve a failed restore
        External backup and restore
          External backup and restore overview
            Block before backing up
            Rules for an external backup
            Prepare for an external backup
              Block and unblock database server
              Track an external backup
            Performing an external backup when chunks are not mirrored
          RS secondary server external backup
            Performing an external backup of an RS secondary server
          Data restored in an external restore
            Rename chunks
            External restore commands
            Rules for an external restore
          Performing an external restore
            Performing a cold external restore
            Performing a warm external restore
            Examples of external restore commands
          Initializing HDR with an external backup and restore
        Customize and maintain ON-Bar
          Customizing ON-Bar and storage-manager commands
            Updating the ON-Bar script during reinstallation
            Print the backup boot files
            Migrate backed-up logical logs to tape
          Expire and synchronize the backup catalogs
            Choose an expiration policy
            The onsmsync utility
              Regenerate the emergency boot file
              Regenerate the sysutils database
              Delete a bad backup
              Expire backups based on the retention date
              Expire a generation of backups
              Expire backups based on the retention interval
              Expire backups with multiple point-in-time restores
              Expire all backups
          Monitor the performance of ON-Bar and the storage managers
            Set ON-Bar performance statistics levels
            View ON-Bar backup and restore performance statistics
        ON-Bar catalog tables
          The bar_action table
          The bar_instance table
          The bar_ixbar table
          The bar_object table
          The bar_server table
          The bar_syncdeltab table
          ON-Bar catalog map
        ON-Bar messages and return codes
          Message format in the ON-Bar message log
          Message numbers
          ON-Bar return codes
      ontape backup and restore system
        Configure ontape
          Set configuration parameters for the ontape utility
            Data transformation filter parameters for ontape
            Tape and tape device parameters for ontape
            Set the tape-device parameters
              Specify separate devices for storage-space and logical-log backups
              Specify tape devices as symbolic links
              Specify a file system directory
              Specify a remote device
              Specify /dev/null for a tape device
              Set TAPEDEV to stdio
              Rewind tape devices before opening and on closing
            Specify the tape-block-size
            Specify the tape size
              Tape size for remote devices
          Changing your ontape configuration
        Back up with ontape
          Summary of ontape tasks
            Start ontape
            Exit codes for ontape
          Change database logging status
          Create a backup
            Backup levels that ontape supports
            Back up after changing the physical schema
            Prepare for a backup
              Avoid temp tables during heavy activity
              Make sure enough logical-log space exists
              Keep a copy of your configuration file
              Verify consistency before a level-0 backup
              Online and quiescent backups
              Back up to tape
                Label tapes created with ontape
              Back up to standard output
              Back up to a directory
                Set the file directory path
                Rename existing files
                Override the default name of the archive files
            ontape utility syntax: Perform a backup
              Backup examples
              Back up raw tables
            Back up to Amazon Simple Storage Service
              The ifxbkpcloud.jar utility
              Cloud storage file naming conventions
            When the logical-log files fill during a backup
            When a backup terminates prematurely
            Monitor backup history by using oncheck
          Back up logical-log files with ontape
            Before you back up the logical-log files
              Use blobspace TEXT and BYTE data types and logical-log files
              Use /dev/null when you do not need to recover
            When to back up logical-log files
            Start an automatic logical-log backup
            Starting a continuous logical-log file backup
            End a continuous logical-log backup
            Devices that logical-log backups must use
        Restore with ontape
          Types of physical restore
            Full-system restore
            Restores of dbspaces, blobspaces, and sbspaces
          Cold, warm, or mixed restores
            Cold restores
            Warm restores
            Mixed restores
          ontape utility syntax: Perform a restore
          Restore the whole system
            Gather backup and logical-log tapes before restoring
            Decide on a complete cold or a mixed restore
            Verify your database server configuration
              Set shared-memory parameters to maximum assigned value
              Set mirroring configuration to level-0 backup state
              Verify that the raw devices or files are available
            Perform a cold restore
              Salvage logical-log files
              Mount tapes during the restore
              Restore logical log files
              Bring the database server online when the restore is over
            Restore selected storage spaces
              Gather the appropriate tapes
              Ensure that needed device are available
              Back up logical-log files
              Perform a warm restore
            Restore raw tables
          Configuring continuous log restore with ontape
          Rename chunks during a restore
            Validation sequence for renaming chunks
            New chunk requirements
            Rename chunks with command-line options
            Rename chunks with a file
            Rename chunks while specifying other options
            Rename a chunk to a nonexistent device
              Renaming a chunk to a nonexistent device
          Restore from standard input
          Restore data to a remote server
          Simultaneous backup and restore by using standard I/O
        Perform an external backup and restore
          Recover data by using an external backup and restore
          Data that is backed up in an external backup
            Rules for an external backup
            Performing an external backup
          Prepare for an external backup
            Block and unblock the database server
            Track an external backup
          Data that is restored in an external restore
            Use external restore commands
            Rules for an external restore
            Rename chunks
            Performing a cold external restore
              Examples of external restore commands
            Initializing HDR with an external backup and restore
      Informix Primary Storage Manager
        HCL Informix Primary Storage Manager
          Examples: Manage storage devices with Informix Primary Storage Manager
          Setting up Informix Primary Storage Manager
            Collecting information about file directories and devices
            Configuring Informix Primary Storage Manager
          Managing storage devices
          The onpsm utility for storage management
            onpsm -C detail output
            onpsm -D list output
            onpsm -O list output
          Device pools
          Device-configuration file for the Informix Primary Storage Manager
          Informix Primary Storage Manager file-naming conventions
          Message logs for Informix Primary Storage Manager
      archecker table level restore utility
        archecker table level restore utility
          Overview of the archecker utility
            The archecker configuration file
            Schema command file
            Table-level restore and locales
          Data restore with archecker
            Physical restore
            Logical restore
              The stager
              The applier
          Syntax for archecker utility commands
            Manually control a logical restore
            Performing a restore with multiple storage managers
            Perform a parallel restore
            Restore tables with large objects
            When to delete restore files
          The archecker schema reference
            The CREATE TABLE statement
            The CREATE EXTERNAL TABLE statement
            The DATABASE statement
            The INSERT statement
            The RESTORE statement
            The SET statement
            Schema command file examples
              Simple schema command file
              Restore a table from a previous backup
              Restore to a different table
              Extract a subset of columns
              Use data filtering
              Restore to an external table
              Restore multiple tables
              Perform a distributed restore
      Backup and restore configuration parameter reference
        Backup and restore configuration parameters
          ON-Bar and ontape configuration parameters and environment variable
            BACKUP_FILTER configuration parameter
            BAR_ACT_LOG configuration parameter
            BAR_BSALIB_PATH configuration parameter
            BAR_CKPTSEC_TIMEOUT configuration parameter
            BAR_DEBUG configuration parameter
            BAR_DEBUG_LOG configuration parameter
            BAR_HISTORY configuration parameter
            BAR_IXBAR_PATH configuration parameter
            BAR_MAX_BACKUP configuration parameter
            BAR_MAX_RESTORE configuration parameter
            BAR_NB_XPORT_COUNT configuration parameter
            BAR_PERFORMANCE configuration parameter
            BAR_PROGRESS_FREQ configuration parameter
            BAR_RETRY configuration parameter
            BAR_SIZE_FACTOR configuration parameter
            BAR_XFER_BUF_SIZE configuration parameter
            IFX_BAR_NO_BSA_PROVIDER environment variable
            IFX_BAR_NO_LONG_BUFFERS environment variable
            IFX_BAR_USE_DEDUP environment variable
            IFX_TSM_OBJINFO_OFF environment variable
            LTAPEBLK configuration parameter
            LTAPEDEV configuration parameter
            LTAPESIZE configuration parameter
            RESTARTABLE_RESTORE configuration parameter
            RESTORE_FILTER configuration parameter
            TAPEBLK configuration parameter
            TAPEDEV configuration parameter
            TAPESIZE configuration parameter
          The archecker utility configuration parameters and environment variable
            AC_CONFIG file environment variable
            AC_DEBUG configuration parameter
            AC_IXBAR configuration parameter
            AC_LTAPEBLOCK configuration parameter
            AC_LTAPEDEV parameter
            AC_MSGPATH configuration parameter
            AC_SCHEMA configuration parameter
            AC_STORAGE configuration parameter
            AC_TAPEBLOCK configuration parameter
            AC_TAPEDEV configuration parameter
            AC_TIMEOUT configuration parameter
            AC_VERBOSE configuration parameter
          Informix Primary Storage Manager configuration parameters
            PSM_ACT_LOG configuration parameter
            PSM_CATALOG_PATH configuration parameter
            PSM_DBS_POOL configuration parameter
            PSM_DEBUG configuration parameter
            PSM_DEBUG_LOG configuration parameter
            PSM_LOG_POOL configuration parameter
          Event alarm configuration parameters
      Cloud Backup
        Back up to Amazon Simple Storage Service using ON-Bar and the PSM
        Back up to Softlayer using ON-Bar and the PSM
      Appendixes
        Troubleshooting some backup and restore errors
          Corrupt page during an archive
          Log backup already running
          No server connection during a restore
          Drop a database before a restore
          No dbspaces or blobspaces during a backup or restore
            Restore blobspace BLOBs
          Changing the system time on the backup system
        Migrate data, servers, and tools
          Backing up before a database server or storage-manager upgrade
          Upgrading a third-party storage manager
          Changing storage-manager vendors
          Switching from ontape to ON-Bar
        GLS support
          Use GLS with the ON-Bar utility
            Identifiers that support non-ASCII characters
            Identifiers that require 7-bit ASCII characters
            Locale of ON-Bar messages
          Use the GL_DATETIME environment variable with ON-Bar
          Use GLS with the ontape utility
    Encrypt archived data with IBM InfoSphere Guardium Encryption Expert
  Replication
    Enterprise Replication
      What's New in Enterprise Replication for Informix, Version 12.10
      About Enterprise Replication
        HCL Informix Enterprise Replication technical overview
          Enterprise Replication Terminology
          Asynchronous Data Replication
          Log-Based Data Capture
          High Performance
          High Availability
          Consistent Information Delivery
          Repair and Initial Data Synchronization
          Flexible Architecture
          Centralized Administration
          Ease of Implementation
          Network Encryption
        How Enterprise Replication Replicates Data
          Data Capture
            Row Images
            Evaluate rows for updates
            Send queues and receive queues
            Data Evaluation Examples
          Data Transport
          Applying replicated data
      Planning and designing for Enterprise Replication
        Plan for Enterprise Replication
          Enterprise Replication Server administrator
          Asynchronous propagation conflicts
          Back up and restore of replication servers
          Compression of replicated data
          Transaction processing impact
          SQL statements and replication
          Global language support for replication
          Replication between multiple server versions
        Schema design for Enterprise Replication
          Unbuffered Logging
          Table Types
          Label-based access control
          Out-of-Row Data
          Shadow columns
          Unique key for replication
          Cascading Deletes
          Triggers
          Constraint and replication
          Sequence Objects
          The NLSCASE database property
          Replicating Table Hierarchies
          Replication and data types
            Replicating on Heterogeneous Hardware
            Serial data types and replication keys
            Replication of TimeSeries data types
            Replication of large objects
              Replicating Simple Large Objects from Tblspaces
              Replication of large objects from blobspaces or sbspaces
            Replication of opaque user-defined data types
        Replication system design
          Primary-Target Replication System
            Primary-Target Data Dissemination
            Data consolidation
            Workload Partitioning
            Workflow Replication
            Primary-Target Considerations
          Update-Anywhere Replication System
          Conflict Resolution
            Conflict resolution rule
              Ignore Conflict-Resolution Rule
              Time stamp conflict resolution rule
              SPL Conflict Resolution Rule
                SPL Conflict Resolution for Large Objects
              Delete wins conflict resolution rule
              Always-Apply Conflict-Resolution Rule
            Conflict Resolution Scope
          Choosing a Replication Network Topology
            Fully Connected Topology
            Hierarchical Routing Topology Terminology
            Hierarchical Tree Topology
            Forest of Trees
      Setting up and managing Enterprise Replication
        Preparing the Replication Environment
          Preparing the Network Environment
            Configuring hosts information for replication servers
            Configuring port and service names for replication servers
            Creating sqlhost group entries for replication servers
            Configuring secure ports for connections between replication servers
            Configuring network encryption for replication servers
            Testing the replication network
            Testing the password file
          Preparing the Disk
            Logical Log Configuration Disk Space
            Logical Log Configuration Guidelines
            Disk Space for Delete Tables
            Shadow column disk space
            Setting Up Send and Receive Queue Spool Areas
              Row Data sbspaces
                Creating sbspaces for Spooled Row Data
                Logging Mode for sbspaces
                Dropping a Spooled Row Data sbspace
            Setting Up the Grouper Paging File
            Creating ATS and RIS Directories
          Preparing the Database Server Environment
            Setting Database Server Environment Variables
            Set configuration parameters for replication
            Time Synchronization
          Preparing Data for Replication
            Preparing Consistent Data
            Blocking Replication
              Using DB-Access to Begin Work Without Replication
              Using ESQL/C to Begin Work Without Replication
            Preparing to Replicate User-Defined Types
            Preparing to Replicate User-Defined Routines
            Preparing Tables for Conflict Resolution
            Preparing Tables for a Consistency Check Index
            Preparing tables without primary keys
            Preparing Logging Databases
            Preparing for Role Separation (UNIX)
          Load and unload data
            High-Performance Loader
            onunload and onload Utilities
            dbexport and dbimport Utilities
            UNLOAD and LOAD Statements
          Data Preparation Example
            Using the cdr start replicate Command
            Using LOAD, UNLOAD, and BEGIN WORK WITHOUT REPLICATION
        Using High-Availability Clusters with Enterprise Replication
          High-availability replication systems
            High-Availability Clusters in a Hierarchical Tree Topology
            Using High-Availability Clusters in a Forest of Trees Topology
            Setting Up Database Server Groups for High-Availability Cluster Servers
          Managing Enterprise Replication with High-Availability Clusters
            Failover for High-availability clusters in an Enterprise Replication environment
            Replication latency for secondary servers
        Defining Replication Servers, Replicates, Participants, and Replicate Sets
          Starting Database Servers
          Defining Replication Servers
            Creating a new domain by cloning a server
              Example of creating a new replication domain by cloning
            Adding a server to the domain by cloning a server
            Customizing the Replication Server Definition
          Define a replicate
            Participant definitions
              Defining Replicates on Table Hierarchies
            Replicate types
              Master Replicate Verification
              Creating Strict Master Replicates
              Creating Empty Master Replicates
            Defining Shadow Replicates
            Specifying Conflict Resolution Rules and Scope
            Specifying Replication Frequency
            Setting Up Failed Transaction Logging
            Replicate only changed columns
            Using the IEEE Floating Point or Canonical Format
            Enabling Triggers
            Enabling code set conversion between replicates
              Configuring code set conversion between replicates
              Code set conversion errors
              Controlling the replication of large objects
          Define replicate sets
            Exclusive Replicate Sets
            Non-Exclusive Replicate Sets
            Customizing the Replicate Set Definition
          Initially Synchronizing Data Among Database Servers
          Set up replication through templates
            Defining Templates
            Realizing Templates
              Verifying Participants without Applying the Template
              Synchronizing Data Among Database Servers
                Improve Performance During Synchronization
              Create tables automatically
              Other synchronization options
              Changing Templates
              Template Example
        Grid setup and management
          Example of setting up a replication system with a grid
          Example of rolling out schema changes in a grid
          Creating a grid
          Grid maintenance
            Viewing grid information
          Adding replication servers to a grid
            Adding a replication server to a grid by running cdr change grid
            Adding a replication server to a grid by cloning
          Adding an externally created replicate into a grid replicate set
            Adding an existing replicate to a grid replicate set by using cdr change replicateset
            Adding an existing replicate to a grid replicate set by altering a table
          Creating replicated tables through a grid
          Enabling replication within a grid transaction
          Propagating updates to data
          Administering servers in the grid with the SQL administration API
          Propagating database object changes
          Propagating external files through a grid
          Rerunning failed grid routines
          Connection management for client connections to participants in a grid
          Grid queries
            Defining tables for grid queries
            Configuring secure connections for grid queries
            Examples of grid queries
        Shard cluster setup
          Creating a shard cluster
            Shard cluster definitions
          Sharded queries
          Shard cluster management and monitoring
        Managing Replication Servers and Replicates
          Managing Replication Servers
            Modify server attributes
            Dynamically Modifying Configuration Parameters for a Replication Server
            Viewing Replication Server Attributes
            Connect to another replication server
            Temporarily stopping replication on a server
            Restarting Replication on a Server
            Suspending Replication for a Server
            Resuming a Suspended Replication Server
            Deleting a Replication Server
          Managing Replicates
            Modify replicates
              Adding or Deleting Participants
              Change replicate attributes
              Changing the replication key of a replicate
            Viewing Replicate Properties
            Starting a Replicate
            Stopping a Replicate
            Suspending a Replicate
            Resuming a Suspended Replicate
            Deleting a Replicate
          Managing Replicate Sets
            Connection management for client connections to participants in a replicate set
            Modifying Replicate Sets
              Adding or Deleting Replicates From a Replicate Set
              Changing Replication Frequency For the Replicate Set
            Viewing Replicate Sets
            Starting a Replicate Set
            Stopping a Replicate Set
            Suspending a Replicate Set
            Resuming a Replicate Set
            Deleting a Replicate Set
          Managing Templates
            Viewing Template Definitions
            Deleting Templates
          Managing Replication Server Network Connections
            Viewing Network Connection Status
            Dropping the Network Connection
            Reestablishing the Network Connection
          Resynchronizing Data among Replication Servers
            Performing Direct Synchronization
              Synchronizing Significantly Inconsistent Tables
            Checking Consistency and Repairing Inconsistent Rows
              Interpreting the Consistency Report
              Increase the speed of consistency checking
                Indexing the ifx_replcheck Column
              Repair inconsistencies by time stamp
              Repairing inconsistencies while enabling a replication server
              Implementing a custom checksum function
                Rules for custom checksum functions
            Repairing Failed Transactions with ATS and RIS Files
            Resynchronize data manually
          Alter, rename, or truncate operations during replication
            Altering multiple tables in a replicate set
            Adding a Replicated Column
            Removing replicated columns
            Modifying the data type or size of a replicated column
            Changing the Name of a Replicated Column, Table, or Database
            Changing or re-creating primary key columns
            Attaching a New Fragment to a Replicated Table
            Remastering a Replicate
              Remastering replicates without name verification
          Recapture replicated transactions
        Monitor and troubleshooting Enterprise Replication
          Solve Replication Processing Problems
          Failed Transaction (ATS and RIS) Files
            Enabling ATS and RIS File Generation
            ATS and RIS File Names
            ATS and RIS File Formats
              XML File Format
                XML Tags
              ATS and RIS Text File Contents
            Disabling ATS and RIS File Generation
            Suppressing Data Sync Errors and Warnings
          Preventing Memory Queues from Overflowing
            Handle potential log wrapping
            Monitoring Disk Usage for Send and Receive Queue Spool
            Increasing the Sizes or Numbers of Storage Spaces
            Recovering when Storage Spaces Fill
          Common configuration problems
          Troubleshooting Tips for Alter Operations
          Enterprise Replication Event Alarms
            Enabling or Disabling Enterprise Replication Event Alarms
      Push data feature
        Push data session survival
        Detach trigger
      Loopback replication
        Loopback Configuration
        Replication definition between primary and pseudo groups
      Appendixes
        The cdr utility
          Interpret the cdr utility syntax
            Command Abbreviations
            Option Abbreviations
            Option Order
            Long Command-Line Examples
            Long Identifiers
            Connect Option
            Participant and participant modifier
            Return Codes for the cdr Utility
            Frequency Options
          cdr add onconfig
          cdr alter
          cdr autoconfig serv
          cdr change grid
          cdr change gridtable
          cdr change onconfig
          cdr change replicate
          cdr change replicateset
          cdr change shardCollection
          cdr check queue
          cdr check replicate
          cdr check replicateset
          cdr check sec2er
          cdr cleanstart
          cdr connect server
          cdr define grid
          cdr define qod
          cdr define region
          cdr define replicate
          cdr define replicateset
          cdr define server
          cdr define shardCollection
          cdr define template
          cdr delete grid
          cdr delete region
          cdr delete replicate
          cdr delete replicateset
          cdr delete server
          cdr delete shardCollection
          cdr delete template
          cdr disable grid
          cdr disable server
          cdr disconnect server
          cdr enable grid
          cdr enable server
          cdr error
          cdr finderr
          cdr list grid
          cdr list replicate
          cdr list replicateset
          cdr list server
          cdr list shardCollection
          cdr list catalog
          cdr list template
          cdr modify grid
          cdr modify replicate
          cdr modify replicateset
          cdr modify server
          cdr realize template
          cdr remaster
          cdr remaster gridtable
          cdr remaster replicateset
          cdr remove onconfig
          cdr repair
          cdr reset qod
          cdr resume replicate
          cdr resume replicateset
          cdr resume server
          cdr start
          cdr start qod
          cdr start replicate
          cdr start replicateset
          cdr start sec2er
          cdr stats rqm
          cdr stats recv
          cdr stats check
          cdr stats sync
          cdr stop
          cdr stop qod
          cdr stop replicate
          cdr stop replicateset
          cdr suspend replicate
          cdr suspend replicateset
          cdr suspend server
          cdr swap shadow
          cdr sync replicate
          cdr sync replicateset
          cdr -V
          cdr view
        Enterprise Replication configuration parameter and environment variable reference
          CDR_APPLY Configuration Parameter
          CDR_AUTO_DISCOVER configuration parameter
          CDR_DBSPACE Configuration Parameter
          CDR_DELAY_PURGE_DTC configuration parameter
          CDR_DSLOCKWAIT Configuration Parameter
          CDR_ENV Configuration Parameter
          CDR_EVALTHREADS Configuration Parameter
          CDR_LOG_LAG_ACTION configuration parameter
          CDR_LOG_STAGING_MAXSIZE Configuration Parameter
          CDR_MAX_DYNAMIC_LOGS Configuration Parameter
          CDR_MAX_FLUSH_SIZE configuration parameter
          CDR_MEM configuration parameter
          CDR_NIFCOMPRESS Configuration Parameter
          CDR_QDATA_SBSPACE Configuration Parameter
          CDR_QUEUEMEM Configuration Parameter
          CDR_SERIAL Configuration Parameter
          CDR_SUPPRESS_ATSRISWARN Configuration Parameter
          CDR_TSINSTANCEID configuration parameter
          ENCRYPT_CDR Configuration Parameter
          GRIDCOPY_DIR Configuration Parameter
          SHARD_ID configuration parameter
          SHARD_MEM configuration parameter
          CDR_ALARMS Environment Variable
          CDR_ATSRISNAME_DELIM Environment Variable
          CDR_DISABLE_SPOOL Environment Variable
          CDR_LOGDELTA Environment Variable
          CDR_PERFLOG Environment Variable
          CDR_RMSCALEFACT Environment Variable
          CDR_ROUTER Environment Variable
          CDRSITES_10X Environment Variable
          CDRSITES_731 Environment Variable
          CDRSITES_92X Environment Variable
        Grid routines
          ifx_get_erstate() function
          ifx_grid_connect() procedure
          ifx_grid_copy() procedure
          ifx_grid_disconnect() procedure
          ifx_grid_execute() procedure
          ifx_grid_function() function
          ifx_grid_procedure() procedure
          ifx_grid_redo() procedure
          ifx_grid_release() function
          ifx_grid_remove() function
          ifx_grid_purge() procedure
          ifx_gridquery_skipped_nodes() function
          ifx_gridquery_skipped_node_count() function
          ifx_node_id() function
          ifx_node_name() function
        Enterprise Replication routines
          ifx_get_erstate() function
          ifx_set_erstate() procedure
        onstat -g commands for Enterprise Replication
          Threads shown by the onstat -g ath command
          onstat -g cat: Print ER global catalog information
          onstat -g cdr: Print ER statistics
          onstat -g cdr config
          onstat -g ddr
          onstat -g dss: Print statistics for data sync threads
          onstat -g dtc: Print statistics about delete table cleaner
          onstat -g grp
          onstat -g nif: Print statistics about the network interface
          onstat -g que: Print statistics for all ER queues
          onstat -g rcv: Print statistics about the receive manager
          onstat -g rep
          onstat -g rqm
          onstat -g sync
        syscdr Tables
          The replcheck_stat Table
          The replcheck_stat_node Table
        SMI Table Reference
          The syscdr_ats Table
          The syscdr_atsdir Table
          The syscdr_ddr Table
          The syscdr_nif Table
          The syscdr_rcv Table
          The syscdr_ris Table
          The syscdr_risdir Table
          The syscdr_rqm Table
          The syscdr_rqmhandle Table
          The syscdr_rqmstamp Table
          The syscdr_state Table
          The syscdrack_buf Table
          The syscdrack_txn Table
          The syscdrctrl_buf Table
          The syscdrctrl_txn Table
          The syscdrerror Table
          The syscdrlatency Table
          The syscdrpart Table
          The syscdrprog Table
          The syscdrq Table
          The syscdrqueued Table
          The syscdrrecv_buf Table
          The syscdrrecv_stats Table
          The syscdrrecv_txn Table
          The syscdrrepl Table
          The syscdrreplset Table
          The syscdrs Table
          The syscdrsend_buf Table
          The syscdrsend_txn Table
          The syscdrserver Table
          The syscdrsync_buf Table
          The syscdrsync_txn Table
          The syscdrtsapply table
          The syscdrtx Table
          Enterprise Replication Queues
            Columns of the Transaction Tables
            Columns of the Buffer Tables
        Replication Examples
          Replication Example Environment
          Primary-Target Example
          Update-Anywhere Example
          Hierarchy Example
        Data sync warning and error messages
    Informix Replication Plug-in for OAT
      Setting up the Replication plug-in
      Monitoring Enterprise Replication
        Viewing the topology of an ER domain
        Configuring alert thresholds
        Checking for alerts on an Enterprise Replication domain
        Viewing the status of an Enterprise Replication node
          Viewing a summary of replication activity at the current node
          Viewing the node as a replication source
          Viewing the node as a replication target
        Monitoring log capture information for a node
          Determining if transactions are being captured for replication
          Monitoring log capture progress for a node
          Preventing DDRBLOCK and log wrap
          Turning on dynamic log file allocation
        Monitoring the send queue for a node
          Viewing target nodes and replicates related to the current node
        Monitoring network I/O for an Enterprise Replication node
        Monitoring disk space usage for a node
        Monitoring the receive queue for a node
        Monitoring how replicated data is applied at the target node
          Monitoring transaction failures
          Determining the apply latency rate
        Reviewing ATS and RIS files for failed transactions
        Reviewing Enterprise Replication errors
        Viewing the ER configuration parameters
      Administering Enterprise Replication
        Setting up Enterprise Replication
          Defining a server for Enterprise Replication
          Defining a replicate set
          Defining a replicate
        Using templates to set up Enterprise Replication
          Defining a template
          Realizing a template
          Deleting a template
        Managing Enterprise Replication with a grid
          Creating a grid
          Deleting a grid
          Adding members to a grid
          Changing the users of a grid
          Enabling or disabling a source server for a grid
          Monitoring the status of grid tasks
          Rerunning a grid command
          Removing a grid command
          Routing client connections in a grid
            Viewing the SLAs for a grid
            Creating an SLA for a grid
            Modifying an SLA for a grid
            Monitoring the quality of data in a grid
        Managing Enterprise Replication servers
          Modifying an ER server
            Changing ATS and RIS file location and format
            Changing the idle timeout for an ER server
            Changing the type for participants on an ER server
            Disabling ATS or RIS file generation on an ER server
            Enabling ATS or RIS file generation on an ER server
          Stopping or restarting replication on a server
            Suspending replication for a server
            Resuming replication to a suspended server
            Stopping replication on a server
            Restarting replication on a server
            Restarting replication with empty queues
            Disabling replication for a server
            Enabling replication for a disabled server
          Disconnecting an ER server
          Reconnecting an ER server
          Deleting an ER server
        Managing replicate sets
          Modifying a replicate set
            Adding and deleting replicates in a replicate set
            Changing replication frequency for a replicate set
          Viewing replicate set properties
          Starting a replicate set
          Stopping a replicate set
          Suspending a replicate set
          Resuming a replicate set
          Deleting a replicate set
        Managing replicates
          Modifying a replicate
            Adding and deleting participants
            Changing the master replicate server
            Changing the conflict resolution rule and scope
            Changing replication frequency for a replicate
            Activating ATS and RIS file generation
            Replicating full rows or changed columns
            Enabling and disabling triggers
            Retaining or removing deleted rows
          Viewing replicate properties
          Starting a replicate
          Stopping a replicate
          Suspending a replicate
          Resuming a replicate
          Deleting a replicate
        Resynchronizing data among replication servers
          Checking a replicate
          Checking and repairing a replicate
          Synchronizing a replicate
          Deleting a check or sync task for a replicate
          Checking a replicate set
          Checking and repairing a replicate set
          Synchronizing a replicate set
          Deleting a check or sync task for a replicate set
          Repairing failed transactions with ATS files
          Repairing failed transactions with RIS files
        Monitoring task status
          Monitoring replicate tasks
          Monitoring replicate set tasks
        Changing ER configuration parameters
      Managing client connections
        Viewing connection units
        Adding a connection unit
        Modifying a failover configuration
        Creating a service level agreement
        Modifying a service level agreement
        Creating a Connection Manager
  System administration
    List of utilities
    Administrator's Guide
      What's new in administration for Informix, Version 12.10
      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
            Database server monitoring
              UNIX operating-system tools
              Windows administrative utilities
        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 IBM 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
            Threads
            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
            Stacks
            Queues
              Ready queues
              Sleep queues
              Wait queues
            Mutexes
          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
                Stacks
                Heaps
            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
          Chunks
            Disk allocation for chunks
              Disk access on Windows
              Unbuffered or buffered disk access on UNIX
            Extendable chunks
            Partitions and offsets
          Pages
          Blobpages
          Sbpages
          Extents
          Dbspaces
            Control of where simple large object data is stored
            Root dbspace
            Temporary dbspaces
          Blobspaces
          Sbspaces
            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
              Logging
            Levels of inheritance for sbspace characteristics
            More information about sbspaces
            Temporary sbspaces
              Comparison of temporary and standard sbspaces
              Temporary smart large objects
          Plogspace
          Extspaces
          Databases
          Tables
            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
          Tblspaces
            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
          Multitenancy
            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
            Compression
              Data that you can compress
              Data that you cannot compress
              B-tree index compression
              Compression ratio estimates
              Compression dictionaries
              Tools for moving compressed data
              BLOBspace Blob Compression
              Methods for viewing compression information
          Load data into a table
        Moving data with external tables
          External tables
          Defining external tables
          Map columns to other columns
          Load data from and unload to a named pipe
            Loading data with named pipes
            FIFO virtual processors
            Unloading data with named pipes
            Copying data from one instance to another using the PIPE option
          Monitor the load or unload operations
            Monitor frequent load and unload operations
            Monitor FIFO virtual processors
          External tables in high-availability cluster environments
          System catalog entries for external tables
          Performance considerations when using external tables
          Manage errors from external table load and unload operations
            Reject files
            External table error messages
            Recoverability of table types for external tables
      Logging and log administration
        Logging
          Database server processes that require logging
          Transaction logging
          Logging of SQL statements and database server activity
            Activity that is always logged
            Activity logged for databases with transaction logging
            Activity that is not logged
          Database-logging status
            Unbuffered transaction logging
            Buffered transaction logging
            ANSI-compliant transaction logging
            No database logging
            Databases with different log-buffering status
            Database logging in an X/Open DTP environment
          Settings or changes for logging status or mode
        Manage the database-logging mode
          Change the database-logging mode
          Modify the database-logging mode with ondblog
            Change the buffering mode with ondblog
            Cancel a logging mode change with ondblog
            End logging with ondblog
            Make a database ANSI compliant with ondblog
            Changing the logging mode of an ANSI-compliant database
          Modify the database logging mode with ontape
            Turn on transaction logging with ontape
            End logging with ontape
            Change buffering mode with ontape
            Make a database ANSI compliant with ontape
          Modify the table-logging mode
            Alter a table to turn off logging
            Alter a table to turn on logging
            Disable logging on temporary tables
          Monitor transactions
          Monitor the logging mode of a database
            Monitor the logging mode with SMI tables
        Logical log
          What is the logical log?
          Location of logical-log files
          Identification of logical-log files
          Status flags of logical-log files
          Size of the logical-log file
            Number of logical-log files
            Performance considerations
          Dynamic log allocation
          Freeing of logical-log files
            Action if the next logical-log file is not free
            Action if the next log file contains the last checkpoint
          Log blobspaces and simple large objects
            Switch log files to activate blobspaces
            Back up log files to free blobpages
            Back up blobspaces after inserting or deleting TEXT and BYTE data
          Log sbspaces and smart large objects
            Sbspace logging
              Logging for smart large objects
              Logging for updated smart large objects
              Turn logging on or off for an sbspace
            Smart-large-object log records
            Prevent long transactions when logging smart-large-object data
          Logging process
            Dbspace logging
            Blobspace logging
        Manage logical-log files
          Estimate the size and number of log files
            Estimate the log size when logging smart large objects
            Estimate the number of logical-log files
          Back up logical-log files
            Backing up blobspaces
            Back up sbspaces
          Switch to the next logical-log file
          Free a logical-log file
            Delete a log file with status D
            Free a log file with status U
            Freeing a log file with status U-B or F
            Freeing a log file with status U-C or U-C-L
            Free a log file with status U-B-L
          Monitor logging activity
            Monitor the logical log for fullness
              The onstat -l command
              The oncheck -pr command
            Monitor temporary logical logs
            SMI tables
            Monitor log-backup status
          Allocate logical log files
            Dynamically add a logical-log file to prevent transaction blocking
              Size and number of dynamically added log files
              Location of dynamically added logical log files
              Monitor events for dynamically added logs
            Dynamically add logical logs for performance
            Adding logical-log files manually
          Dropping logical-log files
          Change the size of logical-log files
          Move logical-log files
          Display logical-log records
          Controlling long transactions
        Physical logging, checkpoints, and fast recovery
          Critical sections
          Physical logging
            Fast recovery use of physically-logged pages
            Backup use of physically-logged pages
            Database server activity that is physically logged
              Physical recovery messages
              Physical logging and simple large objects
              Physical logging and smart large objects
          Size and location of the physical log
            Strategy for estimating the size of the physical log
            Physical-log overflow when transaction logging is turned off
          Checkpoints
            LRU values for flushing a buffer pool between checkpoints
            Checkpoints during backup
          Fast recovery
            Need for fast recovery
            Situations when fast recovery is initiated
              Fast recovery and buffered logging
              Possible physical log overflow during fast recovery
              Fast recovery and no logging
            Fast recovery after a checkpoint
              The server returns to the last-checkpoint state
              The server locates the checkpoint record in the logical log
              The server rolls forward logical-log records
              The server rolls back uncommitted transactions
        Manage the physical log
          Change the physical-log location and size
          Monitor physical and logical-logging activity
          Monitor checkpoint information
            Turn checkpoint tuning on or off
            Force a checkpoint
            Server-provided checkpoint statistics
            SMI tables
          Turn automatic LRU tuning on or off
      Fault tolerance
        Mirroring
          Mirroring
            Benefits of mirroring
            Costs of mirroring
            Consequences of not mirroring
            Data to mirror
            Alternatives to mirroring
              Logical volume managers
              Hardware mirroring
              External backup and restore
          Mirroring process
            Creation of a mirror chunk
            Mirror status flags
            Recovery
            Actions during processing
              Disk writes to mirror chunks
              Disk reads from mirror chunks
              Detection of media failures
              Chunk recovery
            Result of stopping mirroring
            Structure of a mirror chunk
        Using mirroring
          Preparing to mirror data
          Enable the MIRROR configuration parameter
          Allocate disk space for mirrored data
            Link chunks (UNIX)
            Relink a chunk to a device after a disk failure
          Using mirroring
            Mirroring the root dbspace during initialization
            Change the mirror status
          Manage mirroring
            Start mirroring for unmirrored storage spaces
              Start mirroring for unmirrored dbspaces using onspaces
            Start mirroring for new storage spaces
              Start mirroring for new spaces using onspaces
            Add mirror chunks
              Add mirror chunks using onspaces
            Swap mirror chunk
            Take down a mirror chunk
              Take down mirror chunks using onspaces
            Recover a mirror chunk
              Recover a mirror chunk using onspaces
            End mirroring
              End mirroring using onspaces
        Consistency checking
          Perform periodic consistency checking
            Verify consistency
              Validate system catalog tables
              Validate data pages
              Validate extents
              Validate indexes
              Validate logical logs
              Validate reserved pages
              Validate metadata
            Monitor for data inconsistency
              Read assertion failures in the message log and dump files
              Validate table and tblspace data
            Retain consistent level-0 backups
          Deal with corruption
            Find symptoms of corruption
            Fix index corruption
            Fix I/O errors on a chunk
          Collect diagnostic information
          Disable I/O errors
          Monitor the database server for disabling I/O errors
            The message log to monitor disabling I/O errors
            Event alarms to monitor disabling I/O errors
            No bad-sector mapping
      High availability and scalability
        Strategies for high availability and scalability
          Components supporting high availability and scalability
            Advantages of data replication
              Clustering versus mirroring
              Clustering versus two-phase commit
              Type of data replicated in clusters
              Primary and secondary database servers
          Transparent scaling and workload balancing strategies
          High availability strategies
        High-availability cluster configuration
          Plan for a high-availability cluster
          Configuring clusters
            Hardware and operating-system requirements for clusters
            Database and data requirements for clusters
            Database server configuration requirements for clusters
              Database server version
              Storage space and chunk configuration
              Non-default page sizes in an HDR environment
              Mirroring
              Physical-log configuration
              Dbspace and logical-log tape backup devices
              Logical-log configuration
              High-availability cluster configuration parameters
              Cluster transaction coordination
            Configuring secure connections for high-availability clusters
          Starting HDR for the First Time
            Decrease setup time using the ontape STDIO feature
          Remote standalone secondary servers
            Comparison of RS secondary servers and HDR secondary servers
            Index page logging
              How index page logging works
              Enable or disable index page logging
              View index page logging statistics
            Starting an RS secondary server for the first time
              Decrease setup time through an alternative backup method
            Converting an offline primary server to an RS secondary server
            Delayed application of log records
              Specifying the log staging directory
              Delay application of log records on an RS secondary server
              Stop the application of log records
            Flow control for remote standalone secondary servers
          Shared disk secondary servers
            SD secondary server
            Disk requirements for SD secondary servers
            Setting up a shared disk secondary server
            Obtain SD secondary server statistics
            Promote an SD secondary server to a primary server
            Convert a primary server to a standard server
            SD secondary server security
            Flow control for shared-disk secondary servers
        Cluster administration
          How data replication works
            How data initially replicates
            Replication of primary-server data to secondary servers
              Fully synchronous mode for HDR replication
              Nearly synchronous mode for HDR replication
              Asynchronous mode for HDR replication
              Lost-and-found transactions
            Data replication configuration examples
              Remote standalone secondary configuration examples
              Shared disk secondary configuration examples
              Enterprise Replication as part of the recoverable group
              High-availability clusters with Enterprise Replication configuration example
              Example of a complex failover recovery strategy
            Troubleshooting high-availability cluster environments
            Design data replication group clients
              Use of temporary dbspaces for sorting and temporary tables
          Performing basic administration tasks
            Changing the configuration parameters for an HDR replication pair
            Back up storage spaces and logical-log files
            Changing the logging mode of databases
            Add and drop chunks and storage spaces
            Renaming chunks
            Saving chunk status on the secondary database server
            Use and change mirroring of chunks
            Manage the physical log
            Manage the logical log
            Manage virtual processors
            Manage shared memory
            Configure SMX connections
            Replicate an index to an HDR secondary database server
            Encrypting data traffic between HDR database servers
            Adjust LRU flushing and automatic tuning in HDR server pairs
            Cloning a primary server
              Creating a clone of a primary server
            Database updates on secondary servers
              Isolation levels on secondary servers
                Set lock mode
              Transient types on high-availability cluster secondary servers
              Row versioning
            Backup and restore with high-availability clusters
            Change the database server mode
            Changing the database server type
            Prevent blocking checkpoints on HDR servers
              View statistics for nonblocking checkpoints on HDR servers
            Monitor HDR status
              Command-line utilities
                The onstat -g dri option
                The oncheck -pr option
              SMI tables
          Obtain RS secondary server statistics
          Remove an RS secondary server
          RS secondary server security
            Create or change a password on an RS secondary server
          Transaction completion during cluster failover
            Configuring the server so that transactions complete after failover
        Connection management through the Connection Manager
          Configuring connection management
            Creating Connection Manager configuration files
              Parameters and format of the Connection Manager configuration file
                CMALARMPROGRAM Connection Manager configuration parameter
                CM_TIMEOUT Connection Manager configuration parameter
                CLUSTER Connection Manager configuration parameter
                DEBUG Connection Manager configuration parameter
                EVENT_TIMEOUT Connection Manager configuration parameter
                FOC Connection Manager configuration parameter
                GRID Connection Manager configuration parameter
                INFORMIXSERVER Connection Manager configuration parameter
                LOCAL_IP Connection Manager configuration parameter
                LOG Connection Manager configuration parameter
                LOGFILE Connection Manager configuration parameter
                MACRO Connection Manager configuration parameter
                NAME Connection Manager configuration parameter
                REPLSET Connection Manager configuration parameter
                SECONDARY_EVENT_TIMEOUT Connection Manager configuration parameter
                SERVERSET Connection Manager configuration parameter
                SLA Connection Manager configuration parameter
                SQLHOSTS Connection Manager configuration parameter
                SSL_LABEL Connection Manager configuration parameter
              Modifying Connection Manager configuration files
              Converting older formats of the Connection Manager configuration file to the current format
            Configuring environments and setting configuration parameters for connection management
            Defining sqlhosts information for connection management
              Defining sqlhosts information for connection management of high-availability clusters
              sqlhosts for HA clusters that use secure ports
              sqlhosts for HA clusters that use DRDA
              sqlhosts for HA clusters that use DRDA and secure ports
              sqlhosts for grids and replicate sets
              sqlhosts for grids and replicate sets that use secure ports
              sqlhosts for HA replication systems
              sqlhosts for HA replication systems that use secure ports
              sqlhosts for server sets
            Creating a password file for connecting to database servers on untrusted networks
              Modifying encrypted password information
            Starting Connection Managers on UNIX and Linux
            Starting Connection Managers on Windows
            Stopping connection management
          Monitoring and troubleshooting connection management
          Strategies for increasing availability with Connection Managers
          Configuration examples for connection management
            Example of configuring connection management for a high-availability cluster
            Example of configuring connection management for a grid or replicate set
            Example of configuring connection management for a high-availability replication system
            Example: Configuring connection management for untrusted networks
            Example: Configuring for prioritizing connections and network monitoring
            Example: Configuring for an SSL connection
              Configuring a CM to connect to Oninit using SSL
              Configuring a client to connect to a CM using SSL
        Cluster failover, redirection, and restoration
          Failover configuration for high-availability clusters
            Failover with ISV cluster management software
            I/O fencing for shared file systems
            Cluster failures
              Automatic switchover
              Automatic switchover without a reliable network
              Manual switchover
              Connecting offline servers to the new primary server
          Redirection and connectivity for data-replication clients
            Redirecting clients automatically with the DBPATH environment variable
              How the DBPATH redirection method works
            Redirecting clients with the connectivity information
              Changing client connectivity information
              Connecting to the database server
              Automatic redirection with server groups
            Redirecting clients with the INFORMIXSERVER environment variable
            Redirecting clients with application code
            Comparison of redirection methods
          Recover HDR and RS clusters after failure
            Recovering a cluster after critical data is damaged
            Restarting HDR or RS clusters after a network failure
            Restarting HDR or RS clusters if the secondary server fails
            Recovering an HDR cluster after the secondary server became the primary server
            Restart if the primary server fails
          Recovering a shared-disk cluster after data is damaged
          Recovering an SD cluster after the secondary server became the primary server
      Distributed data
        Multiphase commit protocols
          Transaction managers
            TP/XA Library with a transaction manager
            Microsoft Transaction Server (MTS/XA)
            Informix transaction support for XA-compliant, external data sources
            XA in high-availability clusters
            Loosely-coupled and tightly-coupled modes
          Two-phase commit protocol
            When the two-phase commit protocol is used
            Two-phase commit concepts
            Phases of the two-phase commit protocol
              Precommit phase
              Postdecision phase
            How the two-phase commit protocol handles failures
              Types of failures that automatic recovery handles
              Administrator's role in automatic recovery
              Automatic-recovery mechanisms for coordinator failure
              Automatic-recovery mechanisms for participant failure
            Presumed-end optimization
          Independent actions
            Situations that initiate independent action
            Possible results of independent action
              Independent actions that allow transactions to complete successfully
              Independent actions that result in an error condition
              Independent actions that result in heuristic decisions
            The heuristic rollback scenario
              Conditions that result in a heuristic rollback
                Condition 1: Logical log fills to a high-watermark
                Condition 2: System administrator executes onmode -z
              Results of a heuristic rollback
                Situation 1: Coordinator issues a commit and all participants report heuristic rollbacks
                Situation 2: Coordinator issued a commit; one participant commits and one reports a heuristic rollback
            The heuristic end-transaction scenario
              When to perform a heuristic end transaction
              How to use onmode -Z
              Action when the transaction is ended heuristically
            Monitor a global transaction
          Two-phase commit protocol errors
          Two-phase commit and logical-log records
            Logical-log records when the transaction commits
            Logical-log records written during a heuristic rollback
            Logical-log records written after a heuristic end transaction
          Configuration parameters used in two-phase commits
            Function of the DEADLOCK_TIMEOUT parameter
            Function of the TXTIMEOUT parameter
          Heterogeneous commit protocol
            Gateways that can participate in a heterogeneous commit transaction
            Enable and disable of heterogeneous commit
            How heterogeneous commit works
              Precommit phase
              Gateway commit phase
              Heterogeneous commit optimization
            Implications of a failed heterogeneous commit
              Database server coordinator failure
              Participant failure
              Interpretation of heterogeneous commit error messages
                Application attempts to update multiple gateway participants
                Failed attempt to commit distributed transaction using heterogeneous commit
        Manually recovering from failed two-phase commit
          Determine if manual recovery is required
            Determine if a transaction was implemented inconsistently
              Global transaction ended prematurely
              Heuristic end transaction
              Heuristic rollback
            Determine if the distributed database contains inconsistent data
              Obtaining information from the logical log
              Obtain the global transaction identifier
            Decide if action is needed to correct the situation
          Example of manual recovery
      Overview of automatic monitoring and corrective actions
        The Scheduler
          Scheduler tables
          Built-in tasks and sensors
          Creating a task
          Creating a sensor
          Actions for task and sensors
          Creating a group
          Creating a threshold
          Creating an alert
          Monitor the scheduler
          Modifying the scheduler
        Remote administration with the SQL administration API
          SQL administration API admin() and task() functions
          Viewing SQL administration API history
            Controlling the size of the command_history table
        Query drill-down
          Specifying startup SQL tracing information by using the SQLTRACE configuration parameter
          Disable SQL tracing globally or for a session
          Enable SQL tracing
          Enable global SQL tracing for a session
      HCL Informix server licensing
        FlexNet Licensing Overview
        Licensing configuration
        Operational considerations
        FlexNet Operations portal
        The REST interface
        Security
          Local License Server
        Informix Warehouse Accelerator
    Administrator's Reference
      What's New in Administrator's Reference for Informix database server, Version 12.10
      Configuring and monitoring Informix
        Database configuration parameters
          onconfig file
            Modifying the onconfig file
            Displaying the settings in the onconfig file
          onconfig Portal: Configuration parameters by functional category
          ADMIN_MODE_USERS configuration parameter
          ADMIN_USER_MODE_WITH_DBSA configuration parameter
          ALARMPROGRAM configuration parameter
          ALLOW_NEWLINE configuration parameter
          ALRM_ALL_EVENTS configuration parameter
          AUTO_AIOVPS configuration parameter
          AUTO_CKPTS configuration parameter
          AUTO_LLOG configuration parameter
          AUTO_TUNE_SERVER_SIZE configuration parameter
          AUTO_LRU_TUNING configuration parameter
          AUTO_READAHEAD configuration parameter
          AUTO_REPREPARE configuration parameter
          AUTO_STAT_MODE configuration parameter
          AUTO_TUNE configuration parameter
          AUTOLOCATE configuration parameter
          BATCHEDREAD_INDEX configuration parameter
          BATCHEDREAD_TABLE configuration parameter
          BLOCKTIMEOUT configuration parameter
          BTSCANNER Configuration Parameter
          BUFFERPOOL configuration parameter
          CHECKALLDOMAINSFORUSER configuration parameter
          CKPTINTVL configuration parameter
          CLEANERS configuration parameter
          CLUSTER_TXN_SCOPE configuration parameter
          CONSOLE configuration parameter
          CONVERSION_GUARD configuration parameter
          DATASKIP Configuration Parameter
          DBCREATE_PERMISSION configuration parameter
          DB_LIBRARY_PATH configuration parameter
          DBSERVERALIASES configuration parameter
          DBSERVERNAME configuration parameter
          DBSPACETEMP configuration parameter
            Use Hash Join Overflow and DBSPACETEMP
          DD_HASHMAX configuration parameter
          DD_HASHSIZE configuration parameter
          DEADLOCK_TIMEOUT configuration parameter
          DEF_TABLE_LOCKMODE configuration parameter
          DEFAULTESCCHAR configuration parameter
          DELAY_APPLY Configuration Parameter
          DIRECT_IO configuration parameter (UNIX)
          DIRECTIVES configuration parameter
          DISABLE_B162428_XA_FIX configuration parameter
          DISK_ENCRYPTION configuration parameter
          DRDA_COMMBUFFSIZE configuration parameter
          DRAUTO configuration parameter
          DRIDXAUTO configuration parameter
          DRINTERVAL configuration parameter
          DRLOSTFOUND configuration parameter
          DRTIMEOUT configuration parameter
          DS_HASHSIZE configuration parameter
          DS_MAX_QUERIES configuration parameter
          DS_MAX_SCANS configuration parameter
          DS_NONPDQ_QUERY_MEM configuration parameter
          DS_POOLSIZE configuration parameter
          DS_TOTAL_MEMORY configuration parameter
            Algorithm for DS_TOTAL_MEMORY
          DUMPCNT configuration parameter (UNIX)
          DUMPCORE configuration parameter (UNIX)
          DUMPDIR configuration parameter
          DUMPGCORE configuration parameter (UNIX)
          DUMPSHMEM configuration parameter (UNIX)
          DYNAMIC_LOGS configuration parameter
          EILSEQ_COMPAT_MODE configuration parameter
          ENABLE_SNAPSHOT_COPY configuration parameter
          ENCRYPT_CIPHERS configuration parameter
          ENCRYPT_HDR configuration parameter
          ENCRYPT_MAC configuration parameter
          ENCRYPT_MACFILE configuration parameter
          ENCRYPT_SMX configuration parameter
          ENCRYPT_SWITCH configuration parameter
          EXPLAIN_STAT configuration parameter
          EXT_DIRECTIVES configuration parameter
          EXTSHMADD configuration parameter
          FAILOVER_CALLBACK configuration parameter
          FAILOVER_TX_TIMEOUT configuration parameter
          FASTPOLL configuration parameter
          FILLFACTOR configuration parameter
          FULL_DISK_INIT configuration parameter
          GSKIT_VERSION configuration parameter
          HA_ALIAS configuration parameter
          HA_FOC_ORDER configuration parameter
          HDR_TXN_SCOPE configuration parameter
          HETERO_COMMIT configuration parameter
          IFX_EXTEND_ROLE configuration parameter
          IFX_FOLDVIEW configuration parameter
          IFX_XA_UNIQUEXID_IN_DATABASE configuration parameter
          INFORMIXCONRETRY configuration parameter
          INFORMIXCONTIME configuration parameter
          LICENSE_SERVER configuration parameter
          LICENSE_TIMING configuration parameter
          LIMITNUMSESSIONS configuration parameter
          LISTEN_TIMEOUT configuration parameter
          LOCKS configuration parameter
          LOGBUFF configuration parameter
          LOGBUF_INTVL configuration parameter
          LOGFILES configuration parameter
          LOG_INDEX_BUILDS configuration parameter
          LOG_STAGING_DIR configuration parameter
          LOGSIZE configuration parameter
          LOW_MEMORY_MGR configuration parameter
          LOW_MEMORY_RESERVE configuration parameter
          LTXEHWM configuration parameter
          LTXHWM configuration parameter
          MAX_FILL_DATA_PAGES configuration parameter
          MAX_INCOMPLETE_CONNECTIONS configuration parameter
          MAX_PDQPRIORITY configuration parameter
          MIRROR configuration parameter
          MIRROROFFSET configuration parameter
          MIRRORPATH configuration parameter
          MSG_DATE configuration parameter
          MSGPATH configuration parameter
          MULTIPROCESSOR configuration parameter
          NET_IO_TIMEOUT_ALARM configuration parameter
          NETTYPE configuration parameter
          NS_CACHE configuration parameter
          NUMFDSERVERS configuration parameter
          OFF_RECVRY_THREADS configuration parameter
          ON_RECVRY_THREADS configuration parameter
          ONDBSPACEDOWN configuration parameter
            Database Server Behavior When ONDBSPACEDOWN Does Not Apply
          ONLIDX_MAXMEM configuration parameter
          OPTCOMPIND configuration parameter
          OPT_GOAL configuration parameter
          PC_HASHSIZE configuration parameter
          PC_POOLSIZE configuration parameter
          PHYSBUFF configuration parameter
          PHYSFILE configuration parameter
          PLOG_OVERFLOW_PATH configuration parameter
          PLCY_HASHSIZE configuration parameter
          PLCY_POOLSIZE configuration parameter
          PN_STAGEBLOB_THRESHOLD configuration parameter
          PRELOAD_DLL_FILE configuration parameter
          QSTATS configuration parameter
          REMOTE_SERVER_CFG configuration parameter
          REMOTE_USERS_CFG configuration parameter
          RESIDENT configuration parameter
          RESTARTABLE_RESTORE configuration parameter
          RESTORE_POINT_DIR configuration parameter
          ROOTNAME configuration parameter
          ROOTOFFSET configuration parameter
          ROOTPATH configuration parameter
          ROOTSIZE configuration parameter
          RSS_FLOW_CONTROL configuration parameter
          RTO_SERVER_RESTART configuration parameter
          S6_USE_REMOTE_SERVER_CFG configuration parameter
          SB_CHECK_FOR_TEMP configuration parameter
          SBSPACENAME configuration parameter
          SBSPACETEMP configuration parameter
          SDS_ALTERNATE configuration parameter
          SDS_ENABLE configuration parameter
          SDS_FLOW_CONTROL configuration parameter
          SDS_LOGCHECK configuration parameter
          SDS_PAGING configuration parameter
          SDS_TEMPDBS configuration parameter
          SDS_TIMEOUT configuration parameter
          SECURITY_LOCALCONNECTION configuration parameter
          SEQ_CACHE_SIZE configuration parameter
          SERVERNUM configuration parameter
          SESSION_LIMIT_LOCKS configuration parameter
          SESSION_LIMIT_LOGSPACE configuration parameter
          SESSION_LIMIT_MEMORY configuration parameter
          SESSION_LIMIT_TEMPSPACE configuration parameter
          SESSION_LIMIT_TXN_TIME configuration parameter
          SHMADD configuration parameter
          SHMBASE configuration parameter
          SHMNOACCESS configuration parameter
          SHMTOTAL configuration parameter
          SHMVIRT_ALLOCSEG configuration parameter
          SHMVIRTSIZE configuration parameter
          SINGLE_CPU_VP configuration parameter
            VPCLASS Values and the SINGLE_CPU_VP Configuration Parameter
          SMX_COMPRESS configuration parameter
          SMX_NUMPIPES configuration parameter
          SMX_PING_INTERVAL configuration parameter
          SMX_PING_RETRY configuration parameter
          SP_AUTOEXPAND configuration parameter
          SP_THRESHOLD configuration parameter
          SP_WAITTIME configuration parameter
          SQL_LOGICAL_CHAR configuration parameter
          SQLTRACE configuration parameter
          SSL_KEYSTORE_LABEL configuration parameter
          STACKSIZE configuration parameter
          STATCHANGE configuration parameter
          STMT_CACHE configuration parameter
          STMT_CACHE_HITS configuration parameter
          STMT_CACHE_NOLIMIT configuration parameter
          STMT_CACHE_NUMPOOL configuration parameter
          STMT_CACHE_SIZE configuration parameter
          STOP_APPLY configuration parameter
          STORAGE_FULL_ALARM configuration parameter
          SYSALARMPROGRAM configuration parameter
          SYSSBSPACENAME configuration parameter
          TBLSPACE_STATS configuration parameter
          TBLTBLFIRST configuration parameter
          TBLTBLNEXT configuration parameter
          TEMPTAB_NOLOG configuration parameter
          TENANT_LIMIT_CONNECTIONS configuration parameter
          TENANT_LIMIT_MEMORY configuration parameter
          TENANT_LIMIT_SPACE configuration parameter
          TLS_VERSION configuration parameter
          TXTIMEOUT configuration parameter
          UNSECURE_ONSTAT configuration parameter
          UPDATABLE_SECONDARY configuration parameter
          USELASTCOMMITTED configuration parameter
          USEOSTIME configuration parameter
          USERMAPPING configuration parameter (UNIX, Linux)
          USRC_HASHSIZE configuration parameter
          USRC_POOLSIZE configuration parameter
          USTLOW_SAMPLE configuration parameter
          VP_MEMORY_CACHE_KB configuration parameter
          VPCLASS configuration parameter
          WSTATS configuration parameter
        The sysmaster database
          The sysmaster Database
            The buildsmi Script
            The bldutil.sh Script
          The System-Monitoring Interface
            Understanding the SMI Tables
            Accessing SMI tables
              SELECT statements
              Triggers and Event Alarms
              SPL and SMI Tables
              Locking and SMI Tables
          The System-Monitoring Interface Tables
            The sysutils Tables
            sysadtinfo
            sysaudit
            syschkio
            syscheckpoint
            syschunks
            sysckptinfo
            syscluster
            syscmsm
            syscmsmsla
            syscmsmtab
            syscmsmunit
            syscompdicts_full
            sysconfig
            sysdatabases
            sysdbslocale
            sysdbspaces
            sysdri
            sysdual
            sysenv
            sysenvses
            sysextents
            sysextspaces
            sysfeatures
            sysha_lagtime Table
            sysha_type
            sysha_workload
            sysipl
            syslocks
            syslogs
            syslogfil table
            sysmgminfo
            sysnetclienttype
            sysnetglobal
            sysnetworkio table
            sysonlinelog
            sysprofile
            sysproxyagents
            sysproxydistributors
            sysproxysessions table
            sysproxytxnops table
            sysproxytxns table
            sysptnhdr
            sysptprof table
            sysrepevtreg table
            sysrepstats table
              User interface for sysrepstats and sysrepevtreg tables
            sysrsslog
            sysscblst
            syssesappinfo
            syssesprof
            syssessions
            syssmx
            syssmxses
            syssqexplain table
            syssqltrace
            syssqltrace_hvar
            syssqltrace_info
            syssqltrace_iter
            syssrcrss
            syssrcsds
            systabnames
            systhreads
            systrgrss
            systrgsds
            sysvpprof
            The SMI Tables Map
            Information from onstat in the SMI Tables
        The sysadmin Database
          The Scheduler tables
            The ph_task Table
            The ph_run Table
            The ph_group Table
            The ph_alert Table
            The ph_threshold Table
          The results tables
          The command_history table
          The storagepool table
          The tenant table
        Disk Structures and Storage
          Dbspace Structure and Storage
            Structure of the Root Dbspace
            Reserved Pages
            Structure of a Regular Dbspace
              Structure of an Additional Dbspace Chunk
              Structure of a Mirror Chunk
            Structure of the Chunk Free-List Page
            Structure of the Tblspace Tblspace
              Tblspace tblspace entries
              Tblspace Numbers
            Structure of the Database Tblspace
              Database Tblspace Entries
            Structure and Allocation of an Extent
              Extent Structure
                Extent size
                Page Types Within a Table Extent
                Page Types Within an Index Extent
              Next-Extent Allocation
                Next-Extent Size
                Extent size doubling
                Lack of Contiguous Space
                Merge of Extents for the Same Table
            Structure and Storage of a Dbspace Page
              Rows in Nonfragmented Tables
                Definition of Rowid
                Use of Rowids
              Rows in Fragmented Tables
                Access to Data in Fragmented Tables with Rowid
              Recommendations on Use of Rowid
              Data-Row Format and Storage
                Storage of Row
                Location of Rows
                Page Compression
            Structure of Fragmented Tables
            Structure of B-Tree Index Pages
              Definition of B-tree terms
              Logical Storage of Indexes
                Creation of Root and Leaf Nodes
                Creation of branch nodes
                Duplicate Key Values
                Key-Value Locking
                Adjacent Key Locking
                Freed Index Pages
                Filling Indexes
                Calculating the Length of Index Items
              Functional Indexes
            Structure of R-Tree Index Pages
          Storage of Simple Large Objects
            Structure of a Blobspace
            Structure of a Dbspace Blobpage
            Simple-Large-Object Storage and the Descriptor
              Creation of Simple Large Objects
              Deletion or Insertion of Simple Large Objects
              Size Limits for Simple Large Objects
            Blobspace Page Types
            Structure of a Blobspace Blobpage
          Sbspace Structure
            Structure of the metadata area
            Sbpage Structure
          Time Stamps
          Database and Table Creation: What Happens on Disk
            Database Creation
              Disk-Space Allocation for System Catalog Tables
              Tracking of System Catalog Tables
            Table Creation
              Disk-Space Allocation
              Entry in the Tblspace Tblspace
              Entries in the System Catalog Tables
              Creation of a Temporary Table
        Interpreting Logical-Log Records
          About Logical-Log Records
            Transactions That Drop a Table or Index
            Transactions That Are Rolled Back
            Checkpoints with Active Transactions
            Distributed Transactions
          Logical-Log Record Structure
            Logical-Log Record Header
            Logical-log record types and additional columns
            Log Record Types for Smart Large Objects
      Administrative Utilities
        Overview of Utilities
          Obtaining utility version information
          Setting local environment variables for utilities (UNIX)
        The finderr utility
        The genoncfg Utility
        The oncheck Utility
          oncheck Check-and-Repair
            What Does Each Option Do?
            Using the -y Option to Perform Repairs
            Repairing Indexes in Sbspaces and External Spaces
            Locking and oncheck
          oncheck utility syntax
          oncheck -cc and-pc: Check system catalog tables
          oncheck -cd and oncheck -cD commands: Check pages
          oncheck -ce, -pe: Check the chunk-free list
          oncheck -ci and -cI: Check index node links
          oncheck -cr and -cR: Check reserved pages
          oncheck -cs, -cS, -ps, -pS: Check and display sbspaces
          oncheck -pB: Display blobspace statistics
          oncheck -pd and pD: Display rows in hexadecimal format
          oncheck -pk, -pK, -pl, -pL: Display index information
          oncheck -pp and -pP: Display the contents of a logical page
          oncheck -pr and pR: Display reserved-page information
          oncheck -pt and -pT: Display tblspaces for a Table or Fragment
          Turn On Locking with -x
          Send Special Arguments to the Access Method with -u
          Return Codes on Exit
        The onclean utility
          The onshutdown script
        The oncmsm utility
        The onconfig_diff utility
        The ondblog utility
        The oninit utility
          The -FILE option
          Return codes for the oninit utility
        The onlog utility
        The onmode utility
          onmode command syntax
          onmode -a: Add a shared-memory segment
          onmode -BC: Allow large chunk mode
          onmode -c: Force a checkpoint
          onmode -C: Control the B-tree scanner
          onmode -cache surrogates: Cache the allowed.surrogates file
          onmode -d: Set data-replication types
          onmode -d: Set High Availability server characteristics
          onmode -d command: Replicate an index with data-replication
          onmode -D, -M, -Q, -S: Change decision-support parameters
          onmode -e: Change usage of the SQL statement cache
          onmode -F: Free unused memory segments
          onmode -I: Control diagnostics collection
          onmode -k, -m, -s, -u, -j: Change database server mode
            Taking the Database Server to Offline Mode with the -k Option
            Bringing the Database Server Online with the -m Option
            Shutting Down the Database Server Gracefully with the -s Option
            Shutting Down the Database Server Immediately with the -u Option
            Changing the Database Server to Administration Mode with the -j Option
          onmode -l: Switch the logical-log file
          onmode -n, -r: Change shared-memory residency
          onmode -O: Override ONDBSPACEDOWN WAIT mode
          onmode -p: Add or drop virtual processors
            Rules for adding and dropping virtual processors
            Monitoring poll threads with onstat
          onmode -P: Start, stop, or restart a listen thread dynamically
          onmode -R: Regenerate .infos.dbservername File
          onmode -W: Change settings for the SQL statement cache
            SQL statement cache examples
          onmode -we: Export a file that contains current configuration parameters
          onmode -wf, -wm: Dynamically change certain configuration parameters
            onmode -wm: Change LRU tuning status
          onmode -wi: Import a configuration parameter file
          onmode -Y: Dynamically change SET EXPLAIN
          onmode -z: Kill a database server session
          onmode -Z: Kill a distributed transaction
        The onparams Utility
          onparams syntax
          onparams -a -d dbspace: Add a logical-log file
          onparams -d -l lognum: Drop a logical-log file
          onparams -p: Change physical-log parameters
            Backing Up After You Change the Physical-Log Size or Location
            Changing the Size of the Physical Log and Using Non-Default Page Sizes
          onparams -b: Add a buffer pool
          Examples of onparams Commands
        The onpassword utility
        The ifxclone utility
        The onspaces utility
          onspaces syntax
          onspaces -a: Add a chunk to a dbspace or blobspace
          onspaces -a: Add a chunk to an sbspace
          onspaces -c -b: Create a blobspace
          onspaces -c -d: Create a dbspace
          onspaces -c -P: Create a plogspace
          onspaces -c -S: Create an sbspace
            Creating a Temporary Sbspace with the -t Option
            Creating an Sbspace with the -Df option
            Changing the -Df Settings
            Using the onspaces -g option
          onspaces -c -x: Create an extspace
          onspaces -ch: Change sbspace default specifications
          onspaces -cl: Clean up stray smart large objects in sbspaces
          onspaces -d: Drop a chunk in a dbspace, blobspace, or sbspace
          onspaces -d: Drop a space
          onspaces -f: Specify DATASKIP parameter
          onspaces -m: Start mirroring
            Using a File to Specify Chunk-Location Information with the -f Option
          onspaces -r: Stop mirroring
          onspaces -ren: Rename a dbspace, blobspace, sbspace, or extspace
            Renaming a dbspace, blobspace, sbspace, or extspace when Enterprise Replication is active
            Performing an Archive after Renaming a Space
          onspaces -s: Change status of a mirrored chunk
          Avoid overwriting a chunk
        The onstat utility
          onstat Utility Commands Sorted by Functional Category
          Monitor the database server status
          onstat command syntax
          onstat command: Equivalent to the onstat -pu command
          onstat - command: Print output header
          onstat -- command: Print onstat options and functions
          Running onstat Commands on a Shared Memory Dump File
          onstat -a command: Print overall status of the database server
          onstat -b command: Print buffer information for buffers in use
          onstat -B command: Prints information about used buffers
          onstat -c command: Print ONCONFIG file contents
          onstat -C command: Print B-tree scanner information
          onstat -d command: Print chunk information
          onstat -D command: Print page-read and page-write information
          onstat -f command: Print dbspace information affected by dataskip
          onstat -F command: Print counts
          onstat -g monitoring options
            onstat -g act command: Print active threads
            onstat -g afr command: Print allocated memory fragments
            onstat -g all command: Print diagnostic information
            onstat -g aqt command: Print data mart and accelerated query table information
            onstat -g arc command: Print archive status
            onstat -g ath command: Print information about all threads
            onstat -g bth and -g BTH: Print blocked and waiting threads
            onstat -g buf command: Print buffer pool profile information
            onstat -g cac command: Print information about caches
            onstat -g ckp command: Print checkpoint history and configuration recommendations
            onstat -g cfg command: Print the current values of configuration parameters
            onstat -g cluster command: Print high-availability cluster information
            onstat -g cmsm command: Print Connection Manager information
            onstat -g con command: Print condition and thread information
            onstat -g cpu: Print runtime statistics
            onstat -g dbc command: Print dbScheduler and dbWorker thread statistics
            onstat -g defragment command: Print defragment partition extents
            onstat -g dic command: Print table information
            onstat -g dis command: Print database server information
            onstat -g dll command: Print dynamic link library file list
            onstat -g dmp command: Print raw memory
            onstat -g dri command: Print high-availability data replication information
            onstat -g dsc command: Print distribution cache information
            onstat -g dsk command: Print the progress of the currently running compression operation
            onstat -g env command: Print environment variable values
            onstat -g ffr command: Print free fragments
            onstat -g glo command: Print global multithreading information
            onstat -g his command: Print SQL trace information
            onstat -g ioa command: Print combined onstat -g information
            onstat -g iob command: Print big buffer use summary
            onstat -g iof command: Print asynchronous I/O statistics
            onstat -g iog command: Print AIO global information
            onstat -g ioq command: Print I/O queue information
            onstat -g ipl command: Print index page logging status information
            onstat -g iov command: Print AIO VP statistics
            onstat -g lap command: Print light appends status information
            onstat -g laq command: Print secondary server queues
            onstat -g lmm command: Print low memory management information
            onstat -g lmx command: Print all locked mutexes
            onstat -g lsc command: Print active light scan status (deprecated)
            onstat -g mem command: Print pool memory statistics
            onstat -g mgm command: Print MGM resource information
            onstat -g nbm command: Print a block bit map
            onstat -g nsc command: Print current shared memory connection information
            onstat -g nsd command: Print poll threads shared-memory data
            onstat -g nss command: Print shared memory network connections status
            onstat -g ntd command: Print network statistics
            onstat -g ntm command: Print network mail statistics
            onstat -g ntt command: Print network user times
            onstat -g ntu command: Print network user statistics
            onstat -g opn command: Print open partitions
            onstat -g osi: Print operating system information
            onstat -g pd command: Print push data session-related information
            onstat -g pd event command: Print push data event-related information
            onstat -g pos command: Print file values
            onstat -g ppd command: Print partition compression dictionary information
            onstat -g ppf command: Print partition profiles
            onstat -g pqs command: Print operators for all SQL queries
            onstat -g prc command: Print sessions using UDR or SPL routines
            onstat -g proxy command: Print proxy distributor information
            onstat -g qst command: Print wait options for mutex and condition queues
            onstat -g rah command: Print read-ahead request statistics
            onstat -g rbm command: Print a block map of shared memory
            onstat -g rea command: Print ready threads
            onstat -g rss command: Print RS secondary server information
            onstat -g rwm command: Print read and write mutexes
            onstat -g sch command: Print VP information
            onstat -g scn command: Print scan information
            onstat -g sds command: Print SD secondary server information
            onstat -g seg command: Print shared memory segment statistics
            onstat -g ses command: Print session-related information
            onstat -g shard command: Print information about the shard definition
            onstat -g sle command: Print all sleeping threads
            onstat -g smb command: Print sbspaces information
            onstat -g smx command: Print multiplexer group information
            onstat -g spi command: Print spin locks with long spins
            onstat -g sql command: Print SQL-related session information
            onstat -g spf: Print prepared statement profiles
            onstat -g src command: Patterns in shared memory
            onstat -g ssc command: Print SQL statement occurrences
            onstat -g stk command: Print thread stack
            onstat -g stm command: Print SQL statement memory usage
            onstat -g stq command: Print queue information
            onstat -g sts command: Print stack usage for each thread
            onstat -g sym command: Print symbol table information for the oninit utility
            onstat -g tpf command: Print thread profiles
            onstat -g ufr command: Print memory pool fragments
            onstat -g vpcache command: Print CPU VP and tenant VP private memory cache statistics
            onstat -g wai command: Print wait queue thread list
            onstat -g wmx command: Print all mutexes with waiters
            onstat -g wst command: Print wait statistics for threads
          onstat -G command: Print TP/XA transaction information
          onstat -h command: Print buffer header hash chain information
          onstat -i command: Initiate interactive mode
          onstat -j command: Provide onpload status information
          onstat -k command: Print active lock information
          onstat -l command: Print physical and logical log information
          onstat -L command: Print the number of free locks
          onstat -m command: Print recent system message log information
          onstat -o command: Output shared memory contents to a file
          onstat -p command: Print profile counts
          onstat -P command: Print partition information
          onstat -r command: Repeatedly print selected statistics
          onstat -R command: Print LRU, FLRU, and MLRU queue information
          onstat -s command: Print latch information
          onstat -t and onstat -T commands: Print tblspace information
          onstat -u command: Print user activity profile
          onstat -x command: Print database server transaction information
            Determine the position of a logical-log record
            Determine the mode of a global transaction
          onstat -X command: Print thread information
          onstat -z command: Clear statistics
          Return codes on exiting the onstat utility
      SQL Administration API
        SQL Administration API Functions
          SQL Administration API Overview
            admin() and task() Function Syntax Behavior
            admin() and task() Argument Size Specifications
            admin() and task() Function Return Codes
          SQL administration API portal: Arguments by privilege groups
          add bufferpool argument: Add a buffer pool (SQL administration API)
          add chunk argument: Add a new chunk (SQL administration API)
          add log argument: Add a new logical log (SQL administration API)
          add memory argument: Increase shared memory (SQL administration API)
          add mirror argument: Add a mirror chunk (SQL administration API)
          alter chunk argument: Change chunk status to online or offline (SQL administration API)
          alter logmode argument: Change the database logging mode (SQL administration API)
          alter plog argument: Change the physical log (SQL administration API)
          archive fake argument: Perform an unrecorded backup (SQL administration API)
          autolocate database add argument: Add a dbspace to the dbspace list (SQL administration API)
          autolocate database anywhere argument: Add all dbspaces to the dbspace list (SQL administration API)
          autolocate database argument: Specify dbspaces for automatic location and fragmentation (SQL administration API)
          autolocate database off argument: Disable automatic fragmentation for a database (SQL administration API)
          autolocate database remove argument: Remove a dbspace from the dbspace list (SQL administration API)
          cdr argument: Administer Enterprise Replication (SQL administration API)
          cdr add trustedhost argument: Add trusted hosts (SQL administration API)
          cdr autoconfig serv argument: Autoconfigure connectivity and replication (SQL administration API)
          cdr list trustedhost argument: List trusted hosts (SQL administration API)
          cdr remove trustedhost argument: Remove trusted hosts (SQL administration API)
          check data argument: Check data consistency (SQL administration API)
          check extents argument: Check extent consistency (SQL administration API)
          check partition argument: Check partition consistency (SQL administration API)
          checkpoint argument: Force a checkpoint (SQL administration API)
          clean sbspace argument: Release unreferenced smart large objects (SQL administration API)
          create blobspace argument: Create a blobspace (SQL administration API)
          create blobspace from storagepool argument: Create a blobspace from the storage pool (SQL administration API)
          create chunk argument: Create a chunk (SQL administration API)
          create chunk from storagepool argument: Create a chunk from the storage pool (SQL administration API)
          create database argument: Create a database (SQL administration API)
          create dbaccessdemo argument: Create the demonstration database (SQL administration API)
          create dbspace argument: Create a dbspace (SQL administration API)
          create dbspace from storagepool argument: Create a dbspace from the storage pool (SQL administration API)
          create plogspace: Create a plogspace (SQL administration API)
          create sbspace argument: Create an sbspace (SQL administration API)
          create sbspace from storagepool argument: Create an sbspace from the storage pool (SQL administration API)
          create sbspace with accesstime argument: Create an sbspace that tracks access time (SQL administration API)
          create sbspace with log argument: Create an sbspace with transaction logging (SQL administration API)
          create tempdbspace argument: Create a temporary dbspace (SQL administration API)
          create tempdbspace from storagepool argument: Create a temporary dbspace from the storage pool (SQL administration API)
          create tempsbspace argument: Create a temporary sbspace (SQL administration API)
          create tempsbspace from storagepool argument: Create a temporary sbspace from the storage pool (SQL administration API)
          defragment argument: Dynamically defragment partition extents (SQL administration API)
          drop blobspace argument: Drop a blobspace (SQL administration API)
          drop blobspace to storagepool argument: Return space from an empty blobspace to the storage pool (SQL administration API)
          drop chunk argument: Drop a chunk (SQL administration API)
          drop chunk to storagepool argument: Return space from an empty chunk to the storage pool (SQL administration API)
          drop database argument: Drop a database (SQL administration API)
          drop dbspace argument: Drop a dbspace (SQL administration API)
          drop dbspace to storagepool argument: Return space from an empty dbspace to the storage pool (SQL administration API)
          drop log argument: Drop a logical log (SQL administration API)
          drop plogspace: Drop the plogspace (SQL administration API)
          drop sbspace argument: Drop an sbspace (SQL administration API)
          drop sbspace to storagepool argument: Return space from an empty sbspace to the storage pool (SQL administration API)
          drop tempdbspace argument: Drop a temporary dbspace (SQL administration API)
          drop tempdbspace to storagepool argument: Return space from an empty temporary dbspace to the storage pool (SQL administration API)
          drop tempsbspace to storagepool argument: Return space from an empty temporary sbspace to the storage pool (SQL administration API)
          export config argument: Export configuration parameter values (SQL administration API)
          file status argument: Display the status of a message log file (SQL administration API)
          grant admin argument: Grant privileges to run SQL administration API commands
          ha make primary argument: Change the mode of a secondary server (SQL administration API)
          ha rss argument: Create an RS secondary server (SQL administration API)
          ha rss add argument: Add an RS secondary server to a primary server (SQL administration API)
          ha rss change argument: Change the password of an RS secondary server (SQL administration API)
          ha rss delete argument: Delete an RS secondary server (SQL administration API)
          ha sds clear argument: Stop shared-disk replication (SQL administration API)
          ha sds primary argument: Convert an SD secondary server to a primary server (SQL administration API)
          ha sds set argument: Create a shared-disk primary server (SQL administration API)
          ha set idxauto argument: Replicate indexes to secondary servers (SQL administration API)
          ha set ipl argument: Log index builds on the primary server (SQL administration API)
          ha set primary argument: Define an HDR primary server (SQL administration API)
          ha set secondary argument: Define an HDR secondary server (SQL administration API)
          ha set standard argument: Convert an HDR server into a standard server (SQL administration API)
          ha set timeout argument: Change SD secondary server timeout (SQL administration API)
          import config argument: Import configuration parameter values (SQL administration API)
          index compress repack shrink arguments: Optimize the storage of B-tree indexes (SQL administration API)
          index estimate_compression argument: Estimate index compression (SQL administration API)
          master_key reset argument: Change the storage space encryption key (SQL administration API)
          message log delete argument: Delete a message log file (SQL administration API)
          message log rotate argument: Rotate the message log file (SQL administration API)
          message log truncate argument: Delete the contents of a message log file (SQL administration API)
          modify chunk extend argument: Extend the size of a chunk (SQL administration API)
          modify chunk extendable argument: Mark a chunk as extendable (SQL administration API)
          modify chunk extendable off argument: Mark a chunk as not extendable (SQL administration API)
          modify config arguments: Modify configuration parameters (SQL administration API)
          modify space expand argument: Expand the size of a space (SQL administration API)
          modify space sp_sizes argument: Modify sizes of an extendable storage space (SQL administration API)
          onbar argument: Backup the storage spaces (SQL administration API)
          onmode and a arguments: Add a shared-memory segment (SQL administration API)
          onmode and c arguments: Force a checkpoint (SQL administration API)
          onmode and C arguments: Control the B-tree scanner (SQL administration API)
          onmode and d arguments: Set data-replication types (SQL administration API)
          onmode and D arguments: Set PDQ priority (SQL administration API)
          onmode and e arguments: Change usage of the SQL statement cache (SQL administration API)
          onmode and F arguments: Free unused memory segments (SQL administration API)
          onmode and j arguments: Switch the database server to administration mode (SQL administration API)
          onmode and l arguments: Switch to the next logical log (SQL administration API)
          onmode and m arguments: Switch to multi-user mode (SQL administration API)
          onmode and M arguments: Temporarily change decision-support memory (SQL administration API)
          onmode and n arguments: Unlock resident memory (SQL administration API)
          onmode and O arguments: Mark a disabled dbspace as down (SQL administration API)
          onmode and p arguments: Add or remove virtual processors (SQL administration API)
          onmode and Q arguments: Set maximum number for decision-support queries (SQL administration API)
          onmode and r arguments: Force residency of shared memory (SQL administration API)
          onmode and S arguments: Set maximum number of decision-support scans (SQL administration API)
          onmode and W arguments: Reset statement cache attributes (SQL administration API)
          onmode and wf arguments: Permanently update a configuration parameter (SQL administration API)
          onmode and wm arguments: Temporarily update a configuration parameter (SQL administration API)
          onmode, wm, and AUTO_LRU_TUNING arguments: Change LRU tuning status (SQL administration API)
          onmode and Y arguments: Change query plan measurements for a session (SQL administration API)
          onmode and z arguments: Terminate a user session (SQL administration API)
          onmode and Z arguments: Terminate a distributed transaction (SQL administration API)
          onsmsync argument: Synchronize with the storage manager catalog (SQL administration API)
          onstat argument: Monitor the database server (SQL administration API)
          ontape archive argument: Backup the data on your database (SQL administration API)
          print error argument: Print an error message (SQL administration API)
          print file info argument: Display directory or file information (SQL administration API)
          print partition argument: Print partition information (SQL administration API)
          rename space argument: Rename a storage space (SQL administration API)
          reset config argument: Revert configuration parameter value (SQL administration API)
          reset config all argument: Revert all dynamically updatable configuration parameter values (SQL administration API)
          reset sysadmin argument: Move the sysadmin database (SQL administration API)
          restart listen argument: Stop and start a listen thread dynamically (SQL administration API)
          revoke admin argument: Revoke privileges to run SQL administration API commands
          scheduler argument: Stop or start the scheduler (SQL administration API)
          scheduler lmm enable argument: Specify automatic low memory management settings (SQL administration API)
          scheduler lmm disable argument: Stop automatic low memory management (SQL administration API)
          set chunk argument: Change the status of a chunk (SQL administration API)
          set dataskip argument: Start or stop skipping a dbspace (SQL administration API)
          set index compression argument: Change index page compression (SQL administration API)
          set onconfig memory argument: Temporarily change a configuration parameter (SQL administration API)
          set onconfig permanent argument: Permanently change a configuration parameter (SQL administration API)
          set sbspace accesstime argument: Control access time tracking (SQL administration API)
          set sbspace avg_lo_size argument: Set the average size of smart large objects (SQL administration API)
          set sbspace logging argument: Change the logging of an sbspace (SQL administration API)
          set sql tracing argument: Set global SQL tracing (SQL administration API)
          set sql tracing database argument: Change database tracing (SQL administration API)
          set sql tracing session argument: Control tracing for a session (SQL administration API)
          set sql tracing user argument: Control tracing for users (SQL administration API)
          set sql user tracing argument: Set global SQL tracing for a user session (SQL administration API)
          start json listener argument: Start the MongoDB API wire listener
          start listen argument: Start a listen thread dynamically (SQL administration API)
          start mirroring argument: Starts storage space mirroring (SQL administration API)
          stop json listener: Stop the wire listener
          stop listen argument: Stop a listen thread dynamically (SQL administration API)
          stop mirroring argument: Stops storage space mirroring (SQL administration API)
          storagepool add argument: Add a storage pool entry (SQL administration API)
          storagepool delete argument: Delete one storage pool entry (SQL administration API)
          storagepool modify argument: Modify a storage pool entry (SQL administration API)
          storagepool purge argument: Delete storage pool entries (SQL administration API)
          Table and fragment compress and uncompress operations (SQL administration API)
            table or fragment arguments: Compress data and optimize storage (SQL administration API)
            Output of the estimate compression operation (SQL administration API)
            purge compression dictionary arguments: Remove compression dictionaries (SQL administration API)
          tenant create argument: Create a tenant database (SQL Administration API)
          tenant drop argument: Drop a tenant database (SQL Administration API)
          tenant update argument: Modify tenant database properties (SQL Administration API)
      Appendixes
        Database server files
        Troubleshooting errors
          Collecting Diagnostics using onmode -I
          Creating Tracepoints
          Collecting data with the ifxcollect tool
        Event Alarms
          Using ALARMPROGRAM to Capture Events
            Setting ALRM_ALL_EVENTS
            Writing Your Own Alarm Script
            Customizing the ALARMPROGRAM Scripts
            Precautions for Foreground Operations in Alarm Scripts
            Interpreting event alarm messages
          Events in the ph_alert Table
          Event Alarm Parameters
          Event alarm IDs
            Severity 5 event alarms
          Connection Manager event alarm IDs
        Messages in the database server log
          How the Messages Are Ordered in This Chapter
            How to view these messages
            Message Categories
          Messages: A-B
            Aborting Long Transaction: tx 0xn.
            Affinitied VP mm to phys proc nn.
            Affinity not enabled for this server.
            Assert Failed: Error from SBSpace cleanup thread.
            Assert Failed: Short description of what failed Who: Description of user/session/thread running at the time Result: State of the affected database server entity Action: What action the database administrator should take See Also: DUMPDIR/af.uniqid containing more diagnostics.
            Begin re-creating indexes deferred during recovery.
            Building 'sysmaster' database requires ~mm pages of logical log. Currently there are nn pages available. Prepare to back up your logs soon.
            Building 'sysmaster' database...
          Messages: C
            Cannot Allocate Physical-log File, mm wanted, nn available.
            Cannot alter a table which has associated violations table.
            Cannot change to mode.
            Cannot Commit Partially Complete Transactions.
            Cannot create a user-defined VP class with 'SINGLE_CPU_VP' non-zero.
            Cannot create violations/diagnostics table.
            Cannot insert from the violations table to the target table.
            Cannot modify/drop a violations/diagnostics table.
            Cannot Open Dbspace nnn.
            Cannot Open Logical Log.
            Cannot Open Mirror Chunk pathname, errorno = nn.
            Cannot Open Primary Chunk pathname, errorno = nnn.
            Cannot Open Primary Chunk chunkname.
            Cannot open sysams in database name, iserrno number.
            Cannot open sysdistrib in database name, iserrno number.
            Cannot open system_table in database name, iserrno number.
            Cannot open systrigbody in database name, iserrno number.
            Cannot open systriggers in database name, iserrno number.
            Cannot open sysxtdtypes in database name, iserrno number.
            Cannot Perform Checkpoint, shut system down.
            Cannot Restore to Checkpoint.
            Cannot Rollback Incomplete Transactions.
            Cannot update pagezero.
            Cannot update syscasts in database name. Iserrno number.
            Can’t affinity VP mm to phys proc nn.
            Changing the sbspace minimum extent value: old value value1, new value value2.
            Checkpoint blocked by down space, waiting for override or shutdown.
            Checkpoint Completed: duration was n seconds.
            Checkpoint Page Write Error.
            Checkpoint Record Not Found in Logical Log.
            Chunk chunkname added to space spacename.
            Chunk chunkname dropped from space spacename.
            Chunk number nn pathname -- Offline.
            Chunk number nn pathname -- Online.
            The chunk pathname must have READ/WRITE permissions for owner and group.
            The chunk pathname must have owner-ID and group-ID set to informix.
            The chunk pathname will not fit in the space specified.
            Cleaning stray LOs in sbspace sbspacename.
            Completed re-creating indexes.
            Configuration has been grown to handle up to integer chunks.
            Configuration has been grown to handle up to integer dbslices.
            Configuration has been grown to handle up to integer dbspaces.
            Continuing Long Transaction (for COMMIT): tx 0xn.
            Could not disable priority aging: errno = number.
            Could not fork a virtual processor: errno = number.
            Create_vp: cannot allocate memory.
          Messages: D-E-F
            Dataskip is OFF for all dbspaces.
            Dataskip is ON for all dbspaces.
            Dataskip is ON for dbspaces: dbspacelist.
            Dataskip will be turned {ON|OFF} for dbspacename.
            DBSERVERALIASES exceeded the maximum limit of 32
            DBSPACETEMP internal list not initialized, using default.
            The DBspace/BLOBspace spacename is now mirrored.
            The DBspace/BLOBspace spacename is no longer mirrored.
            devname: write failed, file system is full.
            Dropping temporary tblspace 0xn, recovering nn pages.
            Dynamically allocated new shared memory segment (size nnnn).
            ERROR: NO "wait for" locks in Critical Section.
            Error building sysmaster database. See outfile.
            Error in dropping system defined type.
            Error in renaming systdist.
            Error removing sysdistrib row for tabid = tabid, colid = colid in database name. iserrno = number
            Error writing pathname errno = number.
            Error writing shmem to file filename (error). Unable to create output file filename errno=mm.Error writing filename errno=nn.
            Fail to extend physical log space.
            Fatal error initializing CWD string. Check permissions on current working directory. Group groupname must have at least execute permission on '.'.
            Fragments dbspacename1 dbspacename2 of table tablename set to non-resident.
            Forced-resident shared memory not available.
            Freed mm shared-memory segment(s) number bytes.
          Messages: G-H-I
            gcore pid; mv core.pid dir/core.pid.ABORT.
            I/O function chunk mm, pagenum nn, pagecnt aa --> errno = bb.
            I/O error, primary/mirror Chunk pathname -- Offline (sanity).
            Informix database_server Initialized - Complete Disk Initialized.
            Informix database_server Initialized - Shared Memory Initialized.
            Informix database_server Stopped.
            In-Place Alter Table. Perform EXECUTE FUNCTION sysadmin:task('table update_ipa', 'table_name','database');
            ERROR: Insufficient available disk in the root dbspace to increase the entire Configuration save area.
            Insufficient available disk in the root dbspace for the CM save area. Increase the size of the root dbspace in the ONCONFIG file and reinitialize the server.
            Internal overflow of shmid's, increase system max shared memory segment size.
          Messages: J-K-L-M
            Listener-thread err = error_number: error_message.
            Lock table overflow - user id mm session id nn.
            Logical-log File not found.
            Logical Log nn Complete.
            Logical logging vberror for type:subtype in (failed_system).
            Log Record: log = ll, pos = 0xn, type = type:subtype(snum), trans = xx
            Log record (type:subtype) at log nn, 0xn was not undone.
            Log record (type:subtype) failed, partnum pnum row rid iserrno num.
            Log record (type:subtype) in log nn, offset 0xn was not rolled back.
            Logical Recovery allocating nn worker threads thread_type.
            Logical Recovery Started.
            Maximum server connections number.
            Memory allocation error.
            Mirror Chunk chunkname added to space spacename. Perform manual recovery.
            Mixed transaction result. (pid=nn user=userid).
            mt_shm_free_pool: pool 0xn has blocks still used (id nn).
            mt_shm_init: can’t create resident/virtual segment.
            mt_shm_remove: WARNING: may not have removed all/correct segments.
          Messages: N-O-P
            Newly specified value of value for the pagesize in the configuration file does not match older value of value. Using the older value.
            Not enough main memory.
            Not enough logical-log files, Increase LOGFILES.
            The number of configured inline poll threads exceeds the number of CPU virtual processors.
            onconfig parameter parameter modified from old_value to new_value.
            oninit: Cannot have SINGLE_CPU_VP non-zero and number of CPU VPs greater than 1.
            oninit: Cannot have SINGLE_CPU_VP non-zero and user-defined VP classes.
            oninit: Fatal error in initializing ASF with 'ASF_INIT_DATA' flags asfcode = '25507'.
            Cannot alter a table which has associated violations table.
            oninit: Too many VPCLASS parameters specified.
            oninit: VPCLASS classname bad affinity specification.
            oninit: VPCLASS classname duplicate class name.
            oninit: VPCLASS classname illegal option.
            oninit: VPCLASS classname maximum number of VPs is out of the range 0-10000.
            oninit: VPCLASS classname name is too long. Maximum length is maxlength.
            oninit: VPCLASS classname number of VPs is greater than the maximum specified.
            oninit: VPCLASS classname number of VPs is out of the range 0-10000.
            onmode: VPCLASS classname name is too long. Maximum length is maxlength.
            Online Mode.
            onspaces: unable to reset dataskip.
            Open transaction detected when changing log versions.
            Out of message shared memory.
            Out of resident shared memory.
            Out of virtual shared memory.
            PANIC: Attempting to bring system down.
            Participant site database_server heuristically rolled back.
            Physical recovery complete: number pages examined, number pages restored.
            Physical recovery started at page (chunk:offset).
            Portions of partition partnum of table tablename in database dbname were not logged. This partition cannot be rolled forward.
            Possible mixed transaction result.
            Prepared participant site server_name did not respond.
            Prepared participant site server_name not responding.
          Messages: Q-R-S
            Quiescent Mode.
            Read failed. Table name, Database name, iserrno = number
            Recovery Mode.
            Recreating index: 'dbsname:"owner".tabname-idxname'.
            Rollforward of log record failed, iserrno = nn.
            Root chunk is full and no additional pages could be allocated to chunk descriptor page.
            scan_logundo: subsys ss, type tt, iserrno ee.
            Session completed abnormally. Committing tx id 0xm, flags 0xn.
            Session completed abnormally. Rolling back tx id 0xm, flags 0xn.
            semctl: errno = nn.
            semget: errno = nn.
            shmat: some_string os_errno: os_err_text.
            shmctl: errno = nn.
            shmdt: errno = nn.
            shmem sent to filename.
            shmget: some_str os_errno: key shmkey: some_string.
            Shutdown (onmode -k) or override (onmode -O).
            Shutdown Mode.
            Space spacename added.
            Space spacename dropped.
            Space spacename -- Recovery Begins(addr).
            Space spacename -- Recovery Complete(addr).
            Space spacename -- Recovery Failed(addr).
            sysmaster database built successfully.
            Successfully extend physical log space
          Messages: T-U-V
            This ddl operation is not allowed due to deferred constraints pending on this table and dependent tables.
            This type of space does not accept log files.
            TIMER VP: Could not redirect I/O in initialization, errno = nn.
            Too Many Active Transactions.
            Too many violations.
            Transaction Not Found.
            Transaction heuristically rolled back.
            Transaction table overflow - user id nn, process id nn.
            Unable to create output file filename errno = nn.
            Unable to extend nn reserved pages for purpose in root chunk.
            Unable to start SQL engine.
            Unable to open tblspace nn, iserrno = nn.
            The value of pagesize pagesize specified in the config file is not a valid pagesize. Use 2048, 4096 or 8192 as the value for PAGESIZE in the onconfig file and restart the server.
            Violations table is not started for the target table.
            Violations table reversion test completed successfully.
            Violations table reversion test failed.
            Violations table reversion test start.
            Violations tables still exist.
            Virtual processor limit exceeded.
            VPCLASS classname name is too long. Maximum length is maxlength.
            VPCLASS classname duplicate class name.
            VPCLASS classname Not enough physical procs for affinity.
          Messages: W-X-Y-Z
            WARNING: aio_wait: errno = nn.
            WARNING: Buffer pool size may cause database server to get into a locked state. Recommended minimum buffer pool size is num times maximum concurrent user threads.
            warning: Chunk time stamps are invalid.
            Warning: name_old is a deprecated onconfig parameter. Use name_new instead. See the release notes and the Informix Administrator's Reference for more information.
            Warning: name_old is a deprecated onconfig parameter. Use name_new instead.
            Warning: Unable to allocate requested big buffer of size nn.
            You are turning off smart large object logging.
          Messages: Symbols
            HH:MM:SS Informix database server Version R.VV.PPPPP Software Serial Number RDS#XYYYYYY.
            argument: invalid argument.
            function_name: cannot allocate memory.
          Conversion and reversion error messages
            Cannot revert new fragment expression for index index, tabid id.
            Cannot revert new table fragment expression for table with id id.
            The conversion of the database name has failed.
            Database name is not revertible...
            Database name: Must drop trigger (id = id_number) before attempting reversion.
            The dummy updates failed while converting database name. This may imply data corruption in the database. If so, restore the original database with the tape backup. For more information, see output_file.
            Error in slow altering a system table.
            Internal server error.
            Must drop long identifiers in table name in database name
            Must drop new database (name) before attempting reversion. Iserrno error_number
            Must drop new user defined statistics in database name, iserrno number
            The pload database contains load/unload jobs referring to long table names, column names, or database names. These jobs will not work as expected until they are redefined.
            Reversion canceled.
            There is a semi-detached index in this table, which cannot be reverted.
            WARNING: Target server version must have a certified Storage Manager installed after conversion/reversion and before bringing up server.
          Conversion and Reversion Messages for Enterprise Replication
            CDR reversion test failed; for details look in $INFORMIXDIR/etc/revtestcdr.out.
            Enterprise Replication is not ready for conversion. The Control and TRG send queues should be empty for conversion/reversion to proceed.
            Enterprise Replication should be in a stopped state for conversion/reversion to proceed.
            ...‘syscdr’ reversion failed; for details look in $INFORMIXDIR/etc/revcdr.out.
            'syscdr' conversion failed. For details, look in $INFORMIXDIR/etc/concdr.out.
            Syscdr should NOT contain new replicate sets for reversion to succeed.
            Syscdr should not contain replicates defined with the --floatieee option for reversion to succeed.
          Dynamic Log Messages
            Dynamically added log file logid to DBspace dbspace_number.
            Log file logid added to DBspace dbspace_number.
            Log file number logid has been dropped from DBspace dbspace_number.
            Log file logid has been pre-dropped.
            Pre-dropped log file number logid has been deleted from DBspace dbspace_number.
            ALERT: Because the oldest logical log (logid) contains records from an open transaction (transaction_address), the server is attempting to dynamically add a log file. But there is no space available. Please add a DBspace or chunk. Then complete the transaction as soon as possible.
            ALERT: The oldest logical log (logid) contains records from an open transaction (transaction_address). Logical logging will remain blocked until a log file is added. Add the log file with the onparams -a command, using the -i (insert) option, as in: onparams -a -d dbspace -s size -i. Then complete the transaction as soon as possible.
            Log file logid has been pre-dropped. It will be deleted from the log list and its space can be reused once you take level-0 archives of all BLOBspaces, Smart BLOBspaces and non-temporary DBspaces.
          Sbspace Metadata Messages
            Allocated number pages to Metadata from chunk number.
            Allocated number pages to Userdata from chunk number.
            Freeing reserved space from chunk number to Metadata.
            Freeing reserved space from chunk number to Userdata.
          Truncate Table Messages
            The table cannot be truncated if it has an open cursor or dirty readers.
            The table cannot be truncated. It has at least one non-empty child table with referential constraints.
        Limits in Informix
    DB-Access User's Guide
      What's new for DB-Access in IBM Informix, Version 12.10
      Getting started with DB-Access
        Requirements for the Informix server DB-Access utility
          Environment variables for DB-Access
        Requirements for the Informix Client Software Development Kit DB-Access utility
        Demonstration databases
          Creating a demonstration database
          dbaccessdemo command: Create demonstration databases
        Start DB-Access
          dbaccess command: Start DB-Access
            CONNECTION menu options
            DATABASE menu options
            QUERY-LANGUAGE menu options
            TABLE menu options
            Example: Start DB-Access for a database
            Example: Run a command file
            Example: View the Information Schema
            Example: Check for ANSI compliance
            Example: Show nonprintable characters in hexadecimal
          Run DB-Access in interactive mode without menus
            Connect to a database environment in interactive mode
      The full-screen menu interface
        The Query-language option
          SQL editor
          A system editor
          Statements that the Run option supports
          Redirect query results
          Choose an existing SQL statement
          Save the current SQL statement
          Support for SPL Routines
          What happens when errors occur
        The Database option
          List of available databases
          Retrieve nondefault locale information
          Close a database
        The Table option
          Display table information
        The Connection and Session options
          Implicit closures
      Appendixes
        How to read online help for SQL statements
        Demonstration SQL
          SQL files for the relational database model
            The alt_cat.sql command file
            The c_calls.sql command file
            The c_cat.sql command file
            The c_custom.sql command file
            The c_index.sql command file
            The c_items.sql command file
            The c_manuf.sql command file
            The c_orders.sql file
            The c_proc.sql command file
            The c_state command file
            The c_stock.sql command file
            The c_stores.sql command file
            The c_table.sql command file
            The c_trig.sql command file
            The c_type.sql command file
            The c_view1.sql command file
            The c_view2.sql command file
            The d_proc.sql command file
            The d_trig.sql command file
            The d_view.sql command file
            The del_stock.sql command file
            The ins_table.sql command file
            The sel_agg.sql command file
            The sel_all.sql command file
            The sel_group.sql command file
            The sel_join.sql command file
            The sel_ojoin1.sql command file
            The sel_ojoin2.sql command file
            The sel_ojoin3.sql command file
            The sel_ojoin4.sql command file
            The sel_order.sql command file
            The sel_sub.sql command file
            The sel_union.sql command file
            The upd_table.sql command file
          SQL files for the Dimensional Database Model
            The createdw.sql file
            The loaddw.sql file
          User-defined routines for the object-relational database model
    High-Performance Loader User's Guide
      High-Performance Loader overview
        Overview of HPL features
        The HPL data-load process
        The HPL data-unload process
        HPL loading modes
        HPL components
          The onpload utility
          The ipload utility
          The onpladm utility
          The onpload database
          Relationships among the parts of the HPL
        Environment variables needed for the HPL
          Preparing multiple onpload databases
          The PLCONFIG environment variable
          The PLOAD_SHMBASE environment variable
            Avoid shared-memory collision
            Set the PLOAD_SHMBASE environment variable
          The PLOAD_LO_PATH environment variable
          The PLOAD_SHMAT environment variable
        Architecture of the onpload utility
          The onpload utility deluxe-mode process
            Threads that the onpload utility uses
            Threads that the database server uses
          The onpload utility express-mode load process
          The onpload utility unload process
      Examples of loading and unloading jobs using the ipload utility
        Prepare to use the ipload utility
        Create a file of data
        Create a database
        The ipload utility
          Start the ipload utility
          Choose a project
          Check the ipload utility default values
            Look at the Defaults window
            Look at the Machines window
        Load Job windows
          Load Job Select window
          Load Job window
        Device-Array windows
          Device Array Selection window
          Device-Array Definition window
        Format windows
          Format Views window
          Record Formats window
          Format-Definition window
        Filter, Discard Records, and Logfile text boxes
        Map Views window
          Creating a map by using Map Views window
        Completing the Load Record Maps window
        Map-Definition window
          Associating each input item with a column of the database table
        Load Options window
        Running the ipload job
        Active Job window
        The ipload utility Generate options
          Use the information you created with the ipload example
          Preparing the Unload Job window
          Performing the unload job
      The ipload utility windows
        The ipload utility GUI or the onpladm command-line interface
          Start the ipload utility
        The ipload utility GUI
          The HPL main window
            Initial options on the HPL main window
            Options of the HPL main window
          Component-Selection windows
          Component-Definition windows
          Load Job and Unload Job windows
          Views windows
            Access views windows
            Available options in a Views window
              Search for a component in a Views window
              Expand the view in a Views window
          Selection-List windows
          Message windows
        The HPL ipload utility buttons
          The HPL ipload utility toolbar buttons
            The Browse button
            The Copy button
              Copying an existing format into a new format
            The Delete button
              Deleting an existing format
            The Notes button
              Creating a note
            The Print button
          The HPL ipload utility icon buttons
          Buttons at the bottom of the HPL ipload utility display
        The HPL online help
        The UNIX keyboard commands to move the cursor
      Define HPL projects
        HPL projects
        Project organization
        Select or create a project with the Projects window
          Defining a new project
          Selecting a project
            Selecting a project for a load or unload job
            Selecting a project to edit
      Configure the High-Performance Loader
        Configure the ipload utility
        Select a database server
          Selecting a database server
          Create the onpload database
        Modify the onpload default values
          The Defaults window
          Specifying the onpload defaults
        Selecting a driver
          The Drivers window
          Adding a custom-driver name
        Modify the machine description
          The Machines window
          Editing the description of a computer
          Adding a computer type to the Machines list
      Define device arrays
        Device arrays
        Multiple devices in a device array
        The Device-Array Selection window
          Creating a device array
          Opening an existing device array
        The Device-Array Definition window
          Adding, editing, and removing devices
            Adding devices to the device array
            Editing a device in the device array
            Deleting a device from the device array
      Define formats
        Formats
        Formats of supported datafile records
        Fixed-length records
          Creating a fixed format
            Data types allowed in a fixed format
          Editing a format
            Adding a new field description to the format
            Inserting a new field into the format
            Editing the description of a field
            Deleting a field description from the format
          Create a fixed format that uses carriage returns
          Create a fixed format that includes BYTE or TEXT data
            Inline data
            Data in a separate file
          Create a fixed format that includes Ext type or Simple LO data
            Fixed-length data
            Inline data
            Simple LO data in a separate file
        Delimited records
          Create a delimited format
            Data types allowed in a delimited format
          Create a delimited format that includes BYTE or TEXT data
          Create a delimited format with extended data types
        COBOL records
          Create a COBOL format
          Picture and usage descriptions
        Other formats
        Format options
          Modifying fixed and COBOL formats
          Modifying delimited-format options
            Testing the import of a CSV file
        Format Views window
      Define queries
        HPL queries
        Creating a query
          Using the Column Selection window
          Editing the WHERE clause
        Editing a query
        Exporting and importing queries
          Importing a query
          Exporting a query
        The Database Views window
      Define maps
        Load and unload maps
          The Map-Definition window
            The Table and Format panes
            Unassigned or multiple-assigned fields and columns
            Identical field names and column names
          Creating a load map
        Unload maps
          Creating an unload map
          Unload data by using functions
        Mapping options
          Defining the mapping options
          Set the mapping options
        Editing options
          Using the Delete button
          Using the Find button
          Using the Specs button
        Map Views window
          Seeing the load maps of a database
          Seeing selected load maps
      Define filters
        Filters
        Example of using filter
        Creating a filter
          Preparing the filter definition
        Modifying a filter
          Editing an existing filter
          Adding an item to the filter
          Inserting an item into the filter sequence
          Deleting a filter
        Filter views
        Filters with code-set conversion (GLS)
      Unload data from a database
        Unload jobs
        Components of the unload job
          Choose the database server
          Run multiple jobs
        The Unload Job windows
          Creating an unload job
          Run the unload job
            Problems during an unload job
          Specify to write to the end of the tape
          The command-line information
          Changing the unload options
          Editing an unload job
        Generate options for an unload job
      Load data to a database table
        Load jobs
        Components of the load job
          Choose the database server
          Run multiple jobs
          Prepare user privileges and the violations table
            Set user constraints
            Manage the violations and diagnostics tables
        The Load Job windows
          Creating a load job
          Run the load job
            Make a level-0 backup
            Problems during a load job
          Specify to read to the end of the tape
          The command-line information
          Changing the load options
          Editing a load job
        Generate options for a load job
      The Generate options of the ipload utility
        Overview of the ipload Generate options
        Tasks that generate load or unload components
        Generate from the Load Job window
          Generating a job from the Load Job window
        Generate from the Unload Job window
          Generating a job that uses a query
          Generating a job that unloads an entire table
        Generate from the Components menu
          The Generate window
            Generate group
            Format type group
          Generating load and unload components
          Using the No Conversion Job option
      The HPL browsing options
        Browsing options
          Preview data-file records
            Using the Record Browser window
              Reviewing data-file records in a selected format
              Searching and editing a format
              Editing a format
          Reviewing records that the conversion rejected
          Viewing the violations table
          View the status of a load job or unload job
            Viewing the log file
            Sample log file
      Manage the High-Performance Loader
        Manage modes, errors, and performance
        HPL modes
          The HPL deluxe mode
          The HPL express mode
          How the express and deluxe modes work
            Foreign-key constraints
            Comparison between an express-mode and a deluxe-mode load operation
        HPL load and unload errors
          Rejected records from the input file
          Constraint violations
          View error records
        HPL performance
          The onpload configuration parameters
          Express-mode limitations
          The onstat options for onpload
          Devices for the device array
          HPL usage tasks
            Reorganize computer configuration
            Alter the schema of a table
            Assess information for loading or unloading external data
          Settings for a no-conversion load or unload job
            Run no-conversion load jobs with tables with hidden columns
          An express-mode load with delimited ASCII
          HPL performance hints
            Choose an efficient format
            Ensure enough converter threads and VPs
            Ensure enough memory
            Ensure enough buffers of adequate size
            Increase the commit interval
        Limitation when using the Excalibur Text DataBlade Module indexes
      The onpload utility
        Overview of the onpload utility
        The onpload file name size limitations on UNIX
        Start the onpload utility
        Using the onpload utility
        The onpload utility syntax
        Set the onpload run mode with the -f option
          Type the onpload -f flags
          Interpret the onpload -d and -f options together
        Modify the size of onpload database parameters
          The onpload -i option
        Override the onpload database values
        Load data into collection data type columns
      The onpladm utility
        Overview of the onpladm utility
          The onpladm utility features
          Specification-file conventions
          Error handling
        Define onpladm utility jobs
          Create onpladm jobs
            Create conversion jobs
              Create conversion jobs by using a quick command
              Create conversion jobs by using detailed specification files
                Create a conversion-load job
                Create a conversion unload job
            Create no-conversion jobs
              Create no-conversion jobs by using a quick command
              Create no-conversion jobs by using detailed specification files
                Create a no-conversion load job
                Create a no-conversion unload job
          Modify a job by using a detailed specification file
          Describe a job
          List all jobs in a project
          Run a job
            The onpladm utility when referential constraints are on tables
          Delete a job
        Define device arrays
          Create a device array
          Modify a device array
          Describe a device array
          List project device arrays
          Deleting a device array
        Define maps
          Create maps
            Create a map by using a quick command
            Create a map with a detailed specification file
          Delete a map
          Describe a map
          Modify a map by using a detailed specification file
          List all maps in a project
        Define formats
          Create a format
          Modify a format by using a specification file
          Describe a format
          List all formats in a project
          Delete a format
        Define queries
          Creating a query
          Modify a query
          Describing a query
          List all queries in a project
          Delete a query
        Define filters
          Create a filter
          Modify a filter
          Describe a filter
          List all filters in a project
          Delete a filter
        Define projects
          Create a project
          Run all jobs in a project
          List all projects
          Delete a project
        Define machine types
          Create a machine type
          Modify a machine type
          Describe a machine
          List all existing machine types
          Delete a machine type
        Define database operations
          Create a database project
          Configure target-server attributes
            Set target-server attribute values
            List target-server defaults
      Appendixes
        The onpload database
          The defaults table in the onpload database
          The delimiters table in the onpload database
          The device table in the onpload database
          The driver table in the onpload database
          The filteritem table in the onpload database
          The filters table in the onpload database
          The formatitem table in the onpload database
          The formats table in the onpload database
          The language table in the onpload database
          The machines table in the onpload database
          The mapitem table in the onpload database
          The mapoption table in the onpload database
          The maps table in the onpload database
          The note table in the onpload database
          The project table in the onpload database
          The query table in the onpload database
          The session table in the onpload database
        High-Performance Loader configuration file
          HPL configuration parameter descriptions
          HPL configuration parameter file conventions
          The AIOBUFFERS configuration parameter
          The AIOBUFSIZE configuration parameter
          The CONVERTTHREADS configuration parameter
          The CONVERTVPS configuration parameter
          The HPLAPIVERSION configuration parameter
          The HPL_DYNAMIC_LIB_PATH configuration parameter
          The STRMBUFFERS configuration parameter
          The STRMBUFFSIZE configuration parameter
        Picture strings
          Alphanumeric pictures
          Numeric pictures
          Date pictures
        Match condition operators and characters
          Operator descriptions and examples
        Custom-conversion functions
          Custom conversion example
          The onpload conversion process
            Integrating custom conversion functions
            API functions
              The DBXget_source_value(fldname,buffer,buflen) routine
              The DBXget_dest_value(fldname,buffer,buflen) routine
              The DBXput_dest_value(fldname,buffer) routine
              The DBXget_dest_length(fldname) routine
        The onstat -j option
          Using the onstat -j option
        The HPL log-file and pop-up messages
          How HPL logfile messages are ordered
          HPL logfile message categories
          The HPL log-file messages
            Blob conversion error occurred on record record_num
            Cannot access database table table_name: SQL error error_num
            Cannot allocate shared memory
            Cannot allocate TLI memory for operating_system structure
            Cannot bind socket connection: errno= operating-system_error_num
            Cannot bind TLI connection: t_errno= t_error_num
            Cannot configure driver driver_name
            Cannot connect to message server: Socket error = UNIX_error_num
            Cannot connect to message server: TLI erro r= t_error_num, TLI event = t_event_num, errno = error_num
            Cannot connect to server_name: SQL error error_num, ISAM error error_num
            Cannot connect worker to server data stream
            Cannot disable table_name object constraints: SQL error error_num, ISAM error error_num
            Cannot disable primary-key constraint. Child-table references exist
            Cannot express load to logged table on HDR server server_name
            Cannot filter indexes for table table_name: SQL error error_num, ISAM error error_num
            Cannot find the shared library path in the plconfig file. Using the shared library from the default location library_location
            Cannot find the user-defined function user_func_name in the shared library: error error_num
            Cannot get systable info for table table_name: SQL error error_num, ISAM error error_num
            Cannot initialize shared library handling
            Cannot load code-set conversion file from file_name to file_name
            Cannot load mapping definitions
            Cannot load the shared library library_location
            Cannot locate delimiter in data file
            Cannot open
            Cannot open simple large object file: file_name, simple large object not loaded
            Cannot open database database_name: SQL error error_num, ISAM error error_num
            Cannot open file file_name: error number operating-system_error_num
            Cannot open TCP connection for server_name: errno operating-system_error_num
            Cannot perform express mode load on table with pseudo rowid
            Cannot perform express-mode load with rowsize = row_length > page_size
            Cannot read file file_name: AIO error code operating-system_error_num
            Cannot re-enable all objects: num_violations violations detected
            Cannot reorder query statement to align simple large objects or Ext Types
            Cannot reorder query statement to align blobs
            Cannot set mode of table_name objects from current_mode to final_mode mode: SQL error error_num, ISAM error error_num
            Cannot start violations table for table_name: SQL error error_num, ISAM error error_num
            Cannot stop violations table for table_name: SQL error error_num, ISAM error error_num
            Cannot unload to multiple devices when the given query cannot be executed in parallel
            Cannot write file file_name: AIO error code operating-system_error_num
            Code-set conversion overflow
            Conversion of onpload database failed due to error error_num
            Conversion of onpload database failed due to error error_num, run as user informix
            Custom conversion function function_name not found in shared library
            Discarded num_bytes null bytes from end of tape device device_name
            Environment variable variable_name expansion would overflow string
            Error accepting socket connection: errno = operating-system_error_num
            Error accessing file_name
            Error accessing format: SQL error error_num, ISAM error error_num
            Error accessing map map_name: SQL error error_num, ISAMerror error_num
            Error accessing sysmaster: SQL error error_num, ISAMerror error_num
            Error accessing table table_name: SQL error error_num, ISAM error error_num
            Error: AIO buffer size buffer_size is less than required minimum size size
            Error error_num closing current database
            Error operating-system_error_num closing file file_name
            Error error_num converting record field field_name to column column_name
            Error declaring cursor: could not get table info
            Error declaring cursor: SQL error error_num, ISAM error error_num
            Error describing unload query query_name: SQL error error_num, ISAM error error_num
            Error error_num initializing backend connection
            Error inserting into table table_name: SQL error error_num, ISAM error error_num
            Error listening for socket connection: t_errno = t_error_num errno = operating-system_error_num
            Error listening for TLI connection: t_errno = t_error_num errno = UNIX_error_num
            Error error_num on record record_num converting column column_name to record field field_name
            Error occurred on record %d reading pipe %s
            Error on close of server load session: SQL error error_num, ISAM error error_num
            Error opening cursor: SQL Error error_num
            Error preparing query: SQL error error_num
            Error preparing statement statement_name: SQL error error_num, ISAM error error_num
            Error preparing unload query query_name: SQL error error_num, ISAM error error_num
            Error error_num reading message queue
            Error operating-system_error_num reading TLI/socket connection
            Error error_num setting isolation level
            Error error_num writing message on message queue
            Error operating-system_error_num writing TLI/socket connection
            Error: Stream buffer size buffer_size is less than required minimum size size
            Exhausted all attempts to allocate shared-memory key.
            Fatal error: cannot execute pipe_name
            Fatal error: cannot load X resource
            Fatal error creating server load session: error error_num
            Fatal error getting stream buffer from server
            Fatal error in server row processing: SQL error error_num, ISAM error error_num
            File type device file file_name is not a regular (disk) file
            Got Interrupt: Shutting down
            Internal error: Cannot initialize AIO library
            Internal error: Cannot send message
            Internal error: error_num. Contact Tech Support
            Internal error: invalid message type error_num
            Internal error error_num reading queue
            Invalid count detected, might be due to abnormal BE shutdown
            Invalid code-set character: Cannot convert
            Invalid HEXASCII simple large object or extended type representation on record record_num
            Invalid HEXASCII simple large object representation in fieldname, record record_num
            Invalid project name project_name entered
            Invalid reject count detected, might be due to abnormal BE shutdown. Using last known reject count and proceeding
            Invalid session ID id_number
            Invalid tape header expecting -> tape_name
            Map map_name type is not a load map
            Method not supported by current driver
            MT cannot bind to vpid
            MT internal failure
            MT failure putting CPU online
            No insert permission on table table_name
            No mapping to simple large object field field_name
            onpload must run on the host host_name that contains the target database
            onpload terminated by signal
            Pipe type device file file_name is not a regular file
            Pload cannot reorder queries having expressions/aggregates and blobs/udts in the same select list
            Query contains unmapped simple large object column column_name: Cannot proceed
            Query for unload is not a select query.
            Record is too long to process: recnum record_num, length record_length, bufsize buffer_size
            Server interface error; expected num_input but got num_received instead
            SQL error error_num executing statement statement_name
            Simple large object or extended type conversion error occurred on record record_num
            Start record record_num is greater than number of records total_num read from input file_name
            Successfully loaded the shared library library_location
            Table table_name will be read-only until level-0 archive
            Tables with BLOBS cannot be loaded in High Performance Mode
            Tables with BLOBS or extended types cannot be loaded in Express mode
            Tables with simple large objects or extended types cannot be processed with no conversion (-fn)
            Tape header is larger than I/O buffer: tape header_length, I/O buffer_size
            Tape type device file file_name is not a character-special or block-special file
            There is no mapping to column column_name, which cannot accept null values
            Unable to load locale categories for locale locale_name: error error_num
            Unload query select item for the query_item expression needs to be assigned a name
            Write/read to/from tape until end of device
            Write to device (tape or pipe) device_name failed; no space left on device. AIO error error_num
          HPL logfile pop-up messages
            Cannot attach to server shared memory
            Cannot create shared-memory message queue: error error_num
            Cannot create shared-memory pool: errno UNIX_error_num
            Cannot initialize multithreaded library
            Cannot initialize shared memory: errno operating-system_error_num
            Cannot load X resource
            Cannot open. Enter (r)etry, (c)ontinue, (q)uit job when ready
            Cannot open log file log_file_name.
            Cannot start I/O. Enter (r)etry, (c)ontinue, (q)uit job when ready
            Fatal error: shared memory will conflict with server
            Incorrect database version. Make sure that it is upgraded properly
            Press ‘r’ when ready, ‘c’ to shutdown device or ‘q’ to quit
            Set the shared library path as an absolute path in the plconfig file
            Tables with blobs cannot be loaded in High-Performance Mode
            Write error. Enter (r)etry, (c)ontinue, (q)uit job when ready
        Custom drivers
          Add a custom driver to the onpload utility
            Adding the driver name to the onpload database
            Preparing the custom-driver code
              Preparing the file that provides the driver functionality
              Preparing the plcstdrv.c file
            Rebuilding the shared-library file
          Connect your code to onpload at run time
            Driver initialization
            Register driver functions
          An example of a custom driver
            The plcstdrv.c file
            Custom-driver code for MYDRIVER
          Available driver methods
            The PL_MTH_OPEN function
            The PL_MTH_CLOSE function
          Available API support functions
            The pl_inherit_methods(driver, methodtable) function
            The pl_set_method_function(methodtable, method, function) function
            The pl_driver_inherit(method) function
            The pl_get_recordlength() function
            The pl_set_informix_conversion(flag) function
            The pl_lock_globals() function
            The pl_reset_inherit_chain(method) function
        Run load and unload jobs on a Windows computer
          The onpladm utility on Windows
            Run the Run Job or Run Project commands
            Running onpladm on UNIX with the database server running on Windows
          Preparing jobs with the ipload utility on Windows computers
        Conversion and reversion scripts for HPL database migration
          Upgrade the High-Performance Loader onpload database
          Revert from the current onpload database
    InformixHQ Guide
      What's new in InformixHQ
      Architecture
      System Compatibility
      Getting Started
        Starting the InformixHQ Server
        Starting the InformixHQ Agent
        Logging in InformixHQ
      InformixHQ Concepts
      InformixHQ Server
        InformixHQ Server Configuration
        InformixHQ UI
          Adding Servers and Groups
          Exploring Groups
          Exploring Informix Database Servers
          Configuring Monitoring
          Configuring Alerting
          Custom Dashboards
          InformixHQ Server Settings
            Configuring Alerting Notification
            Creating Custom Reports
            Creating Custom Sensors
          User Settings
            Configuring User Alerting Notification
          Users and Permissions
      InformixHQ Agent
        InformixHQ Agent Configuration
      Frequently asked questions (FAQs) about InformixHQ
        High level architecture and functionality
        Getting Started
        Monitoring and the Repository Database
        Security
        Users and Permissions
    Performance Guide
      Performance basics
        Developing a basic approach to performance measurement and tuning
        Quick start for acceptable performance on a small database
        Performance goals
        Measurements of performance
          Throughput
            Ways to measure throughput
            Standard throughput benchmarks
          Response time
            Response time and throughput
            Response-time measurement
              Operating-system timing commands
              Operating-system tools for monitoring performance
              Timing functions within your application
          Cost per transaction
        Resource utilization and performance
          Resource utilization
          CPU utilization
          Memory utilization
          Disk utilization
        Factors that affect resource utilization
        Maintenance of good performance
      Performance monitoring and the tools you use
        Evaluate the current configuration
        Create a performance history
          The importance of a performance history
          Tools that create a performance history
            Operating-system tools
            Database server tools
              Performance information that the onstat utility displays
        Monitor performance with the OpenAdmin Tool (OAT) for Informix
        Monitor database server resources
          Monitor resources that impact CPU utilization
          Monitor memory utilization
          Monitor disk I/O utilization
            Using onstat -g to monitor I/O utilization
            Using the oncheck utility to monitor I/O utilization
        Monitor transactions
          Using the onlog utility to monitor transactions
          Using the onstat utility to monitor transactions
        Monitor sessions and queries
          Monitoring memory usage for each session
          Using the SET EXPLAIN statement
      Effect of configuration on CPU utilization
        UNIX configuration parameters that affect CPU utilization
          UNIX semaphore parameters
          UNIX file-descriptor parameters
          UNIX memory configuration parameters
        Windows configuration parameters that affect CPU utilization
        Configuration parameters and environment variables that affect CPU utilization
          Specifying virtual processor class information
            Setting the number of CPU VPs
            Disabling process priority aging for CPU VPs
            Specifying processor affinity
              Distributing computation impact
              Isolating AIO VPs from CPU VPs
              Avoiding a certain CPU
            Setting the number of AIO VPs
          Setting the MULTIPROCESSOR configuration parameter when using multiple CPU VPs
          Setting the SINGLE_CPU_VP configuration parameter when using one CPU VP
          Optimizing access methods
            Setting the value of OPTCOMPIND within a session
          Limiting PDQ resources in queries
          Limiting the performance impact of CPU-intensive queries
          Limiting the number of PDQ scan threads that can run concurrently
          Configuring poll threads
            Specifying the connection protocol
            Specifying virtual-processor classes for poll threads
            Specifying the number of connections and poll threads
            Improve connection performance and scalability
          Enabling fast polling
        Network buffer pools
          Network buffers
          Support for private network buffers
          Network buffer size
        Virtual processors and CPU utilization
          Adding virtual processors
          Monitoring virtual processors
            Using some onstat-g commands to monitor virtual processors
              Monitor virtual processors with the onstat-g glo command
              Monitor virtual processors with the onstat-g rea command
              Monitor virtual processors with the onstat-g ioq command
            Using SMI tables to monitor virtual processors
          Private memory caches
        Connections and CPU utilization
          Multiplexed connections and CPU utilization
          MaxConnect for multiple connections UNIX
      Effect of configuration on memory utilization
        Shared memory
          Resident portion of shared memory
          Virtual portion of shared memory
          Message portion of shared memory
          Buffer pool portion of shared memory
          Estimating the size of the resident portion of shared memory
          Estimating the size of the virtual portion of shared memory
          Estimating the size of the message portion of shared memory
          Configuring UNIX shared memory
          Freeing shared memory with onmode -F
        Configuration parameters that affect memory utilization
          Setting the size of the buffer pool, logical-log buffer, and physical-log buffer
            The BUFFERPOOL configuration parameter and memory utilization
            The DS_TOTAL_MEMORY configuration parameter and memory utilization
              Algorithm for determining DS_TOTAL_MEMORY
              Deriving a minimum for decision-support memory
              Deriving a working value for decision-support memory
                When the DS_TOTAL_MEMORY configuration parameter is set
                When the DS_TOTAL_MEMORY configuration parameter is not set
              Checking the derived value for decision-support memory
            The LOGBUFF configuration parameter and memory utilization
            The LOW_MEMORY_RESERVE configuration parameter and memory utilization
            The PHYSBUFF configuration parameter and memory utilization
          The LOCKS configuration parameter and memory utilization
          The RESIDENT configuration parameter and memory utilization
          The SHMADD and EXTSHMADD configuration parameters and memory utilization
          The SHMTOTAL configuration parameter and memory utilization
          The SHMVIRTSIZE configuration parameter and memory utilization
          The SHMVIRT_ALLOCSEG configuration parameter and memory utilization
          The STACKSIZE configuration parameter and memory utilization
        Configure and monitor memory caches
          Data-dictionary cache
            Data-dictionary configuration
          Data-distribution cache
            Data-distribution configuration
          Monitor and tune the SQL statement cache
            Prepared statements and the statement cache
            SQL statement cache configuration
            Number of SQL statement executions
              Monitoring the number of hits on the SQL statement cache
              Determining the number of nonshared entries in the SQL statement cache
            Monitoring and tuning the size of the SQL statement cache
              Changing the size of the SQL statement cache
              Too many single-use queries in the SQL statement cache
            Memory limit and size
            Multiple SQL statement cache pools
              Number of SQL statement cache pools
              Size of SQL statement cache pools and the current cache
            SQL statement cache information in onstat -g ssc output
        Session memory
        Data-replication buffers and memory utilization
        Memory latches
          Monitoring latches with command-line utilities
            Monitoring latches with onstat -p
            Monitoring latches with onstat -s
          Monitoring latches with SMI tables
        Encrypted values
      Effect of configuration on I/O activity
        Chunk and dbspace configuration
          Associate disk partitions with chunks
          Associate dbspaces with chunks
          Placing system catalog tables with database tables
        I/O for cooked files for dbspace chunks
          Direct I/O (UNIX)
          Direct I/O (Windows)
          Concurrent I/O (AIX only)
          Enabling the direct I/O or concurrent I/O option (UNIX)
          Confirming the use of the direct or concurrent I/O option (UNIX)
        Placement of critical data
          Consider separate disks for critical data components
          Consider mirroring for critical data components
            Consider mirroring the root dbspace
            Consider mirroring smart-large-object chunks
            Mirroring and its effect on the logical log
            Mirroring and its effect on the physical log
        Configuration parameters that affect critical data
        Configure dbspaces for temporary tables and sort files
          Creating temporary dbspaces
          Specify temporary tables in the DBSPACETEMP configuration parameter
          Override the DBSPACETEMP configuration parameter for a session
          Estimating temporary space for dbspaces and hash joins
          PSORT_NPROCS environment variable
        Configure sbspaces for temporary smart large objects
          Creating temporary sbspaces
          Specify which sbspaces to use for temporary storage
        Placement of simple large objects
          Advantage of blobspaces over dbspaces
          Blobpage size considerations
            Optimize blobspace blobpage size
            Obtain blobspace storage statistics
            Determine blobpage fullness with oncheck -pB output
              Interpreting blobpage average fullness
              Analyzing efficiency criteria with oncheck -pB output
        Factors that affect I/O for smart large objects
          Disk layout for sbspaces
          Configuration parameters that affect sbspace I/O
          onspaces options that affect sbspace I/O
            Sbspace extents
            Lightweight I/O for smart large objects
              Advantages of lightweight I/O for smart large objects
              Specifying lightweight I/O for smart large objects
            Logging
        Table I/O
          Sequential scans
          Light scans
          Unavailable data
        Configuration parameters that affect table I/O
          How DATASKIP affects table I/O
        Background I/O activities
          Configuration parameters that affect checkpoints
            RTO_SERVER_RESTART and its effect on checkpoints
              Automatic checkpoints, LRU tuning, and AIO virtual processor tuning
            CKPTINTVL and its effect on checkpoints
            LOGSIZE and LOGFILES and their effect on checkpoints
            Checkpoints and the physical log
            ONDBSPACEDOWN and its effect on checkpoints
          Configuration parameters that affect logging
            LOGBUFF and PHYSBUFF and their effect on logging
            LOGFILES and its effect on logging
              Calculating the space allocated to logical log files
            LOGSIZE and its effect on logging
              Estimating logical-log size when logging dbspaces
              Estimating the logical-log size when logging simple large objects
              Estimating the logical-log size when logging smart large objects
            DYNAMIC_LOGS and its effect on logging
            AUTO_LLOG and its effect on logging
            LTXHWM and LTXEHWM and their effect on logging
            TEMPTAB_NOLOG and its effect on logging
            SESSION_LIMIT_LOGSPACE and its effect on logging
            SESSION_LIMIT_TXN_TIME and its effect on logging
          Configuration parameters that affect page cleaning
            CLEANERS and its effect on page cleaning
            BUFFERPOOL and its effect on page cleaning
            RTO_SERVER_RESTART and its effect on page cleaning
          Configuration parameters that affect backup and restore
            ON-Bar configuration parameters
            ontape configuration parameters (UNIX)
          Configuration parameters that affect rollback and recovery
            OFF_RECVRY_THREADS and ON_RECVRY_THREADS and their effect on fast recovery
            PLOG_OVERFLOW_PATH and its effect on fast recovery
            RTO_SERVER_RESTART and its effect on fast recovery
            The LOW_MEMORY_RESERVE configuration parameter and memory utilization
          Configuration parameters that affect data replication and auditing
            Configuration parameters that affect data replication
            Configuration parameters that affect auditing
          LRU tuning
      Table performance considerations
        Placing tables on disk
          Isolating high-use tables
          Placing high-use tables on middle partitions of disks
          Using multiple disks
            Using multiple disks for a dbspace
            Using multiple disks for logical logs
            Spreading temporary tables and sort files across multiple disks
          Backup and restore considerations when placing tables on disks
          Factors affecting the performance of nonfragmented tables and table fragments
        Estimating table size
          Estimating data pages
            Estimating tables with fixed-length rows
            Estimating tables with variable-length rows
            Selecting an intermediate value for the size of the table
          Estimating pages that simple large objects occupy
            Storing simple large objects in the tblspace or a separate blobspace
            Estimating tblspace pages for simple large objects
        Managing the size of first and next extents for the tblspace tblspace
        Managing sbspaces
          Estimating pages that smart large objects occupy
            Estimating the size of the sbspace and metadata area
            Sizing the metadata area manually for a new chunk
              Example of calculating the metadata area for a new chunk
          Improving metadata I/O for smart large objects
          Monitoring sbspaces
            Monitoring sbspaces with oncheck -cS
            Monitoring sbspaces with oncheck -pe
            Monitoring sbspaces with oncheck -pS
            Monitoring sbspaces with onstat -g smb
          Changing storage characteristics of smart large objects
            Altering smart-large-object columns
        Managing extents
          Choosing table extent sizes
            Extent sizes for tables in a dbspace
            Extent sizes for table fragments
            Extent sizes for smart large objects in sbspaces
          Monitoring active tblspaces
          Monitoring the upper limit on extents and extent interleaving
            Considering the upper limit on extents
            Checking for extent interleaving
            Eliminating interleaved extents
              Reorganizing dbspaces and tables to eliminate extent interleaving
              Creating or altering an index to cluster
              Using ALTER TABLE to eliminate extent interleaving
          Reclaiming unused space within an extent
            Reclaiming space in an empty extent with ALTER INDEX
            Reclaiming space in an empty extent by unloading and re-creating or reloading a table
            Releasing space in an empty extent with ALTER FRAGMENT
          Managing extent deallocation with the TRUNCATE keyword
          Defragment partitions to merge extents
        Storing multiple table fragments in a single dbspace
        Displaying a list of table and index partitions
        Changing tables to improve performance
          Loading and unloading tables
            Advantages of logging tables
            Advantages of nonlogging tables
              Quickly loading a large standard table
              Quickly loading a new nonlogging table
          Dropping indexes for table-update efficiency
          Creating and enabling referential constraints efficiently
          Attaching or detaching fragments
          Altering a table definition
            Slow alter
            In-place alter
              Conditions for in-place alter operations
              Performance considerations for DML statements
              Performance of in-place alters for DDL operations
              Altering a column that is part of an index
            Fast alter
        Denormalize the data model to improve performance
          Shortening rows
          Expelling long strings
            Convert CHAR columns into VARCHAR columns to shorten rows (GLS)
            Convert a long string to a TEXT data type column
            Move strings to a companion table
            Build a symbol table
          Splitting wide tables
          Redundant data
            Adding redundant data
        Reduce disk space in tables with variable length rows
        Reduce disk space by compressing tables and fragments
      Indexes and index performance considerations
        Types of indexes
          B-tree indexes
            Structure of conventional index pages
          Forest of trees indexes
          R-tree indexes
          Indexes that DataBlade modules provide
        Estimating index pages
          Index extent sizes
            Formula for estimating the extent size of an attached index
            Formula for estimating the extent size of a detached index
          Estimating conventional index pages
        Managing indexes
          Space costs of indexes
          Time costs of indexes
          Unclaimed index space
          Indexes on columns
            Filtered columns in large tables
            Order-by and group-by columns
            Avoiding columns with duplicate keys
            Clustering
              Configuration parameters that affect the degree of clustering
          Nonunique indexes
        Improve query performance with a forest of trees index
          Detecting root node contention
          Creating a forest of trees index
          Disabling and enabling a forest of trees index
          Performing a range scan on a forest of trees index
          Determining if you are using a forest of trees index
          Finding the number of hashed columns and subtrees in a forest of trees index
        Creating and dropping an index in an online environment
          When you cannot create or drop indexes online
          Creating attached indexes in an online environment
          Limiting memory allocation while creating indexes online
        Improving performance for index builds
          Estimating memory needed for sorting
          Estimating temporary space for index builds
        Storing multiple index fragments in a single dbspace
        Improving performance for index checks
        Indexes on user-defined data types
          Defining indexes for user-defined data types
            B-tree secondary-access method
              Uses for a B-tree index
              Extending a generic B-tree index
            Identifying the available access methods
            User-defined secondary-access methods
              R-tree indexes
            Using a functional index
              What is a functional index?
              When is a functional index used?
              Creating a functional index
          Using an index that a DataBlade module provides
          Choosing operator classes for indexes
            Operator classes
              Strategy and support functions of a secondary access method
              Default operator classes
            Built-in B-tree operator class
              B-tree strategy functions
              B-tree support function
            Identifying the available operator classes
            User-defined operator classes
      Locking
        Locks
          Locking granularity
          Row and key locks
            Key-value locks
          Page locks
          Table locks
          Database locks
        Configuring the lock mode
        Setting the lock mode to wait
        Locks with the SELECT statement
          Isolation level
            Dirty Read isolation
            Committed Read isolation
              Ways to reduce the risk of Committed Read isolation level conflicts
            Cursor Stability isolation
            Repeatable Read isolation
          Locking nonlogging tables
          Update cursors
        Locks placed with INSERT, UPDATE, and DELETE statements
        The internal lock table
        Monitoring locks
          Configuring and managing lock usage
          Monitoring lock waits and lock errors
          Monitoring the number of free locks
          Monitoring deadlocks
          Monitoring isolation levels that sessions use
        Locks for smart large objects
          Byte-range locking
            How the database server manages byte-range locks
            Using byte-range locks
            Monitoring byte-range locks
            Setting number of locks for byte-range locking
          Lock promotion
          Dirty Read isolation level and smart large objects
      Fragmentation guidelines
        Planning a fragmentation strategy
          Fragmentation goals
            Improved query performance through fragmentation strategy
            Reduced contention between queries and transactions
            Increased data availability
            Increased granularity for backup and restore
          Examining your data and queries
          Considering physical fragmentation factors
        Distribution schemes
          Choosing a distribution scheme
          Designing an expression-based distribution scheme
          Suggestions for improving fragmentation
        Strategy for fragmenting indexes
          Attached indexes
          Detached indexes
          Restrictions on indexes for fragmented tables
        Strategy for fragmenting temporary tables
        Distribution schemes that eliminate fragments
          Fragmentation expressions for fragment elimination
          Query expressions for fragment elimination
            Range expressions in query
            Equality expressions in query
          Effectiveness of fragment elimination
            Nonoverlapping fragments on a single column
            Overlapping fragments on a single column
            Nonoverlapping fragments, multiple columns
        Improve the performance of operations that attach and detach fragments
          Improving ALTER FRAGMENT ATTACH performance
            Distribution schemes for reusing indexes
              Fragmenting the index in the same way as the table
              Fragmenting the index with the same distribution scheme as the table
              Attaching unfragmented tables together
            Ensuring no data movement when you attach a fragment
            Indexes on attached tables
              Example for situation when corresponding index does not exist
              Example for situation when index on table is not usable
          Improving ALTER FRAGMENT DETACH performance
            Fragmenting the index in the same way as the table
            Fragmenting the index using same distribution scheme as the table
          Forcing out transactions when altering table fragments
        Monitoring Fragment Use
          Monitoring fragmentation with the onstat -g ppf command
          Monitoring fragmentation with SET EXPLAIN output
      Queries and the query optimizer
        The query plan
          The access plan
          The join plan
            Nested-loop join
            Hash join
            Join order
          Example of query-plan execution
            Example of a join with column filters
            Example of a join with indexes
          Query plans that include an index self-join path
          Query plan evaluation
          Report that shows the query plan chosen by the optimizer
            The explain output file
            Query statistics section provides performance debugging information
          Sample query plan reports
            Single-table query
            Multitable query
            Key-first scan
            Query plans for subqueries
            Query plans for collection-derived tables
              Example showing how the database server completes the query
              Derived tables folded into parent queries
          XML query plans in IBM Data Studio
        Factors that affect the query plan
          Statistics held for the table and index
          Filters in the query
          Indexes for evaluating a filter
          Effect of PDQ on the query plan
          Effect of OPTCOMPIND on the query plan
            Single-table query
            Multitable query
          Effect of available memory on the query plan
        Time costs of a query
          Memory-activity costs
          Sort-time costs
          Row-reading costs
          Sequential access costs
          Nonsequential access costs
          Index lookup costs
            Reading duplicate values from an index
            Searching for NCHAR or NVARCHAR columns in an index
          In-place ALTER TABLE costs
          View costs
          Small-table costs
          Data-mismatch costs
          Encrypted-value costs
          GLS functionality costs
          Network-access costs
        Optimization when SQL is within an SPL routine
          SQL optimization
            Displaying the execution plan
            Automatic reoptimization
            Reoptimizing SPL routines
            Optimization levels for SQL in SPL routines
          Execution of an SPL routine
          SPL routine executable format stored in UDR cache
            Adjust the UDR cache
        Trigger execution
          Performance implications for triggers
            SELECT triggers on tables in a table hierarchy
            SELECT triggers and row buffering
      Optimizer directives
        What optimizer directives are
          Optimizer directives that are embedded in queries
          External optimizer directives
        Reasons to use optimizer directives
        Preparation for using directives
        Guidelines for using directives
        Types of optimizer directives that are supported in SQL statements
          Access-method directives
          Join-order directives
            Effect of join order on join plan
            Join order when you use views
          Join-method directives
          Optimization-goal directives
          Star-join directives
          EXPLAIN directives
          Example of directives that can alter a query plan
        Configuration parameters and environment variables for optimizer directives
        Optimizer directives and SPL routines
        Forcing reoptimization to avoid an index and previously prepared statement problem
        External optimizer directives
          Creating and saving external directives
          Enabling external directives
          Deleting external directives
      Parallel database query (PDQ)
        What PDQ is
        Structure of a PDQ query
        Database server operations that use PDQ
          Parallel update and delete operations
          Parallel insert operations
            Explicit inserts with SELECT...INTO TEMP statements
            Implicit inserts with INSERT INTO...SELECT statements
          Parallel index builds
          Parallel user-defined routines
          Hold cursors that use PDQ
          SQL operations that do not use PDQ
          Update statistics operations affected by PDQ
          SPL routines and triggers and PDQ
          Correlated and uncorrelated subqueries
          OUTER index joins and PDQ
          Remote tables used with PDQ
        The Memory Grant Manager
        The allocation of resources for parallel database queries
          Limiting the priority of decision-support queries
            Limiting the value of the PDQ priority
            Maximizing OLTP throughput for queries
            Conserving resources when using PDQ
            Allowing maximum use of parallel processing
            Determining the level of parallel processing
            Limits on parallel operations associated with PDQ priority
            Using SPL routines with PDQ queries
          Adjusting the amount of memory for DSS and PDQ queries
          Limiting the number of concurrent scans
          Limiting the maximum number of PDQ queries
        Managing PDQ queries
          Analyzing query plans with SET EXPLAIN output
          Influencing the choice of a query plan
          Setting the PDQ priority dynamically
          Enabling the database server to allocate PDQ memory
          User control of PDQ resources
          DBA control of resources for PDQ and DSS queries
            Controlling resources allocated to PDQ
            DBA control of resources allocated to decision-support queries
        Monitoring resources used for PDQ and DSS queries
          Using the onstat Utility
            Monitoring PDQ threads with onstat utility commands
            Monitoring resources allocated for a session running a DSS query
          Identifying parallel scans in SET EXPLAIN output
      Improving individual query performance
        Test queries using a dedicated test system
        Display the query plan
        Improve filter selectivity
          Filters with user-defined routines
          Avoid some filters
            Avoid difficult regular expressions
            Avoid noninitial substrings
          Use join filters and post-join filters
        Automatic statistics updating
          How AUS works
          AUS expiration policies
            Changing AUS expiration policies
          Viewing AUS statements
          Prioritizing databases in AUS
          Rescheduling AUS
          Disabling AUS
        Update statistics when they are not generated automatically
          Update the statistics for the number of rows
          Drop data distributions if necessary when upgrading
            Drop distributions in LOW mode without gathering statistics
          Creating data distributions
          Updating statistics for join columns
          Updating statistics for columns with user-defined data types
          Update statistics in parallel on very large databases
          Adjust the amount of memory and disk space for UPDATE STATISTICS
          Data sampling during update statistics operations
          Display data distributions
        Improve performance by adding or removing indexes
          Replace autoindexes with permanent indexes
          Use composite indexes
          Indexes for data warehouse applications
          Configure B-tree scanner information to improve transaction processing
            Alice scan mode values
            Leaf and range scan mode settings
            B-tree scanner index compression levels and transaction processing performance
            Setting the level for B-tree scanner compression of indexes
          Determine the amount of free space in an index page
        Optimizer estimates of distributed queries
          Buffer data transfers for a distributed query
          The query plan of a distributed query
        Improve sequential scans
        Enable view folding to improve query performance
        Reduce the join and sort operations
          Avoid or simplify sort operations
          Use parallel sorts
          Use temporary tables to reduce sorting scope
          Configuring memory for queries with hash joins, aggregates, and other memory-intensive elements
        Optimize user-response time for queries
          Optimization level
          Optimization goals
            Specifying the query performance goal
            Preferred query plans for user-response-time optimization
              Nested-loop joins versus hash joins
              Table scans versus index scans
              Ordering with fragmented indexes
        Optimize queries for user-defined data types
          Parallel UDRs
          Selectivity and cost functions
          User-defined statistics for UDTs
          Negator functions
        Optimize queries with the SQL statement cache
          When to use the SQL statement cache
          Using the SQL statement cache
            Enabling the SQL statement cache
            Placing statements in the cache
          Monitoring memory usage for each session
            Display all user threads and session memory usage
            Display detailed session information and memory usage
            Display information about session SQL statements
            Display information about the memory that SQL statements use in a session
          Monitoring usage of the SQL statement cache
        Monitor sessions and threads
          Monitor sessions and threads with onstat commands
            Monitor blocking threads with the onstat -g bth and onstat -g BTH commands
            Monitor threads with onstat –u output
            Monitor threads with onstat -g ath output
            Monitor threads with onstat -g act output
            Monitor threads with onstat -g cpu output
            Monitor session resources with onstat -g ses output
            Monitor session memory with onstat -g mem and onstat -g stm output
          Monitor sessions and threads with SMI tables
        Monitor transactions
          Display information about transactions
          Display information about transaction locks
          Display statistics on user sessions
          Display Statistics on Sessions Executing SQL Statements
      The onperf utility on UNIX
        Overview of the onperf utility
          Basic onperf utility functions
            Display metric values
            Save metric values to a file
            Review metric measurements
          onperf utility tools
        Requirements for running the onperf utility
        Starting the onperf utility and exiting from it
        The onperf user interface
          Graph tool
            Graph-tool title bar
            Graph-tool graph menu
            Graph-tool metrics menu
            Graph-tool view menu
            The graph-tool Configure menu and the Configuration dialog box
            Graph-tool Tools menu
            Changing the scale of metrics
            Displaying recent-history values
          Query-tree tool
          Status tool
          Activity tools
        Why you might want to use onperf
          Routine monitoring with onperf
          Diagnosing sudden performance loss
          Diagnosing performance degradation
        onperf utility metrics
          Database server metrics
          Disk-chunk metrics
          Disk-spindle metrics
          Physical-processor metrics
          Virtual-processor metrics
          Session metrics
          Tblspace metrics
          Fragment metrics
      Appendix
        Case studies and examples
          Case study of a situation in which disks are overloaded
    SNMP Subagent Guide
      SNMP concepts
        What is SNMP?
        Purpose of the SNMP
        The SNMP architecture
          SNMP network managers
          Master agents
          Subagents
          Managed components
          Management Information Bases
      Informix implementation of SNMP
        Components of the Informix implementation
        Purpose of Informix SNMP
          Event notification
          Data requests
          Traps
          Information that OnSNMP provides
        SNMP standard
        SNMP architecture
        Informix implementation of SNMP on UNIX or Linux
          The runsnmp.ksh script
          UNIX master agents
            Assuring compatibility
            Installing and configuring a master agent manually
            Starting and stopping a master agent
              Starting a master agent manually
              Stopping a master agent manually
              Making sure that a master agent is running correctly
          UNIX subagent
          UNIX server discovery process
            Preparing onsrvapd manually
            Issue the onsrvapd command
              Starting onsrvapd manually
              Making sure that onsrvapd is running correctly
            Choose an installation directory
        Informix implementation of SNMP on Windows
          Windows master agent
          Windows subagent
            Start and stop OnSNMP
            Configure OnSNMP
            Windows registry key for the OnSNMP logging level
          Windows server discovery process
            Start and stop onsrvapd
            Installing the Informix SNMP agent
        GLS and SNMP
        MIB types and objects
        Table indexing
          Numeric index values
          Alphabetical index values
        Refresh control value
        Files installed for SNMP
          Files installed on UNIX or Linux
          Files installed on Windows
      Management Information Base reference
        Application MIB
          applTable
        RDBMS MIB
          rdbmsDbInfoTable
          rdbmsDbTable
          rdbmsRelTable
          rdbmsSrvInfoTable
          rdbmsSrvLimitedResourceTable
          rdbmsSrvParamTable
          rdbmsSrvTable
          rdbmsTraps
            frdbmsStateChange trap
        Online MIB in the Informix Private MIB
          onActiveBarTable
          onActiveTableTable
          onBarTable
          onChunkTable
          onDatabaseTable
          onDbspaceTable
          onErQueueTable
          onErSiteTable
          onFragmentTable
          onLockTable
          onLogicalLogTable
          onPhysicalLogTable
          onServerTable
          onSessionTable
          onSqlHostTable
          onTableTable
  Backup and restore
    Backup and Restore Guide
      What's New in the Backup and Restore Guide, Version 12.10
      Overview of backup and restore
        Backup and restore concepts
          Recovery system
            Backup systems
            Backup levels
            Logical-log backup
              Manual and continuous logical-log backups
              Log salvage
              Save logical-log backups
            Restore systems
              Physical and logical restores
              Warm, cold, and mixed restores
              Continuous log restore
          Comparison of the ON-Bar and ontape utilities
        Plan for backup and restore
          Plan a recovery strategy
            Types of data loss
            Determine failure severity
            Data use determines your backup schedule
            Schedule backups
            Security requirements for label-based access control
          Plan a backup system for a production database server
            Evaluate hardware and memory resources
            Evaluate backup and restore time
            Evaluate logging and transaction activity
            Compress row data
            Transform data with external programs
      ON-Bar backup and restore system
        Overview of the ON-Bar backup and restore system
          ON-Bar components
            Backup Services API (XBSA)
            ON-Bar catalog tables
            ixbar file: ON-Bar emergency boot file
            bar_act.log file: ON-Bar activity log
            ON-Bar script
        Configure the storage manager and ON-Bar
          Configure a storage manager
            Storage-manager definitions in the sm_versions file
            Configuring TSM
              Editing the TSM client options files
                Editing the TSM client user options file
                Editing the TSM client system options file
              Assigning a TSM management class for a backup
              Setting the HCL Informix Interface for TSM environment variables
              Registering with the TSM server
              Initializing the HCL Informix Interface for TSM password
              Updating the storage-manager definition in the sm_versions file for TSM
              Configuring ON-Bar for optional TSM features
            Configuring a third-party storage manager
          Validating your storage manager
          Configuring ON-Bar
            ON-Bar security
          Verifying the configuration of ON-Bar and your storage manager
          Files that ON-Bar and storage managers use
        Back up with ON-Bar
          Preparing to back up data
            Administrative files to back up
          onbar -b syntax: Backing up
            List of storage spaces in a file
            Backing up blobspaces
          onbar -m syntax: Monitoring recent ON-Bar activity
          Viewing a list of registered backups
          onbar -P syntax: Printing backed-up logical logs
          onbar -v syntax: Verifying backups
            Temporary space for backup verification
            Verification failures
              Diagnosing why a backup failed verification
              Verifying an expired backup
              Restoring when a backup is missing data
        Restore data with ON-Bar
          Pre-restore checklist
            Storage space status and required actions
          Storage device availability
          onbar -r syntax: Restoring data
            Avoid salvaging logical logs
            Performing a cold restore
            Configuring a continuous log restore by using ON-Bar
            Restoring data by using a mixed restore
              Strategies for using a mixed restore
            Recreating chunk files during a restore
              Restoring when using cooked chunks
              Restoring when using raw chunks
            Reinitializing the database server and restoring data
          Replacing disks during a restore
            Renaming a chunk to a nonexistent device
          Restoring to a different computer
          onbar -RESTART syntax: Restarting a failed restore
          Resolve a failed restore
        External backup and restore
          External backup and restore overview
            Block before backing up
            Rules for an external backup
            Prepare for an external backup
              Block and unblock database server
              Track an external backup
            Performing an external backup when chunks are not mirrored
          RS secondary server external backup
            Performing an external backup of an RS secondary server
          Data restored in an external restore
            Rename chunks
            External restore commands
            Rules for an external restore
          Performing an external restore
            Performing a cold external restore
            Performing a warm external restore
            Examples of external restore commands
          Initializing HDR with an external backup and restore
        Customize and maintain ON-Bar
          Customizing ON-Bar and storage-manager commands
            Updating the ON-Bar script during reinstallation
            Print the backup boot files
            Migrate backed-up logical logs to tape
          Expire and synchronize the backup catalogs
            Choose an expiration policy
            The onsmsync utility
              Regenerate the emergency boot file
              Regenerate the sysutils database
              Delete a bad backup
              Expire backups based on the retention date
              Expire a generation of backups
              Expire backups based on the retention interval
              Expire backups with multiple point-in-time restores
              Expire all backups
          Monitor the performance of ON-Bar and the storage managers
            Set ON-Bar performance statistics levels
            View ON-Bar backup and restore performance statistics
        ON-Bar catalog tables
          The bar_action table
          The bar_instance table
          The bar_ixbar table
          The bar_object table
          The bar_server table
          The bar_syncdeltab table
          ON-Bar catalog map
        ON-Bar messages and return codes
          Message format in the ON-Bar message log
          Message numbers
          ON-Bar return codes
      ontape backup and restore system
        Configure ontape
          Set configuration parameters for the ontape utility
            Data transformation filter parameters for ontape
            Tape and tape device parameters for ontape
            Set the tape-device parameters
              Specify separate devices for storage-space and logical-log backups
              Specify tape devices as symbolic links
              Specify a file system directory
              Specify a remote device
              Specify /dev/null for a tape device
              Set TAPEDEV to stdio
              Rewind tape devices before opening and on closing
            Specify the tape-block-size
            Specify the tape size
              Tape size for remote devices
          Changing your ontape configuration
        Back up with ontape
          Summary of ontape tasks
            Start ontape
            Exit codes for ontape
          Change database logging status
          Create a backup
            Backup levels that ontape supports
            Back up after changing the physical schema
            Prepare for a backup
              Avoid temp tables during heavy activity
              Make sure enough logical-log space exists
              Keep a copy of your configuration file
              Verify consistency before a level-0 backup
              Online and quiescent backups
              Back up to tape
                Label tapes created with ontape
              Back up to standard output
              Back up to a directory
                Set the file directory path
                Rename existing files
                Override the default name of the archive files
            ontape utility syntax: Perform a backup
              Backup examples
              Back up raw tables
            Back up to Amazon Simple Storage Service
              The ifxbkpcloud.jar utility
              Cloud storage file naming conventions
            When the logical-log files fill during a backup
            When a backup terminates prematurely
            Monitor backup history by using oncheck
          Back up logical-log files with ontape
            Before you back up the logical-log files
              Use blobspace TEXT and BYTE data types and logical-log files
              Use /dev/null when you do not need to recover
            When to back up logical-log files
            Start an automatic logical-log backup
            Starting a continuous logical-log file backup
            End a continuous logical-log backup
            Devices that logical-log backups must use
        Restore with ontape
          Types of physical restore
            Full-system restore
            Restores of dbspaces, blobspaces, and sbspaces
          Cold, warm, or mixed restores
            Cold restores
            Warm restores
            Mixed restores
          ontape utility syntax: Perform a restore
          Restore the whole system
            Gather backup and logical-log tapes before restoring
            Decide on a complete cold or a mixed restore
            Verify your database server configuration
              Set shared-memory parameters to maximum assigned value
              Set mirroring configuration to level-0 backup state
              Verify that the raw devices or files are available
            Perform a cold restore
              Salvage logical-log files
              Mount tapes during the restore
              Restore logical log files
              Bring the database server online when the restore is over
            Restore selected storage spaces
              Gather the appropriate tapes
              Ensure that needed device are available
              Back up logical-log files
              Perform a warm restore
            Restore raw tables
          Configuring continuous log restore with ontape
          Rename chunks during a restore
            Validation sequence for renaming chunks
            New chunk requirements
            Rename chunks with command-line options
            Rename chunks with a file
            Rename chunks while specifying other options
            Rename a chunk to a nonexistent device
              Renaming a chunk to a nonexistent device
          Restore from standard input
          Restore data to a remote server
          Simultaneous backup and restore by using standard I/O
        Perform an external backup and restore
          Recover data by using an external backup and restore
          Data that is backed up in an external backup
            Rules for an external backup
            Performing an external backup
          Prepare for an external backup
            Block and unblock the database server
            Track an external backup
          Data that is restored in an external restore
            Use external restore commands
            Rules for an external restore
            Rename chunks
            Performing a cold external restore
              Examples of external restore commands
            Initializing HDR with an external backup and restore
      Informix Primary Storage Manager
        HCL Informix Primary Storage Manager
          Examples: Manage storage devices with Informix Primary Storage Manager
          Setting up Informix Primary Storage Manager
            Collecting information about file directories and devices
            Configuring Informix Primary Storage Manager
          Managing storage devices
          The onpsm utility for storage management
            onpsm -C detail output
            onpsm -D list output
            onpsm -O list output
          Device pools
          Device-configuration file for the Informix Primary Storage Manager
          Informix Primary Storage Manager file-naming conventions
          Message logs for Informix Primary Storage Manager
      archecker table level restore utility
        archecker table level restore utility
          Overview of the archecker utility
            The archecker configuration file
            Schema command file
            Table-level restore and locales
          Data restore with archecker
            Physical restore
            Logical restore
              The stager
              The applier
          Syntax for archecker utility commands
            Manually control a logical restore
            Performing a restore with multiple storage managers
            Perform a parallel restore
            Restore tables with large objects
            When to delete restore files
          The archecker schema reference
            The CREATE TABLE statement
            The CREATE EXTERNAL TABLE statement
            The DATABASE statement
            The INSERT statement
            The RESTORE statement
            The SET statement
            Schema command file examples
              Simple schema command file
              Restore a table from a previous backup
              Restore to a different table
              Extract a subset of columns
              Use data filtering
              Restore to an external table
              Restore multiple tables
              Perform a distributed restore
      Backup and restore configuration parameter reference
        Backup and restore configuration parameters
          ON-Bar and ontape configuration parameters and environment variable
            BACKUP_FILTER configuration parameter
            BAR_ACT_LOG configuration parameter
            BAR_BSALIB_PATH configuration parameter
            BAR_CKPTSEC_TIMEOUT configuration parameter
            BAR_DEBUG configuration parameter
            BAR_DEBUG_LOG configuration parameter
            BAR_HISTORY configuration parameter
            BAR_IXBAR_PATH configuration parameter
            BAR_MAX_BACKUP configuration parameter
            BAR_MAX_RESTORE configuration parameter
            BAR_NB_XPORT_COUNT configuration parameter
            BAR_PERFORMANCE configuration parameter
            BAR_PROGRESS_FREQ configuration parameter
            BAR_RETRY configuration parameter
            BAR_SIZE_FACTOR configuration parameter
            BAR_XFER_BUF_SIZE configuration parameter
            IFX_BAR_NO_BSA_PROVIDER environment variable
            IFX_BAR_NO_LONG_BUFFERS environment variable
            IFX_BAR_USE_DEDUP environment variable
            IFX_TSM_OBJINFO_OFF environment variable
            LTAPEBLK configuration parameter
            LTAPEDEV configuration parameter
            LTAPESIZE configuration parameter
            RESTARTABLE_RESTORE configuration parameter
            RESTORE_FILTER configuration parameter
            TAPEBLK configuration parameter
            TAPEDEV configuration parameter
            TAPESIZE configuration parameter
          The archecker utility configuration parameters and environment variable
            AC_CONFIG file environment variable
            AC_DEBUG configuration parameter
            AC_IXBAR configuration parameter
            AC_LTAPEBLOCK configuration parameter
            AC_LTAPEDEV parameter
            AC_MSGPATH configuration parameter
            AC_SCHEMA configuration parameter
            AC_STORAGE configuration parameter
            AC_TAPEBLOCK configuration parameter
            AC_TAPEDEV configuration parameter
            AC_TIMEOUT configuration parameter
            AC_VERBOSE configuration parameter
          Informix Primary Storage Manager configuration parameters
            PSM_ACT_LOG configuration parameter
            PSM_CATALOG_PATH configuration parameter
            PSM_DBS_POOL configuration parameter
            PSM_DEBUG configuration parameter
            PSM_DEBUG_LOG configuration parameter
            PSM_LOG_POOL configuration parameter
          Event alarm configuration parameters
      Cloud Backup
        Back up to Amazon Simple Storage Service using ON-Bar and the PSM
        Back up to Softlayer using ON-Bar and the PSM
      Appendixes
        Troubleshooting some backup and restore errors
          Corrupt page during an archive
          Log backup already running
          No server connection during a restore
          Drop a database before a restore
          No dbspaces or blobspaces during a backup or restore
            Restore blobspace BLOBs
          Changing the system time on the backup system
        Migrate data, servers, and tools
          Backing up before a database server or storage-manager upgrade
          Upgrading a third-party storage manager
          Changing storage-manager vendors
          Switching from ontape to ON-Bar
        GLS support
          Use GLS with the ON-Bar utility
            Identifiers that support non-ASCII characters
            Identifiers that require 7-bit ASCII characters
            Locale of ON-Bar messages
          Use the GL_DATETIME environment variable with ON-Bar
          Use GLS with the ontape utility
    Encrypt archived data with IBM InfoSphere Guardium Encryption Expert
  Replication
    Enterprise Replication
      What's New in Enterprise Replication for Informix, Version 12.10
      About Enterprise Replication
        HCL Informix Enterprise Replication technical overview
          Enterprise Replication Terminology
          Asynchronous Data Replication
          Log-Based Data Capture
          High Performance
          High Availability
          Consistent Information Delivery
          Repair and Initial Data Synchronization
          Flexible Architecture
          Centralized Administration
          Ease of Implementation
          Network Encryption
        How Enterprise Replication Replicates Data
          Data Capture
            Row Images
            Evaluate rows for updates
            Send queues and receive queues
            Data Evaluation Examples
          Data Transport
          Applying replicated data
      Planning and designing for Enterprise Replication
        Plan for Enterprise Replication
          Enterprise Replication Server administrator
          Asynchronous propagation conflicts
          Back up and restore of replication servers
          Compression of replicated data
          Transaction processing impact
          SQL statements and replication
          Global language support for replication
          Replication between multiple server versions
        Schema design for Enterprise Replication
          Unbuffered Logging
          Table Types
          Label-based access control
          Out-of-Row Data
          Shadow columns
          Unique key for replication
          Cascading Deletes
          Triggers
          Constraint and replication
          Sequence Objects
          The NLSCASE database property
          Replicating Table Hierarchies
          Replication and data types
            Replicating on Heterogeneous Hardware
            Serial data types and replication keys
            Replication of TimeSeries data types
            Replication of large objects
              Replicating Simple Large Objects from Tblspaces
              Replication of large objects from blobspaces or sbspaces
            Replication of opaque user-defined data types
        Replication system design
          Primary-Target Replication System
            Primary-Target Data Dissemination
            Data consolidation
            Workload Partitioning
            Workflow Replication
            Primary-Target Considerations
          Update-Anywhere Replication System
          Conflict Resolution
            Conflict resolution rule
              Ignore Conflict-Resolution Rule
              Time stamp conflict resolution rule
              SPL Conflict Resolution Rule
                SPL Conflict Resolution for Large Objects
              Delete wins conflict resolution rule
              Always-Apply Conflict-Resolution Rule
            Conflict Resolution Scope
          Choosing a Replication Network Topology
            Fully Connected Topology
            Hierarchical Routing Topology Terminology
            Hierarchical Tree Topology
            Forest of Trees
      Setting up and managing Enterprise Replication
        Preparing the Replication Environment
          Preparing the Network Environment
            Configuring hosts information for replication servers
            Configuring port and service names for replication servers
            Creating sqlhost group entries for replication servers
            Configuring secure ports for connections between replication servers
            Configuring network encryption for replication servers
            Testing the replication network
            Testing the password file
          Preparing the Disk
            Logical Log Configuration Disk Space
            Logical Log Configuration Guidelines
            Disk Space for Delete Tables
            Shadow column disk space
            Setting Up Send and Receive Queue Spool Areas
              Row Data sbspaces
                Creating sbspaces for Spooled Row Data
                Logging Mode for sbspaces
                Dropping a Spooled Row Data sbspace
            Setting Up the Grouper Paging File
            Creating ATS and RIS Directories
          Preparing the Database Server Environment
            Setting Database Server Environment Variables
            Set configuration parameters for replication
            Time Synchronization
          Preparing Data for Replication
            Preparing Consistent Data
            Blocking Replication
              Using DB-Access to Begin Work Without Replication
              Using ESQL/C to Begin Work Without Replication
            Preparing to Replicate User-Defined Types
            Preparing to Replicate User-Defined Routines
            Preparing Tables for Conflict Resolution
            Preparing Tables for a Consistency Check Index
            Preparing tables without primary keys
            Preparing Logging Databases
            Preparing for Role Separation (UNIX)
          Load and unload data
            High-Performance Loader
            onunload and onload Utilities
            dbexport and dbimport Utilities
            UNLOAD and LOAD Statements
          Data Preparation Example
            Using the cdr start replicate Command
            Using LOAD, UNLOAD, and BEGIN WORK WITHOUT REPLICATION
        Using High-Availability Clusters with Enterprise Replication
          High-availability replication systems
            High-Availability Clusters in a Hierarchical Tree Topology
            Using High-Availability Clusters in a Forest of Trees Topology
            Setting Up Database Server Groups for High-Availability Cluster Servers
          Managing Enterprise Replication with High-Availability Clusters
            Failover for High-availability clusters in an Enterprise Replication environment
            Replication latency for secondary servers
        Defining Replication Servers, Replicates, Participants, and Replicate Sets
          Starting Database Servers
          Defining Replication Servers
            Creating a new domain by cloning a server
              Example of creating a new replication domain by cloning
            Adding a server to the domain by cloning a server
            Customizing the Replication Server Definition
          Define a replicate
            Participant definitions
              Defining Replicates on Table Hierarchies
            Replicate types
              Master Replicate Verification
              Creating Strict Master Replicates
              Creating Empty Master Replicates
            Defining Shadow Replicates
            Specifying Conflict Resolution Rules and Scope
            Specifying Replication Frequency
            Setting Up Failed Transaction Logging
            Replicate only changed columns
            Using the IEEE Floating Point or Canonical Format
            Enabling Triggers
            Enabling code set conversion between replicates
              Configuring code set conversion between replicates
              Code set conversion errors
              Controlling the replication of large objects
          Define replicate sets
            Exclusive Replicate Sets
            Non-Exclusive Replicate Sets
            Customizing the Replicate Set Definition
          Initially Synchronizing Data Among Database Servers
          Set up replication through templates
            Defining Templates
            Realizing Templates
              Verifying Participants without Applying the Template
              Synchronizing Data Among Database Servers
                Improve Performance During Synchronization
              Create tables automatically
              Other synchronization options
              Changing Templates
              Template Example
        Grid setup and management
          Example of setting up a replication system with a grid
          Example of rolling out schema changes in a grid
          Creating a grid
          Grid maintenance
            Viewing grid information
          Adding replication servers to a grid
            Adding a replication server to a grid by running cdr change grid
            Adding a replication server to a grid by cloning
          Adding an externally created replicate into a grid replicate set
            Adding an existing replicate to a grid replicate set by using cdr change replicateset
            Adding an existing replicate to a grid replicate set by altering a table
          Creating replicated tables through a grid
          Enabling replication within a grid transaction
          Propagating updates to data
          Administering servers in the grid with the SQL administration API
          Propagating database object changes
          Propagating external files through a grid
          Rerunning failed grid routines
          Connection management for client connections to participants in a grid
          Grid queries
            Defining tables for grid queries
            Configuring secure connections for grid queries
            Examples of grid queries
        Shard cluster setup
          Creating a shard cluster
            Shard cluster definitions
          Sharded queries
          Shard cluster management and monitoring
        Managing Replication Servers and Replicates
          Managing Replication Servers
            Modify server attributes
            Dynamically Modifying Configuration Parameters for a Replication Server
            Viewing Replication Server Attributes
            Connect to another replication server
            Temporarily stopping replication on a server
            Restarting Replication on a Server
            Suspending Replication for a Server
            Resuming a Suspended Replication Server
            Deleting a Replication Server
          Managing Replicates
            Modify replicates
              Adding or Deleting Participants
              Change replicate attributes
              Changing the replication key of a replicate
            Viewing Replicate Properties
            Starting a Replicate
            Stopping a Replicate
            Suspending a Replicate
            Resuming a Suspended Replicate
            Deleting a Replicate
          Managing Replicate Sets
            Connection management for client connections to participants in a replicate set
            Modifying Replicate Sets
              Adding or Deleting Replicates From a Replicate Set
              Changing Replication Frequency For the Replicate Set
            Viewing Replicate Sets
            Starting a Replicate Set
            Stopping a Replicate Set
            Suspending a Replicate Set
            Resuming a Replicate Set
            Deleting a Replicate Set
          Managing Templates
            Viewing Template Definitions
            Deleting Templates
          Managing Replication Server Network Connections
            Viewing Network Connection Status
            Dropping the Network Connection
            Reestablishing the Network Connection
          Resynchronizing Data among Replication Servers
            Performing Direct Synchronization
              Synchronizing Significantly Inconsistent Tables
            Checking Consistency and Repairing Inconsistent Rows
              Interpreting the Consistency Report
              Increase the speed of consistency checking
                Indexing the ifx_replcheck Column
              Repair inconsistencies by time stamp
              Repairing inconsistencies while enabling a replication server
              Implementing a custom checksum function
                Rules for custom checksum functions
            Repairing Failed Transactions with ATS and RIS Files
            Resynchronize data manually
          Alter, rename, or truncate operations during replication
            Altering multiple tables in a replicate set
            Adding a Replicated Column
            Removing replicated columns
            Modifying the data type or size of a replicated column
            Changing the Name of a Replicated Column, Table, or Database
            Changing or re-creating primary key columns
            Attaching a New Fragment to a Replicated Table
            Remastering a Replicate
              Remastering replicates without name verification
          Recapture replicated transactions
        Monitor and troubleshooting Enterprise Replication
          Solve Replication Processing Problems
          Failed Transaction (ATS and RIS) Files
            Enabling ATS and RIS File Generation
            ATS and RIS File Names
            ATS and RIS File Formats
              XML File Format
                XML Tags
              ATS and RIS Text File Contents
            Disabling ATS and RIS File Generation
            Suppressing Data Sync Errors and Warnings
          Preventing Memory Queues from Overflowing
            Handle potential log wrapping
            Monitoring Disk Usage for Send and Receive Queue Spool
            Increasing the Sizes or Numbers of Storage Spaces
            Recovering when Storage Spaces Fill
          Common configuration problems
          Troubleshooting Tips for Alter Operations
          Enterprise Replication Event Alarms
            Enabling or Disabling Enterprise Replication Event Alarms
      Push data feature
        Push data session survival
        Detach trigger
      Loopback replication
        Loopback Configuration
        Replication definition between primary and pseudo groups
      Appendixes
        The cdr utility
          Interpret the cdr utility syntax
            Command Abbreviations
            Option Abbreviations
            Option Order
            Long Command-Line Examples
            Long Identifiers
            Connect Option
            Participant and participant modifier
            Return Codes for the cdr Utility
            Frequency Options
          cdr add onconfig
          cdr alter
          cdr autoconfig serv
          cdr change grid
          cdr change gridtable
          cdr change onconfig
          cdr change replicate
          cdr change replicateset
          cdr change shardCollection
          cdr check queue
          cdr check replicate
          cdr check replicateset
          cdr check sec2er
          cdr cleanstart
          cdr connect server
          cdr define grid
          cdr define qod
          cdr define region
          cdr define replicate
          cdr define replicateset
          cdr define server
          cdr define shardCollection
          cdr define template
          cdr delete grid
          cdr delete region
          cdr delete replicate
          cdr delete replicateset
          cdr delete server
          cdr delete shardCollection
          cdr delete template
          cdr disable grid
          cdr disable server
          cdr disconnect server
          cdr enable grid
          cdr enable server
          cdr error
          cdr finderr
          cdr list grid
          cdr list replicate
          cdr list replicateset
          cdr list server
          cdr list shardCollection
          cdr list catalog
          cdr list template
          cdr modify grid
          cdr modify replicate
          cdr modify replicateset
          cdr modify server
          cdr realize template
          cdr remaster
          cdr remaster gridtable
          cdr remaster replicateset
          cdr remove onconfig
          cdr repair
          cdr reset qod
          cdr resume replicate
          cdr resume replicateset
          cdr resume server
          cdr start
          cdr start qod
          cdr start replicate
          cdr start replicateset
          cdr start sec2er
          cdr stats rqm
          cdr stats recv
          cdr stats check
          cdr stats sync
          cdr stop
          cdr stop qod
          cdr stop replicate
          cdr stop replicateset
          cdr suspend replicate
          cdr suspend replicateset
          cdr suspend server
          cdr swap shadow
          cdr sync replicate
          cdr sync replicateset
          cdr -V
          cdr view
        Enterprise Replication configuration parameter and environment variable reference
          CDR_APPLY Configuration Parameter
          CDR_AUTO_DISCOVER configuration parameter
          CDR_DBSPACE Configuration Parameter
          CDR_DELAY_PURGE_DTC configuration parameter
          CDR_DSLOCKWAIT Configuration Parameter
          CDR_ENV Configuration Parameter
          CDR_EVALTHREADS Configuration Parameter
          CDR_LOG_LAG_ACTION configuration parameter
          CDR_LOG_STAGING_MAXSIZE Configuration Parameter
          CDR_MAX_DYNAMIC_LOGS Configuration Parameter
          CDR_MAX_FLUSH_SIZE configuration parameter
          CDR_MEM configuration parameter
          CDR_NIFCOMPRESS Configuration Parameter
          CDR_QDATA_SBSPACE Configuration Parameter
          CDR_QUEUEMEM Configuration Parameter
          CDR_SERIAL Configuration Parameter
          CDR_SUPPRESS_ATSRISWARN Configuration Parameter
          CDR_TSINSTANCEID configuration parameter
          ENCRYPT_CDR Configuration Parameter
          GRIDCOPY_DIR Configuration Parameter
          SHARD_ID configuration parameter
          SHARD_MEM configuration parameter
          CDR_ALARMS Environment Variable
          CDR_ATSRISNAME_DELIM Environment Variable
          CDR_DISABLE_SPOOL Environment Variable
          CDR_LOGDELTA Environment Variable
          CDR_PERFLOG Environment Variable
          CDR_RMSCALEFACT Environment Variable
          CDR_ROUTER Environment Variable
          CDRSITES_10X Environment Variable
          CDRSITES_731 Environment Variable
          CDRSITES_92X Environment Variable
        Grid routines
          ifx_get_erstate() function
          ifx_grid_connect() procedure
          ifx_grid_copy() procedure
          ifx_grid_disconnect() procedure
          ifx_grid_execute() procedure
          ifx_grid_function() function
          ifx_grid_procedure() procedure
          ifx_grid_redo() procedure
          ifx_grid_release() function
          ifx_grid_remove() function
          ifx_grid_purge() procedure
          ifx_gridquery_skipped_nodes() function
          ifx_gridquery_skipped_node_count() function
          ifx_node_id() function
          ifx_node_name() function
        Enterprise Replication routines
          ifx_get_erstate() function
          ifx_set_erstate() procedure
        onstat -g commands for Enterprise Replication
          Threads shown by the onstat -g ath command
          onstat -g cat: Print ER global catalog information
          onstat -g cdr: Print ER statistics
          onstat -g cdr config
          onstat -g ddr
          onstat -g dss: Print statistics for data sync threads
          onstat -g dtc: Print statistics about delete table cleaner
          onstat -g grp
          onstat -g nif: Print statistics about the network interface
          onstat -g que: Print statistics for all ER queues
          onstat -g rcv: Print statistics about the receive manager
          onstat -g rep
          onstat -g rqm
          onstat -g sync
        syscdr Tables
          The replcheck_stat Table
          The replcheck_stat_node Table
        SMI Table Reference
          The syscdr_ats Table
          The syscdr_atsdir Table
          The syscdr_ddr Table
          The syscdr_nif Table
          The syscdr_rcv Table
          The syscdr_ris Table
          The syscdr_risdir Table
          The syscdr_rqm Table
          The syscdr_rqmhandle Table
          The syscdr_rqmstamp Table
          The syscdr_state Table
          The syscdrack_buf Table
          The syscdrack_txn Table
          The syscdrctrl_buf Table
          The syscdrctrl_txn Table
          The syscdrerror Table
          The syscdrlatency Table
          The syscdrpart Table
          The syscdrprog Table
          The syscdrq Table
          The syscdrqueued Table
          The syscdrrecv_buf Table
          The syscdrrecv_stats Table
          The syscdrrecv_txn Table
          The syscdrrepl Table
          The syscdrreplset Table
          The syscdrs Table
          The syscdrsend_buf Table
          The syscdrsend_txn Table
          The syscdrserver Table
          The syscdrsync_buf Table
          The syscdrsync_txn Table
          The syscdrtsapply table
          The syscdrtx Table
          Enterprise Replication Queues
            Columns of the Transaction Tables
            Columns of the Buffer Tables
        Replication Examples
          Replication Example Environment
          Primary-Target Example
          Update-Anywhere Example
          Hierarchy Example
        Data sync warning and error messages
    Informix Replication Plug-in for OAT
      Setting up the Replication plug-in
      Monitoring Enterprise Replication
        Viewing the topology of an ER domain
        Configuring alert thresholds
        Checking for alerts on an Enterprise Replication domain
        Viewing the status of an Enterprise Replication node
          Viewing a summary of replication activity at the current node
          Viewing the node as a replication source
          Viewing the node as a replication target
        Monitoring log capture information for a node
          Determining if transactions are being captured for replication
          Monitoring log capture progress for a node
          Preventing DDRBLOCK and log wrap
          Turning on dynamic log file allocation
        Monitoring the send queue for a node
          Viewing target nodes and replicates related to the current node
        Monitoring network I/O for an Enterprise Replication node
        Monitoring disk space usage for a node
        Monitoring the receive queue for a node
        Monitoring how replicated data is applied at the target node
          Monitoring transaction failures
          Determining the apply latency rate
        Reviewing ATS and RIS files for failed transactions
        Reviewing Enterprise Replication errors
        Viewing the ER configuration parameters
      Administering Enterprise Replication
        Setting up Enterprise Replication
          Defining a server for Enterprise Replication
          Defining a replicate set
          Defining a replicate
        Using templates to set up Enterprise Replication
          Defining a template
          Realizing a template
          Deleting a template
        Managing Enterprise Replication with a grid
          Creating a grid
          Deleting a grid
          Adding members to a grid
          Changing the users of a grid
          Enabling or disabling a source server for a grid
          Monitoring the status of grid tasks
          Rerunning a grid command
          Removing a grid command
          Routing client connections in a grid
            Viewing the SLAs for a grid
            Creating an SLA for a grid
            Modifying an SLA for a grid
            Monitoring the quality of data in a grid
        Managing Enterprise Replication servers
          Modifying an ER server
            Changing ATS and RIS file location and format
            Changing the idle timeout for an ER server
            Changing the type for participants on an ER server
            Disabling ATS or RIS file generation on an ER server
            Enabling ATS or RIS file generation on an ER server
          Stopping or restarting replication on a server
            Suspending replication for a server
            Resuming replication to a suspended server
            Stopping replication on a server
            Restarting replication on a server
            Restarting replication with empty queues
            Disabling replication for a server
            Enabling replication for a disabled server
          Disconnecting an ER server
          Reconnecting an ER server
          Deleting an ER server
        Managing replicate sets
          Modifying a replicate set
            Adding and deleting replicates in a replicate set
            Changing replication frequency for a replicate set
          Viewing replicate set properties
          Starting a replicate set
          Stopping a replicate set
          Suspending a replicate set
          Resuming a replicate set
          Deleting a replicate set
        Managing replicates
          Modifying a replicate
            Adding and deleting participants
            Changing the master replicate server
            Changing the conflict resolution rule and scope
            Changing replication frequency for a replicate
            Activating ATS and RIS file generation
            Replicating full rows or changed columns
            Enabling and disabling triggers
            Retaining or removing deleted rows
          Viewing replicate properties
          Starting a replicate
          Stopping a replicate
          Suspending a replicate
          Resuming a replicate
          Deleting a replicate
        Resynchronizing data among replication servers
          Checking a replicate
          Checking and repairing a replicate
          Synchronizing a replicate
          Deleting a check or sync task for a replicate
          Checking a replicate set
          Checking and repairing a replicate set
          Synchronizing a replicate set
          Deleting a check or sync task for a replicate set
          Repairing failed transactions with ATS files
          Repairing failed transactions with RIS files
        Monitoring task status
          Monitoring replicate tasks
          Monitoring replicate set tasks
        Changing ER configuration parameters
      Managing client connections
        Viewing connection units
        Adding a connection unit
        Modifying a failover configuration
        Creating a service level agreement
        Modifying a service level agreement
        Creating a Connection Manager
Client APIs and tools
  Change Data Capture API Programmer's Guide
    Getting started with the Change Data Capture API
      The Change Data Capture API
        Change Data Capture API components
        Smart large object read functions
        CDC record sequence numbers
        Data for capture
      Preparing to use the Change Data Capture API
      Writing an application to capture data changes
        Handling errors
      Handling smart large objects
      Restarting data capture
      Monitoring data capture
    Change Data Capture functions
      The cdc_activatesess() function
      The cdc_closesess() function
      The cdc_deactivatesess() function
      The cdc_endcapture() function
      The cdc_errortext() function
      The cdc_opensess() function
      The cdc_recboundary() function
      The cdc_set_fullrowlogging() function
      The cdc_startcapture() function
    Change Data Capture records
      Format of CDC records
      The CDC_REC_BEGINTX record
      The CDC_REC_COMMTX record
      The CDC_REC_DELETE record
      The CDC_REC_DISCARD record
      The CDC_REC_ERROR record
      The CDC_REC_INSERT record
      The CDC_REC_RBTX record
      The CDC_REC_TABSCHEMA record
      The CDC_REC_TIMEOUT record
      The CDC_REC_TRUNCATE record
      The CDC_REC_UPDAFT record
      The CDC_REC_UPDBEF record
    The syscdc system database
      The syscdcerrcodes table
      The syscdcrectypes table
    Change Data Capture error codes
    onstat -g cdc
    Change Data Capture sample program
  Embedded SQLJ for HCL Informix
    Introduction to HCL Informix embedded SQLJ
    Preparation to use embedded SQLJ
    Fundamentals of embedded SQLJ programs
      Embedded SQL statements
      Result sets and iterators
      A simple embedded SQLJ program
    The embedded SQLJ language
      Embedded SQLJ statements
      Host variables
      SELECT statements that return a single row
      Result sets
        Positional iterators
        Named iterators
        Column aliases
        Iterator methods
        Positioned updates and deletes
      SQL query execution and monitoring
      SPL routine and function calls
      SQL and Java type mappings
      Language character sets
      Java package importation
      SQLJ reserved names
      Handling errors
    Embedded SQLJ source code processing
      SQL program translation, compiling, and running
      The ifxsqlj command
      Options for the ifxsqlj command
      Online checking
      The ifxprofp tool
    Appendix
      Embedded SQLJ and database connections
        The ConnectionManager class
        Database URLs
        Nondefault connection contexts
        MultiConnect.sqlj sample program
      Descriptions of sample programs included with HCL Informix Embedded SQLJ
  ESQL/C Guide
    What is Informix ESQL/C?
      Informix ESQL/C programming
        What is Informix ESQL/C?
          ESQL/C components
            ESQL/C files for Windows
            ESQL/C library functions
          Creating an ESQL/C program
        Embed SQL statements
          Case sensitivity in embedded SQL statements
          Quotation marks and escape characters
            Newline characters in quoted strings
          Add comments to ESQL/C programs
          Host variables
        Declaring and using host variables
          Declare a host variable
            Host variable names
            Host-variable data types
            Initial host-variable values
            Scope of host variables
            Sample host-variable declarations
          Host variable information
            SQL identifiers
              Long identifiers
              Delimited identifiers
                Example of a delimited identifier
            Null values in host variables
          Host variables in data structures
            Arrays of host variables
            C structures as host variables
            C typedef statements as host variables
            Pointers as host variables
            Function parameters as host variables
          Host variables in Windows environments
            Declare variables with non-ANSI storage-class modifiers
          Indicator variables
            Declare indicator variables
            Associate an indicator variable with a host variable
            Indicate null values
            Indicate truncated values
            An example of using indicator variables
        ESQL/C header files
          Declare function prototypes
          Header files included in your program
        ESQL/C preprocessor directives
          The include directive
          The define and undef directives
          The ifdef, ifndef, elif, else, and endif directives
        Set and retrieve environment variables in Windows environments
          The InetLogin structure
            Fields of the InetLogin structure
            InetLogin field values
            Precedence of configuration values
        Global ESQL/C variables in a Windows environment
        A sample Informix ESQL/C program
          Compile the demo1 program
          Guide to demo1.ec file
      Compile programs
        Compile the Informix ESQL/C program
          The ESQL/C preprocessor
          The C preprocessor and compiler
          Default compilation order
          Run the C preprocessor first
        The esql command
          Requirements for using the esql command
          Syntax of the esql command
          Options that affect preprocessing
            Check the version number
            Associate options with files
            Preprocess without compiling or linking
            Generate thread-safe code
            Check for ANSI-standard SQL syntax
            Define and undefine definitions while preprocessing
            Check for missing indicator variables
            Name the location of include files
            Line numbers
            Cursor names and statement IDs
            Redirect errors and warnings
            Suppress warnings
            Enabling the GLS for Unicode (GLU) feature
            The X/Open standards
          Run the C preprocessor before the ESQL/C preprocessor
            Options for running the C preprocessor first
            The CPFIRST environment variable (UNIX)
            Using the eprotect.exe utility (Windows)
            The order of compilation when the C preprocessor runs first
            Define host variables based on C #defines and typedefs
            Allow all valid C declaration syntax inside the EXEC SQL declare section
            Exclude statements inside C header files
            SQL keyword protection
            SQL keyword protection and the dollar sign ($) symbol
          Preprocessor options specific to Windows environments
        Compiling and linking options of the esql command
          Name the executable file
          Set the type of executable files created (Windows)
          Pass options to the C compiler
          Specify a particular C compiler (Windows)
          Compile without linking
          Special compile options for Windows environments
            Specify the name of a project file
            Create a response file
            Implicit options invoked by the esql preprocessor in Windows environments
          Linking options
            General linking options
              Linking other C source and object files
              Specify versions of Informix ESQL/C general libraries
            Special linking options for Windows
              Pass arguments to the linker
              Pass arguments to the resource compiler
              ESQL/C dynamic link libraries
              Same runtime routines for version independence
        Access the ESQL Client-interface DLL in Windows environments
          Access the import library
          Locate a DLL
          Build an application DLL
      Informix ESQL/C data types
        Choose data types for host variables
          Data type constants
            SQL data type constants
            ESQL/C data type constants
            X/Open data type constants
          Header files for data types
        Data conversion
          Fetch and insert with host variables
            Convert numbers and strings
            Convert floating-point numbers to strings
            Convert BOOLEAN values to characters
            Convert DATETIME and INTERVAL values
            Convert between VARCHAR and character data types
          Perform arithmetic operations
            Convert numbers to numbers
            Operations that involve a decimal value
              Convert the non-decimal numeric operand
              Obtain the DECIMAL data type of the arithmetic result
        Data-type alignment library functions
      Character and string data types
        Character data types
          The char data type
          The fixchar data type
          The string data type
          The varchar data type
          The lvarchar data type
            The lvarchar keyword syntax
            A lvarchar host variable of a fixed size
            The lvarchar pointer host variable
        Fetch and insert character data types
          Fetch and insert CHAR data
            Fetch CHAR data
            Insert CHAR data
          Fetch and insert VARCHAR data
            Fetch VARCHAR data
            Insert VARCHAR data
          Fetch and insert lvarchar data
            Fetch lvarchar data
            Insert lvarchar data
          Fetch and insert with an ANSI-compliant database
        Character and string library functions
      Numeric data types
        The integer data types
          The integer host variable types
          The INT8 and SERIAL8 SQL data types
          The int8 data type
          The int8 library functions
        The BOOLEAN data type
        The decimal data type
          The decimal structure
          The decimal library functions
        The floating-point data types
          Declare float host variables
          Implicit data conversion
        Format numeric strings
          Sample format strings for numeric expressions
          Numeric-formatting functions
      Time data types
        The SQL DATE data type
          Format date strings
        DATE library functions
        The SQL DATETIME and INTERVAL data types
          The datetime data type
          The interval data type
          Macros for datetime and interval data types
          Fetch and insert DATETIME and INTERVAL values
            Fetch and insert into datetime host variables
            Fetch and insert into interval host variables
            Implicit data conversion
          ANSI SQL standards for DATETIME and INTERVAL values
          Converting data for datetime values
          Converting data for interval values
        Support of non-ANSI DATETIME formats
          The USE_DTENV environment variable
        DATETIME and INTERVAL library functions
      Simple large objects
        Choose a large-object data type
        Programming with simple large objects
          Declare a host variable for a simple large object
          Access the locator structure
            The fields of the locator structure
            Locations for simple-large-object data
        Locate simple large objects in memory
          Allocate the memory buffer
            A memory buffer that the ESQL/C libraries allocate
            A memory buffer that the program allocates
          Select a simple large object into memory
          Insert a simple large object from memory
        Locate simple large objects in files
          File-open mode flags
          Error returns in loc_status
          Locate simple large objects in open files
            Select a simple large object into an open file
            Insert a simple large object from an open file
          Locate simple large objects in named files
            Select a simple large object into a named file
            Insert a simple large object from a named file
        User-defined simple-large-object locations
          Select a simple large object into a user-defined location
          Insert a simple large object into a user-defined location
          User-defined simple-large-object functions
            The user-defined open function
            The user-defined read function
            The user-defined write function
            The user-defined close function
        The dispcat_pic program
          Preparing to run the dispcat_pic program
          Load the simple-large-object images
            Choose the image files
            Loading the simple-large-object images with the blobload utility
          Guide to the dispcat_pic.ec File
          Guide to the prdesc.c file
          Guide to the inpfuncs.c file
      Smart large objects
        Data structures for smart large objects
          Declare a host variable
          The LO-specification structure
            The ifx_lo_create_spec_t structure
              Disk-storage information
              Create-time flags
            ESQL/C functions that use the LO-specification structure
            Obtain storage characteristics
              The system-specified storage characteristics
              The column-level storage characteristics
              The user-defined storage characteristics
            Deallocate the LO-specification structure
          The LO-pointer structure
            Store a smart large object
            The ifx_lo_t structure
            ESQL/C functions that use the LO-pointer structure
          The LO file descriptor
            ESQL/C library functions that use an LO file descriptor
        Creating a smart large object
        Accessing a smart large object
          Select a smart large object
          Open a smart large object
            Access modes
              Set dirty read access mode
              The LO_APPEND flag
              Lightweight I/O
            Smart-large-object locks
              Range of a lock
            Duration of an open on a smart large object
          Delete a smart large object
          Modifying a smart large object
            Read data from a smart large object
            Write data to a smart large object
          Close a smart large object
        Obtaining the status of a smart large object
          Obtaining a valid LO-pointer structure
          Allocate and access an LO-status structure
            Allocate an LO-status structure
            Access the LO-status structure
          Deallocate the LO-status structure
        Alter a smart-large-object column
        Migrate simple large objects
        The ESQL/C API for smart large objects
      Complex data types
        Access a collection
          Access a collection derived table
            Advantage of a collection derived table
            Restrictions on a collection derived table
          Declaring collection variables
            Syntax of the collection data type
            Typed and untyped collection variables
              The typed collection variable
              The untyped collection variable
            Client collections
          Manage memory for collections
          Operate on a collection variable
            The collection-derived table clause on collections
              Access a collection variable
              Distinguish between columns and collection variables
            Initialize a collection variable
            Insert elements into a collection variable
              Insert one element
                Insert elements into SET and MULTISET collections
                Insert elements into LIST collections
              Inserting more than one element
                Declare an insert cursor for a collection variable
                Put elements into the insert cursor
                Free cursor resources
            Select from a collection variable
              Select one element
              Select one row element
              Selecting more than one element
                Declare a select cursor for a collection variable
                Fetch elements from the select cursor
            Update a collection variable
              Update all elements
              Updating one element
            Specify element values
              Literal values as elements
              ESQL/C host variables as elements
            Delete elements from a collection variable
              Delete all elements
              Delete one element
            Access a nested collection
              Select values from a nested collection
              Insert values into a nested collection
          Operate on a collection column
            Select from a collection column
            Insert into and update a collection column
              Delete an entire collection
        Access row types
          Declare row variables
            Typed and untyped row variables
              The typed row variable
              The untyped row variable
            Named row types
              In a collection-derived table
            Client-side rows
          Manage memory for rows
          Operate on a row variable
            The collection-derived table clause on row types
              Access a row variable
              Distinguish between columns and row variables
            Initialize a row variable
            Insert into a row variable
            Select from a row variable
            Update a row variable
            Delete from a row variable
            Specify field names
              Host variable field names
            Specify field values
              Literal values as field values
              Constructed rows
              ESQL/C host variables as field values
          Access a typed table
          Operate on a row-type column
            Select from a row-type column
            Insert into and update row-type columns
            Delete an entire row type
      Opaque data types
        The SQL opaque data type
        Access the external format of an opaque type
          Declare lvarchar host variables
            An lvarchar host variable of a fixed size
            The lvarchar pointer host variable
              To allocate memory yourself
            The opaque type name
          The lvarchar host variables
            Fixed-size lvarchar host variables
              Inserting from a fixed-size lvarchar host variable
              Select into a fixed-size lvarchar host variable
            The lvarchar pointer variables
              Insert from an lvarchar pointer host variable
              Select into an lvarchar pointer host variable
        Access the internal format of an opaque type
          Access a fixed-length opaque type
            Declare fixed binary host variables
              The opaque type
            Fixed binary host variables
              Insert from a fixed binary host variable
              Select into a fixed binary host variable
          Access a varying-length opaque type
            Declare var binary host variables
            The var binary host variables
              Insert from a var binary host variable
              Select into a var binary host variable
        The lvarchar pointer and var binary library functions
        Access predefined opaque data types
    Database server communication
      Exception handling
        Obtain diagnostic information after an SQL statement
          Types of diagnostic information
            Types of database exceptions
            Descriptive information
          Types of status variables
        Exception handling with SQLSTATE
          The GET DIAGNOSTICS statement
            Statement information
            Exception information
          The SQLSTATE variable
            Class and subclass codes
            List of SQLSTATE class codes
          Check for exceptions with SQLSTATE
            Determining the cause of an exception in SQLSTATE
            Success in SQLSTATE
            NOT FOUND in SQLSTATE
            Warnings in SQLSTATE
            Runtime errors in SQLSTATE
              GET DIAGNOSTICS failure
            Multiple exceptions
        Exception handling with the sqlca structure
          Fields of the sqlca structure
          The SQLCODE variable
            SQLCODE in pure C modules
            SQLCODE and the exit() call
            SQLCODE after a DESCRIBE statement
          Check for exceptions with sqlca
            Success in sqlca
            NOT FOUND in SQLCODE
            Warnings in sqlca.sqlwarn
            Runtime errors in SQLCODE
              Errors after a PREPARE statement
              SQLCODE after an EXECUTE statement
          Display error text (Windows)
        Choose an exception-handling strategy
          Check after each SQL statement
          The WHENEVER statement
        Library functions for retrieving error messages
          Display error text in a Windows environment
        A program that uses exception handling
          Compile the program
          Guide to the getdiag.ec file
          Guide to the exp_chk.ec file
      Working with the database server
        The client-server architecture of ESQL/C applications
        The client-server connection
          Sources of connection information about a UNIX operating system
            Access the sqlhosts file
            Specify the default database server
          Sources of connection information in a Windows environment
            Set environment variables for connections in a Windows environment
            The sqlhosts information in a Windows environment
            A central registry
            Connection authentication functionality in a Windows environment
          Connect to a database server
            Establish a connection
              The explicit connection
              The implicit Connection
              Summary of connection types
            Establish an explicit connection in a Windows environment
            Password encryption
            Pluggable Authentication Modules (PAM)
            LDAP authentication
            Multiplexed connections
              Client requirements for execution
              Limitations for multiplexed connections
          Identify the database server
            A specific database server
            The default database server
        Interact with the database server
          Determine features of the database server
          Switch between multiple database connections
            Make a connection current
            Handling transactions
          Identify an explicit connection
          Obtain available databases
          Check the status of the database server
          Establishing a separate database connection for the child process
          Interrupt an SQL request
            Interruptible SQL statements
            Allow a user to interrupt
            Set up a timeout interval
              The timeout interval
              The callback function
          Error checking during data transfer
          Terminate a connection
        Optimized message transfers
          Restrictions on optimized message transfers
          Enabling optimized message transfers
            Set the OPTMSG environment variable
            Set the OptMsg global variable
          Error handling with optimized message transfers
        Database server control functions
        The timeout program
          Compile the program
          Guide to the timeout.ec File
          Example output
        ESQL/C connection library functions in a Windows environment
      Informix libraries
        Choose a version of the Informix general libraries
          The Informix general libraries
          The esql command
          Link static Informix general libraries
            Link static Informix general libraries into an ESQL/C module
          Link shared Informix general libraries
            Symbolic names of linked shared libraries (UNIX)
              Linking shared Informix general libraries to an ESQL/C module
          Choose between shared and static library versions
        Compatibility of preexisting ESQL/C applications with current library versions
          The ifx_getversion utility (UNIX)
          Check the API version of a library
        Create thread-safe ESQL/C applications
          Characteristics of thread-safe ESQL/C code
          Program a thread-safe ESQL/C application
            Concurrent active connections
            Connections across threads
            The DISCONNECT ALL Statement
            Prepared statements across threads
            Cursors across threads
            Environment variables across threads
            Message file descriptors
            Decimal functions
            DCE restrictions (UNIX)
              Operating-system calls
              The fork() operating-system call
              Resource allocation
          Link thread-safe libraries
            Linking thread-safe Informix general libraries to an ESQL/C module on a UNIX operating system
            Define thread-safe variables (UNIX)
            Link shared or static versions
            Linking thread-safe Informix general libraries to an ESQL/C module in a Windows environment
        ESQL/C thread-safe decimal functions
        Context threaded optimization
        A sample thread-safe program
          Source listing
          Output
        Create a dynamic thread library on UNIX operating systems
          Data types
          Register the dynamic thread functions
          Set the $THREADLIB environment variable
          Create the shared library
          Compile with the -thread and -l preprocessor options
    Dynamic SQL
      Using dynamic SQL
        Execute dynamic SQL
          Assemble and prepare the SQL statement
            Assemble the statement
            Prepare statements that have collection variables
            Check the prepared statement
          Execute the SQL statement
          Free resources
        A database cursor
          Receive more than one row
            A select cursor
            A function cursor
          Send more than one row
          Name the cursor
          Optimize cursor execution
            Size the cursor buffer
              Default buffer size
            Automatically freeing a cursor
              Enable the AUTOFREE feature
              The SET AUTOFREE statement
            Defer execution of the PREPARE statement
              Restrictions on deferred-PREPARE
              Enable the deferred-PREPARE Feature
              The SET DEFERRED_PREPARE statement
        The collect.ec program
        Optimize OPEN, FETCH, and CLOSE
          Restrictions on OPTOFC
          Enable the OPTOFC Feature
        Using OPTOFC and Deferred-PREPARE together
        SQL statements that are known at compile time
          Execute non-SELECT statements
            The PREPARE and EXECUTE statements
            The EXECUTE IMMEDIATE statement
          Execute SELECT statements
            The PREPARE and EXECUTE INTO statements
            Declare a select cursor
          The lvarptr.ec program
          Execute user-defined routines in Informix
            A user-defined procedure
            A user-defined function
              A noncursor function
              A function cursor
          Execute statements with input parameters
            An EXECUTE USING statement
            An OPEN USING statement
            The demo2.ec sample program
        SQL statements that are not known at compile time
      Determine SQL statements
        Dynamic-management structure
          A system-descriptor area
            Fixed-length portion
            An item descriptor
          An sqlda structure
            Fixed-length portion
            An sqlvar_struct structure
            Descriptive information
        The DESCRIBE statement
          Determine the statement type
          Determine the data type of a column
            SQL data types specific to Informix
            X/Open SQL data types
            Constants for ESQL/C data types
          Determine input parameters
          Check for a WHERE clause
        Determine statement information at run time
          Handling an unknown select list
          Handling an unknown column list
          Determine unknown input parameters
          Determine return values dynamically
          Handling statements that contain user-defined data types
            SQL statements with opaque-type columns
              Insert opaque-type data
              Truncation of opaque-type data
            SQL statements with distinct-type columns
        A fetch array
          Using a fetch array
          Sample fetch array program
          Allocate memory for the fetch arrays
            Allocating memory for a fetch array
          Obtain values from fetch arrays
          Free memory for a fetch array
      A system-descriptor area
        Manage a system-descriptor area
          Allocate memory for a system-descriptor area
          Initialize the system-descriptor area
            The DESCRIBE statement and input parameters
            The DESCRIBE statement and memory allocation
          Assign and obtain values from a system-descriptor area
            The SET DESCRIPTOR Statement
              An lvarchar pointer host variable with a descriptor
            The GET DESCRIPTOR statement
          Specify input parameter values
          Put column values into a system-descriptor area
          Free memory allocated to a system-descriptor area
        Using a system-descriptor area
        Handling an unknown select list
          Execute a SELECT that returns multiple rows
            The demo4.ec sample program
          Execute a singleton SELECT
        Handling unknown return values
          Execute a noncursor function
            A sample program that executes an SPL function
          Executing a cursor function
        Handling an unknown column list
          Execute a simple insert
            A sample program that executes a dynamic INSERT statement
          Execute an INSERT that is associated with a cursor
        Handling a parameterized SELECT statement
          Execute a parameterized SELECT that returns multiple rows
            A sample program that uses a dynamic SELECT statement
          Execute a parameterized singleton SELECT statement
        Handling a parameterized user-defined routine
          Execute a parameterized function
          Execute a parameterized procedure
        Handling a parameterized UPDATE or DELETE statement
        The dyn_sql program
          Compile the program
          Guide to the dyn_sql.ec file
      An sqlda structure
        Manage an sqlda structure
          Define an sqlda structure
          Allocate memory for the sqlda structure
          Initialize the sqlda structure
          Allocate memory for column data
          Assign and obtain values from an sqlda structure
          Specify input parameter values
          Put column values into an sqlda structure
          Free memory allocated to an sqlda structure
        An sqlda structure to execute SQL statements
        Handling an unknown select list
          Execute a SELECT that returns multiple rows
            The demo3.ec sample program
          Execute a singleton SELECT
        Handling unknown return values
          Execute a noncursor function
          Executing a cursor function
        Handling an unknown column list
          Execute a simple insert
          Execute an INSERT that is associated with a cursor
        Handling a parameterized SELECT statement
          Execute a parameterized SELECT that returns multiple rows
            A sample program that uses an sqlda structure
          Execute a parameterized singleton SELECT statement
        Handling a parameterized user-defined routine
          Execute a parameterized function
          Execute a parameterized procedure
        Handling a parameterized UPDATE or DELETE statement
    Appendixes
      The ESQL/C example programs
      The ESQL/C function library
        Informix ESQL/C library functions
        The bigintcvasc() function
        The bigintcvdbl() function
        The bigintcvdec() function
        The bigintcvflt() function
        The bigintcvifx_int8() function
        The bigintcvint2() function
        The bigintcvint4() function
        The biginttoasc() function
        The biginttodbl() function
        The biginttodec() function
        The biginttoflt() function
        The biginttoifx_int8() function
        The biginttoint2() function
        The biginttoint4() function
        The bycmpr() function
        The bycopy() function
        The byfill() function
        The byleng() function
        The decadd() function
        The deccmp() function
        The deccopy() function
        The deccvasc() function
        The deccvdbl() function
        The deccvflt() function
        The deccvint() function
        The deccvlong() function
        The decdiv() function
        The dececvt() and decfcvt() functions
        The decmul() function
        The decround() function
        The decsub() function
        The dectoasc() function
        The dectodbl() function
        The dectoint() function
        The dectolong() function
        The dectrunc() function
        The dtaddinv() function
        The dtcurrent() function
        The dtcvasc() function
        The dtcvfmtasc() function
        The dtextend() function
        The dtsub() function
        The dtsubinv() function
        The dttoasc() function
        The dttofmtasc() function
        The GetConnect() function (Windows)
        The ifx_cl_card() function
        The ifx_dececvt() and ifx_decfcvt() function
        The ifx_defmtdate() function
        The ifx_dtcvasc() function
        The ifx_dtcvfmtasc() function
        The ifx_dttofmtasc() function
        The ifx_getenv() function
        The ifx_getcur_conn_name() function
        The ifx_getserial8() function
        The ifx_int8add() function
        The ifx_int8cmp() function
        The ifx_int8copy() function
        The ifx_int8cvasc() function
        The ifx_int8cvdbl() function
        The ifx_int8cvdec() function
        The ifx_int8cvflt() function
        The ifx_int8cvint() function
        The ifx_int8cvlong() function
        The ifx_int8div() function
        The ifx_int8mul() function
        The ifx_int8sub() function
        The ifx_int8toasc() function
        The ifx_int8todbl() function
        The ifx_int8todec() function
        The ifx_int8toflt() function
        The ifx_int8toint() function
        The ifx_int8tolong() function
        The ifx_lo_alter() function
        The ifx_lo_close() function
        The ifx_lo_col_info() function
        The ifx_lo_copy_to_file() function
        The ifx_lo_copy_to_lo() function
        The ifx_lo_create() function
        The ifx_lo_def_create_spec() function
        The ifx_lo_filename() function
        The ifx_lo_from_buffer() function
        The ifx_lo_lock() function
        The ifx_lo_open() function
        The ifx_lo_read() function
        The ifx_lo_readwithseek() function
        The ifx_lo_release() function
        The ifx_lo_seek() function
        The ifx_lo_spec_free() function
        The ifx_lo_specget_def_open_flags() function
        The ifx_lo_specget_estbytes() function
        The ifx_lo_specget_extsz() function
        The ifx_lo_specget_flags() function
        The ifx_lo_specget_maxbytes() function
        The ifx_lo_specget_sbspace() function
        The ifx_lo_specset_def_open_flags() function
        The ifx_lo_specset_estbytes() function
        The ifx_lo_specset_extsz() function
        The ifx_lo_specset_flags() function
        The ifx_lo_specset_maxbytes() function
        The ifx_lo_specset_sbspace() function
        The ifx_lo_stat() function
        The ifx_lo_stat_atime() function
        The ifx_lo_stat_cspec() function
        The ifx_lo_stat_ctime() function
        The ifx_lo_stat_free() function
        The ifx_lo_stat_mtime_sec() function
        The ifx_lo_stat_refcnt() function
        The ifx_lo_stat_size() function
        The ifx_lo_tell() function
        The ifx_lo_to_buffer() function
        The ifx_lo_truncate() function
        The ifx_lo_unlock() function
        The ifx_lo_write() function
        The ifx_lo_writewithseek() function
        The ifx_lvar_alloc() function
        The ifx_putenv() function
        The ifx_strdate() function
        The ifx_var_alloc() function
        The ifx_var_dealloc() function
        The ifx_var_flag() function
        The ifx_var_freevar() function
        The ifx_var_getdata() function
        The ifx_var_getlen() function
        The ifx_var_isnull() function
        The ifx_var_setdata() function
        The ifx_var_setlen() function
        The ifx_var_setnull() function
        The incvasc() function
        The incvfmtasc() function
        The intoasc() function
        The intofmtasc() function
        The invdivdbl() function
        The invdivinv() function
        The invextend() function
        The invmuldbl() function
        The ldchar() function
        The rdatestr() function
        The rdayofweek() function
        The rdefmtdate() function
        The rdownshift() function
        The ReleaseConnect() function (Windows)
        The rfmtdate() function
        The rfmtdec() function
        The rfmtdouble() function
        The rfmtlong() function
        The rgetlmsg() function
        The rgetmsg() function
        The risnull() function
        The rjulmdy() function
        The rleapyear() function
        The rmdyjul() function
        The rsetnull() function
        The rstod() function
        The rstoi() function
        The rstol() function
        The rstrdate() function
        The rtoday() function
        The rtypalign() function
        The rtypmsize() function
        The rtypname() function
        The rtypsize() function
        The rtypwidth() function
        The rupshift() function
        The SetConnect() function (Windows)
        The sqgetdbs() function
        The sqlbreak() function
        The sqlbreakcallback() function
        The sqldetach() function
        The sqldone() function
        The sqlexit() function
        The sqlsignal() function
        The sqlstart() function
        The stcat() function
        The stchar() function
        The stcmpr() function
        The stcopy() function
        The stleng() function
      Examples for smart-large-object functions
        Prerequisites
        The create_clob.ec program
          Storage characteristics for the example
        The get_lo_info.ec program
        The upd_lo_descr.ec program
  GLS User's Guide
    What's new in GLS
    GLS fundamentals
      Character-representation conventions
        Single-byte characters
        Multibyte characters
        Single-byte and multibyte characters in the same string
        White space characters in strings
        Trailing white space characters
      The GLS feature
        GLS support by HCL Informix products
          HCL Informix database servers
            Culture-specific features
          HCL Informix client applications and utilities
          The HCL Informix GLS application programming interface
          Supported data types
          International Language Supplement
      A GLS locale
        Code sets for character data
        Character classes of the code set
        Collation order for character data
          Code-set order
          Localized order
          International Components for Unicode (ICU)
          Collation support
        Display formats
          Numeric and monetary formats
          Date and time formats
      Set a GLS locale
        Locales in the client/server environment
          The client locale
          The database locale
          The server locale
        The default locale
          The default code set
          Default display formats for date and time
          Default display formats for numeric and monetary values
        Set a nondefault locale
      GLS locales with HCL Informix products
        Support for non-ASCII characters
        Establish a database connection
          Send the client locale
          Verify the database locale
          Check for connection warnings
          Determine the server-processing locale
            Locale information for the database
            Locale information for the client application
        Perform code-set conversion
          When code-set conversion is performed
        Locate message files
      Customize display formats
        Customize date and time display formats
          Era-based date and time formats
          Date and time precedence
        Customize currency display formats
      GLS Unicode options
    GLS environment variables
      Set and retrieve environment variables
      GLS-related environment variables
        CC8BITLEVEL environment variable
        CLIENT_LOCALE environment variable
        DBDATE environment variable (deprecated)
        DBLANG environment variable
        DB_LOCALE environment variable
        DBMONEY environment variable
        DBTIME environment variable (deprecated)
        ESQLMF environment variable
        GL_DATE environment variable
          The year formatting directives
          Alternative date formats
          Optional date format qualifiers
            Field specification for reading a DATE value
            Field specification for displaying a DATE value
        GL_DATETIME environment variable
          Alternative time formats
          Optional time format qualifiers
          Creation-time settings
        GLS8BITFSYS environment variable
          Restrictions on non-ASCII file names
            Make sure that your operating system is 8-bit clean
            Make sure that your product supports the same code set
            The server code set
            The client code set
        GL_USEGLU environment variable
        IFX_PUA_DISPLAY_MAPPING environment variable
        SERVER_LOCALE environment variable
        USE_DTENV environment variable
    SQL features
      Name database objects
        Rules for identifiers
        Non-ASCII characters in identifiers
          Qualifiers of SQL identifiers
          Owner names
          Path names and file names
          Delimited identifiers
        Valid characters in identifiers
      Character data types
        Localized collation of character data
          The NCHAR data type
            Collate NCHAR data
            Handle NCHAR data
            Multibyte characters with NCHAR
            Treat NCHAR values as numeric values
            Nonprintable characters with NCHAR
          The NVARCHAR data type
            Collate NVARCHAR data
            Handle NVARCHAR data
            Multibyte characters with NVARCHAR
            Nonprintable characters with NVARCHAR
            Store numeric values in an NVARCHAR column
          Performance considerations
        Other character data types
          The CHAR data type
          The VARCHAR data type
          The LVARCHAR data type
          The TEXT data type
      Handle character data
        Specify quoted strings
        Specify comments
        Specify column substrings
          Column substrings in single-byte code sets
          Column substrings in multibyte code sets
          Partial characters in column substrings
            Avoidance in a multibyte code set
          Errors involving partial characters
          Partial characters in an ORDER BY clause
            Avoidance in TEXT and BYTE columns
        Specify arguments to the TRIM function
        Search functions that are not case-sensitive
        Collate character data
          Collation order in CREATE INDEX
          Collation order in SELECT statements
            The ORDER BY clause
            Logical predicates in a WHERE clause
            Relational-operator conditions
            BETWEEN conditions
            IN conditions
          Comparisons with MATCHES and LIKE conditions
            MATCHES condition
            LIKE condition
            Wildcard characters in LIKE and MATCHES conditions
        SQL length functions
          The LENGTH function
          The OCTET_LENGTH function
          The CHAR_LENGTH function
      Locale-sensitive data types
        Handle the MONEY data type
          Specify values for the scale parameter
          Format of currency notation
        Handle extended data types
          Opaque data types
          Complex data types
          Distinct data types
        Handle smart large objects
      Data manipulation statements
        Specify conditions in the WHERE clause
        Specify era-based dates
        Load and unload data
          Load data into a database
          Unload data from a database
      Data definition statements
        Automatic resizing of the expansion factor
    Database server features
      GLS support by HCL Informix database servers
        Database server code-set conversion
        Data that the database server converts
      Locale-specific support for utilities
        Non-ASCII characters in database server utilities
        Non-ASCII characters in SQL utilities
      Locale support for C User-defined routines (Informix and DB API)
        Current processing locale for UDRs
        Non-ASCII characters in source code
          In C-language statements
          In SQL statements
        Copy character data
        The HCL Informix GLS library
          Character processing with HCL Informix GLS
          Compatibility of wide-character data types
        Code-set conversion and the DataBlade API
          Character strings in UDRs
          Character strings in opaque-type support functions
        Locale-specific data formatting
        Globalized exception messages
          Insert customized exception messages
          Insert a localized exception message from a C UDR
          Search for customized messages
          Specify parameter markers
        Globalized tracing messages
          Insert messages in the systracemsgs system catalog table
          Put globalized trace messages into code
          Search for trace messages
        Locale-sensitive data in an opaque data type
          Globalized input and output support functions
          Globalized send and receive support functions
    General SQL API features (ESQL/C)
      Support for GLS in HCL Informix client applications
        Client application code-set conversion
          Data that a client application converts
      Globalize client applications
        Globalization
        Localization
          Choose a GLS locale
          Translate messages
      Handle locale-specific data
        Process characters
        Format data
        Avoid partial characters
          Copy character data
          Code-set conversion
    IBM Informix ESQL/C features
      Handle non-ASCII characters
        Non-ASCII characters in host variables
        Generate non-ASCII file names
        Non-ASCII characters in ESQL/C source files
          Filter non-ASCII characters
          Invoke the ESQL/C filter
      Define variables for locale-sensitive data
      Enhanced ESQL/C library functions
        DATE-format functions
          GL_DATE support
          DBDATE extensions (deprecated)
          Extended DATE-format strings
          Precedence for date display formats
        DATETIME-format functions
          GL_DATETIME support
          DBTIME support
          Extended DATETIME-format strings
          Precedence for DATETIME display formats
        Numeric-format functions
          Support for multibyte characters
          Locale-specific numeric formatting
          Currency-symbol formatting
          DBMONEY extensions
        String functions
        GLS-specific error messages
      Handle code-set conversion
        Writing TEXT values
        The DESCRIBE statement
          The sqldata field
          The sqlname field
      The TRIM function
    Appendix
      Manage GLS files
        Access GLS files
        GLS locale files
          Locale categories
            The CTYPE category
            The COLLATION category
            The NUMERIC category
            The MONETARY category
            The TIME category
            The MESSAGES category
          Location of locale files
            Locale-file subdirectories
            Locale source and object files
            Locale file names
        Other GLS files
          Code-set-conversion files
            Code-set-conversion source and object files
            Code-set-conversion file names
            Required for code-set conversion
          Code-set files
          The HCL Informix registry file (Windows)
        Remove unused files
          Remove locale and code-set-conversion files
          Remove code-set files
        The glfiles utility (UNIX)
          List code-set-conversion files
          List GLS locale files
          List character-mapping files
  Informix GLS API
    Using Informix GLS
      Internationalized programs with Informix GLS
        What is Informix GLS?
        Informix GLS compatibility
        Choose a GLS Locale
      Using Informix GLS in a C-language program
        Compile and link Informix GLS
          Informix GLS in ESQL/C applications
          Informix GLS in DataBlade programs
            DataBlade client applications
            DataBlade user-defined routines
        Initialize the Informix GLS library
        Informix GLS exceptions
        Allocate memory
        Input and output streams
        Run the program
      Improve program performance
        Optimize Informix GLS
        Processing wide characters
    Character processing
      Types of characters
        Single-byte characters
        Multibyte characters
          The gl_mchar_t data type
          Wide characters
            The gl_wchar_t data type
            Conversion between multibyte and wide characters
      Character operations
        Character classification
        Case conversion
          Case conversion for multibyte characters
            Determine when to allocate a destination buffer
            Determine the number of bytes read and written
          Case conversion for wide characters
          Exception handling
          Performance issues
        Code-set conversion
          Determining if code-set conversion is needed
          Perform code-set conversion
            Determine when to allocate a destination buffer
            Specify code-set names
            Preserve state information
          Performance issues
      String operations
        String traversal
          Multibyte-character-string traversal
          Wide-character-string traversal
        String processing
          Concatenation
          String copying
          String-length determination
          Character searching
        Character/string comparison and sorting
      Other operations
        String and character termination
          Character-string termination
          Multibyte-character termination
        Managing memory for strings and characters
          Multibyte-character-string allocation
          Wide-character-string allocation
          String deallocation
        Keep multibyte strings consistent
          Truncate multibyte strings
          Fragment multibyte strings
    Data formatting
      Locale-specific data formats
        The LC_NUMERIC locale-file category
        The LC_MONETARY locale-file category
        The LC_TIME locale-file category
      Conversion and formatting with Informix GLS
        Convert a locale-specific string
        Format a locale-specific string
    Informix GLS functions
      Function summary
      Function reference
        The ifx_gl_case_conv_outbuflen() function
        The ifx_gl_complen() function
        The ifx_gl_conv_needed() function
        The ifx_gl_convert_date() function
        The ifx_gl_convert_datetime() function
        The ifx_gl_convert_money() function
        The ifx_gl_convert_number() function
        The ifx_gl_cv_mconv() function
        The ifx_gl_cv_outbuflen() function
        The ifx_gl_cv_sb2sb_table() function
        The ifx_gl_format_date() function
        The ifx_gl_format_datetime() function
        The ifx_gl_format_money() function
        The ifx_gl_format_number() function
        The ifx_gl_getmb() function
        The ifx_gl_init() function
        The ifx_gl_ismalnum() function
        The ifx_gl_ismalpha() function
        The ifx_gl_ismblank() function
        The ifx_gl_ismcntrl() function
        The ifx_gl_ismdigit() function
        The ifx_gl_ismgraph() function
        The ifx_gl_ismlower() function
        The ifx_gl_ismprint() function
        The ifx_gl_ismpunct() function
        The ifx_gl_ismspace() function
        The ifx_gl_ismupper() function
        The ifx_gl_ismxdigit() function
        The ifx_gl_iswalnum() function
        The ifx_gl_iswalpha() function
        The ifx_gl_iswblank() function
        The ifx_gl_iswcntrl() function
        The ifx_gl_iswdigit() function
        The ifx_gl_iswgraph() function
        The ifx_gl_iswlower() function
        The ifx_gl_iswprint() function
        The ifx_gl_iswpunct() function
        The ifx_gl_iswspace() function
        The ifx_gl_iswupper() function
        The ifx_gl_iswxdigit() function
        The ifx_gl_lc_errno() function
        The ifx_gl_mb_loc_max() function
        The ifx_gl_mblen() function
        The ifx_gl_mbscat() function
        The ifx_gl_mbschr() function
        The ifx_gl_mbscoll() function
        The ifx_gl_mbscpy() function
        The ifx_gl_mbscspn() function
        The ifx_gl_mbslen() function
        The ifx_gl_mbsmbs() function
        The ifx_gl_mbsncat() function
        The ifx_gl_mbsncpy() function
        The ifx_gl_mbsnext() function
        The ifx_gl_mbsntsbytes() function
        The ifx_gl_mbsntslen() function
        The ifx_gl_mbspbrk() function
        The ifx_gl_mbsprev() function
        The ifx_gl_mbsrchr() function
        The ifx_gl_mbsspn() function
        The ifx_gl_mbstowcs() function
        The ifx_gl_mbtowc() function
        The ifx_gl_putmb() function
        The ifx_gl_tomlower() function
        The ifx_gl_tomupper() function
        The ifx_gl_towlower() function
        The ifx_gl_towupper() function
        The ifx_gl_wcscat() function
        The ifx_gl_wcschr() function
        The ifx_gl_wcscoll() function
        The ifx_gl_wcscpy() function
        The ifx_gl_wcscspn() function
        The ifx_gl_wcslen() function
        The ifx_gl_wcsncat() function
        The ifx_gl_wcsncpy() function
        The ifx_gl_wcsntslen() function
        The ifx_gl_wcspbrk() function
        The ifx_gl_wcsrchr() function
        The ifx_gl_wcsspn() function
        The ifx_gl_wcstombs() function
        The ifx_gl_wcswcs() function
        The ifx_gl_wctomb() function
    Appendix
      List of Informix GLS error numbers
  Informix Object Interface for C++ Guide
    Architecture of the object interface for C++
      Operation classes
      Value interfaces and value objects
      Class hierarchy
      Implementation notes
        Restrictions
        Passing objects—compiler dependency
        Informix database server compatibility
      Globalization
        ITFactory list and the type map
    Issue database queries and retrieve results
      Using operation classes
      Create connections
      Find system names and database names
        Using ITSystemNameList
        Using ITDBNameList
      Manage errors
        Using the error handling feature
      Connection transaction states
      Issue queries
        When to use the different ITQuery methods
        Query method example
        Using prepared statements
        Using cursors
        Using the large object manager
        Using ITRoutineManager
    Access data values
      Access data values
      Value object management
      The ITValue interface
      The ITConversions interface
      The ITDatum interface
      The ITDateTime interface
      The ITLargeObject interface
      The ITErrorInfo interface
      The ITRow interface
      The ITSet interface
      The ITContainer interface
      The ITContainCvt interface
    Create and extend value objects
      The raw data object
      Build simple value objects
      Expose multiple interfaces
      Value objects and connection events
      Create row type value objects
        Create row type value objects without an open connection
        Create collection type value objects without an open connection
      Object Containment and Delegation
      Dynamic loading
        Map files
        Guidelines
    Operation class reference
      The ITConnection class
      The ITConnectionStamp class
      The ITContainerIter class
      The ITCursor class
      The ITDBInfo class
      The ITDBNameList class
      The ITErrorManager class
      The ITFactoryList class
        Successful initialization verification
      The ITInt8 class
      The ITLargeObjectManager class
        Accessing smart large objects in nondefault sbspaces
      The ITMVDesc class
      The ITObject class
      The ITPosition class
      The ITPreserveData class
      The ITQuery class
      The ITRoutineManager class
      The ITStatement class
      The ITString class
      The ITSystemNameList class
      The ITTypeInfo class
    Value interface reference
      The ITContainCvt interface
      The ITContainer interface
      The ITConversions interface
        C++ compiler interpretation of long doubles
      The ITDateTime interface
      The ITDatum interface
      The ITErrorInfo interface
      The ITEssential interface
      The ITLargeObject interface
      The ITRow interface
      The ITSet interface
      The ITValue interface
        Use of ITValue::Printable with null value objects
    Appendixes
      Supported data types
      Example programs
      The ITLocale class
        Multibyte character string termination
        Multibyte character termination
        Memory allocation
        Access the ITLocale object
        Error return method
        String comparison methods
          The MCollate method
          The WCollate method
        String processing methods
          The MConcatenate method
          The MScan method
          The MCopy method
          The MComplSpanSize method
          The MLength method
          The MFindSubstr method
          The MNConcatenate method
          The MNCopy method
          The MNTSBytes method
          The MNTSLength method
          The MSpan method
          The MRScan method
          The MSpanSize method
          The WConcatenate method
          The WScan method
          The WCopy method
          The WComplSpanSize method
          The WLength method
          The WNConcatenate method
          The WNCopy method
          The WNTSLength method
          The WSpan method
          The WRScan method
          The WSpanSize method
          The WFindSubstr method
        Environment method
        Code set conversion methods
          The ConvertCodeset method
          The NeedToConvertCodeset method
          The SizeForCodesetConversion method
        Character classification methods
          The IsAlnum method
          The IsAlpha method
          The IsBlank method
          The IsCntrl method
          The IsDigit method
          The IsGraph method
          The IsLower method
          The IsPrint method
          The IsPunct method
          The IsSpace method
          The IsUpper method
          The IsXDigit method
        Character case conversion methods
          The ToUpper—Wide Character method
          The ToUpper—Multibyte Character method
          The ToLower—Wide Character method
          The ToLower—Multibyte Character method
        Built-in data type conversion methods
          The ConvertDate method
          The FormatDate method
          The ConvertDatetime method
          The FormatDatetime method
          The ConvertNumber method
          The FormatNumber method
          The ConvertMoney method
          The FormatMoney method
        Multibyte and wide character conversion methods
          The MToWString method
          The MToWChar method
          The WToMString method
          The WToMChar method
        Multibyte string traversal and indexing methods
          The MCharBytes method
          The MCharLen method
          The MNextChar method
          The MPrevChar method
  Informix ODBC Driver Guide
    Overview of HCL Informix ODBC Driver
      What is HCL Informix ODBC Driver?
        HCL Informix ODBC Driver features
          Support for extended data types
          Support for GLS data types
          Extended error detection
        Additional values for some ODBC function arguments
      ODBC component overview
        HCL Informix ODBC Driver with a driver manager
        HCL Informix ODBC Driver without a driver manager (UNIX)
      HCL Informix ODBC Driver with the DMR
      HCL Informix ODBC Driver components
        Environment variables
          Set environment variables on UNIX
          Set environment variables in Windows
        Header files
        Data types
        Libraries
      The HCL Informix ODBC Driver API
        Environment, connection, and statement handles
        Buffers
          Input buffers
          Output buffers
        SQLGetInfo argument implementation
      Global Language Support
      X/Open standard interface
      External authentication
        Pluggable Authentication Module (PAM) on UNIX and Linux
        LDAP Authentication on Windows
        The SQLSetConnectAttr() function with authentication
          Connection pooling and authentication
          Connect functions
          Third-party applications or intermediate code
      Bypass ODBC parsing
      BufferLength in character for SQLGetDiagRecW
      Informix and ISAM error descriptions in SQLGetDiagRec
      Improved performance for single-threaded applications
      Partially supported and unsupported ODBC features
        Transaction processing
          Transaction isolation levels
          Changing the transaction mode
        ODBC cursors
        ODBC bookmarks
        SQLBulkOperations
        SQLDescribeParam
        Unsupported Microsoft ODBC driver features
    Configure data sources
      Configure a DSN on UNIX
        The odbcinst.ini file
          ODBC drivers
          Driver specifications
        The odbc.ini file
          ODBC Data Sources
          Data-source specification
          Set the isolation level (UNIX only)
        ODBC section
        Set the $ODBCINI environment variable
        The .netrc file
      Configuring a DSN in Windows
        Configuring a new user DSN or system DSN
        Removing a DSN
        Reconfiguring an existing DSN
        Configuring a file DSN
        Creating logs of calls to the drivers
      Creating and configuring a DSN on Mac OS X
      Connection string keywords that make a connection
      DSN migration tool
        Setting up and using the DSN migration tool
        DSN migration tool examples
    Data types
      Data types
      SQL data types
        Standard SQL data types
          Visual Basic client-side cursors
        Additional SQL data types for GLS
        Additional SQL data types for Informix
        Precision, scale, length, and display size
          Standard SQL data types
          Additional SQL data types for Informix
      C data types
        C interval structure
        Transfer data
      Report standard ODBC types
        SQL_INFX_ATTR_ODBC_TYPES_ONLY
        SQL_INFX_ATTR_LO_AUTOMATIC
        SQL_INFX_ATTR_DEFAULT_UDT_FETCH_TYPE
        Report wide character columns
        DSN settings for report standard ODBC data types
      Convert data
        Standard conversions
        Additional conversions for GLS
        Additional conversions for Informix
        Convert data from SQL to C
          Default C data types
            Standard default C data types
            Additional default C data types for Informix
          SQL to C: Binary
          SQL to C: Boolean
          SQL to C: Character
          SQL to C: Date
          SQL to C: Numeric
          SQL to C: Time stamp
          SQL-to-C data conversion examples
        Convert data from C to SQL
          C to SQL: Binary
          C to SQL: Bit
          C to SQL: Character
          C to SQL: Date
          C to SQL: Numeric
          C to SQL: Time stamp
          C-to-SQL data conversion examples
    Smart large objects
      Data structures for smart large objects
        Working with a smart-large-object data structure
      Storage of smart large objects
        Disk-storage information
        Create-time flags
        Inheritance hierarchy
          Using system-specified storage characteristics
          Using column-level storage characteristics
          User-defined storage characteristics
      Example of creating a smart large object
      Transfer smart-large-object data
      Access a smart large object
        Smart-large-object automation
          Set the access method using SQL_INFX_ATTR_LO_AUTOMATIC
          Insert, update, and delete smart large objects using the ODBC API
          Select smart large objects using the ODBC API
        The ifx_lo functions
          Select a smart large object using ifx_lo functions
          Open a smart large object using ifx_lo functions
            Access modes
          Lightweight I/O
          Smart-large-object locks
          Duration of an open operation on a smart large object
          Delete a smart large object
          Modifying a smart large object
          Close a smart large object
          Example of retrieving a smart large object from the database using ifx_lo functions
      Retrieve the status of a smart large object
        Example of retrieving information about a smart large object
      Read or write a smart large object to or from a file
    Rows and collections
      Allocating and binding a row or collection buffer
        Fixed-type buffers and unfixed-type buffers
        Buffers and memory allocation
        SQL data
        Performing a local fetch
        Example of retrieving row and collection data from the database
      Example of creating a row and a list on the client
      Modify a row or collection
      Retrieve information about a row or collection
    Client functions
      Call a client function
        SQL syntax
        Function syntax
          Executing a client function with SQLPrepare() and SQLExecute()
          Executing a client function with SQLExecDirect()
        Input and output parameters
        The SQL_BIGINT data type
        Return codes
      Functions for smart large objects
        The ifx_lo_alter() function
        The ifx_lo_close() function
        The ifx_lo_col_info() function
        The ifx_lo_create() function
        The ifx_lo_def_create_spec() function
        The ifx_lo_open() function
        The ifx_lo_read() function
        The ifx_lo_readwithseek() function
        The ifx_lo_seek() function
        The ifx_lo_specget_estbytes() function
        The ifx_lo_specget_extsz() function
        The ifx_lo_specget_flags() function
        The ifx_lo_specget_maxbytes() function
        The ifx_lo_specget_sbspace() function
        The ifx_lo_specset_estbytes() function
        The ifx_lo_specset_extsz() function
        The ifx_lo_specset_flags() function
        The ifx_lo_specset_maxbytes() function
        The ifx_lo_specset_sbspace() function
        The ifx_lo_stat() function
        The ifx_lo_stat_atime() function
        The ifx_lo_stat_cspec() function
        The ifx_lo_stat_ctime() function
        The ifx_lo_stat_refcnt() function
        The ifx_lo_stat_size() function
        The ifx_lo_tell() function
        The ifx_lo_truncate() function
        The ifx_lo_write() function
        The ifx_lo_writewithseek() function
      Functions for rows and collections
        The ifx_rc_count() function
        The ifx_rc_create() function
        The ifx_rc_delete() function
        The ifx_rc_describe() function
        The ifx_rc_fetch() function
        The ifx_rc_free() function
        The ifx_rc_insert() function
        The ifx_rc_isnull() function
        The ifx_rc_setnull() function
        The ifx_rc_typespec() function
        The ifx_rc_update() function
    Improve application performance
      Error checking during data transfer
      Enable delimited identifiers in ODBC
      Connection level optimizations
      Optimizing query execution
      Insert multiple rows
      Automatically freeing a cursor
        Enabling the AUTOFREE feature
        The AUTOFREE feature
      Delay execution of the SQL PREPARE statement
      Set the fetch array size for simple-large-object data
      The SPL output parameter feature
      OUT and INOUT parameters
      Asynchronous execution
      Update data with positioned updates and deletes
      BIGINT and BIGSERIAL data types
      Message transfer optimization
        Message chaining restrictions
        Disable message chaining
        Errors with optimized message transfers
    Error messages
      Diagnostic SQLSTATE values
      Map SQLSTATE values to Informix error messages
      Map Informix error messages to SQLSTATE values
        Deprecated and new HCL Informix ODBC Driver APIs
        SQLAllocConnect (core level only)
        SQLAllocEnv (core level only)
        SQLAllocStmt (core level only)
        SQLBindCol (core level only)
        SQLBindParameter (level one only)
        SQLBrowseConnect (level two only)
        SQLCancel (core level only)
        SQLColAttributes (core level only)
        SQLColumnPrivileges (level two only)
        SQLColumns (level one only)
        SQLConnect (core level only)
        SQLDataSources (level two only)
        SQLDescribeCol (core level only)
        SQLDisconnect
          Usage
        SQLDriverConnect (level one only)
        SQLDrivers (level two only)
        SQLError (core level only)
        SQLExecDirect (core level only)
        SQLExecute (core level only)
        SQLExtendedFetch (level two only)
        SQLFetch (core level only)
        SQLForeignKeys (level two only)
        SQLFreeConnect (core level only)
        SQLFreeEnv (core level only)
        SQLFreeStmt (core level only)
        SQLGetConnectOption (level one only)
        SQLGetCursorName (core level only)
        SQLGetData (level one only)
        SQLGetFunctions (level one only)
        SQLGetInfo (level one only)
        SQLGetStmtOption (level one only)
        SQLGetTypeInfo (level one only)
        SQLMoreResults (level two only)
        SQLNativeSql (level two only)
          Usage
        SQLNumParams (level two only)
        SQLNumResultCols (core level only)
        SQLParamData (level one only)
      SQLParamOptions (core and level two only)
        SQLPrepare
        SQLPrimaryKeys (level two only)
        SQLProcedureColumns (level two only)
        SQLProcedures (level two only)
        SQLPutData (level one only)
        SQLRowCount (core level only)
        SQLSetConnectOption (level one only)
        SQLSetCursorName (core level only)
        SQLSetStmtOption (level one only)
        SQLSpecialColumns (level one only)
        SQLStatistics (level one only)
        SQLTablePrivileges (level two only)
        SQLTables (level one only)
        SQLTransact (core level only)
    Unicode
      Overview of Unicode
        Unicode versions
      Unicode in an ODBC application
      Unicode in an ODBC application
        Configuration
      Supported Unicode functions
  .NET provider options
    Differences between .NET Providers
    Informix .NET Provider Guide
      What's new in HCL Informix .NET Provider, Version 4.10
      Overview of the HCL Informix .NET Provider
        What is the Informix .NET Provider?
        Supported programming environments
        Support for IPv6
        Installing the HCL Informix .NET Provider
          Prepare the database server
        Overview of the .NET provider class library
        Thread-safety of provider types
        Namespace requirements
        Connecting to a database
          Reconcile DataSet changes with the database
          The connection pool
          Set FullTrust permission
        The ? parameter markers
        Call stored procedures
        IfxProviderFactory objects to write database-independent code
        Distributed transactions
        The OUT and INOUT Parameters
        Generic coding with the ADO.NET common base classes
        Error messages
          Tracing
          Error checking during data transfer
      Mapping data types
        Retrieve data
        Set data types for a parameter
        Display format of FLOAT, DECIMAL, or MONEY data types
      Type reference
        Supported public .NET interfaces
        Supported Public .NET base classes
        Prototype syntax
        IfxBlob class
          The IfxBlob internal cursor
          Create an IfxBlob
            IfxBlob constructors
          IfxBlob public properties
          IfxBlob public methods
        IfxClob class
          The IfxClob internal cursor
          Create an IfxClob
            IfxClob constructors
          IfxClob public properties
          IfxClob public methods
        IfxCommand class
          Create an IfxCommand
            IfxCommand constructors
          IfxCommand public properties
          IfxCommand public methods
          IfxCommand examples
        IfxCommandBuilder class
          Create an IfxCommandBuilder
            IfxCommandBuilder constructors
          IfxCommandBuilder public properties
          IfxCommandBuilder public methods
          IfxCommandBuilder examples
        IfxConnection class
          Create an IfxConnection
            IfxConnection constructors
          IfxConnection public properties
            ConnectionString property
            UserDefinedTypeFormat property
          IfxConnection public methods
          IfxConnection public events
          IfxConnection example
        IfxConnectionStringBuilder class
          Create an IfxConnectionStringBuilder
          IfxConnectionStringBuilder public properties
          IfxConnectionStringBuilder public methods
        IfxDataAdapter class
          Create an IfxDataAdapter
            IfxDataAdapter constructors
          IfxDataAdapter public properties
          IfxDataAdapter public methods
          IfxDataAdapter examples
        IfxDataReader class
          IfxDataReader public properties
          IfxDataReader public methods
          IfxDataReader example
        IfxDataSourceEnumerator class
          Create an IfxDataSourceEnumerator
          IfxDataSourceEnumerator public properties
          IfxDataSourceEnumerator public methods
        IfxDateTime structure
          Create an IfxDateTime
            IfxDateTime constructors
          IfxDateTime public properties
          IfxDateTime public methods
        IfxDecimal structure
          Create an IfxDecimal
            IfxDecimal constructors
          IfxDecimal properties
          IfxDecimal methods
        IfxError class
          IfxError public properties
        IfxErrorCollection class
          IfxErrorCollection public properties
          IfxErrorCollection public methods
        IfxException class
          IfxException public properties
        IfxMonthSpan structure
          Create an IfxMonthSpan
            IfxMonthSpan constructors
          IfxMonthSpan public properties
          IfxMonthSpan public methods
        IfxParameter class
          Create an IfxParameter class
            IfxParameter constructors
          IfxParameter public properties
          IfxParameter examples
        IfxParameterCollection class
          Create an IfxParameterCollection
          IfxParameterCollection public properties
          IfxParameterCollection public methods
        IfxProviderFactory class
          IfxProviderFactory public methods
        IfxSmartLOBCreateTimeFlags enumeration
        IfxSmartLOBFileLocation enumeration
        IfxSmartLOBLocator class
        IfxSmartLOBLockMode enumeration
        IfxSmartLOBOpenMode enumeration
        IfxSmartLOBWhence enumeration
        IfxTimeSpan structure
          Create an IfxTimeSpan
            IfxTimeSpan constructors
          IfxTimeSpan public properties
          IfxTimeSpan public methods
        IfxTimeUnit enumeration
        IfxTransaction class
          IfxTransaction public properties
          IfxTransaction public methods
          IfxTransaction example
        IfxType enumeration
      Sample programs
        Demonstration programs
        HCL Informix .NET Provider examples
          Retrieve a single value
          Retrieve multiple rows
          Execute SQL that does not return data and using a transaction
          Retrieve data into a DataSet
          IfxCommandBuilder object to reconcile changes with the database
          Call a stored procedure
          Distributed transactions
          Write CLOBs to files
  Informix 4GL
  Informix JDBC Driver Guide
    What's new in HCL Informix JDBC Driver, Version 4.10
    Getting started
      What is JDBC?
      What is a JDBC driver?
      HCL Informix JDBC Driver
        Classes implemented in Informix JDBC Driver
          Informix classes that implement Java interfaces
          Informix classes that extend the JDBC specification
          Informix classes that provide support beyond the Java specification
          UDTManager and UDRManager classes
        Files in HCL Informix JDBC Driver
      Obtain the JDBC driver
      Installing the JDBC Driver
        Installing JDBC driver in graphical or console mode
        Installing the JDBC driver in silent mode
      Using the driver in an application
      Using the driver in an applet
      Uninstall the JDBC Driver
        Uninstall in graphical or console mode
        Uninstall in silent mode
    Connect to the database
      Load HCL Informix JDBC Driver
      A DataSource object
      The DriverManager.getConnection() method
        Format of database URLs
          IP address in connection URLs
        Database versus database server connections
        Specify properties
      Informix environment variables with the HCL Informix JDBC Driver
      Dynamically reading the Informix sqlhosts file
        Connection property syntax
        Administration requirements
        Utilities to update the LDAP server with sqlhosts data
          The SqlhUpload utility
          The SqlhDelete utility
      Connections to the servers of a high-availability cluster
        Properties for connecting to high-availability cluster servers through HCL Informix Connection Managers
        Properties for connecting to high-availability cluster servers through SQLHOST file group entries
        Properties for connecting directly to an HDR pair of servers
        Checks for read-only status of high-availability secondary servers
        Connection retry attempts to HDR secondary servers
      An HTTP proxy server
        Configuring your environment to use a proxy server
          Specify a timeout
        The proxy with an LDAP server
          Specify where LDAP lookup occurs
        Specify sqlhosts file lookup
      Other multitier solutions
      Encryption options
        FIPS-compliant security package
        Password encryption
          Configure the database server
        Connecting JDBC applications with SSL
        CSM network encryption
          CSM network encryption syntax
          Option tags
          Option parameters
      Using single sign-on access control with the Informix JDBC Driver
      PAM authentication method
        PAM in JDBC
      Close the connection
    Perform database operations
      Query the database
        Example of sending a query to the Informix database
        Reoptimize queries
        Result sets
          Scrollable result set for multiple rows
        Deallocate resources
        Execute across threads
        Scroll cursors
          Scroll sensitivity
          Client-side scrolling
          Result set updatability
        Hold cursors
      Update the database
        Perform batch updates
          SQL statements and batch updates
          Return value from Statement.executeBatch() method
        Perform bulk inserts
      Parameters, escape syntax, and unsupported methods
        The CallableStatement OUT parameters
          Server and driver restrictions and limitations
            Server restrictions
            Driver enhancement
            Driver restrictions and limitations
              IN and OUT parameter type mapping
        Named parameters in a CallableStatement
          Requirements and restrictions for named parameters in a CallableStatement
            Verify support for named parameters in a CallableStatement
          Retrieve parameter names for stored procedures
          Named parameters and unique stored procedures
            Example of number of named parameters equals the number of arguments
            Example of number of named parameters Is less than the number of arguments
          Named parameters and overloaded stored procedures
        JDBC support for DESCRIBE INPUT
        The escape syntax
        Unsupported methods and methods that behave differently
      Handle transactions
        Autocommit
          Logged Database
          ANSI Databases
          Non-logged Databases
        Transactions with Large Objects
        Transactions with XA
        Transactions with Savepoints
      Handle errors
        Handle errors with the SQLException class
        Retrieve the syntax error offset
          Catch RSAM error messages
        Handle errors with the com.informix.jdbc.Message class
      Access database metadata
      Other Informix extensions to the JDBC API
        The Auto Free feature
        Obtaining driver version information
      Store and retrieve XML documents
        Set up your environment to use XML methods
          Set your CLASSPATH
          Specify a parser factory
        Insert data
        Retrieve data
        Insert data examples
          The XMLtoString() examples
          The XMLtoInputStream() example
        Retrieve data examples
          The StringtoDOM() example
          The InputStreamtoDOM() example
          The getInputSource() examples
    Work with Informix types
      Distinct data types
        Insert data examples
        Retrieve data example
        Unsupported methods
      BYTE and TEXT data types
        Cache large objects
        Example: Inserting or updating data
        Example: Selecting data
      SERIAL and SERIAL8 data types
      BIGINT and BIGSERIAL data types
      INTERVAL data type
        The Interval class
          Variables for binary qualifiers
          Interval methods
        The IntervalYM class
          The IntervalYM constructors
          The IntervalYM methods
        The IntervalDF class
          The IntervalDF constructors
          The IntervalDF methods
        Interval example
      Collections and arrays
        Collection examples
        Array example
      Named and unnamed rows
        Interval and collection support
        Unsupported methods
        The SQLData interface
          SQLData examples
        The Struct interface
          Struct examples
        The ClassGenerator utility
          Simple named row example
          Nested named row example
      Type cache information
      Smart large object data types
        Smart large objects in the database server
        Smart large objects in a client application
          Creating smart large objects
            Create an IfxLobDescriptor object
            Create an IfxLocator object
            Create an IfxSmartBlob object
            Inserting a smart large object into a column
          Accessing smart large objects
        Perform operations on smart large objects
          Open a smart large object
          Position within a smart large object
          Read data from a smart large object
          Write data to a smart large object
          Truncate a smart large object
          Measure a smart large object
          Close and release a smart large object
          Convert IfxLocator to a hexadecimal string
        Work with storage characteristics
          System-specified storage characteristics
            Obtain information about storage characteristics
            Example of setting sbspace characteristics
          Work with disk-storage information
          Work with logging, last-access time, and data integrity
            Logging
            Last-access time
            Data integrity
          Changing the storage characteristics
            Set create flags
        Work with status characteristics
        Work with locks
          Byte-range locking
        Cache large objects
        Avoid errors transferring large objects
        Smart large object examples
          Create a smart large object
          Insert data into a smart large object
          Retrieve data from a smart large object
    Work with opaque types
      The IfmxUDTSQLInput interface
        Read data
        Position in the data stream
        Set or obtain data attributes
      The IfmxUDTSQLOutput interface
      Map opaque data types
      Type cache information
      Unsupported methods
      Creating opaque types and UDRs
        Overview of creating opaque types and UDRs
        Preparing to create opaque types and UDRs
        Creating opaque types
          Creating an opaque type from an existing Java class
          Creating an opaque type without an existing Java class
        Creating a UDR
        Requirements for the Java class
        SQL names
        Specify characteristics for an opaque type
          Specify field count
          Specify additional field characteristics
          Specify length
          Specify alignment
          Alignment values
          Specify SQL names
          Specify the Java class name
          Specifying Java source file retention
        Creating the JAR and class files
          Create the .class and .java files
          Create the .jar file
        Send the class definition to the database server
          Specify deployment descriptor actions
          Specify a JAR file temporary path
        Creating an opaque type from existing code
          The setXXXCast() methods
          The setSupportUDR() and setUDR() methods
        Remove opaque types and JAR files
        Create UDRs
        Remove UDRs and JAR files
          Remove overloaded UDRs
        Obtain information about opaque types and UDRs
          The getXXX() methods in the UDTMetaData class
          The getXXX() methods in the UDRMetaData class
        Execute in a transaction
      Examples
        Class definition
        Insert data
        Retrieve data
        Smart large objects within an opaque type
        Create an opaque type from an existing Java class with UDTManager
          Create an opaque type using default support functions
            The opaque type
          Create an opaque type using support functions you supply
            The opaque type
        Create an opaque type without an existing Java class
        Create UDRs with UDRManager
    Globalization and date formats
      Support for Java and globalization
      Support for HCL Informix GLS variables
      Support for DATE end-user formats
        The GL_DATE variable
        The DBDATE variable (deprecated)
        The DBCENTURY variable
      Precedence rules for end-user formats
      Support for code-set conversion
        Unicode to database code set
        Unicode to client code set
        Connect to a database with non-ASCII characters
        Code-set conversion for TEXT and CLOB data types
          Convert with the IFX_CODESETLOB environment variable
          Convert with Java methods
        Code-set conversion for BLOB and BYTE data types
      User-defined locales
        Connect with the NEWLOCALE and NEWCODESET environment variables
        Connect with the NEWNLSMAP environment variable
      Support for globalized error messages
    Smart trigger feature
    Tuning and troubleshooting
      Debug your JDBC API program
      Manage performance
        Manage the fetch buffer size
        Manage memory for large objects
        Reduce network traffic
        Bulk inserts
        A connection pool
          Deploying a ConnectionPoolDataSource object
          Tune the Connection Pool Manager
          High-Availability Data Replication with connection pooling
          Clean pooled connections
          Manage connections
        Avoid application hanging problems (HP-UX only)
    Appendixes
      Sample code files
        Summary of available examples
          Examples in the demo directory
            Examples in the basic directory
            Examples in the bson directory
            Examples in the clob-blob directory
            Examples in the udt-distinct directory
            Examples in the complex-types directory
            Examples in the proxy directory
            Examples in the connection-pool directory
            Examples in the xml directory
            Examples in the hdr directory
          Examples in the tools directory
            Examples in the udtudrmgr directory
      DataSource extensions
        Read and write properties
        Get and set standard properties
        Get and set Informix connection properties
        Get and set connection pool DataSource properties
      Mapping data types
        Data type mapping between Informix and JDBC data types
          Data type mapping between extended types and Java and JDBC types
          Data type mapping between C opaque types and Java
        Data type mapping for PreparedStatement.setXXX() extensions
          The mapping extensions
            The extensions for opaque types
              The setBindColType() methods
              The setBindColIfxType() methods
              The clearBindColType() method
              Prebinding example
            Other mapping extensions
          The IfxTypes class
          Extension summary
            Nonextended data types
            Informix extended data types
        Data type mapping for ResultSet.getXXX() methods
          Nonextended data types
          Informix extended data types
        Data type mapping for UDT manager and UDR manager
          Mapping for casts
          Mapping for field types
            Field lengths and date-time data
      Convert internal Informix data types
        The IfxToJavaType class
          The convertDateToDays() method
          The convertDaysToDate() method
          The IfxToJavaChar() method
          The IfxToJavaDate() method
          The IfxToJavaDateTime() method
          The IfxToDateTimeUnloadString() method
          The IfxToJavaDecimal() method
          The IfxToJavaDouble() method
          The IfxToJavaInt() method
          The IfxToJavaInterval() method
          The IfxToJavaLongBigInt() method
          The IfxToJavaLongInt() method
          The IfxToJavaReal() method
          The IfxToJavaSmallInt() method
          The rleapyear() method
          The widenByte() method
      Error messages
        -79700
        -79702
        -79703
        -79704
        -79705
        -79706
        -79707
        -79708
        -79709
        -79710
        -79711
        -79712
        -79713
        -79714
        -79715
        -79716
        -79717
        -79718
        -79719
        -79720
        -79721
        -79722
        -79723
        -79724
        -79725
        -79726
        -79727
        -79728
        -79729
        -79730
        -79731
        -79732
        -79733
        -79734
        -79735
        -79736
        -79737
        -79738
        -79739
        -79740
        -79741
        -79742
        -79744
        -79745
        -79746
        -79747
        -79748
        -79749
        -79750
        -79755
        -79756
        -79757
        -79758
        -79759
        -79760
        -79761
        -79762
        -79764
        -79765
        -79766
        -79767
        -79768
        -79769
        -79770
        -79771
        -79772
        -79774
        -79775
        -79776
        -79777
        -79778
        -79780
        -79781
        -79782
        -79783
        -79784
        -79785
        -79786
        -79788
        -79789
        -79790
        -79792
        -79793
        -79794
        -79795
        -79796
        -79797
        -79798
        -79799
        -79800
        -79801
        -79802
        -79803
        -79804
        -79805
        -79806
        -79807
        -79808
        -79809
        -79811
        -79812
        -79814
        -79815
        -79816
        -79817
        -79818
        -79819
        -79820
        -79821
        -79822
        -79823
        -79824
        -79825
        -79826
        -79827
        -79828
        -79829
        -79830
        -79831
        -79834
        -79836
        -79837
        -79838
        -79839
        -79840
        -79842
        -79843
        -79844
        -79845
        -79846
        -79847
        -79848
        -79849
        -79850
        -79851
        -79852
        -79853
        -79854
        -79855
        -79856
        -79857
        -79858
        -79859
        -79860
        -79861
        -79862
        -79863
        -79864
        -79865
        -79868
        -79877
        -79878
        -79879
        -79880
        -79881
  Informix International Language Supplement (ILS) User Guide
    Introduction
    Syntax conventions
    Installation
      Installation notes for HP platform
    User interface files
      Compatibility matrix file
      Supported code set names used by Informix
      Language and country and region codes used by Informix: IS0 639
      Country and region codes used by Informix: IS0 3166
      GLS registry file
      Configuration
      CLIENT_LOCALE environment variable
      Working with the US product
      DBLANG environment variable
      Note for Russian users
  Informix OLE DB Provider Guide
  Informix OLE DB Provider Guide
    Overview and setup
      Introduction to HCL Informix OLE DB Provider
      Install and configure Informix OLE DB Provider
        Manually adding HCL Informix OLE DB Provider to the registry
        Manually removing HCL Informix OLE DB Provider from the registry
        Upgrading from previous versions
      Sample programs
      Support of OLE DB specifications
      Support of LDAP Authentication in Windows
      Supported interfaces
    HCL Informix OLE DB Provider
      Supported applications
      Connect to a data source
      Cursors
      Data types
        Data type mappings
        The INTERVAL type mapping
        The DATETIME type mapping
        The decimal and money type mapping
        Large object and user-defined data type mapping
        Data conversions from OLE DB types to HCL Informix types
        Data conversions from HCL Informix types to OLE DB types
      Threading support
      Transaction support
        Distributed transactions
        Local transactions
      Distributed transaction support
      Identifiers
      Support for Dynamic Query Extension
      Support for SQL 99 Joins
      International GLS Locales
        Conversion between Unicode and MBCS character sets
        The UNICODE provider string keyword
        The REPORTSTRINGASWSTRING provider string keyword
      Troubleshooting installation, configuration, or operation problems
        HCL Informix OLE DB Provider not registered
        Class not registered
        Cannot establish a connection
        Database not found
        The oledbversion table not found
        Nonalphabetic MBCS characters generate syntax errors
        Server-side cursor fails to update records
        Attempt to use provider from web server or other server fails
        Cannot connect to transaction manager
        Driver not found error
        Errors for stored procedures
        Known issues with OLE DB .NET bridge
  Change Data Capture API Programmer's Guide
    Getting started with the Change Data Capture API
      The Change Data Capture API
        Change Data Capture API components
        Smart large object read functions
        CDC record sequence numbers
        Data for capture
      Preparing to use the Change Data Capture API
      Writing an application to capture data changes
        Handling errors
      Handling smart large objects
      Restarting data capture
      Monitoring data capture
    Change Data Capture functions
      The cdc_activatesess() function
      The cdc_closesess() function
      The cdc_deactivatesess() function
      The cdc_endcapture() function
      The cdc_errortext() function
      The cdc_opensess() function
      The cdc_recboundary() function
      The cdc_set_fullrowlogging() function
      The cdc_startcapture() function
    Change Data Capture records
      Format of CDC records
      The CDC_REC_BEGINTX record
      The CDC_REC_COMMTX record
      The CDC_REC_DELETE record
      The CDC_REC_DISCARD record
      The CDC_REC_ERROR record
      The CDC_REC_INSERT record
      The CDC_REC_RBTX record
      The CDC_REC_TABSCHEMA record
      The CDC_REC_TIMEOUT record
      The CDC_REC_TRUNCATE record
      The CDC_REC_UPDAFT record
      The CDC_REC_UPDBEF record
    The syscdc system database
      The syscdcerrcodes table
      The syscdcrectypes table
    Change Data Capture error codes
    onstat -g cdc
    Change Data Capture sample program
  Embedded SQLJ for HCL Informix
    Introduction to HCL Informix embedded SQLJ
    Preparation to use embedded SQLJ
    Fundamentals of embedded SQLJ programs
      Embedded SQL statements
      Result sets and iterators
      A simple embedded SQLJ program
    The embedded SQLJ language
      Embedded SQLJ statements
      Host variables
      SELECT statements that return a single row
      Result sets
        Positional iterators
        Named iterators
        Column aliases
        Iterator methods
        Positioned updates and deletes
      SQL query execution and monitoring
      SPL routine and function calls
      SQL and Java type mappings
      Language character sets
      Java package importation
      SQLJ reserved names
      Handling errors
    Embedded SQLJ source code processing
      SQL program translation, compiling, and running
      The ifxsqlj command
      Options for the ifxsqlj command
      Online checking
      The ifxprofp tool
    Appendix
      Embedded SQLJ and database connections
        The ConnectionManager class
        Database URLs
        Nondefault connection contexts
        MultiConnect.sqlj sample program
      Descriptions of sample programs included with HCL Informix Embedded SQLJ
  ESQL/C Guide
    What is Informix ESQL/C?
      Informix ESQL/C programming
        What is Informix ESQL/C?
          ESQL/C components
            ESQL/C files for Windows
            ESQL/C library functions
          Creating an ESQL/C program
        Embed SQL statements
          Case sensitivity in embedded SQL statements
          Quotation marks and escape characters
            Newline characters in quoted strings
          Add comments to ESQL/C programs
          Host variables
        Declaring and using host variables
          Declare a host variable
            Host variable names
            Host-variable data types
            Initial host-variable values
            Scope of host variables
            Sample host-variable declarations
          Host variable information
            SQL identifiers
              Long identifiers
              Delimited identifiers
                Example of a delimited identifier
            Null values in host variables
          Host variables in data structures
            Arrays of host variables
            C structures as host variables
            C typedef statements as host variables
            Pointers as host variables
            Function parameters as host variables
          Host variables in Windows environments
            Declare variables with non-ANSI storage-class modifiers
          Indicator variables
            Declare indicator variables
            Associate an indicator variable with a host variable
            Indicate null values
            Indicate truncated values
            An example of using indicator variables
        ESQL/C header files
          Declare function prototypes
          Header files included in your program
        ESQL/C preprocessor directives
          The include directive
          The define and undef directives
          The ifdef, ifndef, elif, else, and endif directives
        Set and retrieve environment variables in Windows environments
          The InetLogin structure
            Fields of the InetLogin structure
            InetLogin field values
            Precedence of configuration values
        Global ESQL/C variables in a Windows environment
        A sample Informix ESQL/C program
          Compile the demo1 program
          Guide to demo1.ec file
      Compile programs
        Compile the Informix ESQL/C program
          The ESQL/C preprocessor
          The C preprocessor and compiler
          Default compilation order
          Run the C preprocessor first
        The esql command
          Requirements for using the esql command
          Syntax of the esql command
          Options that affect preprocessing
            Check the version number
            Associate options with files
            Preprocess without compiling or linking
            Generate thread-safe code
            Check for ANSI-standard SQL syntax
            Define and undefine definitions while preprocessing
            Check for missing indicator variables
            Name the location of include files
            Line numbers
            Cursor names and statement IDs
            Redirect errors and warnings
            Suppress warnings
            Enabling the GLS for Unicode (GLU) feature
            The X/Open standards
          Run the C preprocessor before the ESQL/C preprocessor
            Options for running the C preprocessor first
            The CPFIRST environment variable (UNIX)
            Using the eprotect.exe utility (Windows)
            The order of compilation when the C preprocessor runs first
            Define host variables based on C #defines and typedefs
            Allow all valid C declaration syntax inside the EXEC SQL declare section
            Exclude statements inside C header files
            SQL keyword protection
            SQL keyword protection and the dollar sign ($) symbol
          Preprocessor options specific to Windows environments
        Compiling and linking options of the esql command
          Name the executable file
          Set the type of executable files created (Windows)
          Pass options to the C compiler
          Specify a particular C compiler (Windows)
          Compile without linking
          Special compile options for Windows environments
            Specify the name of a project file
            Create a response file
            Implicit options invoked by the esql preprocessor in Windows environments
          Linking options
            General linking options
              Linking other C source and object files
              Specify versions of Informix ESQL/C general libraries
            Special linking options for Windows
              Pass arguments to the linker
              Pass arguments to the resource compiler
              ESQL/C dynamic link libraries
              Same runtime routines for version independence
        Access the ESQL Client-interface DLL in Windows environments
          Access the import library
          Locate a DLL
          Build an application DLL
      Informix ESQL/C data types
        Choose data types for host variables
          Data type constants
            SQL data type constants
            ESQL/C data type constants
            X/Open data type constants
          Header files for data types
        Data conversion
          Fetch and insert with host variables
            Convert numbers and strings
            Convert floating-point numbers to strings
            Convert BOOLEAN values to characters
            Convert DATETIME and INTERVAL values
            Convert between VARCHAR and character data types
          Perform arithmetic operations
            Convert numbers to numbers
            Operations that involve a decimal value
              Convert the non-decimal numeric operand
              Obtain the DECIMAL data type of the arithmetic result
        Data-type alignment library functions
      Character and string data types
        Character data types
          The char data type
          The fixchar data type
          The string data type
          The varchar data type
          The lvarchar data type
            The lvarchar keyword syntax
            A lvarchar host variable of a fixed size
            The lvarchar pointer host variable
        Fetch and insert character data types
          Fetch and insert CHAR data
            Fetch CHAR data
            Insert CHAR data
          Fetch and insert VARCHAR data
            Fetch VARCHAR data
            Insert VARCHAR data
          Fetch and insert lvarchar data
            Fetch lvarchar data
            Insert lvarchar data
          Fetch and insert with an ANSI-compliant database
        Character and string library functions
      Numeric data types
        The integer data types
          The integer host variable types
          The INT8 and SERIAL8 SQL data types
          The int8 data type
          The int8 library functions
        The BOOLEAN data type
        The decimal data type
          The decimal structure
          The decimal library functions
        The floating-point data types
          Declare float host variables
          Implicit data conversion
        Format numeric strings
          Sample format strings for numeric expressions
          Numeric-formatting functions
      Time data types
        The SQL DATE data type
          Format date strings
        DATE library functions
        The SQL DATETIME and INTERVAL data types
          The datetime data type
          The interval data type
          Macros for datetime and interval data types
          Fetch and insert DATETIME and INTERVAL values
            Fetch and insert into datetime host variables
            Fetch and insert into interval host variables
            Implicit data conversion
          ANSI SQL standards for DATETIME and INTERVAL values
          Converting data for datetime values
          Converting data for interval values
        Support of non-ANSI DATETIME formats
          The USE_DTENV environment variable
        DATETIME and INTERVAL library functions
      Simple large objects
        Choose a large-object data type
        Programming with simple large objects
          Declare a host variable for a simple large object
          Access the locator structure
            The fields of the locator structure
            Locations for simple-large-object data
        Locate simple large objects in memory
          Allocate the memory buffer
            A memory buffer that the ESQL/C libraries allocate
            A memory buffer that the program allocates
          Select a simple large object into memory
          Insert a simple large object from memory
        Locate simple large objects in files
          File-open mode flags
          Error returns in loc_status
          Locate simple large objects in open files
            Select a simple large object into an open file
            Insert a simple large object from an open file
          Locate simple large objects in named files
            Select a simple large object into a named file
            Insert a simple large object from a named file
        User-defined simple-large-object locations
          Select a simple large object into a user-defined location
          Insert a simple large object into a user-defined location
          User-defined simple-large-object functions
            The user-defined open function
            The user-defined read function
            The user-defined write function
            The user-defined close function
        The dispcat_pic program
          Preparing to run the dispcat_pic program
          Load the simple-large-object images
            Choose the image files
            Loading the simple-large-object images with the blobload utility
          Guide to the dispcat_pic.ec File
          Guide to the prdesc.c file
          Guide to the inpfuncs.c file
      Smart large objects
        Data structures for smart large objects
          Declare a host variable
          The LO-specification structure
            The ifx_lo_create_spec_t structure
              Disk-storage information
              Create-time flags
            ESQL/C functions that use the LO-specification structure
            Obtain storage characteristics
              The system-specified storage characteristics
              The column-level storage characteristics
              The user-defined storage characteristics
            Deallocate the LO-specification structure
          The LO-pointer structure
            Store a smart large object
            The ifx_lo_t structure
            ESQL/C functions that use the LO-pointer structure
          The LO file descriptor
            ESQL/C library functions that use an LO file descriptor
        Creating a smart large object
        Accessing a smart large object
          Select a smart large object
          Open a smart large object
            Access modes
              Set dirty read access mode
              The LO_APPEND flag
              Lightweight I/O
            Smart-large-object locks
              Range of a lock
            Duration of an open on a smart large object
          Delete a smart large object
          Modifying a smart large object
            Read data from a smart large object
            Write data to a smart large object
          Close a smart large object
        Obtaining the status of a smart large object
          Obtaining a valid LO-pointer structure
          Allocate and access an LO-status structure
            Allocate an LO-status structure
            Access the LO-status structure
          Deallocate the LO-status structure
        Alter a smart-large-object column
        Migrate simple large objects
        The ESQL/C API for smart large objects
      Complex data types
        Access a collection
          Access a collection derived table
            Advantage of a collection derived table
            Restrictions on a collection derived table
          Declaring collection variables
            Syntax of the collection data type
            Typed and untyped collection variables
              The typed collection variable
              The untyped collection variable
            Client collections
          Manage memory for collections
          Operate on a collection variable
            The collection-derived table clause on collections
              Access a collection variable
              Distinguish between columns and collection variables
            Initialize a collection variable
            Insert elements into a collection variable
              Insert one element
                Insert elements into SET and MULTISET collections
                Insert elements into LIST collections
              Inserting more than one element
                Declare an insert cursor for a collection variable
                Put elements into the insert cursor
                Free cursor resources
            Select from a collection variable
              Select one element
              Select one row element
              Selecting more than one element
                Declare a select cursor for a collection variable
                Fetch elements from the select cursor
            Update a collection variable
              Update all elements
              Updating one element
            Specify element values
              Literal values as elements
              ESQL/C host variables as elements
            Delete elements from a collection variable
              Delete all elements
              Delete one element
            Access a nested collection
              Select values from a nested collection
              Insert values into a nested collection
          Operate on a collection column
            Select from a collection column
            Insert into and update a collection column
              Delete an entire collection
        Access row types
          Declare row variables
            Typed and untyped row variables
              The typed row variable
              The untyped row variable
            Named row types
              In a collection-derived table
            Client-side rows
          Manage memory for rows
          Operate on a row variable
            The collection-derived table clause on row types
              Access a row variable
              Distinguish between columns and row variables
            Initialize a row variable
            Insert into a row variable
            Select from a row variable
            Update a row variable
            Delete from a row variable
            Specify field names
              Host variable field names
            Specify field values
              Literal values as field values
              Constructed rows
              ESQL/C host variables as field values
          Access a typed table
          Operate on a row-type column
            Select from a row-type column
            Insert into and update row-type columns
            Delete an entire row type
      Opaque data types
        The SQL opaque data type
        Access the external format of an opaque type
          Declare lvarchar host variables
            An lvarchar host variable of a fixed size
            The lvarchar pointer host variable
              To allocate memory yourself
            The opaque type name
          The lvarchar host variables
            Fixed-size lvarchar host variables
              Inserting from a fixed-size lvarchar host variable
              Select into a fixed-size lvarchar host variable
            The lvarchar pointer variables
              Insert from an lvarchar pointer host variable
              Select into an lvarchar pointer host variable
        Access the internal format of an opaque type
          Access a fixed-length opaque type
            Declare fixed binary host variables
              The opaque type
            Fixed binary host variables
              Insert from a fixed binary host variable
              Select into a fixed binary host variable
          Access a varying-length opaque type
            Declare var binary host variables
            The var binary host variables
              Insert from a var binary host variable
              Select into a var binary host variable
        The lvarchar pointer and var binary library functions
        Access predefined opaque data types
    Database server communication
      Exception handling
        Obtain diagnostic information after an SQL statement
          Types of diagnostic information
            Types of database exceptions
            Descriptive information
          Types of status variables
        Exception handling with SQLSTATE
          The GET DIAGNOSTICS statement
            Statement information
            Exception information
          The SQLSTATE variable
            Class and subclass codes
            List of SQLSTATE class codes
          Check for exceptions with SQLSTATE
            Determining the cause of an exception in SQLSTATE
            Success in SQLSTATE
            NOT FOUND in SQLSTATE
            Warnings in SQLSTATE
            Runtime errors in SQLSTATE
              GET DIAGNOSTICS failure
            Multiple exceptions
        Exception handling with the sqlca structure
          Fields of the sqlca structure
          The SQLCODE variable
            SQLCODE in pure C modules
            SQLCODE and the exit() call
            SQLCODE after a DESCRIBE statement
          Check for exceptions with sqlca
            Success in sqlca
            NOT FOUND in SQLCODE
            Warnings in sqlca.sqlwarn
            Runtime errors in SQLCODE
              Errors after a PREPARE statement
              SQLCODE after an EXECUTE statement
          Display error text (Windows)
        Choose an exception-handling strategy
          Check after each SQL statement
          The WHENEVER statement
        Library functions for retrieving error messages
          Display error text in a Windows environment
        A program that uses exception handling
          Compile the program
          Guide to the getdiag.ec file
          Guide to the exp_chk.ec file
      Working with the database server
        The client-server architecture of ESQL/C applications
        The client-server connection
          Sources of connection information about a UNIX operating system
            Access the sqlhosts file
            Specify the default database server
          Sources of connection information in a Windows environment
            Set environment variables for connections in a Windows environment
            The sqlhosts information in a Windows environment
            A central registry
            Connection authentication functionality in a Windows environment
          Connect to a database server
            Establish a connection
              The explicit connection
              The implicit Connection
              Summary of connection types
            Establish an explicit connection in a Windows environment
            Password encryption
            Pluggable Authentication Modules (PAM)
            LDAP authentication
            Multiplexed connections
              Client requirements for execution
              Limitations for multiplexed connections
          Identify the database server
            A specific database server
            The default database server
        Interact with the database server
          Determine features of the database server
          Switch between multiple database connections
            Make a connection current
            Handling transactions
          Identify an explicit connection
          Obtain available databases
          Check the status of the database server
          Establishing a separate database connection for the child process
          Interrupt an SQL request
            Interruptible SQL statements
            Allow a user to interrupt
            Set up a timeout interval
              The timeout interval
              The callback function
          Error checking during data transfer
          Terminate a connection
        Optimized message transfers
          Restrictions on optimized message transfers
          Enabling optimized message transfers
            Set the OPTMSG environment variable
            Set the OptMsg global variable
          Error handling with optimized message transfers
        Database server control functions
        The timeout program
          Compile the program
          Guide to the timeout.ec File
          Example output
        ESQL/C connection library functions in a Windows environment
      Informix libraries
        Choose a version of the Informix general libraries
          The Informix general libraries
          The esql command
          Link static Informix general libraries
            Link static Informix general libraries into an ESQL/C module
          Link shared Informix general libraries
            Symbolic names of linked shared libraries (UNIX)
              Linking shared Informix general libraries to an ESQL/C module
          Choose between shared and static library versions
        Compatibility of preexisting ESQL/C applications with current library versions
          The ifx_getversion utility (UNIX)
          Check the API version of a library
        Create thread-safe ESQL/C applications
          Characteristics of thread-safe ESQL/C code
          Program a thread-safe ESQL/C application
            Concurrent active connections
            Connections across threads
            The DISCONNECT ALL Statement
            Prepared statements across threads
            Cursors across threads
            Environment variables across threads
            Message file descriptors
            Decimal functions
            DCE restrictions (UNIX)
              Operating-system calls
              The fork() operating-system call
              Resource allocation
          Link thread-safe libraries
            Linking thread-safe Informix general libraries to an ESQL/C module on a UNIX operating system
            Define thread-safe variables (UNIX)
            Link shared or static versions
            Linking thread-safe Informix general libraries to an ESQL/C module in a Windows environment
        ESQL/C thread-safe decimal functions
        Context threaded optimization
        A sample thread-safe program
          Source listing
          Output
        Create a dynamic thread library on UNIX operating systems
          Data types
          Register the dynamic thread functions
          Set the $THREADLIB environment variable
          Create the shared library
          Compile with the -thread and -l preprocessor options
    Dynamic SQL
      Using dynamic SQL
        Execute dynamic SQL
          Assemble and prepare the SQL statement
            Assemble the statement
            Prepare statements that have collection variables
            Check the prepared statement
          Execute the SQL statement
          Free resources
        A database cursor
          Receive more than one row
            A select cursor
            A function cursor
          Send more than one row
          Name the cursor
          Optimize cursor execution
            Size the cursor buffer
              Default buffer size
            Automatically freeing a cursor
              Enable the AUTOFREE feature
              The SET AUTOFREE statement
            Defer execution of the PREPARE statement
              Restrictions on deferred-PREPARE
              Enable the deferred-PREPARE Feature
              The SET DEFERRED_PREPARE statement
        The collect.ec program
        Optimize OPEN, FETCH, and CLOSE
          Restrictions on OPTOFC
          Enable the OPTOFC Feature
        Using OPTOFC and Deferred-PREPARE together
        SQL statements that are known at compile time
          Execute non-SELECT statements
            The PREPARE and EXECUTE statements
            The EXECUTE IMMEDIATE statement
          Execute SELECT statements
            The PREPARE and EXECUTE INTO statements
            Declare a select cursor
          The lvarptr.ec program
          Execute user-defined routines in Informix
            A user-defined procedure
            A user-defined function
              A noncursor function
              A function cursor
          Execute statements with input parameters
            An EXECUTE USING statement
            An OPEN USING statement
            The demo2.ec sample program
        SQL statements that are not known at compile time
      Determine SQL statements
        Dynamic-management structure
          A system-descriptor area
            Fixed-length portion
            An item descriptor
          An sqlda structure
            Fixed-length portion
            An sqlvar_struct structure
            Descriptive information
        The DESCRIBE statement
          Determine the statement type
          Determine the data type of a column
            SQL data types specific to Informix
            X/Open SQL data types
            Constants for ESQL/C data types
          Determine input parameters
          Check for a WHERE clause
        Determine statement information at run time
          Handling an unknown select list
          Handling an unknown column list
          Determine unknown input parameters
          Determine return values dynamically
          Handling statements that contain user-defined data types
            SQL statements with opaque-type columns
              Insert opaque-type data
              Truncation of opaque-type data
            SQL statements with distinct-type columns
        A fetch array
          Using a fetch array
          Sample fetch array program
          Allocate memory for the fetch arrays
            Allocating memory for a fetch array
          Obtain values from fetch arrays
          Free memory for a fetch array
      A system-descriptor area
        Manage a system-descriptor area
          Allocate memory for a system-descriptor area
          Initialize the system-descriptor area
            The DESCRIBE statement and input parameters
            The DESCRIBE statement and memory allocation
          Assign and obtain values from a system-descriptor area
            The SET DESCRIPTOR Statement
              An lvarchar pointer host variable with a descriptor
            The GET DESCRIPTOR statement
          Specify input parameter values
          Put column values into a system-descriptor area
          Free memory allocated to a system-descriptor area
        Using a system-descriptor area
        Handling an unknown select list
          Execute a SELECT that returns multiple rows
            The demo4.ec sample program
          Execute a singleton SELECT
        Handling unknown return values
          Execute a noncursor function
            A sample program that executes an SPL function
          Executing a cursor function
        Handling an unknown column list
          Execute a simple insert
            A sample program that executes a dynamic INSERT statement
          Execute an INSERT that is associated with a cursor
        Handling a parameterized SELECT statement
          Execute a parameterized SELECT that returns multiple rows
            A sample program that uses a dynamic SELECT statement
          Execute a parameterized singleton SELECT statement
        Handling a parameterized user-defined routine
          Execute a parameterized function
          Execute a parameterized procedure
        Handling a parameterized UPDATE or DELETE statement
        The dyn_sql program
          Compile the program
          Guide to the dyn_sql.ec file
      An sqlda structure
        Manage an sqlda structure
          Define an sqlda structure
          Allocate memory for the sqlda structure
          Initialize the sqlda structure
          Allocate memory for column data
          Assign and obtain values from an sqlda structure
          Specify input parameter values
          Put column values into an sqlda structure
          Free memory allocated to an sqlda structure
        An sqlda structure to execute SQL statements
        Handling an unknown select list
          Execute a SELECT that returns multiple rows
            The demo3.ec sample program
          Execute a singleton SELECT
        Handling unknown return values
          Execute a noncursor function
          Executing a cursor function
        Handling an unknown column list
          Execute a simple insert
          Execute an INSERT that is associated with a cursor
        Handling a parameterized SELECT statement
          Execute a parameterized SELECT that returns multiple rows
            A sample program that uses an sqlda structure
          Execute a parameterized singleton SELECT statement
        Handling a parameterized user-defined routine
          Execute a parameterized function
          Execute a parameterized procedure
        Handling a parameterized UPDATE or DELETE statement
    Appendixes
      The ESQL/C example programs
      The ESQL/C function library
        Informix ESQL/C library functions
        The bigintcvasc() function
        The bigintcvdbl() function
        The bigintcvdec() function
        The bigintcvflt() function
        The bigintcvifx_int8() function
        The bigintcvint2() function
        The bigintcvint4() function
        The biginttoasc() function
        The biginttodbl() function
        The biginttodec() function
        The biginttoflt() function
        The biginttoifx_int8() function
        The biginttoint2() function
        The biginttoint4() function
        The bycmpr() function
        The bycopy() function
        The byfill() function
        The byleng() function
        The decadd() function
        The deccmp() function
        The deccopy() function
        The deccvasc() function
        The deccvdbl() function
        The deccvflt() function
        The deccvint() function
        The deccvlong() function
        The decdiv() function
        The dececvt() and decfcvt() functions
        The decmul() function
        The decround() function
        The decsub() function
        The dectoasc() function
        The dectodbl() function
        The dectoint() function
        The dectolong() function
        The dectrunc() function
        The dtaddinv() function
        The dtcurrent() function
        The dtcvasc() function
        The dtcvfmtasc() function
        The dtextend() function
        The dtsub() function
        The dtsubinv() function
        The dttoasc() function
        The dttofmtasc() function
        The GetConnect() function (Windows)
        The ifx_cl_card() function
        The ifx_dececvt() and ifx_decfcvt() function
        The ifx_defmtdate() function
        The ifx_dtcvasc() function
        The ifx_dtcvfmtasc() function
        The ifx_dttofmtasc() function
        The ifx_getenv() function
        The ifx_getcur_conn_name() function
        The ifx_getserial8() function
        The ifx_int8add() function
        The ifx_int8cmp() function
        The ifx_int8copy() function
        The ifx_int8cvasc() function
        The ifx_int8cvdbl() function
        The ifx_int8cvdec() function
        The ifx_int8cvflt() function
        The ifx_int8cvint() function
        The ifx_int8cvlong() function
        The ifx_int8div() function
        The ifx_int8mul() function
        The ifx_int8sub() function
        The ifx_int8toasc() function
        The ifx_int8todbl() function
        The ifx_int8todec() function
        The ifx_int8toflt() function
        The ifx_int8toint() function
        The ifx_int8tolong() function
        The ifx_lo_alter() function
        The ifx_lo_close() function
        The ifx_lo_col_info() function
        The ifx_lo_copy_to_file() function
        The ifx_lo_copy_to_lo() function
        The ifx_lo_create() function
        The ifx_lo_def_create_spec() function
        The ifx_lo_filename() function
        The ifx_lo_from_buffer() function
        The ifx_lo_lock() function
        The ifx_lo_open() function
        The ifx_lo_read() function
        The ifx_lo_readwithseek() function
        The ifx_lo_release() function
        The ifx_lo_seek() function
        The ifx_lo_spec_free() function
        The ifx_lo_specget_def_open_flags() function
        The ifx_lo_specget_estbytes() function
        The ifx_lo_specget_extsz() function
        The ifx_lo_specget_flags() function
        The ifx_lo_specget_maxbytes() function
        The ifx_lo_specget_sbspace() function
        The ifx_lo_specset_def_open_flags() function
        The ifx_lo_specset_estbytes() function
        The ifx_lo_specset_extsz() function
        The ifx_lo_specset_flags() function
        The ifx_lo_specset_maxbytes() function
        The ifx_lo_specset_sbspace() function
        The ifx_lo_stat() function
        The ifx_lo_stat_atime() function
        The ifx_lo_stat_cspec() function
        The ifx_lo_stat_ctime() function
        The ifx_lo_stat_free() function
        The ifx_lo_stat_mtime_sec() function
        The ifx_lo_stat_refcnt() function
        The ifx_lo_stat_size() function
        The ifx_lo_tell() function
        The ifx_lo_to_buffer() function
        The ifx_lo_truncate() function
        The ifx_lo_unlock() function
        The ifx_lo_write() function
        The ifx_lo_writewithseek() function
        The ifx_lvar_alloc() function
        The ifx_putenv() function
        The ifx_strdate() function
        The ifx_var_alloc() function
        The ifx_var_dealloc() function
        The ifx_var_flag() function
        The ifx_var_freevar() function
        The ifx_var_getdata() function
        The ifx_var_getlen() function
        The ifx_var_isnull() function
        The ifx_var_setdata() function
        The ifx_var_setlen() function
        The ifx_var_setnull() function
        The incvasc() function
        The incvfmtasc() function
        The intoasc() function
        The intofmtasc() function
        The invdivdbl() function
        The invdivinv() function
        The invextend() function
        The invmuldbl() function
        The ldchar() function
        The rdatestr() function
        The rdayofweek() function
        The rdefmtdate() function
        The rdownshift() function
        The ReleaseConnect() function (Windows)
        The rfmtdate() function
        The rfmtdec() function
        The rfmtdouble() function
        The rfmtlong() function
        The rgetlmsg() function
        The rgetmsg() function
        The risnull() function
        The rjulmdy() function
        The rleapyear() function
        The rmdyjul() function
        The rsetnull() function
        The rstod() function
        The rstoi() function
        The rstol() function
        The rstrdate() function
        The rtoday() function
        The rtypalign() function
        The rtypmsize() function
        The rtypname() function
        The rtypsize() function
        The rtypwidth() function
        The rupshift() function
        The SetConnect() function (Windows)
        The sqgetdbs() function
        The sqlbreak() function
        The sqlbreakcallback() function
        The sqldetach() function
        The sqldone() function
        The sqlexit() function
        The sqlsignal() function
        The sqlstart() function
        The stcat() function
        The stchar() function
        The stcmpr() function
        The stcopy() function
        The stleng() function
      Examples for smart-large-object functions
        Prerequisites
        The create_clob.ec program
          Storage characteristics for the example
        The get_lo_info.ec program
        The upd_lo_descr.ec program
  GLS User's Guide
    What's new in GLS
    GLS fundamentals
      Character-representation conventions
        Single-byte characters
        Multibyte characters
        Single-byte and multibyte characters in the same string
        White space characters in strings
        Trailing white space characters
      The GLS feature
        GLS support by HCL Informix products
          HCL Informix database servers
            Culture-specific features
          HCL Informix client applications and utilities
          The HCL Informix GLS application programming interface
          Supported data types
          International Language Supplement
      A GLS locale
        Code sets for character data
        Character classes of the code set
        Collation order for character data
          Code-set order
          Localized order
          International Components for Unicode (ICU)
          Collation support
        Display formats
          Numeric and monetary formats
          Date and time formats
      Set a GLS locale
        Locales in the client/server environment
          The client locale
          The database locale
          The server locale
        The default locale
          The default code set
          Default display formats for date and time
          Default display formats for numeric and monetary values
        Set a nondefault locale
      GLS locales with HCL Informix products
        Support for non-ASCII characters
        Establish a database connection
          Send the client locale
          Verify the database locale
          Check for connection warnings
          Determine the server-processing locale
            Locale information for the database
            Locale information for the client application
        Perform code-set conversion
          When code-set conversion is performed
        Locate message files
      Customize display formats
        Customize date and time display formats
          Era-based date and time formats
          Date and time precedence
        Customize currency display formats
      GLS Unicode options
    GLS environment variables
      Set and retrieve environment variables
      GLS-related environment variables
        CC8BITLEVEL environment variable
        CLIENT_LOCALE environment variable
        DBDATE environment variable (deprecated)
        DBLANG environment variable
        DB_LOCALE environment variable
        DBMONEY environment variable
        DBTIME environment variable (deprecated)
        ESQLMF environment variable
        GL_DATE environment variable
          The year formatting directives
          Alternative date formats
          Optional date format qualifiers
            Field specification for reading a DATE value
            Field specification for displaying a DATE value
        GL_DATETIME environment variable
          Alternative time formats
          Optional time format qualifiers
          Creation-time settings
        GLS8BITFSYS environment variable
          Restrictions on non-ASCII file names
            Make sure that your operating system is 8-bit clean
            Make sure that your product supports the same code set
            The server code set
            The client code set
        GL_USEGLU environment variable
        IFX_PUA_DISPLAY_MAPPING environment variable
        SERVER_LOCALE environment variable
        USE_DTENV environment variable
    SQL features
      Name database objects
        Rules for identifiers
        Non-ASCII characters in identifiers
          Qualifiers of SQL identifiers
          Owner names
          Path names and file names
          Delimited identifiers
        Valid characters in identifiers
      Character data types
        Localized collation of character data
          The NCHAR data type
            Collate NCHAR data
            Handle NCHAR data
            Multibyte characters with NCHAR
            Treat NCHAR values as numeric values
            Nonprintable characters with NCHAR
          The NVARCHAR data type
            Collate NVARCHAR data
            Handle NVARCHAR data
            Multibyte characters with NVARCHAR
            Nonprintable characters with NVARCHAR
            Store numeric values in an NVARCHAR column
          Performance considerations
        Other character data types
          The CHAR data type
          The VARCHAR data type
          The LVARCHAR data type
          The TEXT data type
      Handle character data
        Specify quoted strings
        Specify comments
        Specify column substrings
          Column substrings in single-byte code sets
          Column substrings in multibyte code sets
          Partial characters in column substrings
            Avoidance in a multibyte code set
          Errors involving partial characters
          Partial characters in an ORDER BY clause
            Avoidance in TEXT and BYTE columns
        Specify arguments to the TRIM function
        Search functions that are not case-sensitive
        Collate character data
          Collation order in CREATE INDEX
          Collation order in SELECT statements
            The ORDER BY clause
            Logical predicates in a WHERE clause
            Relational-operator conditions
            BETWEEN conditions
            IN conditions
          Comparisons with MATCHES and LIKE conditions
            MATCHES condition
            LIKE condition
            Wildcard characters in LIKE and MATCHES conditions
        SQL length functions
          The LENGTH function
          The OCTET_LENGTH function
          The CHAR_LENGTH function
      Locale-sensitive data types
        Handle the MONEY data type
          Specify values for the scale parameter
          Format of currency notation
        Handle extended data types
          Opaque data types
          Complex data types
          Distinct data types
        Handle smart large objects
      Data manipulation statements
        Specify conditions in the WHERE clause
        Specify era-based dates
        Load and unload data
          Load data into a database
          Unload data from a database
      Data definition statements
        Automatic resizing of the expansion factor
    Database server features
      GLS support by HCL Informix database servers
        Database server code-set conversion
        Data that the database server converts
      Locale-specific support for utilities
        Non-ASCII characters in database server utilities
        Non-ASCII characters in SQL utilities
      Locale support for C User-defined routines (Informix and DB API)
        Current processing locale for UDRs
        Non-ASCII characters in source code
          In C-language statements
          In SQL statements
        Copy character data
        The HCL Informix GLS library
          Character processing with HCL Informix GLS
          Compatibility of wide-character data types
        Code-set conversion and the DataBlade API
          Character strings in UDRs
          Character strings in opaque-type support functions
        Locale-specific data formatting
        Globalized exception messages
          Insert customized exception messages
          Insert a localized exception message from a C UDR
          Search for customized messages
          Specify parameter markers
        Globalized tracing messages
          Insert messages in the systracemsgs system catalog table
          Put globalized trace messages into code
          Search for trace messages
        Locale-sensitive data in an opaque data type
          Globalized input and output support functions
          Globalized send and receive support functions
    General SQL API features (ESQL/C)
      Support for GLS in HCL Informix client applications
        Client application code-set conversion
          Data that a client application converts
      Globalize client applications
        Globalization
        Localization
          Choose a GLS locale
          Translate messages
      Handle locale-specific data
        Process characters
        Format data
        Avoid partial characters
          Copy character data
          Code-set conversion
    IBM Informix ESQL/C features
      Handle non-ASCII characters
        Non-ASCII characters in host variables
        Generate non-ASCII file names
        Non-ASCII characters in ESQL/C source files
          Filter non-ASCII characters
          Invoke the ESQL/C filter
      Define variables for locale-sensitive data
      Enhanced ESQL/C library functions
        DATE-format functions
          GL_DATE support
          DBDATE extensions (deprecated)
          Extended DATE-format strings
          Precedence for date display formats
        DATETIME-format functions
          GL_DATETIME support
          DBTIME support
          Extended DATETIME-format strings
          Precedence for DATETIME display formats
        Numeric-format functions
          Support for multibyte characters
          Locale-specific numeric formatting
          Currency-symbol formatting
          DBMONEY extensions
        String functions
        GLS-specific error messages
      Handle code-set conversion
        Writing TEXT values
        The DESCRIBE statement
          The sqldata field
          The sqlname field
      The TRIM function
    Appendix
      Manage GLS files
        Access GLS files
        GLS locale files
          Locale categories
            The CTYPE category
            The COLLATION category
            The NUMERIC category
            The MONETARY category
            The TIME category
            The MESSAGES category
          Location of locale files
            Locale-file subdirectories
            Locale source and object files
            Locale file names
        Other GLS files
          Code-set-conversion files
            Code-set-conversion source and object files
            Code-set-conversion file names
            Required for code-set conversion
          Code-set files
          The HCL Informix registry file (Windows)
        Remove unused files
          Remove locale and code-set-conversion files
          Remove code-set files
        The glfiles utility (UNIX)
          List code-set-conversion files
          List GLS locale files
          List character-mapping files
  Informix GLS API
    Using Informix GLS
      Internationalized programs with Informix GLS
        What is Informix GLS?
        Informix GLS compatibility
        Choose a GLS Locale
      Using Informix GLS in a C-language program
        Compile and link Informix GLS
          Informix GLS in ESQL/C applications
          Informix GLS in DataBlade programs
            DataBlade client applications
            DataBlade user-defined routines
        Initialize the Informix GLS library
        Informix GLS exceptions
        Allocate memory
        Input and output streams
        Run the program
      Improve program performance
        Optimize Informix GLS
        Processing wide characters
    Character processing
      Types of characters
        Single-byte characters
        Multibyte characters
          The gl_mchar_t data type
          Wide characters
            The gl_wchar_t data type
            Conversion between multibyte and wide characters
      Character operations
        Character classification
        Case conversion
          Case conversion for multibyte characters
            Determine when to allocate a destination buffer
            Determine the number of bytes read and written
          Case conversion for wide characters
          Exception handling
          Performance issues
        Code-set conversion
          Determining if code-set conversion is needed
          Perform code-set conversion
            Determine when to allocate a destination buffer
            Specify code-set names
            Preserve state information
          Performance issues
      String operations
        String traversal
          Multibyte-character-string traversal
          Wide-character-string traversal
        String processing
          Concatenation
          String copying
          String-length determination
          Character searching
        Character/string comparison and sorting
      Other operations
        String and character termination
          Character-string termination
          Multibyte-character termination
        Managing memory for strings and characters
          Multibyte-character-string allocation
          Wide-character-string allocation
          String deallocation
        Keep multibyte strings consistent
          Truncate multibyte strings
          Fragment multibyte strings
    Data formatting
      Locale-specific data formats
        The LC_NUMERIC locale-file category
        The LC_MONETARY locale-file category
        The LC_TIME locale-file category
      Conversion and formatting with Informix GLS
        Convert a locale-specific string
        Format a locale-specific string
    Informix GLS functions
      Function summary
      Function reference
        The ifx_gl_case_conv_outbuflen() function
        The ifx_gl_complen() function
        The ifx_gl_conv_needed() function
        The ifx_gl_convert_date() function
        The ifx_gl_convert_datetime() function
        The ifx_gl_convert_money() function
        The ifx_gl_convert_number() function
        The ifx_gl_cv_mconv() function
        The ifx_gl_cv_outbuflen() function
        The ifx_gl_cv_sb2sb_table() function
        The ifx_gl_format_date() function
        The ifx_gl_format_datetime() function
        The ifx_gl_format_money() function
        The ifx_gl_format_number() function
        The ifx_gl_getmb() function
        The ifx_gl_init() function
        The ifx_gl_ismalnum() function
        The ifx_gl_ismalpha() function
        The ifx_gl_ismblank() function
        The ifx_gl_ismcntrl() function
        The ifx_gl_ismdigit() function
        The ifx_gl_ismgraph() function
        The ifx_gl_ismlower() function
        The ifx_gl_ismprint() function
        The ifx_gl_ismpunct() function
        The ifx_gl_ismspace() function
        The ifx_gl_ismupper() function
        The ifx_gl_ismxdigit() function
        The ifx_gl_iswalnum() function
        The ifx_gl_iswalpha() function
        The ifx_gl_iswblank() function
        The ifx_gl_iswcntrl() function
        The ifx_gl_iswdigit() function
        The ifx_gl_iswgraph() function
        The ifx_gl_iswlower() function
        The ifx_gl_iswprint() function
        The ifx_gl_iswpunct() function
        The ifx_gl_iswspace() function
        The ifx_gl_iswupper() function
        The ifx_gl_iswxdigit() function
        The ifx_gl_lc_errno() function
        The ifx_gl_mb_loc_max() function
        The ifx_gl_mblen() function
        The ifx_gl_mbscat() function
        The ifx_gl_mbschr() function
        The ifx_gl_mbscoll() function
        The ifx_gl_mbscpy() function
        The ifx_gl_mbscspn() function
        The ifx_gl_mbslen() function
        The ifx_gl_mbsmbs() function
        The ifx_gl_mbsncat() function
        The ifx_gl_mbsncpy() function
        The ifx_gl_mbsnext() function
        The ifx_gl_mbsntsbytes() function
        The ifx_gl_mbsntslen() function
        The ifx_gl_mbspbrk() function
        The ifx_gl_mbsprev() function
        The ifx_gl_mbsrchr() function
        The ifx_gl_mbsspn() function
        The ifx_gl_mbstowcs() function
        The ifx_gl_mbtowc() function
        The ifx_gl_putmb() function
        The ifx_gl_tomlower() function
        The ifx_gl_tomupper() function
        The ifx_gl_towlower() function
        The ifx_gl_towupper() function
        The ifx_gl_wcscat() function
        The ifx_gl_wcschr() function
        The ifx_gl_wcscoll() function
        The ifx_gl_wcscpy() function
        The ifx_gl_wcscspn() function
        The ifx_gl_wcslen() function
        The ifx_gl_wcsncat() function
        The ifx_gl_wcsncpy() function
        The ifx_gl_wcsntslen() function
        The ifx_gl_wcspbrk() function
        The ifx_gl_wcsrchr() function
        The ifx_gl_wcsspn() function
        The ifx_gl_wcstombs() function
        The ifx_gl_wcswcs() function
        The ifx_gl_wctomb() function
    Appendix
      List of Informix GLS error numbers
  Informix Object Interface for C++ Guide
    Architecture of the object interface for C++
      Operation classes
      Value interfaces and value objects
      Class hierarchy
      Implementation notes
        Restrictions
        Passing objects—compiler dependency
        Informix database server compatibility
      Globalization
        ITFactory list and the type map
    Issue database queries and retrieve results
      Using operation classes
      Create connections
      Find system names and database names
        Using ITSystemNameList
        Using ITDBNameList
      Manage errors
        Using the error handling feature
      Connection transaction states
      Issue queries
        When to use the different ITQuery methods
        Query method example
        Using prepared statements
        Using cursors
        Using the large object manager
        Using ITRoutineManager
    Access data values
      Access data values
      Value object management
      The ITValue interface
      The ITConversions interface
      The ITDatum interface
      The ITDateTime interface
      The ITLargeObject interface
      The ITErrorInfo interface
      The ITRow interface
      The ITSet interface
      The ITContainer interface
      The ITContainCvt interface
    Create and extend value objects
      The raw data object
      Build simple value objects
      Expose multiple interfaces
      Value objects and connection events
      Create row type value objects
        Create row type value objects without an open connection
        Create collection type value objects without an open connection
      Object Containment and Delegation
      Dynamic loading
        Map files
        Guidelines
    Operation class reference
      The ITConnection class
      The ITConnectionStamp class
      The ITContainerIter class
      The ITCursor class
      The ITDBInfo class
      The ITDBNameList class
      The ITErrorManager class
      The ITFactoryList class
        Successful initialization verification
      The ITInt8 class
      The ITLargeObjectManager class
        Accessing smart large objects in nondefault sbspaces
      The ITMVDesc class
      The ITObject class
      The ITPosition class
      The ITPreserveData class
      The ITQuery class
      The ITRoutineManager class
      The ITStatement class
      The ITString class
      The ITSystemNameList class
      The ITTypeInfo class
    Value interface reference
      The ITContainCvt interface
      The ITContainer interface
      The ITConversions interface
        C++ compiler interpretation of long doubles
      The ITDateTime interface
      The ITDatum interface
      The ITErrorInfo interface
      The ITEssential interface
      The ITLargeObject interface
      The ITRow interface
      The ITSet interface
      The ITValue interface
        Use of ITValue::Printable with null value objects
    Appendixes
      Supported data types
      Example programs
      The ITLocale class
        Multibyte character string termination
        Multibyte character termination
        Memory allocation
        Access the ITLocale object
        Error return method
        String comparison methods
          The MCollate method
          The WCollate method
        String processing methods
          The MConcatenate method
          The MScan method
          The MCopy method
          The MComplSpanSize method
          The MLength method
          The MFindSubstr method
          The MNConcatenate method
          The MNCopy method
          The MNTSBytes method
          The MNTSLength method
          The MSpan method
          The MRScan method
          The MSpanSize method
          The WConcatenate method
          The WScan method
          The WCopy method
          The WComplSpanSize method
          The WLength method
          The WNConcatenate method
          The WNCopy method
          The WNTSLength method
          The WSpan method
          The WRScan method
          The WSpanSize method
          The WFindSubstr method
        Environment method
        Code set conversion methods
          The ConvertCodeset method
          The NeedToConvertCodeset method
          The SizeForCodesetConversion method
        Character classification methods
          The IsAlnum method
          The IsAlpha method
          The IsBlank method
          The IsCntrl method
          The IsDigit method
          The IsGraph method
          The IsLower method
          The IsPrint method
          The IsPunct method
          The IsSpace method
          The IsUpper method
          The IsXDigit method
        Character case conversion methods
          The ToUpper—Wide Character method
          The ToUpper—Multibyte Character method
          The ToLower—Wide Character method
          The ToLower—Multibyte Character method
        Built-in data type conversion methods
          The ConvertDate method
          The FormatDate method
          The ConvertDatetime method
          The FormatDatetime method
          The ConvertNumber method
          The FormatNumber method
          The ConvertMoney method
          The FormatMoney method
        Multibyte and wide character conversion methods
          The MToWString method
          The MToWChar method
          The WToMString method
          The WToMChar method
        Multibyte string traversal and indexing methods
          The MCharBytes method
          The MCharLen method
          The MNextChar method
          The MPrevChar method
  Informix ODBC Driver Guide
    Overview of HCL Informix ODBC Driver
      What is HCL Informix ODBC Driver?
        HCL Informix ODBC Driver features
          Support for extended data types
          Support for GLS data types
          Extended error detection
        Additional values for some ODBC function arguments
      ODBC component overview
        HCL Informix ODBC Driver with a driver manager
        HCL Informix ODBC Driver without a driver manager (UNIX)
      HCL Informix ODBC Driver with the DMR
      HCL Informix ODBC Driver components
        Environment variables
          Set environment variables on UNIX
          Set environment variables in Windows
        Header files
        Data types
        Libraries
      The HCL Informix ODBC Driver API
        Environment, connection, and statement handles
        Buffers
          Input buffers
          Output buffers
        SQLGetInfo argument implementation
      Global Language Support
      X/Open standard interface
      External authentication
        Pluggable Authentication Module (PAM) on UNIX and Linux
        LDAP Authentication on Windows
        The SQLSetConnectAttr() function with authentication
          Connection pooling and authentication
          Connect functions
          Third-party applications or intermediate code
      Bypass ODBC parsing
      BufferLength in character for SQLGetDiagRecW
      Informix and ISAM error descriptions in SQLGetDiagRec
      Improved performance for single-threaded applications
      Partially supported and unsupported ODBC features
        Transaction processing
          Transaction isolation levels
          Changing the transaction mode
        ODBC cursors
        ODBC bookmarks
        SQLBulkOperations
        SQLDescribeParam
        Unsupported Microsoft ODBC driver features
    Configure data sources
      Configure a DSN on UNIX
        The odbcinst.ini file
          ODBC drivers
          Driver specifications
        The odbc.ini file
          ODBC Data Sources
          Data-source specification
          Set the isolation level (UNIX only)
        ODBC section
        Set the $ODBCINI environment variable
        The .netrc file
      Configuring a DSN in Windows
        Configuring a new user DSN or system DSN
        Removing a DSN
        Reconfiguring an existing DSN
        Configuring a file DSN
        Creating logs of calls to the drivers
      Creating and configuring a DSN on Mac OS X
      Connection string keywords that make a connection
      DSN migration tool
        Setting up and using the DSN migration tool
        DSN migration tool examples
    Data types
      Data types
      SQL data types
        Standard SQL data types
          Visual Basic client-side cursors
        Additional SQL data types for GLS
        Additional SQL data types for Informix
        Precision, scale, length, and display size
          Standard SQL data types
          Additional SQL data types for Informix
      C data types
        C interval structure
        Transfer data
      Report standard ODBC types
        SQL_INFX_ATTR_ODBC_TYPES_ONLY
        SQL_INFX_ATTR_LO_AUTOMATIC
        SQL_INFX_ATTR_DEFAULT_UDT_FETCH_TYPE
        Report wide character columns
        DSN settings for report standard ODBC data types
      Convert data
        Standard conversions
        Additional conversions for GLS
        Additional conversions for Informix
        Convert data from SQL to C
          Default C data types
            Standard default C data types
            Additional default C data types for Informix
          SQL to C: Binary
          SQL to C: Boolean
          SQL to C: Character
          SQL to C: Date
          SQL to C: Numeric
          SQL to C: Time stamp
          SQL-to-C data conversion examples
        Convert data from C to SQL
          C to SQL: Binary
          C to SQL: Bit
          C to SQL: Character
          C to SQL: Date
          C to SQL: Numeric
          C to SQL: Time stamp
          C-to-SQL data conversion examples
    Smart large objects
      Data structures for smart large objects
        Working with a smart-large-object data structure
      Storage of smart large objects
        Disk-storage information
        Create-time flags
        Inheritance hierarchy
          Using system-specified storage characteristics
          Using column-level storage characteristics
          User-defined storage characteristics
      Example of creating a smart large object
      Transfer smart-large-object data
      Access a smart large object
        Smart-large-object automation
          Set the access method using SQL_INFX_ATTR_LO_AUTOMATIC
          Insert, update, and delete smart large objects using the ODBC API
          Select smart large objects using the ODBC API
        The ifx_lo functions
          Select a smart large object using ifx_lo functions
          Open a smart large object using ifx_lo functions
            Access modes
          Lightweight I/O
          Smart-large-object locks
          Duration of an open operation on a smart large object
          Delete a smart large object
          Modifying a smart large object
          Close a smart large object
          Example of retrieving a smart large object from the database using ifx_lo functions
      Retrieve the status of a smart large object
        Example of retrieving information about a smart large object
      Read or write a smart large object to or from a file
    Rows and collections
      Allocating and binding a row or collection buffer
        Fixed-type buffers and unfixed-type buffers
        Buffers and memory allocation
        SQL data
        Performing a local fetch
        Example of retrieving row and collection data from the database
      Example of creating a row and a list on the client
      Modify a row or collection
      Retrieve information about a row or collection
    Client functions
      Call a client function
        SQL syntax
        Function syntax
          Executing a client function with SQLPrepare() and SQLExecute()
          Executing a client function with SQLExecDirect()
        Input and output parameters
        The SQL_BIGINT data type
        Return codes
      Functions for smart large objects
        The ifx_lo_alter() function
        The ifx_lo_close() function
        The ifx_lo_col_info() function
        The ifx_lo_create() function
        The ifx_lo_def_create_spec() function
        The ifx_lo_open() function
        The ifx_lo_read() function
        The ifx_lo_readwithseek() function
        The ifx_lo_seek() function
        The ifx_lo_specget_estbytes() function
        The ifx_lo_specget_extsz() function
        The ifx_lo_specget_flags() function
        The ifx_lo_specget_maxbytes() function
        The ifx_lo_specget_sbspace() function
        The ifx_lo_specset_estbytes() function
        The ifx_lo_specset_extsz() function
        The ifx_lo_specset_flags() function
        The ifx_lo_specset_maxbytes() function
        The ifx_lo_specset_sbspace() function
        The ifx_lo_stat() function
        The ifx_lo_stat_atime() function
        The ifx_lo_stat_cspec() function
        The ifx_lo_stat_ctime() function
        The ifx_lo_stat_refcnt() function
        The ifx_lo_stat_size() function
        The ifx_lo_tell() function
        The ifx_lo_truncate() function
        The ifx_lo_write() function
        The ifx_lo_writewithseek() function
      Functions for rows and collections
        The ifx_rc_count() function
        The ifx_rc_create() function
        The ifx_rc_delete() function
        The ifx_rc_describe() function
        The ifx_rc_fetch() function
        The ifx_rc_free() function
        The ifx_rc_insert() function
        The ifx_rc_isnull() function
        The ifx_rc_setnull() function
        The ifx_rc_typespec() function
        The ifx_rc_update() function
    Improve application performance
      Error checking during data transfer
      Enable delimited identifiers in ODBC
      Connection level optimizations
      Optimizing query execution
      Insert multiple rows
      Automatically freeing a cursor
        Enabling the AUTOFREE feature
        The AUTOFREE feature
      Delay execution of the SQL PREPARE statement
      Set the fetch array size for simple-large-object data
      The SPL output parameter feature
      OUT and INOUT parameters
      Asynchronous execution
      Update data with positioned updates and deletes
      BIGINT and BIGSERIAL data types
      Message transfer optimization
        Message chaining restrictions
        Disable message chaining
        Errors with optimized message transfers
    Error messages
      Diagnostic SQLSTATE values
      Map SQLSTATE values to Informix error messages
      Map Informix error messages to SQLSTATE values
        Deprecated and new HCL Informix ODBC Driver APIs
        SQLAllocConnect (core level only)
        SQLAllocEnv (core level only)
        SQLAllocStmt (core level only)
        SQLBindCol (core level only)
        SQLBindParameter (level one only)
        SQLBrowseConnect (level two only)
        SQLCancel (core level only)
        SQLColAttributes (core level only)
        SQLColumnPrivileges (level two only)
        SQLColumns (level one only)
        SQLConnect (core level only)
        SQLDataSources (level two only)
        SQLDescribeCol (core level only)
        SQLDisconnect
          Usage
        SQLDriverConnect (level one only)
        SQLDrivers (level two only)
        SQLError (core level only)
        SQLExecDirect (core level only)
        SQLExecute (core level only)
        SQLExtendedFetch (level two only)
        SQLFetch (core level only)
        SQLForeignKeys (level two only)
        SQLFreeConnect (core level only)
        SQLFreeEnv (core level only)
        SQLFreeStmt (core level only)
        SQLGetConnectOption (level one only)
        SQLGetCursorName (core level only)
        SQLGetData (level one only)
        SQLGetFunctions (level one only)
        SQLGetInfo (level one only)
        SQLGetStmtOption (level one only)
        SQLGetTypeInfo (level one only)
        SQLMoreResults (level two only)
        SQLNativeSql (level two only)
          Usage
        SQLNumParams (level two only)
        SQLNumResultCols (core level only)
        SQLParamData (level one only)
      SQLParamOptions (core and level two only)
        SQLPrepare
        SQLPrimaryKeys (level two only)
        SQLProcedureColumns (level two only)
        SQLProcedures (level two only)
        SQLPutData (level one only)
        SQLRowCount (core level only)
        SQLSetConnectOption (level one only)
        SQLSetCursorName (core level only)
        SQLSetStmtOption (level one only)
        SQLSpecialColumns (level one only)
        SQLStatistics (level one only)
        SQLTablePrivileges (level two only)
        SQLTables (level one only)
        SQLTransact (core level only)
    Unicode
      Overview of Unicode
        Unicode versions
      Unicode in an ODBC application
      Unicode in an ODBC application
        Configuration
      Supported Unicode functions
  .NET provider options
    Differences between .NET Providers
    Informix .NET Provider Guide
      What's new in HCL Informix .NET Provider, Version 4.10
      Overview of the HCL Informix .NET Provider
        What is the Informix .NET Provider?
        Supported programming environments
        Support for IPv6
        Installing the HCL Informix .NET Provider
          Prepare the database server
        Overview of the .NET provider class library
        Thread-safety of provider types
        Namespace requirements
        Connecting to a database
          Reconcile DataSet changes with the database
          The connection pool
          Set FullTrust permission
        The ? parameter markers
        Call stored procedures
        IfxProviderFactory objects to write database-independent code
        Distributed transactions
        The OUT and INOUT Parameters
        Generic coding with the ADO.NET common base classes
        Error messages
          Tracing
          Error checking during data transfer
      Mapping data types
        Retrieve data
        Set data types for a parameter
        Display format of FLOAT, DECIMAL, or MONEY data types
      Type reference
        Supported public .NET interfaces
        Supported Public .NET base classes
        Prototype syntax
        IfxBlob class
          The IfxBlob internal cursor
          Create an IfxBlob
            IfxBlob constructors
          IfxBlob public properties
          IfxBlob public methods
        IfxClob class
          The IfxClob internal cursor
          Create an IfxClob
            IfxClob constructors
          IfxClob public properties
          IfxClob public methods
        IfxCommand class
          Create an IfxCommand
            IfxCommand constructors
          IfxCommand public properties
          IfxCommand public methods
          IfxCommand examples
        IfxCommandBuilder class
          Create an IfxCommandBuilder
            IfxCommandBuilder constructors
          IfxCommandBuilder public properties
          IfxCommandBuilder public methods
          IfxCommandBuilder examples
        IfxConnection class
          Create an IfxConnection
            IfxConnection constructors
          IfxConnection public properties
            ConnectionString property
            UserDefinedTypeFormat property
          IfxConnection public methods
          IfxConnection public events
          IfxConnection example
        IfxConnectionStringBuilder class
          Create an IfxConnectionStringBuilder
          IfxConnectionStringBuilder public properties
          IfxConnectionStringBuilder public methods
        IfxDataAdapter class
          Create an IfxDataAdapter
            IfxDataAdapter constructors
          IfxDataAdapter public properties
          IfxDataAdapter public methods
          IfxDataAdapter examples
        IfxDataReader class
          IfxDataReader public properties
          IfxDataReader public methods
          IfxDataReader example
        IfxDataSourceEnumerator class
          Create an IfxDataSourceEnumerator
          IfxDataSourceEnumerator public properties
          IfxDataSourceEnumerator public methods
        IfxDateTime structure
          Create an IfxDateTime
            IfxDateTime constructors
          IfxDateTime public properties
          IfxDateTime public methods
        IfxDecimal structure
          Create an IfxDecimal
            IfxDecimal constructors
          IfxDecimal properties
          IfxDecimal methods
        IfxError class
          IfxError public properties
        IfxErrorCollection class
          IfxErrorCollection public properties
          IfxErrorCollection public methods
        IfxException class
          IfxException public properties
        IfxMonthSpan structure
          Create an IfxMonthSpan
            IfxMonthSpan constructors
          IfxMonthSpan public properties
          IfxMonthSpan public methods
        IfxParameter class
          Create an IfxParameter class
            IfxParameter constructors
          IfxParameter public properties
          IfxParameter examples
        IfxParameterCollection class
          Create an IfxParameterCollection
          IfxParameterCollection public properties
          IfxParameterCollection public methods
        IfxProviderFactory class
          IfxProviderFactory public methods
        IfxSmartLOBCreateTimeFlags enumeration
        IfxSmartLOBFileLocation enumeration
        IfxSmartLOBLocator class
        IfxSmartLOBLockMode enumeration
        IfxSmartLOBOpenMode enumeration
        IfxSmartLOBWhence enumeration
        IfxTimeSpan structure
          Create an IfxTimeSpan
            IfxTimeSpan constructors
          IfxTimeSpan public properties
          IfxTimeSpan public methods
        IfxTimeUnit enumeration
        IfxTransaction class
          IfxTransaction public properties
          IfxTransaction public methods
          IfxTransaction example
        IfxType enumeration
      Sample programs
        Demonstration programs
        HCL Informix .NET Provider examples
          Retrieve a single value
          Retrieve multiple rows
          Execute SQL that does not return data and using a transaction
          Retrieve data into a DataSet
          IfxCommandBuilder object to reconcile changes with the database
          Call a stored procedure
          Distributed transactions
          Write CLOBs to files
  Informix 4GL
  Informix JDBC Driver Guide
    What's new in HCL Informix JDBC Driver, Version 4.10
    Getting started
      What is JDBC?
      What is a JDBC driver?
      HCL Informix JDBC Driver
        Classes implemented in Informix JDBC Driver
          Informix classes that implement Java interfaces
          Informix classes that extend the JDBC specification
          Informix classes that provide support beyond the Java specification
          UDTManager and UDRManager classes
        Files in HCL Informix JDBC Driver
      Obtain the JDBC driver
      Installing the JDBC Driver
        Installing JDBC driver in graphical or console mode
        Installing the JDBC driver in silent mode
      Using the driver in an application
      Using the driver in an applet
      Uninstall the JDBC Driver
        Uninstall in graphical or console mode
        Uninstall in silent mode
    Connect to the database
      Load HCL Informix JDBC Driver
      A DataSource object
      The DriverManager.getConnection() method
        Format of database URLs
          IP address in connection URLs
        Database versus database server connections
        Specify properties
      Informix environment variables with the HCL Informix JDBC Driver
      Dynamically reading the Informix sqlhosts file
        Connection property syntax
        Administration requirements
        Utilities to update the LDAP server with sqlhosts data
          The SqlhUpload utility
          The SqlhDelete utility
      Connections to the servers of a high-availability cluster
        Properties for connecting to high-availability cluster servers through HCL Informix Connection Managers
        Properties for connecting to high-availability cluster servers through SQLHOST file group entries
        Properties for connecting directly to an HDR pair of servers
        Checks for read-only status of high-availability secondary servers
        Connection retry attempts to HDR secondary servers
      An HTTP proxy server
        Configuring your environment to use a proxy server
          Specify a timeout
        The proxy with an LDAP server
          Specify where LDAP lookup occurs
        Specify sqlhosts file lookup
      Other multitier solutions
      Encryption options
        FIPS-compliant security package
        Password encryption
          Configure the database server
        Connecting JDBC applications with SSL
        CSM network encryption
          CSM network encryption syntax
          Option tags
          Option parameters
      Using single sign-on access control with the Informix JDBC Driver
      PAM authentication method
        PAM in JDBC
      Close the connection
    Perform database operations
      Query the database
        Example of sending a query to the Informix database
        Reoptimize queries
        Result sets
          Scrollable result set for multiple rows
        Deallocate resources
        Execute across threads
        Scroll cursors
          Scroll sensitivity
          Client-side scrolling
          Result set updatability
        Hold cursors
      Update the database
        Perform batch updates
          SQL statements and batch updates
          Return value from Statement.executeBatch() method
        Perform bulk inserts
      Parameters, escape syntax, and unsupported methods
        The CallableStatement OUT parameters
          Server and driver restrictions and limitations
            Server restrictions
            Driver enhancement
            Driver restrictions and limitations
              IN and OUT parameter type mapping
        Named parameters in a CallableStatement
          Requirements and restrictions for named parameters in a CallableStatement
            Verify support for named parameters in a CallableStatement
          Retrieve parameter names for stored procedures
          Named parameters and unique stored procedures
            Example of number of named parameters equals the number of arguments
            Example of number of named parameters Is less than the number of arguments
          Named parameters and overloaded stored procedures
        JDBC support for DESCRIBE INPUT
        The escape syntax
        Unsupported methods and methods that behave differently
      Handle transactions
        Autocommit
          Logged Database
          ANSI Databases
          Non-logged Databases
        Transactions with Large Objects
        Transactions with XA
        Transactions with Savepoints
      Handle errors
        Handle errors with the SQLException class
        Retrieve the syntax error offset
          Catch RSAM error messages
        Handle errors with the com.informix.jdbc.Message class
      Access database metadata
      Other Informix extensions to the JDBC API
        The Auto Free feature
        Obtaining driver version information
      Store and retrieve XML documents
        Set up your environment to use XML methods
          Set your CLASSPATH
          Specify a parser factory
        Insert data
        Retrieve data
        Insert data examples
          The XMLtoString() examples
          The XMLtoInputStream() example
        Retrieve data examples
          The StringtoDOM() example
          The InputStreamtoDOM() example
          The getInputSource() examples
    Work with Informix types
      Distinct data types
        Insert data examples
        Retrieve data example
        Unsupported methods
      BYTE and TEXT data types
        Cache large objects
        Example: Inserting or updating data
        Example: Selecting data
      SERIAL and SERIAL8 data types
      BIGINT and BIGSERIAL data types
      INTERVAL data type
        The Interval class
          Variables for binary qualifiers
          Interval methods
        The IntervalYM class
          The IntervalYM constructors
          The IntervalYM methods
        The IntervalDF class
          The IntervalDF constructors
          The IntervalDF methods
        Interval example
      Collections and arrays
        Collection examples
        Array example
      Named and unnamed rows
        Interval and collection support
        Unsupported methods
        The SQLData interface
          SQLData examples
        The Struct interface
          Struct examples
        The ClassGenerator utility
          Simple named row example
          Nested named row example
      Type cache information
      Smart large object data types
        Smart large objects in the database server
        Smart large objects in a client application
          Creating smart large objects
            Create an IfxLobDescriptor object
            Create an IfxLocator object
            Create an IfxSmartBlob object
            Inserting a smart large object into a column
          Accessing smart large objects
        Perform operations on smart large objects
          Open a smart large object
          Position within a smart large object
          Read data from a smart large object
          Write data to a smart large object
          Truncate a smart large object
          Measure a smart large object
          Close and release a smart large object
          Convert IfxLocator to a hexadecimal string
        Work with storage characteristics
          System-specified storage characteristics
            Obtain information about storage characteristics
            Example of setting sbspace characteristics
          Work with disk-storage information
          Work with logging, last-access time, and data integrity
            Logging
            Last-access time
            Data integrity
          Changing the storage characteristics
            Set create flags
        Work with status characteristics
        Work with locks
          Byte-range locking
        Cache large objects
        Avoid errors transferring large objects
        Smart large object examples
          Create a smart large object
          Insert data into a smart large object
          Retrieve data from a smart large object
    Work with opaque types
      The IfmxUDTSQLInput interface
        Read data
        Position in the data stream
        Set or obtain data attributes
      The IfmxUDTSQLOutput interface
      Map opaque data types
      Type cache information
      Unsupported methods
      Creating opaque types and UDRs
        Overview of creating opaque types and UDRs
        Preparing to create opaque types and UDRs
        Creating opaque types
          Creating an opaque type from an existing Java class
          Creating an opaque type without an existing Java class
        Creating a UDR
        Requirements for the Java class
        SQL names
        Specify characteristics for an opaque type
          Specify field count
          Specify additional field characteristics
          Specify length
          Specify alignment
          Alignment values
          Specify SQL names
          Specify the Java class name
          Specifying Java source file retention
        Creating the JAR and class files
          Create the .class and .java files
          Create the .jar file
        Send the class definition to the database server
          Specify deployment descriptor actions
          Specify a JAR file temporary path
        Creating an opaque type from existing code
          The setXXXCast() methods
          The setSupportUDR() and setUDR() methods
        Remove opaque types and JAR files
        Create UDRs
        Remove UDRs and JAR files
          Remove overloaded UDRs
        Obtain information about opaque types and UDRs
          The getXXX() methods in the UDTMetaData class
          The getXXX() methods in the UDRMetaData class
        Execute in a transaction
      Examples
        Class definition
        Insert data
        Retrieve data
        Smart large objects within an opaque type
        Create an opaque type from an existing Java class with UDTManager
          Create an opaque type using default support functions
            The opaque type
          Create an opaque type using support functions you supply
            The opaque type
        Create an opaque type without an existing Java class
        Create UDRs with UDRManager
    Globalization and date formats
      Support for Java and globalization
      Support for HCL Informix GLS variables
      Support for DATE end-user formats
        The GL_DATE variable
        The DBDATE variable (deprecated)
        The DBCENTURY variable
      Precedence rules for end-user formats
      Support for code-set conversion
        Unicode to database code set
        Unicode to client code set
        Connect to a database with non-ASCII characters
        Code-set conversion for TEXT and CLOB data types
          Convert with the IFX_CODESETLOB environment variable
          Convert with Java methods
        Code-set conversion for BLOB and BYTE data types
      User-defined locales
        Connect with the NEWLOCALE and NEWCODESET environment variables
        Connect with the NEWNLSMAP environment variable
      Support for globalized error messages
    Smart trigger feature
    Tuning and troubleshooting
      Debug your JDBC API program
      Manage performance
        Manage the fetch buffer size
        Manage memory for large objects
        Reduce network traffic
        Bulk inserts
        A connection pool
          Deploying a ConnectionPoolDataSource object
          Tune the Connection Pool Manager
          High-Availability Data Replication with connection pooling
          Clean pooled connections
          Manage connections
        Avoid application hanging problems (HP-UX only)
    Appendixes
      Sample code files
        Summary of available examples
          Examples in the demo directory
            Examples in the basic directory
            Examples in the bson directory
            Examples in the clob-blob directory
            Examples in the udt-distinct directory
            Examples in the complex-types directory
            Examples in the proxy directory
            Examples in the connection-pool directory
            Examples in the xml directory
            Examples in the hdr directory
          Examples in the tools directory
            Examples in the udtudrmgr directory
      DataSource extensions
        Read and write properties
        Get and set standard properties
        Get and set Informix connection properties
        Get and set connection pool DataSource properties
      Mapping data types
        Data type mapping between Informix and JDBC data types
          Data type mapping between extended types and Java and JDBC types
          Data type mapping between C opaque types and Java
        Data type mapping for PreparedStatement.setXXX() extensions
          The mapping extensions
            The extensions for opaque types
              The setBindColType() methods
              The setBindColIfxType() methods
              The clearBindColType() method
              Prebinding example
            Other mapping extensions
          The IfxTypes class
          Extension summary
            Nonextended data types
            Informix extended data types
        Data type mapping for ResultSet.getXXX() methods
          Nonextended data types
          Informix extended data types
        Data type mapping for UDT manager and UDR manager
          Mapping for casts
          Mapping for field types
            Field lengths and date-time data
      Convert internal Informix data types
        The IfxToJavaType class
          The convertDateToDays() method
          The convertDaysToDate() method
          The IfxToJavaChar() method
          The IfxToJavaDate() method
          The IfxToJavaDateTime() method
          The IfxToDateTimeUnloadString() method
          The IfxToJavaDecimal() method
          The IfxToJavaDouble() method
          The IfxToJavaInt() method
          The IfxToJavaInterval() method
          The IfxToJavaLongBigInt() method
          The IfxToJavaLongInt() method
          The IfxToJavaReal() method
          The IfxToJavaSmallInt() method
          The rleapyear() method
          The widenByte() method
      Error messages
        -79700
        -79702
        -79703
        -79704
        -79705
        -79706
        -79707
        -79708
        -79709
        -79710
        -79711
        -79712
        -79713
        -79714
        -79715
        -79716
        -79717
        -79718
        -79719
        -79720
        -79721
        -79722
        -79723
        -79724
        -79725
        -79726
        -79727
        -79728
        -79729
        -79730
        -79731
        -79732
        -79733
        -79734
        -79735
        -79736
        -79737
        -79738
        -79739
        -79740
        -79741
        -79742
        -79744
        -79745
        -79746
        -79747
        -79748
        -79749
        -79750
        -79755
        -79756
        -79757
        -79758
        -79759
        -79760
        -79761
        -79762
        -79764
        -79765
        -79766
        -79767
        -79768
        -79769
        -79770
        -79771
        -79772
        -79774
        -79775
        -79776
        -79777
        -79778
        -79780
        -79781
        -79782
        -79783
        -79784
        -79785
        -79786
        -79788
        -79789
        -79790
        -79792
        -79793
        -79794
        -79795
        -79796
        -79797
        -79798
        -79799
        -79800
        -79801
        -79802
        -79803
        -79804
        -79805
        -79806
        -79807
        -79808
        -79809
        -79811
        -79812
        -79814
        -79815
        -79816
        -79817
        -79818
        -79819
        -79820
        -79821
        -79822
        -79823
        -79824
        -79825
        -79826
        -79827
        -79828
        -79829
        -79830
        -79831
        -79834
        -79836
        -79837
        -79838
        -79839
        -79840
        -79842
        -79843
        -79844
        -79845
        -79846
        -79847
        -79848
        -79849
        -79850
        -79851
        -79852
        -79853
        -79854
        -79855
        -79856
        -79857
        -79858
        -79859
        -79860
        -79861
        -79862
        -79863
        -79864
        -79865
        -79868
        -79877
        -79878
        -79879
        -79880
        -79881
  Informix International Language Supplement (ILS) User Guide
    Introduction
    Syntax conventions
    Installation
      Installation notes for HP platform
    User interface files
      Compatibility matrix file
      Supported code set names used by Informix
      Language and country and region codes used by Informix: IS0 639
      Country and region codes used by Informix: IS0 3166
      GLS registry file
      Configuration
      CLIENT_LOCALE environment variable
      Working with the US product
      DBLANG environment variable
      Note for Russian users
  Informix OLE DB Provider Guide
  Informix OLE DB Provider Guide
    Overview and setup
      Introduction to HCL Informix OLE DB Provider
      Install and configure Informix OLE DB Provider
        Manually adding HCL Informix OLE DB Provider to the registry
        Manually removing HCL Informix OLE DB Provider from the registry
        Upgrading from previous versions
      Sample programs
      Support of OLE DB specifications
      Support of LDAP Authentication in Windows
      Supported interfaces
    HCL Informix OLE DB Provider
      Supported applications
      Connect to a data source
      Cursors
      Data types
        Data type mappings
        The INTERVAL type mapping
        The DATETIME type mapping
        The decimal and money type mapping
        Large object and user-defined data type mapping
        Data conversions from OLE DB types to HCL Informix types
        Data conversions from HCL Informix types to OLE DB types
      Threading support
      Transaction support
        Distributed transactions
        Local transactions
      Distributed transaction support
      Identifiers
      Support for Dynamic Query Extension
      Support for SQL 99 Joins
      International GLS Locales
        Conversion between Unicode and MBCS character sets
        The UNICODE provider string keyword
        The REPORTSTRINGASWSTRING provider string keyword
      Troubleshooting installation, configuration, or operation problems
        HCL Informix OLE DB Provider not registered
        Class not registered
        Cannot establish a connection
        Database not found
        The oledbversion table not found
        Nonalphabetic MBCS characters generate syntax errors
        Server-side cursor fails to update records
        Attempt to use provider from web server or other server fails
        Cannot connect to transaction manager
        Driver not found error
        Errors for stored procedures
        Known issues with OLE DB .NET bridge
Common Files for IC
  Notices
  Example code conventions
  How to read the syntax diagrams
  Dotted decimal syntax diagrams
  Compliance with industry standards
  Java technology dependencies
  Assumptions about your locale
  Demonstration databases
  Notices
  Example code conventions
  How to read the syntax diagrams
  Dotted decimal syntax diagrams
  Compliance with industry standards
  Java technology dependencies
  Assumptions about your locale
  Demonstration databases
Data warehousing
  Dimensional databases
    Dimensional databases
      Overview of data warehousing
      Why build a dimensional database?
      What is dimensional data?
    Design a dimensional data model
      Concepts of dimensional data modeling
        The fact table
        Dimensions of the data model
          Dimension elements
          Dimension attributes
          Dimension tables
      Building a dimensional data model
        A business process
        Summary of a business process
        Determine the granularity of the fact table
          How granularity affects the size of the database
          Use the business process to determine the granularity
            Customer by product level granularity
            Customer by product by district level granularity
            Customer by product by district by day level granularity
        Identify the dimensions and hierarchies
        Establish referential relationships
          Choose the measures for the fact table
            Keys to join the fact table with the dimension tables
          Resisting normalization
          Choose the attributes for the dimension tables
        Fragmentation: Storage distribution strategies
          Fragmentation by ROUND ROBIN
          Fragmentation by EXPRESSION
          Fragmentation by LIST
          Fragmentation by INTERVAL
      Handle common dimensional data-modeling problems
        Minimize the number of attributes in a dimension table
        Dimensions that occasionally change
        Use the snowflake schema for hierarchical dimension tables
    Implement a dimensional database
      Implement the sales_demo dimensional database
        Create the dimensional database
        The CREATE TABLE statement for the dimension and fact tables
        Mapping data from data sources to the database
        Load data into the dimensional database
        Test the dimensional database
        Change the storage distribution strategy
      Implementing a dimensional data model and loading data with Informix Warehouse
      Moving data from relational tables into dimensional tables by using external tables
    Performance tuning dimensional databases
      Query execution plans
      Data distribution statistics
        Fragment-level statistics
        Automatic management of data distribution statistics
  Informix Warehouse Accelerator
    What's new in HCL Informix Warehouse Accelerator, Version 12.10
    Overview of Informix Warehouse Accelerator
      Overview: Accelerating queries with Informix Warehouse Accelerator
      Informix Warehouse Accelerator architecture options
      Informix Warehouse Accelerator internal architecture
      Permissions for administering Informix Warehouse Accelerator
      Tools for administering Informix Warehouse Accelerator
      Java classes for Informix Warehouse Accelerator
      Accelerated queries
        Queries that benefit from acceleration
          Query Example: Quantity, revenue, and cost by item
          Query Example: Profit by store
          Query Example: Revenue by store for each brand
          Query Example: Week to day profits
          Query block example: Average employee sales
          Query block example: Sales count
        Types of queries that are not accelerated
      Supported data types
      Supported functions and expressions
      Supported and unsupported joins
    Installation
      Informix Warehouse Accelerator prerequisites and requirements
      Informix Warehouse Accelerator directory structure
      Preparing the Informix database server
      Verifying the Informix database server environment
      Installing Informix Warehouse Accelerator
      Uninstalling Informix Warehouse Accelerator
      Updating Informix Warehouse Accelerator
    Configuration
      Configuring Informix Warehouse Accelerator
      Configuring Informix Warehouse Accelerator for hardware clusters
      Configuring Informix Warehouse Accelerator on secondary servers in a high-availability environment
      dwainst.conf configuration file
      Configuring memory for Informix Warehouse Accelerator
      The ondwa utility
        Users who can run the ondwa commands
        ondwa setup command
        ondwa start command
        ondwa status command
        ondwa listmarts command
        ondwa getpin command
        ondwa tasks command
        ondwa stop command
        ondwa reset command
        ondwa clean command
    Create an accelerator
    Data marts and AQTs
      Accelerated query tables
      Data marts
      Create a data mart
        Workload analysis
        Creating data mart definitions manually by using workload analysis
          Example: Create a data mart from the command line
          Contents of query probing data
          Removing probing data from the database
      Deploy and load the data mart
      Types of tables for acceleration
        Load data from external tables
        Load data from views
        Load data from synonyms
        Load data from time series virtual tables
        Example: in-memory acceleration of JSON
      Update a data mart
        Reloading the data mart
        Re-creating a data mart
        Replacing a data mart
      Drop a data mart
      Data marts for time series data
        Define virtual partitions by assigning a calendar
        Identify a virtual partition
        Limit the size of data with time windows
        Refresh time series virtual partition
        Example: Accelerating time series data
        Example: Continuous refresh of accelerated time series data
    Turning on query acceleration
      use_dwa session environment variable
    SQL administration routines
      SQL administration routines sorted by task
      ifx_createMart() function
      ifx_def2Mart() procedure
      ifx_dropMart() function
      ifx_dropPartMart() function
      ifx_genMartDef() function
      ifx_getdwaMetrics() function
      ifx_getMartdef() function
      ifx_getMartStat() function
      ifx_listMarts() function
      ifx_loadMart() function
      ifx_loadPartMart() function
      ifx_probe2Mart() procedure
      ifx_refreshMart() function
      ifx_removeDWA() function
      ifx_removeTrickleFeed() function
      ifx_setMart() function
      ifx_setupDWA() function
      ifx_setupTrickleFeed() function
      ifx_TSDW_createWindow() function
      ifx_TSDW_dropWindow() function
      ifx_TSDW_moveWindows() function
      ifx_TSDW_updatePartition() function
      ifx_TSDW_setCalendar() function
      ifx_xml2Mart() procedure
    Informix Smart Analytics Optimizer Studio
      Installing Informix Smart Analytics Optimizer Studio
      Creating an accelerator by using Informix Smart Analytics Optimizer Studio
      Creating data mart definitions by using Informix Smart Analytics Optimizer Studio
        References in data marts
        Join tables at run time
        Fact table for the data mart
      Deploying and loading a data mart by using Informix Smart Analytics Optimizer Studio
      Interface elements of Informix Smart Analytics Optimizer Studio
        Menu bar
        Toolbar
        Data Source Explorer window
        Data Project Explorer window
        Data mart editor
          Canvas
          Palette
        Outline view
        Properties view
    Reversion requirements for an Informix warehouse server and Informix Warehouse Accelerator
    Troubleshooting
      Missing sbspace
      Ensuring a result set includes the most current data
    Sample warehouse schema
    Sysmaster interface (SMI) pseudo tables for query probing data
    Supported locales
  Informix SQL Warehousing Tool
  Dimensional databases
    Dimensional databases
      Overview of data warehousing
      Why build a dimensional database?
      What is dimensional data?
    Design a dimensional data model
      Concepts of dimensional data modeling
        The fact table
        Dimensions of the data model
          Dimension elements
          Dimension attributes
          Dimension tables
      Building a dimensional data model
        A business process
        Summary of a business process
        Determine the granularity of the fact table
          How granularity affects the size of the database
          Use the business process to determine the granularity
            Customer by product level granularity
            Customer by product by district level granularity
            Customer by product by district by day level granularity
        Identify the dimensions and hierarchies
        Establish referential relationships
          Choose the measures for the fact table
            Keys to join the fact table with the dimension tables
          Resisting normalization
          Choose the attributes for the dimension tables
        Fragmentation: Storage distribution strategies
          Fragmentation by ROUND ROBIN
          Fragmentation by EXPRESSION
          Fragmentation by LIST
          Fragmentation by INTERVAL
      Handle common dimensional data-modeling problems
        Minimize the number of attributes in a dimension table
        Dimensions that occasionally change
        Use the snowflake schema for hierarchical dimension tables
    Implement a dimensional database
      Implement the sales_demo dimensional database
        Create the dimensional database
        The CREATE TABLE statement for the dimension and fact tables
        Mapping data from data sources to the database
        Load data into the dimensional database
        Test the dimensional database
        Change the storage distribution strategy
      Implementing a dimensional data model and loading data with Informix Warehouse
      Moving data from relational tables into dimensional tables by using external tables
    Performance tuning dimensional databases
      Query execution plans
      Data distribution statistics
        Fragment-level statistics
        Automatic management of data distribution statistics
  Informix Warehouse Accelerator
    What's new in HCL Informix Warehouse Accelerator, Version 12.10
    Overview of Informix Warehouse Accelerator
      Overview: Accelerating queries with Informix Warehouse Accelerator
      Informix Warehouse Accelerator architecture options
      Informix Warehouse Accelerator internal architecture
      Permissions for administering Informix Warehouse Accelerator
      Tools for administering Informix Warehouse Accelerator
      Java classes for Informix Warehouse Accelerator
      Accelerated queries
        Queries that benefit from acceleration
          Query Example: Quantity, revenue, and cost by item
          Query Example: Profit by store
          Query Example: Revenue by store for each brand
          Query Example: Week to day profits
          Query block example: Average employee sales
          Query block example: Sales count
        Types of queries that are not accelerated
      Supported data types
      Supported functions and expressions
      Supported and unsupported joins
    Installation
      Informix Warehouse Accelerator prerequisites and requirements
      Informix Warehouse Accelerator directory structure
      Preparing the Informix database server
      Verifying the Informix database server environment
      Installing Informix Warehouse Accelerator
      Uninstalling Informix Warehouse Accelerator
      Updating Informix Warehouse Accelerator
    Configuration
      Configuring Informix Warehouse Accelerator
      Configuring Informix Warehouse Accelerator for hardware clusters
      Configuring Informix Warehouse Accelerator on secondary servers in a high-availability environment
      dwainst.conf configuration file
      Configuring memory for Informix Warehouse Accelerator
      The ondwa utility
        Users who can run the ondwa commands
        ondwa setup command
        ondwa start command
        ondwa status command
        ondwa listmarts command
        ondwa getpin command
        ondwa tasks command
        ondwa stop command
        ondwa reset command
        ondwa clean command
    Create an accelerator
    Data marts and AQTs
      Accelerated query tables
      Data marts
      Create a data mart
        Workload analysis
        Creating data mart definitions manually by using workload analysis
          Example: Create a data mart from the command line
          Contents of query probing data
          Removing probing data from the database
      Deploy and load the data mart
      Types of tables for acceleration
        Load data from external tables
        Load data from views
        Load data from synonyms
        Load data from time series virtual tables
        Example: in-memory acceleration of JSON
      Update a data mart
        Reloading the data mart
        Re-creating a data mart
        Replacing a data mart
      Drop a data mart
      Data marts for time series data
        Define virtual partitions by assigning a calendar
        Identify a virtual partition
        Limit the size of data with time windows
        Refresh time series virtual partition
        Example: Accelerating time series data
        Example: Continuous refresh of accelerated time series data
    Turning on query acceleration
      use_dwa session environment variable
    SQL administration routines
      SQL administration routines sorted by task
      ifx_createMart() function
      ifx_def2Mart() procedure
      ifx_dropMart() function
      ifx_dropPartMart() function
      ifx_genMartDef() function
      ifx_getdwaMetrics() function
      ifx_getMartdef() function
      ifx_getMartStat() function
      ifx_listMarts() function
      ifx_loadMart() function
      ifx_loadPartMart() function
      ifx_probe2Mart() procedure
      ifx_refreshMart() function
      ifx_removeDWA() function
      ifx_removeTrickleFeed() function
      ifx_setMart() function
      ifx_setupDWA() function
      ifx_setupTrickleFeed() function
      ifx_TSDW_createWindow() function
      ifx_TSDW_dropWindow() function
      ifx_TSDW_moveWindows() function
      ifx_TSDW_updatePartition() function
      ifx_TSDW_setCalendar() function
      ifx_xml2Mart() procedure
    Informix Smart Analytics Optimizer Studio
      Installing Informix Smart Analytics Optimizer Studio
      Creating an accelerator by using Informix Smart Analytics Optimizer Studio
      Creating data mart definitions by using Informix Smart Analytics Optimizer Studio
        References in data marts
        Join tables at run time
        Fact table for the data mart
      Deploying and loading a data mart by using Informix Smart Analytics Optimizer Studio
      Interface elements of Informix Smart Analytics Optimizer Studio
        Menu bar
        Toolbar
        Data Source Explorer window
        Data Project Explorer window
        Data mart editor
          Canvas
          Palette
        Outline view
        Properties view
    Reversion requirements for an Informix warehouse server and Informix Warehouse Accelerator
    Troubleshooting
      Missing sbspace
      Ensuring a result set includes the most current data
    Sample warehouse schema
    Sysmaster interface (SMI) pseudo tables for query probing data
    Supported locales
  Informix SQL Warehousing Tool
Designing databases
  Designing and Implementing a Database
    What's new in Database Design and Implementation for HCL Informix, Version 12.10
    Basics of database design and implementation
      Plan a database
        Select a data model for your database
        Use ANSI-compliant databases
          Differences between ANSI-compliant and non-ANSI-compliant databases
            Transactions
            Transaction logging
            Owner naming
            Privileges on objects
            Default isolation level
            Character data types
            DECIMAL data type
            Escape characters
            Cursor behavior
            SQLCODE field of the SQL communications area
            Synonym behavior
          Determine if an existing database is ANSI-compliant
        Use a customized language environment for your database (GLS)
      Build a relational data model
        Build a data model
        Overview of the entity-relationship data model
        Identify and define principal data objects
          Discover entities
            Select possible entities
            List of entities
            Telephone directory example
              Generic and significant entities
              Fundamental entities
              Unitary entities
            Diagram entities
          Define the relationships
            Connectivity
            Existence dependency
            Cardinality
            Discover the relationships
            Diagram relationships
          Identify attributes
            Select attributes for entities
            List attributes
            About entity occurrences
        Diagram data objects
          How to read E-R diagrams
          Telephone directory example
            After the diagram is complete
        Translate E-R data objects into relational constructs
          Define tables, rows, and columns
            Place constraints on columns
            Domain characteristics
          Determine keys for tables
            Primary keys
              Composite keys
              System-assigned keys
            Foreign keys (join columns)
            Add keys to the telephone directory diagram
        Resolve relationships
          Resolve m:n relationships
          Resolve other special relationships
        Normalize a data model
          First normal form
          Second normal form
          Third normal form
          Summary of normalization rules
      Select data types
        Define the domains
        Data types
          Select a data type
          Numeric types
            Counters and codes: BIGINT, INT8, INTEGER, and SMALLINT
            Automatic sequences: BIGSERIAL, SERIAL, and SERIAL8
              Alter the next BIGSERIAL, SERIAL, or SERIAL8 number
            Approximate numbers: FLOAT and SMALLFLOAT
            Adjustable-precision floating point: DECIMAL(p)
            Fixed-precision numbers: DECIMAL and MONEY
              Select a currency format
          Chronological data types
            Calendar dates: DATE
              Select a date format (GLS)
            Exact points in time: DATETIME
              Durations using INTERVAL
              Force the format of a DATETIME or INTERVAL value
            Select a DATETIME format (GLS)
          BOOLEAN data type
          Character data types (GLS)
            Character data: CHAR(n) and NCHAR(n)
            Variable-length strings: CHARACTER VARYING(m,r), VARCHAR(m,r), NVARCHAR(m,r), and LVARCHAR(m)
            Variable-length execution time
            Large character objects: TEXT
            Binary objects: BYTE
            Use TEXT and BYTE data types
            Change the data type
          Null values
        Default values
        Check constraints
        Referential constraints
      Implement a relational data model
        Create the database
          Use CREATE DATABASE
            Avoid name conflicts
            Select a dbspace
            Select the type of logging
          Use CREATE TABLE
            Create a fragmented table
            Drop or modify a table
          Use CREATE INDEX
            Composite indexes
            Bidirectional traversal of indexes
          Use synonyms for table names
          Use synonym chains
          Use command scripts
            Capture the schema
            Execute the file
            An example
        Populate the database
          Move data from other HCL Informix databases
          Load source data into a table
          Perform bulk-load operations
    Managing databases
      Table fragmentation strategies
        What is fragmentation?
          Why use fragmentation?
          Whose responsibility is fragmentation?
          Fragmentation and logging
        Distribution schemes for table fragmentation
          Expression-based distribution scheme
            Range rule
            Arbitrary rule
            Use the MOD function
            Insert and update rows
          Round-robin distribution scheme
        Create a fragmented table
          Create a new fragmented table
          Create a fragmented table from nonfragmented tables
            More than one nonfragmented table
            Use a single nonfragmented table
          Rowids in a fragmented table
          Fragment smart large objects
        Modify fragmentation strategies
          Reinitialize a fragmentation strategy
          Modify fragmentation strategies
            The ADD clause
            The DROP clause
            The MODIFY clause
        Grant and revoke privileges on fragments
      Grant and limit access to your database
        Use SQL to restrict access to data
        Control access to databases
        Grant privileges
          Database-level privileges
            Connect privilege
              Users and the public
            Resource privilege
            Database-administrator privilege
          Ownership rights
          Table-level privileges
            Access privileges
              Privileges in the system catalog tables
            Index, alter, and references privileges
            Under privileges for typed tables
            Privileges on table fragments
          Column-level privileges
          Type-level privileges
            Usage privileges for user-defined types
            Under privileges for named row types
          Routine-level privileges
          Language-level privileges
            SPL routines
            External routines
          Automate privileges
            Automate with a command script
            Roles
              Create a role
              Manipulate user privileges and grant roles to other roles
              Enable default roles and non-default roles
              Confirm membership In roles and drop roles
          Determine current role at runtime
        Use SPL routines to control access to data
          Restrict data reads
          Restrict changes to data
          Monitor changes to data
          Restrict object creation
        Views
          Create views
            Typed views
            Duplicate rows from views
          Restrictions on views
            When the basis of the view changes
          Modify with a view
            Delete with a view
            Update a view
            Insert into a view
            Use the WITH CHECK OPTION keywords
            Re-execution of a prepared statement when the view definition changes
        Privileges and views
          Privileges when creating a view
          Privileges when using a view
      Distributed queries
        Overview of distributed queries
          Distributed queries across databases of one Informix instance
          Distributed queries across databases of two or more Informix instances
          Coordinator and participant servers in a distributed query
        Configure the database server to use distributed queries
        Syntax of a distributed query
          Access a remote server and database
            Database Name segment
            Database Object Name segment
          Valid statements for accessing remote objects
          Access remote tables
            Table permissions
            Qualify table references
          Other remote operations
            Open a remote database
            Create a remote database
            Create a synonym for a remote table
        Monitor distributed queries
        Server environment and distributed queries
        Logging-type restrictions on distributed queries
        Transaction processing
          Isolation levels
          DEADLOCK_TIMEOUT and SET LOCK MODE
          Two-phase commit and recovery
    Object-relational databases
      Create and use extended data types in Informix
        HCL Informix data types
          Fundamental or atomic data types
          Predefined data types
          Other predefined data types
          Extended data types
            Complex data types
            User-defined data types
            Distinct data types
            Opaque data types
            DataBlade data types
        Smart large objects
          BLOB data type
          CLOB data type
          Use smart large objects
          Copy smart large objects
        Complex data types
          Collection data types
            Null values in collections
            SET collection types
            MULTISET collection types
            LIST collection types
            Nested collection types
            Add a collection type to an existing table
            Restrictions on collections
          Named row types
            When to use a named row type
            Select a name for a named row type
            Restrictions on named row types
              Restrictions on data types
              Restrictions on constraints
              Restrictions on indexes
              Restrictions on serial data types
            Use a named row type to create a typed table
            Change the type of a table
              Convert an untyped table into a typed table
              Convert a typed table into an untyped table
            Use a named row type to create a column
            Use a named row type within another row type
            Drop named row types
          Unnamed row types
      Type and table inheritance
        What is inheritance?
        Type inheritance
          Define a type hierarchy
          Routine overloading for types in a type hierarchy
          Inheritance and type substitutability
          Drop named row types from a type hierarchy
        Table inheritance
          Relationship between type and table hierarchies
          Define a table hierarchy
          Inheritance of table behavior in a table hierarchy
          Modify table behavior in a table hierarchy
            Constraints on tables in a table hierarchy
            Add indexes to tables in a table hierarchy
            Triggers on tables in a table hierarchy
          SERIAL types in a table hierarchy
          Add a new table to a table hierarchy
          Drop a table in a table hierarchy
          Altering the structure of a table in a table hierarchy
          Query tables in a table hierarchy
          Create a view on a table in a table hierarchy
      Create and use user-defined casts
        What is a cast?
          User-defined casts
          Invoke casts
          Restrictions on user-defined casts
        Cast row types
          Cast between named and unnamed row types
          Cast between unnamed row types
          Cast between named row types
          Explicit casts on fields
            Explicit casts on fields of an unnamed row type
            Explicit casts on fields of a named row type
          Cast individual fields of a row type
        Cast collection data types
          Restrictions on collection-type conversions
          Collections with different element types
            Implicit cast between element types
            Explicit cast between element types
          Convert relational data to a MULTISET collection
        Cast distinct data types
          Explicit casts with distinct types
          Cast between a distinct type and its source type
          Add and drop casts on a distinct type
        Cast to smart large objects
        Create cast functions for user-defined casts
          An example of casting between named row types
          An example of casting between distinct data types
          Multilevel casting
  Designing and Implementing a Database
    What's new in Database Design and Implementation for HCL Informix, Version 12.10
    Basics of database design and implementation
      Plan a database
        Select a data model for your database
        Use ANSI-compliant databases
          Differences between ANSI-compliant and non-ANSI-compliant databases
            Transactions
            Transaction logging
            Owner naming
            Privileges on objects
            Default isolation level
            Character data types
            DECIMAL data type
            Escape characters
            Cursor behavior
            SQLCODE field of the SQL communications area
            Synonym behavior
          Determine if an existing database is ANSI-compliant
        Use a customized language environment for your database (GLS)
      Build a relational data model
        Build a data model
        Overview of the entity-relationship data model
        Identify and define principal data objects
          Discover entities
            Select possible entities
            List of entities
            Telephone directory example
              Generic and significant entities
              Fundamental entities
              Unitary entities
            Diagram entities
          Define the relationships
            Connectivity
            Existence dependency
            Cardinality
            Discover the relationships
            Diagram relationships
          Identify attributes
            Select attributes for entities
            List attributes
            About entity occurrences
        Diagram data objects
          How to read E-R diagrams
          Telephone directory example
            After the diagram is complete
        Translate E-R data objects into relational constructs
          Define tables, rows, and columns
            Place constraints on columns
            Domain characteristics
          Determine keys for tables
            Primary keys
              Composite keys
              System-assigned keys
            Foreign keys (join columns)
            Add keys to the telephone directory diagram
        Resolve relationships
          Resolve m:n relationships
          Resolve other special relationships
        Normalize a data model
          First normal form
          Second normal form
          Third normal form
          Summary of normalization rules
      Select data types
        Define the domains
        Data types
          Select a data type
          Numeric types
            Counters and codes: BIGINT, INT8, INTEGER, and SMALLINT
            Automatic sequences: BIGSERIAL, SERIAL, and SERIAL8
              Alter the next BIGSERIAL, SERIAL, or SERIAL8 number
            Approximate numbers: FLOAT and SMALLFLOAT
            Adjustable-precision floating point: DECIMAL(p)
            Fixed-precision numbers: DECIMAL and MONEY
              Select a currency format
          Chronological data types
            Calendar dates: DATE
              Select a date format (GLS)
            Exact points in time: DATETIME
              Durations using INTERVAL
              Force the format of a DATETIME or INTERVAL value
            Select a DATETIME format (GLS)
          BOOLEAN data type
          Character data types (GLS)
            Character data: CHAR(n) and NCHAR(n)
            Variable-length strings: CHARACTER VARYING(m,r), VARCHAR(m,r), NVARCHAR(m,r), and LVARCHAR(m)
            Variable-length execution time
            Large character objects: TEXT
            Binary objects: BYTE
            Use TEXT and BYTE data types
            Change the data type
          Null values
        Default values
        Check constraints
        Referential constraints
      Implement a relational data model
        Create the database
          Use CREATE DATABASE
            Avoid name conflicts
            Select a dbspace
            Select the type of logging
          Use CREATE TABLE
            Create a fragmented table
            Drop or modify a table
          Use CREATE INDEX
            Composite indexes
            Bidirectional traversal of indexes
          Use synonyms for table names
          Use synonym chains
          Use command scripts
            Capture the schema
            Execute the file
            An example
        Populate the database
          Move data from other HCL Informix databases
          Load source data into a table
          Perform bulk-load operations
    Managing databases
      Table fragmentation strategies
        What is fragmentation?
          Why use fragmentation?
          Whose responsibility is fragmentation?
          Fragmentation and logging
        Distribution schemes for table fragmentation
          Expression-based distribution scheme
            Range rule
            Arbitrary rule
            Use the MOD function
            Insert and update rows
          Round-robin distribution scheme
        Create a fragmented table
          Create a new fragmented table
          Create a fragmented table from nonfragmented tables
            More than one nonfragmented table
            Use a single nonfragmented table
          Rowids in a fragmented table
          Fragment smart large objects
        Modify fragmentation strategies
          Reinitialize a fragmentation strategy
          Modify fragmentation strategies
            The ADD clause
            The DROP clause
            The MODIFY clause
        Grant and revoke privileges on fragments
      Grant and limit access to your database
        Use SQL to restrict access to data
        Control access to databases
        Grant privileges
          Database-level privileges
            Connect privilege
              Users and the public
            Resource privilege
            Database-administrator privilege
          Ownership rights
          Table-level privileges
            Access privileges
              Privileges in the system catalog tables
            Index, alter, and references privileges
            Under privileges for typed tables
            Privileges on table fragments
          Column-level privileges
          Type-level privileges
            Usage privileges for user-defined types
            Under privileges for named row types
          Routine-level privileges
          Language-level privileges
            SPL routines
            External routines
          Automate privileges
            Automate with a command script
            Roles
              Create a role
              Manipulate user privileges and grant roles to other roles
              Enable default roles and non-default roles
              Confirm membership In roles and drop roles
          Determine current role at runtime
        Use SPL routines to control access to data
          Restrict data reads
          Restrict changes to data
          Monitor changes to data
          Restrict object creation
        Views
          Create views
            Typed views
            Duplicate rows from views
          Restrictions on views
            When the basis of the view changes
          Modify with a view
            Delete with a view
            Update a view
            Insert into a view
            Use the WITH CHECK OPTION keywords
            Re-execution of a prepared statement when the view definition changes
        Privileges and views
          Privileges when creating a view
          Privileges when using a view
      Distributed queries
        Overview of distributed queries
          Distributed queries across databases of one Informix instance
          Distributed queries across databases of two or more Informix instances
          Coordinator and participant servers in a distributed query
        Configure the database server to use distributed queries
        Syntax of a distributed query
          Access a remote server and database
            Database Name segment
            Database Object Name segment
          Valid statements for accessing remote objects
          Access remote tables
            Table permissions
            Qualify table references
          Other remote operations
            Open a remote database
            Create a remote database
            Create a synonym for a remote table
        Monitor distributed queries
        Server environment and distributed queries
        Logging-type restrictions on distributed queries
        Transaction processing
          Isolation levels
          DEADLOCK_TIMEOUT and SET LOCK MODE
          Two-phase commit and recovery
    Object-relational databases
      Create and use extended data types in Informix
        HCL Informix data types
          Fundamental or atomic data types
          Predefined data types
          Other predefined data types
          Extended data types
            Complex data types
            User-defined data types
            Distinct data types
            Opaque data types
            DataBlade data types
        Smart large objects
          BLOB data type
          CLOB data type
          Use smart large objects
          Copy smart large objects
        Complex data types
          Collection data types
            Null values in collections
            SET collection types
            MULTISET collection types
            LIST collection types
            Nested collection types
            Add a collection type to an existing table
            Restrictions on collections
          Named row types
            When to use a named row type
            Select a name for a named row type
            Restrictions on named row types
              Restrictions on data types
              Restrictions on constraints
              Restrictions on indexes
              Restrictions on serial data types
            Use a named row type to create a typed table
            Change the type of a table
              Convert an untyped table into a typed table
              Convert a typed table into an untyped table
            Use a named row type to create a column
            Use a named row type within another row type
            Drop named row types
          Unnamed row types
      Type and table inheritance
        What is inheritance?
        Type inheritance
          Define a type hierarchy
          Routine overloading for types in a type hierarchy
          Inheritance and type substitutability
          Drop named row types from a type hierarchy
        Table inheritance
          Relationship between type and table hierarchies
          Define a table hierarchy
          Inheritance of table behavior in a table hierarchy
          Modify table behavior in a table hierarchy
            Constraints on tables in a table hierarchy
            Add indexes to tables in a table hierarchy
            Triggers on tables in a table hierarchy
          SERIAL types in a table hierarchy
          Add a new table to a table hierarchy
          Drop a table in a table hierarchy
          Altering the structure of a table in a table hierarchy
          Query tables in a table hierarchy
          Create a view on a table in a table hierarchy
      Create and use user-defined casts
        What is a cast?
          User-defined casts
          Invoke casts
          Restrictions on user-defined casts
        Cast row types
          Cast between named and unnamed row types
          Cast between unnamed row types
          Cast between named row types
          Explicit casts on fields
            Explicit casts on fields of an unnamed row type
            Explicit casts on fields of a named row type
          Cast individual fields of a row type
        Cast collection data types
          Restrictions on collection-type conversions
          Collections with different element types
            Implicit cast between element types
            Explicit cast between element types
          Convert relational data to a MULTISET collection
        Cast distinct data types
          Explicit casts with distinct types
          Cast between a distinct type and its source type
          Add and drop casts on a distinct type
        Cast to smart large objects
        Create cast functions for user-defined casts
          An example of casting between named row types
          An example of casting between distinct data types
          Multilevel casting
Embedding Informix
  Embedding HCL Informix
    What's new for embeddability in HCL Informix, Version 12.10
    Overview of embedding Informix products
      Customize the size of Informix
      Customize a silent installation
      Easy deployment
      Synchronize connectivity information between servers and clients on Windows
      Automated administration
      Easy configuration in embedded environments
      Specify the Informix environment in the onconfig file
      Maintain Informix availability
    Deploying Informix software
      The deployment utility
        Planning for deploying Informix
        Creating a snapshot with the deployment assistant
          The ifxdeployassist command
        Creating a snapshot for deployment manually
        Deploying a snapshot with the deployment utility
        The ifxdeploy command: The deployment utility
          The ifxdeploy command (Deprecated)
            The ifxdeploy.conf file (Deprecated)
      The syncsqlhosts utility
      Removing a snapshot with the deployment utility
      Deploying Informix and client products with RPM-based installation (Linux)
    Informix embeddability deployment tutorial
      Introducing the Informix deployment assistant
      Introducing the Informix deployment utility
      Automating deployments of reduced-footprint Informix on Linux
        Perform Informix installation and create an instance on Linux
        Creating a snapshot for deployment on Linux
        Silently deploy snapshots on Linux
      Automating deployments of reduced-footprint Informix on Windows
        Perform Informix installation and create an instance on Windows
        Creating a snapshot for deployment on Windows
        Silently deploy Informix on Windows
    Manage memory in embedded environments
      Optimize storage
      Manage message logs in an embedded environment
        Enabling and disabling the tasks that automatically rotate message log files
        Tasks that automatically rotate message log files
        Configuring the frequency of automatic rotation of message log files
        Configuring the maximum number of message log files to retain
        Reducing the size of message log files
      Reserve memory for critical activities in embedded environments
      Maintain a targeted amount of memory in embedded applications
  Embedding HCL Informix
    What's new for embeddability in HCL Informix, Version 12.10
    Overview of embedding Informix products
      Customize the size of Informix
      Customize a silent installation
      Easy deployment
      Synchronize connectivity information between servers and clients on Windows
      Automated administration
      Easy configuration in embedded environments
      Specify the Informix environment in the onconfig file
      Maintain Informix availability
    Deploying Informix software
      The deployment utility
        Planning for deploying Informix
        Creating a snapshot with the deployment assistant
          The ifxdeployassist command
        Creating a snapshot for deployment manually
        Deploying a snapshot with the deployment utility
        The ifxdeploy command: The deployment utility
          The ifxdeploy command (Deprecated)
            The ifxdeploy.conf file (Deprecated)
      The syncsqlhosts utility
      Removing a snapshot with the deployment utility
      Deploying Informix and client products with RPM-based installation (Linux)
    Informix embeddability deployment tutorial
      Introducing the Informix deployment assistant
      Introducing the Informix deployment utility
      Automating deployments of reduced-footprint Informix on Linux
        Perform Informix installation and create an instance on Linux
        Creating a snapshot for deployment on Linux
        Silently deploy snapshots on Linux
      Automating deployments of reduced-footprint Informix on Windows
        Perform Informix installation and create an instance on Windows
        Creating a snapshot for deployment on Windows
        Silently deploy Informix on Windows
    Manage memory in embedded environments
      Optimize storage
      Manage message logs in an embedded environment
        Enabling and disabling the tasks that automatically rotate message log files
        Tasks that automatically rotate message log files
        Configuring the frequency of automatic rotation of message log files
        Configuring the maximum number of message log files to retain
        Reducing the size of message log files
      Reserve memory for critical activities in embedded environments
      Maintain a targeted amount of memory in embedded applications
Extending Informix
  Informix extensions and DataBlade modules
    Database Extensions User's Guide
      What's New in Database Extensions for Informix database server, Version 12.10
      Large object management
        About Large Object Locator
          Large object requirements
        Large Object Locator data types
          The lld_locator data type
          The lld_lob data type
        Large Object Locator functions
          Interfaces
            API library
            ESQL/C library
            SQL interface
          Working with large objects
            The lld_close() function
            The lld_copy() function
            The lld_create() function
            The lld_delete() function
            The lld_open() function
            The lld_read() function
            The lld_seek() function
            The lld_tell() function
            The lld_write() function
          Client file support
            The lld_create_client() function
            The lld_delete_client() function
            The lld_from_client() function
            The lld_open_client() function
            The lld_to_client() function
          Error utility functions
            The lld_error_raise() function
            The lld_sqlstate() function
          Smart large object functions
            The LOCopy function
            The LOToFile function
            The LLD_LobType function
        Large Object Locator example code
          The SQL interface
            The lld_lob type
              Implicit lld_lob casts
              Explicit lld_lob casts
              The LLD_LobType function
            The lld_locator type
              Insert an lld_locator row into a table
              Create a smart large object
              Copy a client file to a large object
              Copy a large object to a large object
              Copy large object data to a client file
              Create and delete a server file
          The API interface
            Create the lld_copy_subset function
            The lld_copy_subset routine
        Large Object Locator error handling
          Large Object Locator errors
          Error handling exceptions
          Error codes
      MQ Messaging
        About MQ messaging
          Prepare to use MQ messaging
            Install and configure WMQ
            Prepare your database server for MQ messaging
            Sample code for setting up queue managers, queues, and channels
            Sample code for setting up the server for use with WMQ
            Switch between server-based and client-based messaging
              Switching from server-based to client-based messaging
              Switching from client-based to server-based messaging
          Verification
            Insert data into a queue
            Read an entry from a queue
            Receive an entry from a queue
            Publish and subscribe to a queue
              Subscribe to a queue
              Unsubscribe from a queue
              Publish to a queue
        MQ messaging tables
          Schema mapping
          General table behavior
          Create and bind a table
          Use INSERT and SELECT
          Retrieve the queue element
          Special considerations
          Table errors
        MQ messaging functions
          Service and policy tables
            The "informix".mqiservice table
            The "informix".mqipubsub table
            The "informix".mqipolicy table
          MQCreateVtiRead() function
          MQCreateVtiReceive() function
          MQCreateVtiWrite() function
          MQHasMessage() function
          MQInquire() function
          MQPublish() function
          MQPublishClob() function
          MQRead() function
          MQReadClob() function
          MQReceive() function
          MQReceiveClob() function
          MQSend() function
          MQSendClob() function
          MQSubscribe() function
          MQTrace() function
          MQUnsubscribe() function
          MQVersion() function
        MQ messaging configuration parameters
          MQSERVER configuration parameter
          MQCHLLIB configuration parameter
          MQCHLTAB configuration parameter
        MQ messaging error handling
        Sample MQ messaging code
      Binary data types
        Binary data types overview
        Store and index binary data
          Binary data types
            The binaryvar data type
            The binary18 data type
            ASCII representation of binary data types
            Binary data type examples
          Insert binary data
          Index binary data
        Binary data type functions
          Bitwise operation functions
            The bit_and() function
            The bit_complement() function
            The bit_or() function
            The bit_xor() function
          Support functions for binary data types
            The bdtrelease() function
            The bdttrace() function
            The LENGTH() function
            The OCTET_LENGTH() function
      Basic Text Search
        Preparing for basic text searching
          Basic text search requirements and restrictions
          Creating a default sbspace
          Creating a space for the bts index
          Creating a space for temporary data
          Creating a bts index
            bts access method syntax
              canonical_maps index parameter
              delete index parameter
              field_token_max index parameter
              max_clause_count index parameter
              query_default_field index parameter
              query_log index parameter
              stopwords index parameter
              thesaurus index parameters
              xact_memory index parameter
              xact_ramdirectory index parameter
        Basic text search queries
          Basic Text Search query syntax
          Basic Text Search query terms
          Basic text search index fields
          Basic Text Search query term modifiers
            Wildcard searches
            Fuzzy searches
            Proximity searches
            Range searches
            Boost a term
          Boolean operators
            AND operator
            OR operator
            NOT operator
        Basic text search JSON index parameters
          JSON index parameters syntax
          all_json_names index parameter
          ignore_json_format_errors index parameter
          include_contents index parameter
          json_array_processing index parameter
          json_names index parameter
          json_path_processing index parameter
          only_json_values index parameter
        Basic Text Search XML index parameters
          XML index parameters syntax
          The xmltags index parameter
            Example: Index specific XML tags
          The all_xmltags index parameter
            Example: Index all XML tags
          The all_xmlattrs index parameter
            Examples: Index XML attributes
          The xmlpath_processing index parameter
            Full paths and relative paths in path processing
            Example: Index XML paths
          The include_contents index parameter
            Example: Index XML tag values and XML tag names
          The strip_xmltags index parameter
            Example: Index XML tag values in a separate field
          The include_namespaces index parameter
            Example: Index namespaces in XML data
          The include_subtag_text index parameter
            Example: Index subtags in XML data
        Basic text search analyzers
          analyzer index parameter
          Analyzer support for query and index options
          Alnum analyzer
          CJK analyzer
          eSoundex analyzer
          Keyword analyzer
          Simple analyzer
          Soundex analyzer
          Snowball analyzer
          Standard analyzer
          Stopword analyzer
          User-defined analyzer
          Whitespace analyzer
        Basic text search functions
          bts_index_compact() function
          bts_index_fields() function
          bts_release() function
          bts_tracefile() function
          bts_tracelevel() function
        Basic text search performance
          Disk space for the bts index
          Adding BTS virtual processors to run multiple queries simultaneously
          Tune configuration parameters for basic text searching
        Basic text search error codes
      Hierarchical data type
        The node data type for querying hierarchical data
          Troubleshooting the node data type
        Node data type functions
          Ancestors() function
          Compare() function
          Depth() function
          Equal() function
          GetMember() function
          GetParent() function
          Graft() function
          GreaterThan() function
          GreaterThanOrEqual() function
          Increment() function
          IsAncestor() function
          IsChild() function
          IsDescendant() function
          IsParent() function
          Length() Node function
          LessThan() function
          LessThanOrEqual() function
          NewLevel() function
          NodeRelease() function
          NotEqual() function
      SQL Packages Extension
        DBMS_ALERT package
          REGISTER procedure
          REMOVE procedure
          REMOVEALL procedure
          SET_DEFAULTS procedure
          SIGNAL procedure
          WAITANY procedure
          WAITONE procedure
        DBMS_LOB package
          APPEND procedures
          COMPARE function
          COPY procedures
          ERASE procedures
          GETLENGTH function
          INSTR function
          READ procedures
          SUBSTR function
          TRIM procedures
          WRITE procedures
        DBMS_OUTPUT package
          DISABLE procedure
          ENABLE procedure
          GET_LINE procedure
          GET_LINES procedure
          NEW_LINE procedure
          PUT procedure
          PUT_LINE procedure
        DBMS_RANDOM package
          INITIALIZE procedure
          SEED procedure
          RANDOM function
          TERMINATE procedure
        UTL_FILE package
          FCLOSE procedure
          FCLOSE_ALL procedure
          FFLUSH procedure
          FOPEN function
          GET_LINE procedure
          NEW_LINE procedure
          PUT procedure
      Regex pattern matching
        Requirements and Restrictions
        Metacharacters
          Regex character names
        Regex Routines
          regex_match function
          regex_replace function
          regex_extract function
          regex_split function
          regex_set_trace procedure
          regex_release function
    Performing XML Publishing
      Publishing SQL result sets in XML
        XML publishing
        The idsxmlvp virtual processor class
        Special characters in XML functions
        The extract() and extractclob() XML functions
        The existsnode() XML function
        The extractvalue() and extractvalueclob() XML functions
        The genxml() and genxmlclob() XML functions
        The genxmlelem() and genxmlelemclob() XML functions
        The genxmlqueryhdr() and genxmlqueryhdrclob() XML functions
        The genxmlquery() and genxmlqueryclob() XML functions
        The genxmlschema() and genxmlschemaclob() XML functions
        The idsxmlparse() XML function
      Transforming documents with XSLT functions
        The xsltransform function
        The xsltransformAsClob function
        The xsltransformAsBlob function
    TimeSeries Data User's Guide
      What's new in TimeSeries data for Informix, Version 12.10
      Informix TimeSeries solution
        Informix TimeSeries solution architecture
        Time series concepts
          TimeSeries data type technical overview
          Regular time series
          Irregular time series
          Packed time series
            Hertz time series
            Compressed numeric time series
          JSON time series
          Calendar
          Time series storage
        Getting started with the Informix TimeSeries solution
          Planning for creating a time series
          Planning for data storage
          Planning for loading time series data
          Planning for replication of time series data
          Planning for accessing time series data
        Hardware and software requirements for the TimeSeries solution
          Installing the HCL Informix TimeSeries Plug-in for Data Studio
          Server and database requirements for time series data
          SQL restrictions for time series data
          Time series global language support
        Sample smart meter data
        Setting up stock data examples
      Data types and system tables
        CalendarPattern data type
        Calendar data type
        TimeSeries data type
          Buffer control
        Time series return types
        CalendarPatterns table
        CalendarTable table
        TSContainerTable table
        TSContainerWindowTable
          TSContainerUsageActiveWindowVTI Table
          TSContainerUsageDormantWindowVTI Table
        TSInstanceTable table
      Create and manage a time series through SQL
        Example for regular data: Create and load a regular time series
        Example for hertz data: Create and load a hertz time series
        Example for compressible data: Create and load a compressed time series
        Example for JSON data: Create and load a time series with JSON documents
        Defining a calendar
          Predefined calendars
        Create a time series column
          Creating a TimeSeries subtype
          Create the database table
        Creating containers
          Rules for rolling window containers
          Monitor containers
          Manage container pools
            Configuring additional container pools
              User-defined container pool policy
        Create a time series
          Creating a time series with metadata
          Time series input string
          Create a time series with the output of a function
        Load data into a time series
          HCL Informix TimeSeries Plug-in for Data Studio
            Creating a load job to load data from a file
            Create a load job to load data from a database
            Running a load job from the command line
            Command-line loader application
          Writing a loader program
          Methods for loading JSON data
            Loading JSON data through an external table
          Loading data from a file into a virtual table
          Load data with the BulkLoad function
            Data file formats for BulkLoad
            Example: Load data with BulkLoad
          Load small amounts of data with SQL functions
        Performance tips for time series
        Delete time series data
        Manage packed data
      Virtual tables for time series data
        Performance of queries on virtual tables
        The structure of virtual tables
        The display of data in virtual tables
        Insert data through virtual tables
        Creating a time series virtual table
        TSCreateVirtualTab procedure
          Example of creating a virtual table
          Example of creating a fragmented virtual table
        TSCreateExpressionVirtualTab procedure
        The TSVTMode parameter
        Drop a virtual table
        Trace functions
          The TSSetTraceFile function
          TSSetTraceLevel function
      Pattern matching searches
        Requirements for pattern matching searches
        Pattern matching criteria
        Indexes on patterns
        Pattern matching routines
          getPatternFromTS function
          TSCreatePatternIndex function
          TSPatternMatch function
          TSDropPatternIndex function
          TSPIndexCleanup procedure
          TSPIndexRelease function
          TSPMatchRelease function
          TSPMatchSetTraceFile function
          TSPMatchSetTraceLevel function
      Advanced analytics
        Requirements and restrictions for advanced analytics functions
        Advanced analytics functions
          Scan_Abnormal and Scan_Abnormal_Default functions
          Scan_DTW_Itakura_Parallelogram_Constraint function
          Scan_DTW_NonConstraint function
          Scan_DTW_Sakoe_Chiba_Constraint function
          Scan_Normal_LCSS and Scan_LCSS functions
          Scan_RangeQuery_LPNorm function
          Scan_RangeQuery_Pearson_Correlation function
          TSAFuncsTraceFile function
          TSAFuncsTraceLevel function
          TSAFuncsRelease function
          TSCompute_Itakura_Parallelogram_Constraint_Dist function
          TSCompute_LCSS_Dist and TSCompute_Normalized_LCSS_Dist functions
          TSCompute_LP_Dist function
          TSCompute_NonConstraint_Dist function
          TSCompute_Sakoe_Chiba_Constraint_Dist function
          TSGetValueList function
          TSPearson_Correlation_Score function
          ValueAsCollection function
      Calendar pattern routines
        AndOp function
        CalPattStartDate function
        Collapse function
        Expand function
        NotOp function
        OrOp function
      Calendar routines
        AndOp function
        CalIndex function
        CalRange function
        CalStamp function
        CalStartDate function
        OrOp function
      Time series SQL routines
        Time series SQL routines sorted by task
        Time series routines that run in parallel
        The flags argument values
        Abs function
        Acos function
        AggregateBy function
        AggregateRange function
        Apply function
        ApplyBinaryTsOp function
        ApplyCalendar function
        ApplyOpToTsSet function
        ApplyUnaryTsOp function
        Asin function
        Atan function
        Atan2 function
        Binary arithmetic functions
        BulkLoad function
        Clip function
        ClipCount function
        ClipGetCount function
        Cos function
        CountIf function
        DelClip function
        DelElem function
        DelRange function
        DelTrim function
        Divide function
        ElemIsHidden function
        ElemIsNull function
        Exp function
        FindHidden function
        GetCalendar function
        GetCalendarName function
        GetClosestElem function
        GetCompression function
        GetContainerName function
        GetElem function
        GetFirstElem function
        GetFirstElementStamp function
        GetHertz function
        GetIndex function
        GetInterval function
        GetLastElem function
        GetLastElementStamp function
        GetLastNonNull function
        GetLastValid function
        GetMetaData function
        GetMetaTypeName function
        GetNelems function
        GetNextNonNull function
        GetNextValid function
        GetNthElem function
        GetOrigin function
        GetPacked function
        GetPreviousValid function
        GetStamp function
        GetThreshold function
        HideElem function
        HideRange function
        InsElem function
        InsSet function
        InstanceId function
        Intersect function
        IsRegular function
        Lag function
        Logn function
        Minus function
        Mod function
        Negate function
        NullCleanup function
        Plus function
        Positive function
        Pow function
        ProjectedClip function
        PutElem function
        PutElemNoDups function
        PutNthElem function
        PutSet function
        PutTimeSeries function
        RevealElem function
        RevealRange function
        Round function
        SetContainerName function
        SetOrigin function
        Sin function
        Sqrt function
        Tan function
        Times function
        TimeSeriesRelease function
        Transpose function
        TSAddPrevious function
        TSCmp function
        TSColNameToList function
        TSColNumToList function
        TSContainerCreate procedure
        TSContainerDestroy procedure
        TSContainerLock procedure
        TSContainerManage function
        TSContainerNElems function
        TSContainerPctUsed function
        TSContainerPoolRoundRobin function
        TSContainerPurge function
        TSContainerSetPool procedure
        TSContainerTotalPages function
        TSContainerTotalUsed function
        TSContainerUsage function
        TSCreate function
        TSCreateIrr function
        TSDecay function
        TSInfo function
        TSL_ActiveHandles function
        TSL_Attach function
        TSL_Commit function
        TSL_Flush function
        TSL_FlushAll function
        TSL_FlushInfo function
        TSL_FlushStatus function
        TSL_GetFmtMessage function
        TSL_GetKeyContainer function
        TSL_GetLogMessage function
        TSL_Init function
        TSL_MessageSet function
        TSL_Put function
        TSL_PutJson function
        TSL_PutRow function
        TSL_PutSQL function
        TSL_SessionClose function
        TSL_SetLogMode function
        TSL_SetNewTS function
        TSL_Shutdown procedure
        TSPrevious function
        TSRollup function
        TSRowNameToList function
        TSRowNumToList function
        TSRowToList function
        TSRunningAvg function
        TSRunningCor function
        TSRunningMed function
        TSRunningSum function
        TSRunningVar function
        TSSetToList function
        TSToXML function
        Unary arithmetic functions
        Union function
        UpdElem function
        UpdMetaData function
        UpdSet function
        WithinC and WithinR functions
      Time series Java class library
        Java class files and sample programs
        Preparing the server for Java classes
        Mapping time series data types
        Querying time series data with the IfmxTimeSeries object
        Obtaining the time series Java class version
      Time series API routines
        Differences in using functions on the server and on the client
        Data structures for the time series API
          The ts_timeseries structure
          The ts_tscan structure
          The ts_tsdesc structure
          The ts_tselem structure
        Time series API routines sorted by task
        The ts_begin_scan() function
        The ts_cal_index() function
        The ts_cal_pattstartdate() function
        The ts_cal_range() function
        The ts_cal_range_index() function
        The ts_cal_stamp() function
        The ts_cal_startdate() function
        The ts_close() function
        The ts_closest_elem() function
        The ts_col_cnt() function
        The ts_col_id() function
        The ts_colinfo_name() function
        The ts_colinfo_number() function
        The ts_copy() function
        The ts_create() function
        The ts_create_with_metadata() function
        The ts_current_offset() function
        The ts_current_timestamp() function
        The ts_datetime_cmp() function
        The ts_del_elem() function
        The ts_elem() function
        The TS_ELEM_HIDDEN macro
        The TS_ELEM_NULL macro
        The ts_elem_to_row() function
        The ts_end_scan() procedure
        The ts_first_elem() function
        The ts_free() procedure
        The ts_free_elem() procedure
        The ts_get_all_cols() procedure
        The ts_get_calname() function
        The ts_get_col_by_name() function
        The ts_get_col_by_number() function
        The ts_get_compressed() function
        The ts_get_containername() function
        The ts_get_flags() function
        The ts_get_hertz() function
        The ts_get_metadata() function
        The ts_get_origin() function
        The ts_get_packed() function
        The ts_get_stamp_fields() procedure
        The ts_get_threshold() function
        The ts_get_ts() function
        The ts_get_typeid() function
        The ts_hide_elem() function
        The ts_index() function
        The ts_ins_elem() function
        The TS_IS_INCONTAINER macro
        The TS_IS_IRREGULAR macro
        The ts_last_elem() function
        The ts_last_valid() function
        The ts_make_elem() function
        The ts_make_elem_with_buf() function
        The ts_make_stamp() function
        The ts_nelems() function
        The ts_next() function
        The ts_next_valid() function
        The ts_nth_elem() function
        The ts_open() function
        The ts_previous_valid() function
        The ts_put_elem() function
        The ts_put_elem_no_dups() function
        The ts_put_last_elem() function
        The ts_put_nth_elem() function
        The ts_put_ts() function
        The ts_reveal_elem() function
        The ts_row_to_elem() function
        The ts_time() function
        The ts_tstamp_difference() function
        The ts_tstamp_minus() function
        The ts_tstamp_plus() function
        The ts_update_metadata() function
        The ts_upd_elem() function
      Appendixes
        The Interp function example
        The TSIncLoad procedure example
    Web DataBlade Module
  Creating extensions
    DataBlade API Programmer's Guide
      DataBlade API overview
        The DataBlade API
          The DataBlade API module
            User-defined routine (Server)
              Types of UDRs
              Differences between C UDRs and UDRs written in SPL
              Write a UDR in C
            The client LIBMI application
            Compatibility of client and server DataBlade API modules
          DataBlade API components
            Header files
              DataBlade API header files
              ESQL/C header files
              Informix GLS header file
              Private header files
            Public data types
              DataBlade API data types
              DataBlade API support data types
              DataBlade API data type structures
            Regular public functions
              DataBlade API functions
              Informix ESQL/C functions
              Informix GLS functions
            Advanced features (Server)
          Internationalization of DataBlade API modules (GLS)
        Access SQL data types
          Type identifiers
          Type descriptors
            Type-structure conversion
            Data type descriptors and column type descriptors
          Character data types
            The mi_char1 and mi_unsigned_char1 data types
            The mi_char and mi_string data types
            The mi_lvarchar data type
              The SQL LVARCHAR data type
              Character data in binary mode of a query
              Character data in C UDRs (Server)
              External representation of an opaque data type (Server)
            Character data in a smart large object
            Character processing
              Transfer character data (Server)
              Convert character data
                DataBlade API functions for string conversion
                ESQL/C functions for string conversion
              Operations on character values
              Character type information
          Varying-length data type structures
            A varying-length structure
            Memory management for a varying-length structure
              Create a varying-length structure
              Deallocate a varying-length structure
            Access a varying-length structure
              Varying-length data and null termination
              Storage of varying-length data
                Store data in a varying-length structure
                Store a null-terminated string
                Set the data pointer
              Information about varying-length data
                Obtain the data length
                Obtain data as a null-terminated string
                Copy data into a user-allocated buffer
                Copy data into a new varying-length structure
                Obtain the data pointer
          Byte data types
            The mi_bitvarying data type
            Byte data in a smart large object
            Byte processing
              Manipulate byte data
              Transfer byte data (Server)
          Boolean data types
            Boolean text representation
            Boolean binary representation
            Pointer data types (Server)
          Simple large objects
          The MI_DATUM data type
            Contents of an MI_DATUM structure
              MI_DATUM in a C UDR (Server)
              MI_DATUM in a client LIBMI application
            Address calculations with MI_DATUM values
            Uses of MI_DATUM structures
          The NULL constant
            SQL NULL value
            NULL-valued pointer
      Data manipulation
        Numeric data types
          Integer data
            Integer text representation
            Integer binary representations
              One-byte integers
              Two-byte integers
              Four-byte integers
              Eight-byte integers
                The int8.h header file
                  Internal INT8 format
                ESQL/C INT8-type functions
                Transfer eight-byte integers (Server)
                Convert INT8 values
                Perform operations on eight-byte values
          Fixed-point data
            Fixed-point text representations
              Decimal text representation
              Monetary text representation
            Fixed-point binary representations
              DECIMAL data type: Fixed-point data
              MONEY data type
              The decimal.h header file
                Internal fixed-point decimal format
                The decimal macros
                ESQL/C DECIMAL-type functions
            Transfer fixed-point data (Server)
            Convert decimal data
              DataBlade API functions for decimal conversion
              ESQL/C functions for decimal conversion
            Perform operations on decimal data
            Obtain fixed-point type information
          Floating-point data
            Floating-point text representation
            Floating-point binary representations
              DECIMAL data type: Floating-point data
              SMALLFLOAT data type
              The FLOAT data type
            Transfer floating-point data (Server)
            Convert floating-point decimal data
            Obtain floating-point type information
          Format numeric strings
        Date and time data types
          Date data
            Date text representation
            Date binary representation
            Transfers of date data (Server)
            Conversion of date representations
              DataBlade API functions for date conversion
              ESQL/C functions for date conversion
            Operations on date data
          Date-time or interval data
            Date-time or interval text representation
            Date-time or interval binary representation
              The DATETIME data type
              The INTERVAL data type
            The datetime.h header file
            Retrieval and insertion of DATETIME and INTERVAL values
              Fetch or Insert into an mi_datetime variable
              Fetch or insert into an mi_interval variable
              Implicit data conversion
            Transfers of date-time or interval data (Server)
            Conversion of date-time or interval representations
              DataBlade API functions for date-time or interval conversion
              ESQL/C functions for date, time, and interval conversion
                Data conversion for DATETIME values
                  Converting a DATETIME value to a DATE value
                  Converting a DATE value into a DATETIME value
                Data conversion for INTERVAL values
            Operations on date and time data
            Functions to obtain information on date and time data
              Qualifier of a date-time or interval data type
              Precision of a date-time or interval data type
              Scale of a date-time or interval data type
        Complex data types
          Collections
            Collection text representation
            Collection binary representation
              A collection structure
              A collection descriptor
            Create a Collection
            Open a collection
              Open a collection with mi_collection_open()
              Open a collection with mi_collection_open_with_options()
            Access the elements of a collection
              Position the cursor
              Insert an element
              Fetch an element
                Move through a cursor
                Obtain the element value
              Update a collection
              Delete an element
              Determine the cardinality of a collection
            Releasing collection resources
              Close a collection
              Free the collection structure
            The listpos() UDR
              SQL statements
              C-language implementation
              Sample listpos() trace output
          Row types
            Row-type text representation
            Row-type binary representation
              A row descriptor
              A row structure
            Create a row type
              Create the row descriptor
              Assign the field values
                Column-value array
                Column-value null array
              Example: Creating a row type
            Access a row type
            Copying a row structure
            Releasing row resources
              Free a row structure
              Free a row descriptor
        Smart large objects
          Smart large objects
            Parts of a smart large object
              The sbspace
              The LO handle
            Information about a smart large object
              Storage characteristics
                Disk-storage information
                Attribute information
                  Logging
                  Last-access time
                  Data integrity
                Open-mode information
                  Access modes
                  Access methods
                  Buffering modes
                  Locking modes
              Status information
          Storing a smart large object in a database
            Valid data types
              CLOB and BLOB data types
              Opaque data type
            Access to a smart large object
              Selecting a smart large object
              Storing a smart large object
          The smart-large-object interface
            Smart-large-object data type structures
              Lo-specification structure
              LO handle
              Lo file descriptor
              Lo-status structure
            Smart-large-object functions
              Functions that create a smart large object
              Functions that perform input and output on a smart large object
              Functions that manipulate an LO handle
              Functions that access an LO-specification structure
              Functions that access an LO-status structure
              Functions that move smart large objects to and from operating-system files
          Creating a smart large object
            Obtain the LO-specification structure
              Specify new storage characteristics
                Allocating memory for an LO-specification structure
                Initialize an LO-specification structure
              Copy storage characteristics from an existing smart large object
            Choosing storage characteristics
              Obtaining storage characteristics
              Storage-characteristics hierarchy
                System-specified storage characteristics
                Obtain column-level storage characteristics
                Define user-specified storage characteristics
                  Access disk-storage information
                  Access attributes
                  Access the default open flag
            Initialize an LO handle and an LO file descriptor
              Obtain an LO handle
                Implicitly allocating an LO handle
                Explicitly allocating an LO handle
              Obtain an LO file descriptor
            Write data to a smart large object
            Storing an LO handle
            Free resources
              Free an LO-specification structure
              Free an LO handle
            Sample code to create a new smart large object
          Accessing a smart large object
            Selecting the LO handle
              Validate an LO handle
            Open a smart large object
            Read data from a smart large object
            Free a smart large object
            Sample code to select an existing smart large object
          Modify a smart large object
            Updating a smart large object
              Updating an LO handle
              Updating the data of an existing smart large object
            Alter storage characteristics
          Obtaining status information for a smart large object
            Obtain a valid LO file descriptor
            Initialize an LO-status structure
              Obtain a valid LO-status structure
              Fill in the LO-status structure
            Obtain status information
            Free an LO-status structure
          Delete a smart large object
            Manage the reference count
              Reference counts for CLOB and BLOB columns
              Reference counts for opaque-type columns
              Reference counts for transient smart large objects
            Free LO file descriptors
          Convert a smart large object to a file or buffer
            Operating-system files
            User-defined buffers
          Convert an LO handle between binary and text
            Binary and text representations of an LO handle
            DataBlade API functions for LO-handle conversion
          Transfer an LO handle between computers (Server)
          Using byte-range locking
          Pass a NULL connection (Server)
      Database access
        Connection handling
          Session management
            Client connection
            UDR connection (Server)
            Connection descriptor
          Initializing a client connection
            Connection parameters
              Establish default connection parameters
                System-default connection parameters
                Overriding the system-default connection parameters
              Obtain current connection parameters
            Database parameters
              Establish default database parameters
                System-default database parameters
                Overriding the system-default database parameters
              Obtain current database parameters
            Session parameters
              System-default session parameters
              Overriding the system-default session parameters
            Set connection parameters for a client connection
          Establish a connection
            Establish a UDR connection (Server)
              Obtain a connection descriptor
              Obtain a session-duration connection descriptor
            Establish a client connection
              Connections with mi_open()
              Connections with mi_server_connect()
          Associate user data with a connection
          Initialize the DataBlade API
          Close a connection
        Execute SQL statements
          Execute SQL statements
            Choose a DataBlade API function
              Type of statement
              Prepared statements and input parameters
              Queries and implicit cursors
            Execute basic SQL statements
              Assemble a statement string
              Send an SQL statement
                The implicit row cursor
                Control modes for query data
                Example: The send_statement() function
            Execute prepared SQL statements
              Prepare an SQL statement
                Assemble a prepared statement
                  Assemble unparameterized statements
                  Assemble parameterized statements
                Assign an optional name
                Return a statement descriptor
              Obtain input-parameter information
              Send the prepared statement
                Statements with mi_exec_prepared_statement()
                Statements with mi_open_prepared_statement()
                  Define an explicit cursor
                  Define a cursor type
                  Define a cursor mode
                  Define a cursor life span
                  Fetch rows into a cursor
                Assign values to input parameters
                  Parameter-value array
                  Parameter-value length array
                  Parameter-value null array
                  Parameter-value type array
                Determine control mode for query data
              Release prepared-statement resources
                Closing a statement cursor
                Drop a prepared statement
            Execute multiple SQL statements
          Process statement results
            Execute the mi_get_result() loop
              Handling unsuccessful statements
              Handling a DDL statement
              Handling a DML Statement
              Handling query rows
              Handling no more results status
            Example: The get_results() function
          Retrieving query data
            Obtain row information
            Obtain column information
            Retrieve rows
              Access the current row
              Execute the mi_next_row() loop
            Obtain column values
              Execute the column-value loop
              Access the columns
                Pass in the value buffer
                Interpret column-value status
              Obtain normal values
                Column values passed back to a C UDR (Server)
                Column values passed back to a client LIBMI application
                Access smart large objects
              Obtain NULL values
              Obtain row values
                Obtain row types
                Obtain jagged rows
                  Retrieving jagged rows
              Obtain collection values
                A collection in text representation
                A collection in binary representation
              Example: The get_data() function
          Complete execution
            Finish execution
              Process remaining rows
              Release statement resources
            Interrupt execution
          Inserting data into the database
            Assemble an insert string
            Send the insert statement
            Process insert results
          Save sets
            Create a save set
            Inserting rows into a save set
            Building a save set
            Free a save set
        Execute user-defined routines
          Access MI_FPARAM routine-state information
            Check routine arguments
              Determine the data type of UDR arguments
              Handling NULL arguments with MI_FPARAM
            Access return-value information
              Determine the data type of UDR return values
              Return a NULL value
            Saving a user state
              Saving user-state information in the first invocation of a UDR
              Obtaining user-state information in subsequent invocations of the UDR
              The MI_FPARAM structure for holding private-state information
            Obtain additional routine information
          Call UDRs within a DataBlade API module
            Call a UDR through an SQL statement
            Call a UDR directly (Server)
            Named parameters and UDRs
          Call UDRs with the Fastpath interface
            Obtain a function descriptor
              Look up a UDR
              Look up cast functions
            Obtain information from a function descriptor
              Obtain the MI_FPARAM structure
              Obtain a routine identifier
              Determine if a UDR handles NULL arguments
              Determine if a routine is a variant function
              Determine if a function is a negator function
              Determine if a function is a commutator function
            Execute the routine
              Pass in argument values
              Receive the return value
              Sample mi_routine_exec() calls
              Execute a built-in cast function
              Reuse a function descriptor
                Function descriptors within an SQL command
                Function descriptors within a session (Server)
                  Cache a session-duration function descriptor
                  Reuse the session-duration function descriptor
                  Deallocate a session-duration function descriptor
            A user-allocated MI_FPARAM structure
              Create a user-allocated MI_FPARAM structure
              A user-allocated MI_FPARAM structure (Server)
              Pass a user-allocated MI_FPARAM structure
              Free a user-allocated MI_FPARAM
            Release routine resources
          Obtain trigger execution information and HDR database server status
            Trigger information
            HDR status information
        Exceptions and events
          DataBlade API event types
          Event-handling mechanisms
            Invoke a callback
              Register a callback
                Types of callbacks
                Connection descriptor
                Callback-function pointer
                Callback handle
                Registration duration
              Enable and disable a callback
              Retrieving a callback function
                Example of retrieving a callback function
            Default behavior
              Default behavior in a C UDR (Server)
              Default behavior in client LIBMI applications
          Callback functions
            Declare a callback function
              Return value of a callback function
              MI_PROC_CALLBACK modifier (Windows)
              Callback-function parameters
            Write a callback function
              Restrictions on content
              Event information
                An error descriptor
                  Access an error descriptor
                  Create a copy of an error descriptor
                A transition descriptor
          Database server exceptions
            Understanding database server exceptions
              Warnings and errors
              Status variables
                The SQLSTATE status value
                  Identify warnings with SQLSTATE
                  Identify runtime errors with SQLSTATE
                SQLCODE status value
                  Identify warnings with SQLCODE
                  Identify runtime errors with SQLCODE
            Overriding the default exception handling
              Exceptions in a C UDR (Server)
                Handling errors from DataBlade API functions
                Register an exception callback
                Determine how to handle the exception
                  Handling an exception in the callback
                  Continue with exception handling
              Exceptions in a client LIBMI application (Client)
            Return error information to the caller
              Define a user-defined error structure
              Implement the callback
                Associate a user-defined error structure with a callback
                Associate a user-defined error structure with the connection
            Handling multiple exceptions
            Raise an exception
              Specify the connection
              Specify the message
                Pass literal messages
                Raise custom messages
                  Search for custom messages
                  Specify parameter markers
                  Adding custom messages
                  Choose an SQLSTATE code
                  Add new messages
          State-transition events
            Understanding state-transition events
              Begin a transaction
              End a session (Server)
            Providing state-transition handling
              State transitions in a C UDR (Server)
                Manage memory allocations
                Manage the transaction
              State transitions in a client LIBMI application
          Client LIBMI errors
        XA-compliant external data sources
          Overview of integrating XA-compliant data sources in transactions
            Support for the two-phase commit protocol
            XA-compliant data sources and data source types
            Infrastructure for creating support routines for XA routines
            Global transaction IDs
            System catalog tables
            Files containing necessary components
          Create user-defined XA-support routines
            The xa_open() function
            The xa_close() function
            The xa_start() function
            The xa_end() function
            The xa_prepare() function
            The xa_rollback() function
            The xa_commit() function
            The xa_recover() function
            The xa_forget() function
            The xa_complete() function
          Create and drop XA data sources and data source types
            Create an XA data source type
            Drop an XA data source type
            Create an XA data source
            Drop an XA data source
          Register and unregister XA-compliant data sources
            The ax_reg() function
            The ax_unreg() function
            The mi_xa_register_xadatasource() function
            The mi_xa_unregister_xadatasource() function
            Get the XID structure
            Get the resource manager ID
          Monitor integrated transactions
      Create user-defined routines
        Develop a user-defined routine
          Designing a UDR
            Development tools
            Uses of a C UDR
            Portability
              DataBlade API data types
              Data conversion
            Insert and update operations
          Creating UDR code
            Variable declaration
            Session management
              Session restrictions
              Transaction management
            SQL statement execution
              Set input parameters
              Retrieve column values
            Routine-state information
            Event handling
            Well-behaved routines
          Compile a C UDR
            Compile options
            Creating a shared-object file
              Creating a shared-object file for a C UDR
              Creating a shared-object file on UNIX or Linux
              Creating a shared-object file on Windows:
          Register a C UDR
            EXTEND role required to register a C UDR
            The external name
              Specify the entry point
              Environment variables
            The UDR language
            Routine modifiers
            Parameters and return values
            Access privileges to run the UDR
          Execute a UDR
            Routine resolution
            The routine manager
              Load a shared-object file
              Create the routine sequence
              Push arguments onto the thread stack
                Mechanism for passing MI_DATUM values
                Argument promotion
              Manage UDR execution
              Return the value
              Release the routine sequence
          Debug a UDR
            Attaching to the database server process with the debugger
              Create a debugging version
              Connect to the database server from a client
              Load the shared-object file for debugging
              Identify the VP process
            Running a debugging session
              Breakpoints
              Debugging hints
              Possible memory errors
              Symbols in shared-object files
            Tracing
              Adding a tracepoint in code
                Choose a trace class
                  The built-in trace class
                  Create a new trace class
                Put trace messages into code
                  The DPRINTF macro
                  Trace blocks
                Define internationalized trace messages (GLS)
              Tracing at run time
                Turn on tracing
                Specify the trace-output file
                Create a UDR to turn tracing on
              The tracing output
          Change a UDR
            Alter a routine
            Unload a shared-object file
        Write a user-defined routine
          Code a C UDR
            Define routine parameters
              Routines with no arguments
              The MI_DATUM arguments
                Pass-arguments by-reference
                Pass-by-value parameters
              The MI_FPARAM argument
            Obtain argument values
              Handling character arguments
              Handling NULL arguments
              Handling opaque-type arguments
                Handling fixed-length opaque-type arguments
                Handling varying-length opaque-type arguments
              Modify argument values
            Define a return value
              Return a value
                Return a NULL value
                Return character values
                Return opaque-type values
              Return multiple values
                An OUT parameter
                The statement-local variable
            Code the routine body
          Virtual processors
            Create a well-behaved routine
              Preserving availability of the CPU VP
                Yield the CPU VP
                Avoid blocking I/O calls
              Write threadsafe code
                Restrict memory allocation
                Avoid modification of global and static variables
                Modify the global process state
              Avoid restricted system calls
                Unsafe operating-system calls
                External-library routines
                Safe operating-system calls
              Choose the user-defined VP class
                The yielding user-defined VP
                The nonyielding user-defined VP
                The single-instance user-defined VP
              Define a user-defined VP
                Define a yielding user-defined VP class
                Define a nonyielding user-defined VP class
                Define a single-instance user-defined VP class
              Assign a C UDR to a user-defined VP class
            Manage virtual processors
          Control the VP environment
            Obtain VP-environment information
              Identify the current VP
              Identify a VP class
            Change the VP environment
              Execute on another VP
              Fork and execute a process
            Lock a UDR
              Lock a routine instance to a VP
              Lock a shared-object file in memory
          Perform input and output
            Access to a stream (Server)
              Accessing a stream in your UDR
              Generic stream I/O functions
              Using predefined stream classes
                The file stream
                The string stream
                The varying-length-data stream
              Create a user-defined stream class
                The stream-open function
                  The stream-operations structure
                  The stream data
                  The stream descriptor
                Initialization of the stream descriptor
                Support for stream access
              Register a UDR that accesses a stream
              Release stream resources
            Access to operating-system files
              Open a file
                Specify a file name
                Call the operating-system open call
                  Specify open flags
                  Specify the open mode
                Share open files
              Close a file
              Copy a file
            Sample file-access UDR
          Access the UDR execution environment
            Access the session environment
            Access the server environment
        Manage memory
          Shared memory
            Access shared memory
            Choose the memory duration
              Public memory durations
                The PER_ROUTINE memory duration
                The PER_COMMAND memory duration
                The PER_STATEMENT memory duration
                The PER_STMT_EXEC memory duration
                  Examples of using PER_STMT_EXEC memory duration
                  Uses of PER_STMT_EXEC memory duration
                The PER_STMT_PREP memory duration
              Advanced memory durations
                The PER_TRANSACTION memory duration
                The PER_SESSION memory duration
                The PER_SYSTEM memory duration
              Memory-duration considerations
                Choose memory duration
                Save the memory address
          Manage shared memory
            Manage user memory
              Allocate user memory (Server)
              Manage the memory duration
                The current memory duration
                Change the memory duration
              Deallocate user memory
            Manage named memory
              Allocate named memory
              Obtain a block of allocated named memory
              Handling concurrency issues
                Sample code that allocates a named-memory
              Deallocate named memory
            Monitor shared memory
          Manage stack space
            Manage stack usage
            Increase stack space
        Create special-purpose UDRs
          Write an end-user routine
          Write a cast function
            Registering a C UDR as a cast function
          Write an iterator function
            Implementing an iterator function with a C user-defined function
            Initialize the iterations
            Return one active-set item
            Release iteration resources
            Call an iterator function from an SQL statement
              Register the iterator function
              Execute the iterator function
          Write an aggregate function
            Extending a built-in aggregate
              Choose the operator function
              Write the operator function
              Register the overloaded operator function
              The extended aggregate
            Creating a user-defined aggregate
              Implementing a user-defined aggregate function with C user-defined functions
              Determine the aggregate state
              Write the aggregate support functions
                The INIT function
                The ITER function
                The COMBINE function
                The FINAL function
              Defining the user-defined aggregate
              The user-defined aggregate
              Determine required aggregate support functions
                Aggregate support functions that the algorithm requires
                Aggregate support functions for the aggregate state
                  Handling a simple state
                  Handling a nonsimple state
                  Using a single-valued state for a UDA
                  Manage an opaque-type state
                  Handling state management for an opaque-type state
                  Using a pointer-valued state for a UDA
                  When to allocate and deallocate a state
                Implement a setup argument
                Return an aggregate result different from the aggregate state
                Execute a user-defined aggregate in parallel queries
              Sample user-defined aggregates
                The SUMSQ user-defined aggregate
                The SQSUM2 user-defined aggregate
                The PERCENT_GTR user-defined aggregate
                The X_PERCENTILE user-defined aggregate
          Provide UDR-optimization functions
            Write selectivity and cost functions
              Query selectivity
                Creating a selectivity function
              Query cost
                Creating a cost function
              The MI_FUNCARG data type
              Obtain information about constant arguments
              Obtain information about column arguments
            implementing a negator function with a C user-defined function
            Implementing a commutator function with a C user-defined function
            Creating parallelizable UDRs
              Write the parallelizable UDR
              Register the parallelizable UDR
              Execute the parallelizable UDR
              Debug the parallelizable UDR
        Extend data types
          Create an Opaque Data Type
            Design an opaque data type
              Determine external representation
              Determine internal representation
                Determine the size of an opaque type
                  Fixed-length opaque data type
                  Varying-length opaque data type
                Specify the memory alignment of an opaque type
                Determine the passing mechanism for an opaque type
            Write opaque-type support functions
              Support functions as casts
                The input and output support functions
                  The input support function
                  The output support function
                  Conversion of opaque-type data between text and binary representations
                The send and receive support functions
                  The receive support function
                  The send support function
                  Conversion of opaque-type data with computer-specific data types
                Bulk-copy support functions
                External unload representation
                  The import support function
                  The export support function
                Internal unload representation
                  The importbin support function
                  The exportbin support function
              Stream support functions
                The streamwrite() support function
                The streamread() support function
                Convert opaque-type data between stream and binary representations
              Disk-storage support functions
                The assign() support function
                The destroy() support function
              Handling locale-specific opaque-type data (GLS)
            Registering an opaque data type
              Register an opaque type in a database
              Register opaque-type support functions
              Register the opaque-type casts
          Provide statistics data for a column
            Collect statistics data
              Design the user-defined statistics
              Define the statistics-collection function
              Collect the statistics
                SET_INIT in statcollect()
                SET_RETONE in statcollect()
                SET_END in statcollect()
              Register the statcollect() function
              Execute the UPDATE STATISTICS statement
            User-defined statistics
              Display statistics data
                Define a statistics-display function
                Create the ASCII histogram
                Register the statprint() function
              User-defined statistics in a query
          Optimize queries
            Query plans
            Selectivity functions
      Appendix
        Write a client LIBMI application
          Manage memory in client LIBMI applications
            Allocate user memory
            Deallocate user memory
          Access operating-system files in client LIBMI applications
          Handling transactions
    DataBlade API Function Reference
      Categories of DataBlade API functions
        The DataBlade API function library
          Data handling
          Session, thread, and transaction management
          SQL statement processing
          User-defined routine execution
          Selectivity and cost functions
          Memory management
          Exception handling
          Smart-large-object interface
          Input and output operations
          Tracing (Server)
          Control of the Virtual-Processor environment (Server)
          Database management (Client)
          Miscellaneous information
          Database server version information
        The ESQL/C function library
      Function descriptions
        The ax_reg() function
        The ax_unreg() function
        The biginttoint2() function
        The bigintcvint2() function
        The biginttoint4() function
        The bigintcvint4() function
        The biginttoasc() function
        The bigintcvasc() function
        The bigintcvdec() function
        The biginttodec() function
        The biginttodbl() function
        The bigintcvdbl() function
        The biginttoflt() function
        The bigintcvflt() function
        The bigintcvifx_int8() function
        The biginttoifx_int8() function
        The bycmpr() function
        The bycopy() function
        The byfill() function
        The byleng() function
        The decadd() function
        The deccmp() function
        The deccopy() function
        The deccvasc() function
        The deccvdbl() function
        The deccvint() function
        The deccvlong() function
        The decdiv() function
        The dececvt() and decfcvt() functions
        The decmul() function
        The decround() function
        The decsub() function
        The dectoasc() function
        The dectodbl() function
        The dectoint() function
        The dectolong() function
        The dectrunc() function
        The dtaddinv() function
        The dtcurrent() function
        The dtcvasc() function
        The dtcvfmtasc() function
        The dtextend() function
        The dtsub() function
        The dtsubinv() function
        The dttoasc() function
        The dttofmtasc() function
        The ifx_int8add() function
        The ifx_int8cmp() function
        The ifx_int8copy() function
        The ifx_int8cvasc() function
        The ifx_int8cvdbl() function
        The ifx_int8cvdec() function
        The ifx_int8cvflt() function
        The ifx_int8cvint() function
        The ifx_int8cvlong() function
        The ifx_int8div() function
        The ifx_int8mul() function
        The ifx_int8sub() function
        The ifx_int8toasc() function
        The ifx_int8todbl() function
        The ifx_int8todec() function
        The ifx_int8toflt() function
        The ifx_int8toint() function
        The ifx_int8tolong() function
        The incvasc() function
        The incvfmtasc() function
        The intoasc() function
        The intofmtasc() function
        The invdivdbl() function
        The invdivinv() function
        The invextend() function
        The invmuldbl() function
        The ldchar() function
        The mi_alloc() function
        The mi_binary_to_date() function
        The mi_binary_to_datetime() function
        The mi_binary_to_decimal() function
        The mi_binary_to_money() function
        The mi_binary_query() function
        The mi_call() function
        The mi_call_on_vp() function
        The mi_cast_get() function
        The mi_class_id() function
        The mi_class_maxvps() function
        The mi_class_name() function
        The mi_class_numvp() function
        The mi_client() function
        The mi_client_locale() function
        The mi_close() function
        The mi_close_statement() function
        The mi_collection_card() function
        The mi_collection_close() function
        The mi_collection_copy() function
        The mi_collection_create() function
        The mi_collection_delete() function
        The mi_collection_fetch() function
        The mi_collection_free() function
        The mi_collection_insert() function
        The mi_collection_open() function
        The mi_collection_open_with_options() function
        The mi_collection_update() function
        The mi_column_count() function
        The mi_column_default() function
        The mi_column_default_string() function
        The mi_column_id() function
        The mi_column_name() function
        The mi_column_nullable() function
        The mi_column_precision() function
        The mi_column_scale() function
        The mi_column_type_id() function
        The mi_column_typedesc() function
        The mi_command_is_finished() function
        The mi_current_command_name() function
        The mi_dalloc() function
        The mi_date_to_binary() function
        The mi_date_to_string() function
        The mi_datetime_compare() function
        The mi_datetime_to_binary() function
        The mi_datetime_to_string() function
        The mi_db_error_raise() function
        The mi_dbcreate() function
        The mi_dbdrop() function
        The mi_decimal_to_binary() function
        The mi_decimal_to_string() function
        The mi_default_callback() function
        The mi_disable_callback() function
        The mi_drop_prepared_statement() function
        The mi_enable_callback() function
        The mi_errmsg() function
        The mi_error_desc_copy() function
        The mi_error_desc_destroy() function
        The mi_error_desc_finish() function
        The mi_error_desc_is_copy() function
        The mi_error_desc_next() function
        The mi_error_level() function
        The mi_error_sql_state() function
        The mi_error_sqlcode() function
        The mi_exec() function
        The mi_exec_prepared_statement() function
        The mi_fetch_statement() function
        The mi_file_allocate() function
        The mi_file_close() function
        The mi_file_errno() function
        The mi_file_open() function
        The mi_file_read() function
        The mi_file_seek() function
        The mi_file_seek8() function
        The mi_file_sync() function
        The mi_file_tell() function
        The mi_file_tell8() function
        The mi_file_to_file() function
        The mi_file_unlink() function
        The mi_file_write() function
        The mi_fix_integer() function
        The mi_fix_smallint() function
        The mi_fp_argisnull() function
        The mi_fp_arglen() function
        The mi_fp_argprec() function
        The mi_fp_argscale() function
        The mi_fp_argtype() function
        The mi_fp_funcname() function
        The mi_fp_funcstate() function
        The mi_fp_getcolid() function
        The mi_fp_getfuncid() function
        The mi_fp_getrow() function
        The mi_fp_nargs() function
        The mi_fp_nrets() function
        The mi_fp_request() function
        The mi_fp_retlen() function
        The mi_fp_retprec() function
        The mi_fp_retscale() function
        The mi_fp_rettype() function
        The mi_fp_returnisnull() function
        The mi_fp_setargisnull() function
        The mi_fp_setarglen() function
        The mi_fp_setargprec() function
        The mi_fp_setargscale() function
        The mi_fp_setargtype() function
        The mi_fp_setcolid() function
        The mi_fp_setfuncid() function
        The mi_fp_setfuncstate() function
        The mi_fp_setisdone() function
        The mi_fp_setnargs() function
        The mi_fp_setnrets() function
        The mi_fp_setretlen() function
        The mi_fp_setretprec() function
        The mi_fp_setretscale() function
        The mi_fp_setrettype() function
        The mi_fp_setreturnisnull() function
        The mi_fp_setrow() function
        The mi_fp_usr_fparam() function
        The mi_fparam_allocate() function
        The mi_fparam_copy() function
        The mi_fparam_free() function
        The mi_fparam_get() function
        The mi_fparam_get_current() function
        The mi_free() function
        The mi_func_commutator() function
        The mi_func_desc_by_typeid() function
        The mi_func_handlesnulls() function
        The mi_func_isvariant() function
        The mi_func_negator() function
        The mi_funcarg_get_argtype() function
        The mi_funcarg_get_colno() function
        The mi_funcarg_get_constant() function
        The mi_funcarg_get_datalen() function
        The mi_funcarg_get_datatype() function
        The mi_funcarg_get_distrib() function
        The mi_funcarg_get_routine_id() function
        The mi_funcarg_get_routine_name() function
        The mi_funcarg_get_tabid() function
        The mi_funcarg_isnull() function
        The mi_get_bigint() function
        The mi_get_bytes() function
        The mi_get_connection_info() function
        The mi_get_connection_option() function
        The mi_get_connection_user_data() function
        The mi_get_cursor_table() function
        The mi_get_database_info() function
        The mi_get_date() function
        The mi_get_datetime() function
        The mi_get_db_locale() function
        The mi_get_dbnames() function
        The mi_get_decimal() function
        The mi_get_default_connection_info() function
        The mi_get_default_database_info() function
        The mi_get_double_precision() function
        The mi_get_duration_size() function
        The mi_get_id() function
        The mi_get_int8() function
        The mi_get_integer() function
        The mi_get_interval() function
        The mi_get_lo_handle() function
        The mi_get_memptr_duration() function
        The mi_get_money() function
        The mi_get_next_sysname() function
        The mi_get_parameter_info() function
        The mi_get_real() function
        The mi_get_result() function
        The mi_get_row_desc() function
        The mi_get_row_desc_from_type_desc() function
        The mi_get_row_desc_without_row() function
        The mi_get_serverenv() function
        The mi_get_session_connection() function
        The mi_get_smallint() function
        The mi_get_statement_row_desc() function
        The mi_get_string() function
        The mi_get_type_source_type() function
        The mi_get_transaction_id() function
        The mi_get_vardata() function
        The mi_get_vardata_align() function
        The mi_get_varlen() function
        The mi_hdr_status() function
        The mi_init_library() function
        The mi_interrupt_check() function
        The mi_interval_compare() function
        The mi_interval_to_string() function
        The mi_issmall_data() function
        The mi_last_serial() function
        The mi_last_serial8() function
        The mi_library_version() function
        The mi_lo_alter() function
        The mi_lo_close() function
        The mi_lo_colinfo_by_ids() function
        The mi_lo_colinfo_by_name() function
        The mi_lo_copy() function
        The mi_lo_create() function
        The mi_lo_decrefcount() function
        The mi_lo_delete_immediate() function
        The mi_lo_expand() function
        The mi_lo_filename() function
        The mi_lo_from_buffer() function
        The mi_lo_from_file() function
        The mi_lo_from_file_by_lofd() function
        The mi_lo_from_string() function
        The mi_lo_increfcount() function
        The mi_lo_invalidate() function
        The mi_lo_lock() function
        The mi_lo_lolist_create() function
        The mi_lo_open() function
        The mi_lo_ptr_cmp() function
        The mi_lo_read() function
        The mi_lo_readwithseek() function
        The mi_lo_release() function
        The mi_lo_seek() function
        The mi_lo_spec_free() function
        The mi_lo_spec_init() function
        The mi_lo_specget_def_open_flags() function
        The mi_lo_specget_estbytes() function
        The mi_lo_specget_extsz() function
        The mi_lo_specget_flags() function
        The mi_lo_specget_maxbytes() function
        The mi_lo_specget_sbspace() function
        The mi_lo_specset_def_open_flags() function
        The mi_lo_specset_estbytes() function
        The mi_lo_specset_extsz() function
        The mi_lo_specset_flags() function
        The mi_lo_specset_maxbytes() function
        The mi_lo_specset_sbspace() function
        The mi_lo_stat() function
        The mi_lo_stat_atime() function
        The mi_lo_stat_cspec() function
        The mi_lo_stat_ctime() function
        The mi_lo_stat_free() function
        The mi_lo_stat_mtime_sec() function
        The mi_lo_stat_mtime_usec() function
        The mi_lo_stat_refcnt() function
        The mi_lo_stat_size() function
        The mi_lo_stat_uid() function
        The mi_lo_tell() function
        The mi_lo_to_buffer() function
        The mi_lo_to_file() function
        The mi_lo_to_string() function
        The mi_lo_truncate() function
        The mi_lo_unlock() function
        The mi_lo_utimes() function
        The mi_lo_validate() function
        The mi_lo_write() function
        The mi_lo_writewithseek() function
        The mi_lock_memory() function
        The mi_lvarchar_to_string() function
        The mi_module_lock() function
        The mi_money_to_binary() function
        The mi_money_to_string() function
        The mi_named_alloc() function
        The mi_named_free() function
        The mi_named_get() function
        The mi_named_zalloc() function
        The mi_new_var() function
        The mi_next_row() function
        The mi_open() function
        The mi_open_prepared_statement() function
        The mi_parameter_count() function
        The mi_parameter_nullable() function
        The mi_parameter_precision() function
        The mi_parameter_scale() function
        The mi_parameter_type_id() function
        The mi_parameter_type_name() function
        The mi_prepare() function
        The mi_process_exec() function
        The mi_put_bigint() function
        The mi_put_bytes() function
        The mi_put_date() function
        The mi_put_datetime() function
        The mi_put_decimal() function
        The mi_put_double_precision() function
        The mi_put_int8() function
        The mi_put_integer() function
        The mi_put_interval() function
        The mi_put_lo_handle() function
        The mi_put_money() function
        The mi_put_real() function
        The mi_put_smallint() function
        The mi_put_string() function
        The mi_query_finish() function
        The mi_query_interrupt() function
        The mi_realloc() function
        The mi_register_callback() function
        The mi_result_command_name() function
        The mi_result_reference() function
        The mi_result_row_count() function
        The mi_retrieve_callback() function
        The mi_routine_end() function
        The mi_routine_exec() function
        The mi_routine_get() function
        The mi_routine_get_by_typeid() function
        The mi_routine_id_get() function
        The mi_row_create() function
        The mi_row_desc_create() function
        The mi_row_desc_free() function
        The mi_row_free() function
        The mi_save_set_count() function
        The mi_save_set_create() function
        The mi_save_set_delete() function
        The mi_save_set_destroy() function
        The mi_save_set_get_first() function
        The mi_save_set_get_last() function
        The mi_save_set_get_next() function
        The mi_save_set_get_previous() function
        The mi_save_set_insert() function
        The mi_save_set_member() function
        The mi_server_connect() function
        The mi_server_library_version() function
        The mi_server_reconnect() function
        The mi_set_connection_user_data() function
        The mi_set_default_connection_info() function
        The mi_set_default_database_info() function
        The mi_set_large() function
        The mi_set_parameter_info() function
        The mi_set_vardata() function
        The mi_set_vardata_align() function
        The mi_set_varlen() function
        The mi_set_varptr() function
        The mi_stack_limit() function
        The mi_statement_command_name() function
        The mi_stream_clear_eof() function
        The mi_stream_close() function
        The mi_stream_eof() function
        The mi_stream_get_error() function
        The mi_stream_getpos() function
        The mi_stream_init() function
        The mi_stream_length() function
        The mi_stream_open_fio() function
        The mi_stream_open_mi_lvarchar() function
        The mi_stream_open_str() function
        The mi_stream_read() function
        The mi_stream_seek() function
        The mi_stream_set_eof() function
        The mi_stream_set_error() function
        The mi_stream_setpos() function
        The mi_stream_tell() function
        The mi_stream_write() function
        The mi_streamread_boolean() function
        The mi_streamread_collection() function
        The mi_streamread_date() function
        The mi_streamread_datetime() function
        The mi_streamread_decimal() function
        The mi_streamread_double() function
        The mi_streamread_int8() function
        The mi_streamread_integer() function
        The mi_streamread_interval() function
        The mi_streamread_lo() function
        The mi_streamread_lo_by_lofd() function
        The mi_streamread_lvarchar() function
        The mi_streamread_money() function
        The mi_streamread_real() function
        The mi_streamread_row() function
        The mi_streamread_smallint() function
        The mi_streamread_string() function
        The mi_streamwrite_boolean() function
        The mi_streamwrite_collection() function
        The mi_streamwrite_date() function
        The mi_streamwrite_datetime() function
        The mi_streamwrite_decimal() function
        The mi_streamwrite_double() function
        The mi_streamwrite_int8() function
        The mi_streamwrite_integer() function
        The mi_streamwrite_interval() function
        The mi_streamwrite_lo() function
        The mi_streamwrite_lvarchar() function
        The mi_streamwrite_money() function
        The mi_streamwrite_real() function
        The mi_streamwrite_row() function
        The mi_streamwrite_smallint() function
        The mi_streamwrite_string() function
        The mi_string_to_date() function
        The mi_string_to_datetime() function
        The mi_string_to_decimal() function
        The mi_string_to_interval() function
        The mi_string_to_lvarchar() function
        The mi_string_to_money() function
        The mi_switch_mem_duration() function
        The mi_sysname() function
        The mi_system() function
        The mi_td_cast_get() function
        The mi_tracefile_set() function
        The mi_tracelevel_set() function
        The mi_transaction_state() function (Server)
        The mi_transition_type() function
        The mi_trigger_event() function
        The mi_trigger_get_new_row() function
        The mi_trigger_get_old_row() function
        The mi_trigger_level() function
        The mi_trigger_name() function
        The mi_trigger_tabname() function
        The mi_try_lock_memory() function
        The mi_type_align() function
        The mi_type_byvalue() function
        The mi_type_constructor_typedesc() function
        The mi_type_element_typedesc() function
        The mi_type_full_name() function
        The mi_type_length() function
        The mi_type_maxlength() function
        The mi_type_owner() function
        The mi_type_precision() function
        The mi_type_qualifier() function
        The mi_type_scale() function
        The mi_type_typedesc() function
        The mi_type_typename() function
        The mi_typedesc_typeid() function
        The mi_typeid_equals() function
        The mi_typeid_is_builtin() function
        The mi_typeid_is_collection() function
        The mi_typeid_is_complex() function
        The mi_typeid_is_distinct() function
        The mi_typeid_is_list() function
        The mi_typeid_is_multiset() function
        The mi_typeid_is_row() function
        The mi_typeid_is_set() function
        The mi_typename_to_id() function
        The mi_typename_to_typedesc() function
        The mi_typestring_to_id() function
        The mi_typestring_to_typedesc() function
        The mi_udr_lock() function
        The mi_unlock_memory() function
        The mi_unregister_callback() function
        The mi_value() function
        The mi_value_by_name() function
        The mi_var_copy() function
        The mi_var_free() function
        The mi_var_to_buffer() function
        The mi_version_comparison() function
        The mi_vpinfo_classid() function
        The mi_vpinfo_isnoyield() function
        The mi_vpinfo_vpid() function
        The mi_xa_get_current_xid() function
        The mi_xa_get_xadatasource_rmid() function
        The mi_xa_register_xadatasource() function
        The mi_xa_unregister_xadatasource() function
        The mi_yield() function
        The mi_zalloc() function
        The rdatestr() function
        The rdayofweek() function
        The rdefmtdate() function
        The rdownshift() function
        The rfmtdate() function
        The rfmtdec() function
        The rfmtdouble() function
        The rfmtlong() function
        The rjulmdy() function
        The rleapyear() function
        The rmdyjul() function
        The rstod() function
        The rstoi() function
        The rstol() function
        The rstrdate() function
        The rtoday() function
        The rupshift() function
        The stcat() function
        The stchar() function
        The stcmpr() function
        The stcopy() function
        The stleng() function
    DataBlade Developers Kit
      DataBlade Module Development Overview
        DataBlade module concepts
          What are DataBlade modules?
            Why extend your Informix database server?
              Better performance
              Simpler applications
              Transaction control
              Scalability
            Why create a DataBlade module?
            Why use the DataBlade Developers Kit?
          DataBlade modules and the database server
            DataBlade module programming languages
              C language
              C++ language
              Java language
              Informix Stored Procedure Language
            Internal architecture of the database server
              DataBlade modules and virtual processors
              DataBlade module memory allocation
              Java virtual machine
            HCL Informix Client Software Development Kit
            Client objects and programs
          DataBlade module components
            Aggregates
            Data types
              Built-in data types
              Qualified built-in data types
              Distinct data types
              Collection data types
              Row data types
              Opaque data types
                Opaque data type support routines
            Routines
              Built-in functions and operator functions
              User-defined routines
            Casts
            Interfaces
            Errors
            Unit tests
            Functional tests
            Imported SQL files
            Imported client files
        Build a DataBlade module
          DataBlade Developers Kit tools
            BladeSmith
            BladePack
            BladeManager
            DBDK Visual C++ Add-In and IfxQuery
          How to create a DataBlade module
          DataBlade module development resources
            The DataBlade Developers Kit Tutorial
            Example DataBlade modules
        Appendixes
          DataBlade module documentation
            Publication overview
            Title-to-topic reference
            Topic-to-title reference
          Informix DataBlade modules
            IBM Informix Excalibur Text Search DataBlade Module
              Extensions to Informix
            IBM Informix Web DataBlade Module
              Extensions to Informix
      DataBlade Developers Kit User's Guide
        Getting started with DataBlade module development
          What is a DataBlade module?
          Informix DataBlade Developers Kit (DBDK) tools
          Prepare to develop DataBlade modules
            Become familiar with HCL Informix software and documentation
              Software requirements for DataBlade module development
              DataBlade Developers Kit Tutorial
              Create a practice DataBlade module
            Design your DataBlade module
              Write a functional specification
              Programming resources
              Write a design specification
              Create an iterative development plan
          Develop your DataBlade module
            Edit and compile DataBlade module code
            Debug your DataBlade module
            Package your DataBlade module
        Design DataBlade modules
          Data model
          Data type design
            Object accessibility
            Handling large objects
          Query language interface
            SQL query structure
            The target list
            The qualification
          Query processing
            Predicate evaluation
              Expensive routines
              User-defined statistics
              Aggregates
              Sort the results
            Grouping
            Casts
            Access path selection
              Unordered row processing
              Secondary access methods
            Plan for transaction semantics
          Interoperability
            Orthogonality
            Simple, clean interfaces
              Name your routines
              Take advantage of polymorphism
              Limit the number of arguments
              Avoid modal routines
        Programming guidelines
          Programming language options
            Options for opaque data types
              ActiveX value objects
              Combined languages in server and client implementations
              Limitations of opaque types for each language
              Embed opaque data types within opaque data types
            Options for routines
              Overload routines in different languages
              Handling opaque data types implemented in a different language
            Multilanguage DataBlade module issues
          C programming guidelines
          C++ programming guidelines
          Java programming guidelines
          DataBlade API programming guidelines
        Create DataBlade objects by using BladeSmith
          Prerequisite tasks
          Task overview
          BladeSmith project window
          Create a project
            DataBlade module project name
            New object prefix
            Server compatibility
            Description locale
            Project version numbers
            Vendor information
          Importing interfaces from another DataBlade module
          Create DataBlade module objects
            Database object name lengths
            Create aggregates
              Properties of aggregates
            Create casts
              Source and target data types
              Implicit and explicit casts
              Cast support functions
            Define errors
              SQL error code
              Error locale
              SQL error text
            Create interfaces
            Create routines
              Routine name
              Statement local variables
              Routine arguments
              Variant functions
              Parallelizable routines
              C routine name
              Routine behavior
              User-defined virtual processor class name
              Stack size
              Cost of routine
              Related functions
                Commutator and negator functions
                Selectivity functions
            Create data types
              Collection data type
                Properties of collection data types
              Distinct data type
              Opaque data type
                Opaque data type name lengths
                Server implementation
                Client implementation
                Accessor methods
                Definition of internal structure
                Fixed or variable size
                Member information
                Maximum size
                Memory alignment
                Support routines
                  Basic text input and output
                  Binary send and receive
                  Text import and export
                  Binary file import and export
                  Contains large objects (not available for C++)
                  Type insert and delete notification (not available for C++)
                  Type compare support
                  B-tree indexing support
                  R-tree indexing support
                  Type mathematic operators
                  More mathematic operators
                  Type concatenation operator
                  Type hash support
                  Statistics support (not available for C++ or Java)
              Qualified data type
              Row data type
                Properties of row data types
          Perform functional test data
            Test data for opaque type support routines
            Test data for user-defined routines
            Test data for cast support routines
          Add SQL files
            Import SQL text from a file
            Object dependencies
          Add client files
          Generate files
            Set generated file properties
              Changing a property of a generated file category
            Generating all files
            Generate SQL scripts
            Generate source files
            Generate test files
            Generate installation package files
            Regenerate files
              Merge changes in source code and unit test files
              Replace Visual C++ project, SQL, functional test, and installation files
            Opening the project file in Visual C++
        Programming DataBlade module routines in C
          Prerequisite tasks
          C programming task overview
          Source files generated by BladeSmith
            C header file
            C source code files
            Microsoft Visual C++ files
            Warning file
          Generated code
            Identify the source of generated code
            Comments in generated code
            The MI_FPARAM function argument
            Server connection handle
            Tracing and error handling
              How tracing works
              Add tracing and error handling
                The DBDK_TRACE_MSG() and DBDK_TRACE_ERROR() macros
                The DBDK_TRACE_ENTER() and DBDK_TRACE_EXIT() macros
              Enabling tracing in a DataBlade module
                Create a trace class
                Create the TraceSet_project() procedure
                  Syntax for the TraceSet_project() procedure
              Enabling tracing in a database session
                Set your locale
                Register tracing routines
                Set a trace output file and a trace threshold
              Standard error messages
            Utility functions generated by BladeSmith
              The Gen_sscanf() utility function
              The Gen_IsMMXMachine() utility function
          Edit opaque type support routines in opaque.c
            Text input and output functions
            Binary send and receive functions
            Text file import and export functions
            Binary file import and export functions
            The assign and destroy routines
            The LOhandles() function
            Comparison functions
              Compare function
              B-Tree Comparison Functions
              R-tree comparison functions
            Mathematical functions
            The Concat() Function
            Hash() Function
          Edit statistics routines in statistics.c
            The statistics collection function
            The statistics print function
            The statistics minimum, maximum, and distribution functions
          Edit routines in udr.c
            Most user-defined routines
            Cast support functions
            Aggregate functions
            Selectivity functions
            Iterator functions
          Compile DataBlade module code
            Compile with tracing support
            Compiling on a UNIX operating system
              Unresolved symbols (HCL Informix 9.14)
              Compile with debug support
            Compiling on a Windows operating system
        Create ActiveX value objects
          Prerequisite tasks
          ActiveX programming task overview
          Source files generated by BladeSmith
          Implement ActiveX value objects
            The generated code
            Add project-specific logic to the source code
            Files to edit
            ActiveX properties
            Access properties by using Visual Basic
          Compile client and server projects
            Compiling a Windows server project
            Compiling a client project
              Setting the include files and library file directories
              Compiling a Windows client project
          Support methods reference
            Internal object methods
            C++ support library
              The DkInStream class
              The DkOutStream class
              Memory management routines
        The ActiveX value objects
          Install and use ActiveX value objects
            Install ActiveX value objects
              Creating a reference to an ActiveX project
            ActiveX Value Objects
          The IRawObjectAccess custom interface
            Instantiating the ActiveX value object
          The ITDkValue custom interface
          ActiveX custom methods
        Programming DataBlade modules in Java
          Prerequisite tasks
          Java programming task overview
          Source files generated by BladeSmith
            Java source code files
            The SQLData interface method support code
            Warning file
          The generated code
            Comments in generated code
            Logging and error handling
            BladeSmith utility classes
          Edit methods
            Most user-defined methods
            Iterators
            Aggregates
            Cast support methods
          Compiling DataBlade module Java code
          Debug and test DataBlade Modules written in Java
            Preparing your environment
            Debugging a DataBlade module
              Installing a DataBlade module
              Register a DataBlade module
              Replace a DataBlade module JAR file
            Perform functional tests
        Debugging and testing DataBlade modules on UNIX
          Prerequisite tasks
          Prepare your environment on UNIX
          The shared object file
            Replace a shared object file
            Shared object file ownership and permissions
            Symbols in shared object files
          Install and register DataBlade modules
            Installing a DataBlade module
            Register a DataBlade module
          Debugging a DataBlade module
            Load the DataBlade module
            Identify the server process
            Run the Solaris debugger
            Set breakpoints
          Debugging a UNIX DataBlade module with Windows
          Performing functional tests
            Functional test overview
              Contents of the functional test directory
              Add custom test files
            Execute functional tests
              The functional test scripts
              Initialize reference files
        Debugging and testing DataBlade modules on Windows
          Prerequisite tasks
          Prepare your environment
          The DBDK Visual C++ Add-In and IfxQuery
            The Debug DataBlade Module command
            Other add-in commands
          Debugging a DataBlade module
            Manually loading the Add-In
            Specify properties for a project
            Setting breakpoints
            Edit unit test files
          Performing functional tests on DataBlade modules
        BladePack
          Prerequisite tasks
          BladePack overview
            BladePack projects
            BladePack online help
            BladePack windows
              Project view
                Files/Directories tab
                Components tab
                Customization tab
              Item view
            Registry keys for Windows
          Packaging for UNIX installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory
              Files and directories to be installed or deleted
                Local paths for files for multiple operating systems
                Specify a target directory
            Manage components
              Creating a component
              Creating a subcomponent
              Creating and copying a shared component
              Component properties
              Assigning items to components
            Customizing the installation
              Adding a custom program
              Adding a readme file
            Build the installation
              Installation type
            Create distribution media
          Packaging for InstallShield 3.1 installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory or change to the registry
              Files and directories to be installed or deleted
                Local paths for files for multiple operating systems
                Specify a target directory
                File sharing options
              Adding registry changes
            Manage components
              Creating a component
              Creating a subcomponent
              Creating and copying a shared component
              Component properties
              Assigning items to components
            Customize the installation
              Adding custom extensions
                Adding a custom routine, dialog box, or program
                Adding a readme file
            Build the installation
              Installation type
              Installation screen display text
            Create distribution media
          Packaging for InstallShield 5.1 installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory or a change to the registry
              Files and directories to be installed
                Local paths for files for multiple operating systems
                Specify a target directory
              Adding registry changes
            Manage components
              Creating a component
              Creating a subcomponent
              Component properties
              Assigning to components
            Customize the Installation
              Adding a readme file
            Build the installation
              Installation type
              Installation screen display text
            Create distribution media
        Appendixes
          Source files generated for DataBlade modules
            C source code files
            ActiveX/C++ source code files
              Client project files
                Support library files
                Project files
              Client files
              Common files
                Support library files
                Object files
              Server project files
              Server files
            Java source code files
            SQL script files
            Unit test files
            Functional test files
              Casting function tests
              Opaque data type support routines tests
              User-defined routine tests
            Installation packaging files
            Alphabetical list of generated files
          Complete BladeSmith-generated code
            Opaque data type support routines in C
            User-defined routines in C
            Opaque data type support routines in C++
            User-defined routines in Java
          Test for an sbspace
            Adding SYSBldTstSBSpace() to your registration script
      DBDK InfoShelf
        Example descriptions
        DataBlade Developers Kit Tutorial
          Tutorial exercise 1: Creating a simple user-defined routine
            Using BladeSmith to create the AddInts DataBlade module project
            Using BladeSmith to create the AddIntegers() function
            Using BladeSmith to generate the AddInts DataBlade module and open the project file in Visual C++
            Assigning a database server and a test database to the project
            Adding code for the AddInts() function to the code generated by BladeSmith
            Building the DataBlade module
            Setting a breakpoint for the AddInts() function
            Editing the AddInts.sql unit test file.
            Debugging the AddInts() function
          Tutorial exercise 2: Creating distinct data types and casts
            Casts
            DataBlade module objects
            Creating a project for the Mercury DataBlade module
            Creating the temperature distinct data type
            Creating the CTemp and FTemp data types
            Creating the user-defined routines
            Creating the decimal to temperature cast
            Creating the integer to temperature, CTemp to FTemp, and FTemp to CTemp casts
            Creating the error message raised if a user enters a temperature lower than absolute zero
            Generating the Mercury DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding your source code to the code generated by BladeSmith
            Building the DataBlade module
            Editing the Setup.sql unit test file
            Running the Mercury DataBlade module
          Tutorial exercise 3: Creating row data types
            Creating a project the RowCircle DataBlade module
            Creating the rciPoint data type
            Creating the rciDistance() function
            Creating the rciCircle data type
            Creating the rciContains() routine
            Generating the RowCircle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding source code to the templates generated by BladeSmith
            Building the DataBlade module
            Editing the rciContains.sql unit test file
            Running the RowCircle DataBlade module
          Tutorial exercise 4: Creating opaque data types
            Creating a project for the Circle DataBlade module
            Creating the Pnt data type
            Creating the Circ data type
            Creating the Distance() function
            Creating the Contains() function
            Generating the Circle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding your source code to the code generated by BladeSmith
            Building the DataBlade module
            Editing the Contains.sql unit test file
            Running the Circle DataBlade module
          Tutorial exercise 5: Using interfaces
            Creating the Point DataBlade module
            Creating the Point data type in the Point DataBlade module
            Creating the Distance() function in the Point DataBlade module
            Creating the Point interface in the Point DataBlade module
            Creating the project for the Circle DataBlade module
            Importing the Point data type and IPoint interface
            Creating the Circle data type in the Circle DataBlade module
            Creating the Contains() function in the Circle DataBlade module
            Generating the Point and Circle DataBlade modules and open the Point project in Visual C++
            Assigning a database server and a test database to the Point project
            Adding source code to the Point DataBlade module udr.c file
            Opening the Circle project and assign a local database server and a test database to it
            Adding source code to the Circle DataBlade module udr.c file
            Building the DataBlade modules
            Editing the Contains.sql unit test file
            Installing and registering the Point DataBlade module
            Running the Circle DataBlade module
          Tutorial exercise 6: Using smart large objects
            Creating a Poem project
            Creating the Poem data type
            Add custom SQL to test for an sbspace
            Generating the Circle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Modifying the source code
            Building the DataBlade module
            Installing the Poem DataBlade module
            Copying the XML files to the Poem.0 project directory.
            Editing the Poem.sql unit test file
            Running the Poem DataBlade module
          Glossary
            BladeSmith
            BladeManager
            Makefiles
            SQL scripts
            Registration
            Special stack requirements
            MI_FPARAM argument
            boolean
            double precision
            Buffered log
            cast support function
            SQL error code
            Behavior of routines
            ESQL/C conversion function
            implicit type conversion
            mi_lvarchar data type
            Text input and output functions
            Binary send and receive functions
            Binary file import and export functions
            Text file import and export functions
            Contains large objects routines
            Type compare functions
            MI_LO_HANDLE data type
            Cost of a routine
            Generating code
            Assign() functions
            Client implementation
            fixed size
            Internal structure
            Server Implementation
            Support routines
            Routine calling options
            Related routines
            Statement local variables
            Locale
            BladePack
            Opaque data types
            Row data types
            Server compatibility
            Building a DataBlade module
            Inheritance
            Distinct data types
            Casts
            Explicit cast
            mi_db_error_raise() function
            New object prefix
            mi_fp_setreturnisnull() function
            An sbspace
            Smart large objects
            Custom SQL file
            Objects dependent on SQL
            Impedance
            Pythagorean formula
            Wrapper function
            EXECUTE FUNCTION SYSBldTstSBSpace(" "); statement
            Registration failure with an sbspace test
            Object grant privileges
            Assigning a database server and test database to a project
            Debug DataBlade module
            Unit test files
            Installing the DBDK Visual C++ Add-In
            IfxQuery tool
            mi_integer data type
            Routine name
            Routine signature
            mercury.txt file
            udr.c routine
            CTempAssign.c routine
            CTempCast.c routine
            DecToTemp.c routine
            FTempAssign.c routine
            FTempCast.c routine
            IntToTempCast.c routine
            rowcircle.txt file with information for creating tables and rows
            Pnt.c source code file
            Circ.c source code file
            circle.txt file with information for creating tables and rows
            interface.txt file with information for creating a table with a circle column
            Poem.c generated source file
            poem.txt file with information for creating a table with a poem column
    J/Foundation Developer's Guide
      Concepts
        Features of Java user-defined routines
        Java virtual processors
        System catalog tables
      Prepare for Java support
        Configure Java support
          Create an sbspace
          Creating the JVP properties file
          Set configuration parameters
          Set environment variables
          GLS support
            NEWLOCALE and NEWCODESET connection properties
            DBCENTURY environment variable
      Configuration parameters
        JVPARGS configuration parameter
        JVPCLASSPATH configuration parameter
        JVPHOME configuration parameter
        JVPJAVAHOME configuration parameter
        JVPJAVALIB configuration parameter
        JVPJAVAVM configuration parameter
        JVPLOGFILE configuration parameter
        JVPPROPFILE configuration parameter
        SBSPACENAME configuration parameter
      Create Java user-defined routines
        Java user-defined routines
        Limitations for Java UDRs
        Creating a Java user-defined routine in the server
        Packages for Java user-defined routines
          The com.informix.udr package
          The com.informix.udr.UDRManager
          The com.informix.udr.UDREnv
          The com.informix.udr.UDRLog
          The com.informix.udr.UDRTraceable
        Creating UDT-to-Java mappings
        Registering Java user-defined routines
          Specify the JVP
          Routine modifiers
          Specify the external name
        A deployment descriptor
        A manifest file
        Compiling the Java code
        Install a JAR file
        Update JAR file names
        Execute the user-defined routine
        Debugging and tracing
          Generate log messages
          The administrative tool
          Debugging a Java user-defined routine
          Traceable events
        Find information about user-defined routines
        Comply with SQLJ
          Unsupported modifiers
          Unsupported optional modifiers
      The Informix JDBC Driver
        Public JDBC interfaces
        The informix-direct subprotocol
        An example that shows query results
      Opaque user-defined data types
        Using the SQLData interface
          Default input/output routines
          SQL definitions for default I/O user-defined routines
          Informix extensions to SQLInput and SQLOutput
            IfmxUDTSQLInput
            IfmxUDTSQLOutput
          The circle class example
        Override the default I/O methods
          I/O function sets and related types
            IfxDataPointer
            Stream implementations
          An example that overrides the default I/O methods
            Usage example
              Variable-length UDT including nondefault input and output methods
              SQL definitions for a variable-length UDT example
        Limitations to streams
    R-Tree Index User's Guide
      What's new in HCL Informix R-Tree Index User's Guide, Version 12.10
      R-tree secondary access method concepts
        About access methods
        The R-tree secondary access method
          R-tree index structure
            Bounding boxes
            Bounding-box-only R-tree indexes
            Hierarchical index structure
          Search with an R-tree index
          Nearest-neighbor searching
          Insertion into an R-tree index
          R-link trees and concurrency
        About operator classes
        R-tree functionality that HCL Informix provides
          R-tree functionality in HCL Informix
          R-tree secondary access method extension
            Additional R-tree components
            Registration
      The R-tree secondary access method
        Before you begin
        Create R-tree indexes
          Syntax
          R-tree index parameters
          Bottom-up building of R-tree indexes
          Using the NO_SORT index parameter
          R-tree index options
            The FRAGMENT clause
            The IN clause
          Examples of creating R-tree indexes
        When does the query optimizer use an R-tree index?
          Complex qualifications
        R-tree indexes and null values
          How an R-tree index internally handles null values
          How strategy functions handle null values
        Perform nearest-neighbor searches
          Limitations
        Database isolation levels and R-tree indexes
        Functional R-tree indexes
      Develop DataBlade modules that use the R-tree secondary access method
        Overview of DataBlade module development
        Decide whether to use the R-tree access method
        Design a user-defined data type
          Data objects and bounding boxes
            Operations on data objects
            Operations on bounding boxes
            Internal C structure for the user-defined data type
          Implementing data type hierarchy
            Example data type hierarchy
            Strategy functions in a data type hierarchy
            Union support function in a data type hierarchy
          Maximum size of the user-defined data type
          Loose bounding box calculations
          Other user-defined data type design considerations
        Creating a new operator class
          Support functions
            Internal uses of the support functions
            The Union function
            The Size function
              Size calculation of a bounding box
            The Inter function
            The RtreeInfo function
              Arguments of the RtreeInfo support function
              SQL definition of the RtreeInfo support function
              C code example for the RtreeInfo support function
            The SFCbits function
            The ObjectLength function
            The SFCvalue function
            The SetUnion function
            Implicit casts
            Example of creating a support function
          Strategy functions
            Internal uses of the strategy functions
              Searches
              Deletes and updates
            The Overlap function
            The Equal function
            The Contains function
            The Within function
            Other strategy functions
            Example of creating a strategy function
          Selectivity and cost functions
          Syntax for creating a new operator class
        Set up nearest-neighbor searching
          Set up a strategy function for nearest-neighbor searching
            The distance-measuring function
            Distance function: Bounding boxes
            Set RtreeInfo to indicate nearest-neighbor functions
        Create registration scripts for dependent DataBlade modules
          Importing the ifxrltree interface object
        Repairing R-tree indexes after migrating to a different version of a DataBlade module
      Manage databases that use the R-tree secondary access method
        Performance tips
          Update statistics
          Deletions
          Effectiveness of bounding box representation
          Clustering spatial data on the disk
        Return the coordinates of the root bounding box
          Syntax
          Example
        Estimate the size of an R-tree index
          Calculating index size based on number of rows
          Calculate index size using the oncheck utility
        R-tree index and logging
          Description of the R-tree-specific logical-log records
            Logical-log records of insertions of items into a leaf page
            Logical-log records of deletions of items from a leaf page
          Using the onlog utility to view R-tree logical-log records
        Cannot rename databases that use the secondary access method
        Drop R-tree indexes before truncating a table
        System catalogs
          The sysams system catalog
          The sysopclasses system catalog
          The sysindices system catalog
        Check R-tree indexes with the oncheck utility
          Check pages with the -ci and -cI options
          Check pages with the -pT option
          Check pages with the -pk and -pK options
          Check pages with the -pl and -pL options
          Other options with -u
      Appendix
        Shapes3 sample DataBlade module
          Description of the sample DataBlade module
            Data types
            Operators
            Operator class
          Sample C code
            The shape.h header file
            Overlap strategy function
            Equal strategy function
            Contains strategy function
            Within strategy function
            Union support function
            Size support function
            Inter support function
            SFCbits support function
            ObjectLength support function
            SFCValue support function
            SetUnion support function
    User-Defined Routines and Data Types Developer's Guide
      Extend the database server
        Create user-defined routines
        Extend built-in data types
        Extend operators
        Build opaque data types
        Extend operator classes
        Routine management
      A user-defined routine
        User-defined routines
          SPL routines
          External-language routines
          Information about user-defined routines
        Tasks that you can perform with user-defined routines
          Extend data type support
          Support user-defined data types
            Cast functions
              Cast between built-in data types
              Cast between other data types
            End-user routines
            Aggregate functions
            Operator functions
              Operators on built-in data types
              Operators on user-defined data types
            Operator-class functions
              Operator-class functions on built-in data types
              Operator classes on user-defined data types
            Optimization functions
            Opaque data type support functions
            Access-method purpose functions
          Create an end-user routine
            Encapsulate multiple SQL statements
            Create triggered actions
            Restrict access to a table (SPL)
            Create iterators
          Invoke a user-defined routine
            Explicit invocation
            Implicit invocation
      Run a user-defined routine
        Invoke a UDR in an SQL statement
          Invoke a UDR with an EXECUTE statement
            Invoke a function
            A SELECT statement in a function argument
            Invoke a procedure
          Invoke a user-defined function in an expression
          Invoke a function that is bound to an operator
          Named parameters and UDRs
        Invoke a UDR in an SPL routine
        Execute a user-defined routine
          Parse the SQL statement
          Optimize the SQL statement
          Execute a UDR across databases of the same database server instance
          Execute the routine
            Execute an SPL routine
            Execute an external language routine
              Load an executable code into memory
              Create the routine sequence
              Manage routine execution
        Understanding routine resolution
          The routine signature
            ANSI and non-ANSI routine signatures
            The routine signature to perform DBA tasks
          Routine overloading
            Create overloaded routines
            Assign a specific routine name
            Specify overloaded routines during invocation
            Overload built-in SQL functions
          The routine-resolution process
            The routine signature
            Candidate list of routines
            Precedence list of data types
            Precedence list for built-in data types
          Routine resolution with user-defined data types
            Routine resolution in a type hierarchy
            Routine resolution with distinct data types
              Routine resolution with two different distinct data types
              Alternate SELECT statements for different distinct data types
            Routine resolution with built-in data types as source
            Routine resolution with collection data types
          Null arguments in overloaded routines
      Develop a user-defined routine
        Plan the routine
          Name the routine
          Define routine parameters
            Number of arguments
            Declare routine parameters
          Return values
            Return a variant or nonvariant value
            OUT parameters and statement-local variables (SLVs)
              Statement-local variables (SLVs)
              SPL procedures with no return values
            The INOUT parameters
          Name return parameters
          An iterator function
            Create an iterator function
            Register an iterator function
            Invoke an iterator function
            An iterator function in the FROM clause of a SELECT statement
              Syntax and usage
              Allocate memory
              Run parallel queries
              Restrictions
              Example SPL iterator function
              Example C iterator function
              Example Java iterator function
          Adhere to coding standards
        Write the routine
          Create a user-defined interface for XA data sources
        Registering a user-defined routine
          Privileges required to create a routine
            Database-level privileges needed for creating a routine
            Language-level privileges needed for creating
            Routine-level privilege
          Create an SPL routine
          Create an external-language routine
            Register a routine written in C
            Register a routine written in Java
            Register an external routine with modifiers
              Modifiers in a C UDR
              Modifiers in a Java UDR
            Register parameters and a return value
          Review information about user-defined routines
        A UDR with HDR
      Extend data types
        Understanding the data type system
        Understanding data types
          Built-in data types
          Extended data types
            Complex data types
            User-defined data types
              Distinct data type
              Opaque data type
            HCL Informix DataBlade modules
        Extend the data type system
          Operations
          Casts
          Operator classes
            Provide additional operator classes
            Extend operator classes
          Optimizer information
      Extend operators and built-in functions
        Operators and operator functions
          Arithmetic operators
          Text operators
          Relational operators
          Overload an operator function
        Built-in functions
          Built-in functions that you can overload
          Built-in functions that you cannot overload
          Overload a built-in function
      Create user-defined casts
        Understanding casts
          Built-in casts
          User-defined casts
            Opaque data types
            Distinct data types
            Named row types
          Casts that you cannot create
        Create a user-defined cast
          Choose the kind of user-defined cast
            Implicit cast
            Explicit cast
          Choose the cast mechanism
            Straight cast
            Creating a cast that has a cast function
            Example of a cast function
          Define the direction of the cast
        Drop a cast
      Create user-defined aggregates
        Extend existing aggregates
          Overload operators for built-in aggregates
          Extending a built-in aggregate
          Example of extending a built-in aggregate
        Create user-defined aggregates
          Support functions
            The INIT function
              Omit the INIT function
              The optional second argument
            The ITER function
            The FINAL function
            The COMBINE function
          Resolve the support functions
          Support-function states
          Using C or Java support functions
          Example of a user-defined aggregate
            User-defined data types with user-defined aggregates
            Omit support functions
              Difference between SUMSQ and SSQ2 aggregates
              Overload the support functions for SSQ2
        Manage aggregates
          Parallel execution of aggregates
          Privileges for user-defined aggregates
          Aggregate information in the system catalog
          Aggregate information from the command line
        Drop an aggregate
      Create an opaque data type
        Opaque data types
          The internal structure
            A fixed-length opaque data type
            A varying-length opaque data type
          Support functions
            Operator functions
            Built-in functions
            Aggregate functions
            Statistics-collecting routines
            End-user routines
          Advantages of opaque data types
        Creating an opaque data type
          Create the internal structure in C
            Data type size
              A fixed-length opaque data type
              A varying-length opaque data type
            Memory alignment
            Parameter passing
          Creating UDT-to-Java mappings
          Write and register the support functions
          Register the opaque data type with the database
            Register the opaque data type
            Create casts for opaque data types
            Non in-row storage
          Grant privileges for an opaque data type
          Create SQL-invoked functions
            Arithmetic and text operator functions for opaque data types
            Built-in functions for opaque data types
            Aggregate functions for opaque data types
            Conditional operators for opaque data types
            Relational operators for opaque data types
              Hashable data types
              Nonhashable data types
            Comparison function for opaque data types
        Customize access methods
          The generic B-tree
          Other access methods
            Index spatial data
            Index other types of data
        Other operations on opaque data types
          Access an opaque data type
          Drop an opaque data type
      Write support functions
        Write support functions
          Identify support functions
          Choose function parameters
          Set privileges for support functions
        Data types for support functions
          The LVARCHAR data type
          The SENDRECV data type
        Handle the external representation
          Input support function
          Output support function
        Handle the internal representation
          The send and receive support functions
            The SENDRECV data type
            Receive support function
            Send support function
        Perform bulk copies
          Import and export support functions
            The IMPEXP data type
            Import support function
            Export support function
          Importbinary and exportbinary support functions
            The IMPEXPBIN data type
            Importbinary support function
            Exportbinary support function
          The stream support functions
        Insert and delete data
          The assign() function
          The destroy() function
          The update() function
          The deepcopy() function
        Handle smart large objects
        Compare data
        Handle locale-sensitive data (GLS)
          Locale-sensitive input and output support functions
          Locale-sensitive receive and send support functions
        Operating system functions
      Extend an operator class
        Operator classes
          Secondary-access methods
            Generic B-tree index
            R-tree index
            Other user-defined secondary-access methods
          Operator classes
            Generic B-tree operator class
              B-tree strategy functions
              B-tree support function
            R-tree index operator class
        Extending an existing operator class
          Extensions of the btree_ops operator class
          Reasons for extending btree_ops
            Generate a single value for a new data type
            Change the sort order
        Create an operator class
          Creating a new B-tree operator class
          Create an absolute-value operator class
          Define an operator class for other secondary-access methods
        Drop an operator class
      Manage a user-defined routine
        Assign the execute privilege to a routine
          Grant and revoke the execute privilege
          Privileges on objects associated with a UDR
          Run a UDR as DBA
          DBA privileges with objects and nested UDRs
        Modify a user-defined routine
          Modify a C UDR
            Remove routines from the shared library
          Modify a Java UDR
        Alter a user-defined routine
        Drop a user-defined routine
      Improve UDR performance
        Improve performance of C user-defined routines
        Optimize a user-defined routine
          Optimize an SPL routine
            Optimization levels
            Automatic optimization
          Update statistics for an SPL routine
        Optimize functions in SQL statements
          Calculate the query plan
          Specify cost and selectivity
            Constant cost and selectivity values
            Dynamic cost and selectivity values
          Calculating cost
          Selectivity and cost examples
        Extend UPDATE STATISTICS
          The UPDATE STATISTICS statement
          Support functions for UPDATE STATISTICS
            The stat data type
            The statcollect() function
            The statprint() function
            Example of user-defined statistics functions
        Negator functions
        A virtual-processor class
          Choose a virtual-processor class
            CPU virtual-processor class
            User-defined virtual-processor class (C)
            JVM virtual-processor class (Java)
          Using virtual processors with UDRs written in C
          Manage virtual processors
            Add and drop virtual processors
            Monitor virtual-processor classes
        Parallel UDRs
          Executing UDRs in parallel
            Execution of a UDR in a query expression
              Parallel UDR in WHERE clause
              Parallel UDR in a join
              Parallel UDR in the select list
              Parallel UDR with GROUP BY
              Parallel UDR in select list for parallel insert
            FastPath execution of a UDR in a DataBlade API (C)
            Implicit UDR execution of a user-defined aggregate
            Implicit UDR execution of a comparison operator
            Implicit execution of an assign UDR
            Execution of a comparison UDR for sort
            Execution of a UDR by an index on a UDT column
          Enable parallel UDRs
            Specify the PARALLELIZABLE modifier
            Write PDQ threadsafe UDRs
            Turn on PDQ and review other configuration parameters
            Enabling parallel UDRs
          Set the number of virtual processors
          Monitor parallel UDRs
        Memory considerations
          Memory durations for C UDRs
          Stack-size considerations (Ext)
          Virtual-memory cache for routines
            The sysprocedures system catalog table
            UDR cache
        I/O considerations
          Isolate system catalog tables
          Balancing the I/O activities
    Virtual-Table Interface Guide
      What's new in the virtual table interface, Version 12.10
      Access methods
        Built-in access methods
        User-defined access methods
          Access to storage spaces
          Seamless use of SQL
        Access-method components
          Components that the Informix database server provides
            Virtual-Table Interface
              Purpose functions
              Descriptors
              Accessor functions
            DataBlade API
            SQL extensions
              Register the access method in a database
              Specify an access method for a virtual table
            API libraries
          Components that you provide
            Purpose functions
            User-defined routines and header files
            User messages and documentation
        Access method flow
          Locate purpose functions
          Execute purpose functions
          Call functions from a purpose function
          Improve an access method
      Develop an access method
        Choose features for the access method
        Write purpose functions
          Start and end processing
          Create and drop database objects
          Provide optimum access method performance
            Provide optimizer information
            Split a scan
          Insert, delete, and update data
        Register purpose functions
          Supply routine modifiers
        Register the access method
        Testing the access method
          Create and specify storage spaces
            Testing the access method with an sbspace
              Create an sbspace
              Specify the logical sbspace name
            Storing virtual data in an extspace
              Specify a logical name
              Specify the physical location for external storage
              Provide a default extspace
            Test the access method for fragmentation support
            Avoid storage-space errors
          Insert, query, and update data
          Check data integrity
        Drop an access method
        Cannot rename databases that have virtual tables
      Design decisions
        Store data in shared memory
          Functions that allocate and free memory
          Memory-duration options
          Persistent user data
        Access database and system catalog tables
        No label-based access control on virtual tables
        Execute a UDR across databases of the same database server instance
        Handle the unexpected
          Callback functions
          Error messages
        Data definition statements
          Interpret the table descriptor
          Manage storage spaces
            Choose DataBlade API functions
            Set the am_sptype value
            Creating a default storage space
              Creating a default sbspace
              Create a default extspace
            Ensure data integrity
              Activate automatic controls in sbspaces
              Add controls for extspaces
            Check storage-space type
            Fragmentation support
          Provide configuration keywords
          Leverage indexes on virtual tables
        Process queries that involve a virtual table
          Interpret the scan descriptor
          Interpret the qualification descriptor
            Interpret the parameter descriptor
            Simple functions
            Runtime values as arguments
            Negation
            Complex expressions
          Qualifying data
            Qualification by the database server
            Qualification by the access method
              Guidelines for implementation
              Execute qualification functions
              Process complex qualifications
            Qualification by external software
            Support for query plan evaluation
              Calculate statement-specific costs
              Update statistics
        Enhancing performance
          Executing in parallel
          Buffering multiple results
        Support for data retrieval, manipulation, and return
          Check isolation levels
          Converting to and from a row format
          Determine transaction success or failure
        Supply error messages and a user guide
          Avoid database server exceptions
            Statements that the access method does not support
            Keywords that the access method does not support
            Storage spaces and fragmentation
            SQL restrictions
          Notify the user about access-method constraints
          Document nonstandard features
      Purpose-function reference
        Purpose-function flow
          The ALTER FRAGMENT statement interface
          The CREATE statement interface
          The DROP statement interface
          The INSERT, DELETE, and UPDATE statement interface
          The SELECT...WHERE statement interface
          The oncheck utility interface
        Purpose-function syntax
          The am_beginscan purpose function
          The am_check purpose function
          The am_close purpose function
          The am_create purpose function
          The am_delete purpose function
          The am_drop purpose function
          The am_endscan purpose function
          The am_getbyid purpose function
          The am_getnext purpose function
          The am_insert purpose function
          The am_open purpose function
          The am_rescan purpose function
          The am_scancost purpose function
          The am_stats purpose function
          The am_truncate purpose function
          The am_update purpose function
      Descriptor function reference
        Descriptor reference
          Qualification descriptor
          Parameter descriptor
          Row descriptor
          Scan descriptor
          Statistics descriptor
          Table descriptor
          Files to include in the access-method build
        Accessor functions
          The mi_eval_am_qual() accessor function
          The mi_init_am_qual() accessor function
          The mi_qual_boolop() accessor function
          The mi_qual_column() accessor function
          The mi_qual_commuteargs() accessor function
          The mi_qual_constant() accessor function
          The mi_qual_constant_nohostvar() accessor function
          The mi_qual_constant_typeid() accessor function
          The mi_qual_constisnull() accessor function
          The mi_qual_constisnull_nohostvar() accessor function
          The mi_qual_const_depends_hostvar() accessor function
          The mi_qual_const_depends_outer() accessor function
          The mi_qual_funcid() accessor function
          The mi_qual_funcname() accessor function
          The mi_qual_handlenull() accessor function
          The mi_qual_issimple() accessor function
          The mi_qual_needoutput() accessor function
          The mi_qual_negate() accessor function
          The mi_qual_nparams() accessor function
          The mi_qual_nquals() accessor function
          The mi_qual_qual() accessor function
          The mi_qual_setoutput() accessor function
          The mi_qual_setreopt() accessor function
          The mi_qual_setvalue() accessor function
          The mi_qual_value() accessor function
          The mi_qual_param() accessor function
          The mi_qual_param_column() accessor function
          The mi_qual_param_constant() accessor function
          The mi_qual_param_constant_typeid() accessor function
          The mi_qual_param_constisnull() accessor function
          The mi_qual_param_expression() accessor function
          The mi_qual_param_iscolumn() accessor function
          The mi_qual_param_isconstant() accessor function
          The mi_qual_param_isexpression() accessor function
          The mi_qual_param_issimple() accessor function
          The mi_scan_forupdate() accessor function
          The mi_scan_isolevel() accessor function
          The mi_scan_locktype() accessor function
          The mi_scan_newquals() accessor function
          The mi_scan_nprojs() accessor function
          The mi_scan_projs() accessor function
          The mi_scan_quals() accessor function
          The mi_scan_setuserdata() accessor function
          The mi_scan_table() accessor function
          The mi_scan_userdata() accessor function
          The mi_tab_amparam() accessor function
          The mi_tab_check_msg() function
          The mi_tab_createdate() accessor function
          The mi_tab_id() accessor function
          The mi_tab_isolevel() accessor function
          The mi_tab_istable() accessor function
          The mi_tab_mode() accessor function
          The mi_tab_name() accessor function
          The mi_tab_niorows() accessor function
          The mi_tab_numfrags() accessor function
          The mi_tab_owner() accessor function
          The mi_tab_partnum() accessor function
          The mi_tab_rowdesc() accessor function
          The mi_tab_setnextrow() accessor function
          The mi_tab_setniorows() accessor function
          The mi_tab_setuserdata() accessor function
          The mi_tab_spaceloc() accessor function
          The mi_tab_spacename() accessor function
          The mi_tab_spacetype() accessor function
          The mi_tab_update_stat_mode() accessor function
          The mi_tab_userdata() accessor function
          The mi_tstats_setnpages() accessor function
          The mi_tstats_setnrows() accessor function
      SQL statements for access methods
        The ALTER ACCESS_METHOD (+) statement
        The CREATE ACCESS_METHOD (+) statement
        The DROP ACCESS_METHOD (+) statement
        Purpose options
      XA-compliant external data sources
        Create a virtual-table interface for XA data sources
    Virtual-Index Interface Guide
      Access methods
        Built-in access methods
        User-defined access methods
          Access to storage spaces
          Seamless use of SQL
        Access-method components
          Components that the Informix database server provides
            Virtual-Index Interface
              Purpose functions
              Descriptors
              Accessor functions
            DataBlade API
            SQL extensions
              Register the access method in a database
              Specify an access method for a virtual index
            API libraries
          Components that you provide
            Purpose functions
            User-defined routines and header files
            Operator class
            User messages and documentation
        Access method flow
          Locate purpose functions
          Execute purpose functions
          Call functions from a purpose function
          Improve an access method
      Develop an access method
        Choose features for the access method
        Write purpose functions
          Start and end processing
          Create and drop database objects
          Provide optimum access method performance
            Provide optimizer information
            Split a scan
          Insert, delete, and update data
        Register purpose functions
        Register the access method
        Specify an operator class
          Supplying an operator class for a secondary access method
          Write or choose strategy and support functions
          Register strategy and support functions
            Make a function nonvariant
            Grant privileges
          Register the operator class
          Add a default operator class to the access method
        Testing the access method
          Create and specify storage spaces
            Testing the access method with an sbspace
              Create an sbspace
              Specify the logical sbspace name
            Storing virtual data in an extspace
              Specify a logical name
              Specify the physical location for external storage
              Provide a default extspace
            Test the access method for fragmentation support
            Avoid storage-space errors
          Insert, query, and update data
          Check data integrity
        Drop an access method
        Cannot rename databases that have virtual indexes
      Design decisions
        Store data in shared memory
          Functions that allocate and free memory
          Memory-duration options
          Persistent user data
        Access database and system catalog tables
        No label-based access control on virtual indexes
        Execute a UDR across databases of the same database server instance
        Handle the unexpected
          Callback functions
          Error messages
        Data definition statements
          Interpret the table descriptor
          Manage storage spaces
            Choose DataBlade API functions
            Set the am_sptype value
            Creating a default storage space
              Creating a default sbspace
              Create a default extspace
            Ensure data integrity
              Activate automatic controls in sbspaces
              Add controls for extspaces
            Check storage-space type
            Fragmentation support
          Provide configuration keywords
          Build new indexes efficiently
          Enable alternative indexes
        Support multiple-column index keys
          Accessing support functions for a multiple-column key
          Accessing strategy functions for a multiple-column key
        Using FastPath
          Obtaining the routine identifier
          Reuse the function descriptor
        Process queries that involve a virtual index
          Interpret the scan descriptor
          Interpret the qualification descriptor
            Simple functions
            Runtime values as arguments
            Negation
            Complex Boolean expressions
          Qualify data
            Execute qualification functions
            Guidelines for implementation
            Process complex qualifications
            Support for query plan evaluation
              Calculate statement-specific costs
              Update statistics
        Enhancing performance
          Executing in parallel
          Bypass table scans
          Buffering multiple results
        Support for data retrieval, manipulation, and return
          Enforcing unique-index constraints
          Check isolation levels
          Converting to and from a row format
          Determine transaction success or failure
        Supply error messages and a user guide for your functions
          Avoid database server exceptions
            Statements that the access method does not support
            Keywords that the access method does not support
            Storage spaces and fragmentation
            SQL restrictions
          Notify the user about access-method constraints
            Data integrity limitations
            WHERE clause limitations
          Document nonstandard features
      Purpose-function reference
        Purpose-function flow
          The ALTER FRAGMENT statement interface
          The CREATE statement interface
          The DROP statement interface
          The INSERT, DELETE, and UPDATE statement interface
          The SELECT...WHERE statement interface
          The oncheck utility interface
        Purpose-function syntax
          The am_beginscan purpose function
          The am_check purpose function
          The am_close purpose function
          The am_create purpose function
          The am_delete purpose function
          The am_drop purpose function
          The am_endscan purpose function
          The am_getnext purpose function
          The am_insert purpose function
          The am_open purpose function
          The am_rescan purpose function
          The am_scancost purpose function
          The am_stats purpose function
          The am_truncate purpose function
          The am_update purpose function
      Descriptor function reference
        Descriptors
          Key descriptor
          Qualification descriptor
          Row descriptor
          Row-ID descriptor
          Scan descriptor
          Statistics descriptor
          Table descriptor
          Files to include in the access-method build
        Accessor functions
          The mi_id_fragid() accessor function
          The mi_id_rowid() accessor function
          The mi_id_setfragid() accessor function
          The mi_id_setrowid() accessor function
          The mi_istats_setclust() accessor function
          The mi_istats_set2lval() accessor function
          The mi_istats_set2sval() accessor function
          The mi_istats_setnlevels() accessor function
          The mi_istats_setnleaves() accessor function
          The mi_istats_setnunique() accessor function
          The mi_key_funcid() accessor function
          The mi_key_nkeys() accessor function
          The mi_key_opclass() and mi_key_opclass_name() accessor functions
          The mi_key_opclass_nstrat() accessor function
          The mi_key_opclass_nsupt() accessor function
          The mi_key_opclass_strat() accessor function
          The mi_key_opclass_supt() accessor function
          The mi_qual_boolop() accessor function
          The mi_qual_column() accessor function
          The mi_qual_commuteargs() accessor function
          The mi_qual_constant() accessor function
          The mi_qual_constant_nohostvar() accessor function
          The mi_qual_constisnull() accessor function
          The mi_qual_constisnull_nohostvar() accessor function
          The mi_qual_const_depends_hostvar() accessor function
          The mi_qual_const_depends_outer() accessor function
          The mi_qual_funcid() accessor function
          The mi_qual_funcname() accessor function
          The mi_qual_handlenull() accessor function
          The mi_qual_issimple() accessor function
          The mi_qual_needoutput() accessor function
          The mi_qual_negate() accessor function
          The mi_qual_nquals() accessor function
          The mi_qual_qual() accessor function
          The mi_qual_setoutput() accessor function
          The mi_qual_setreopt() accessor function
          The mi_qual_stratnum() accessor function
          The mi_scan_forupdate() accessor function
          The mi_scan_isolevel() accessor function
          The mi_scan_locktype() accessor function
          The mi_scan_newquals() accessor function
          The mi_scan_nprojs() accessor function
          The mi_scan_projs() accessor function
          The mi_scan_quals() accessor function
          The mi_scan_setuserdata() accessor function
          The mi_scan_table() accessor function
          The mi_scan_userdata() accessor function
          The mi_tab_amparam() accessor function
          The mi_tab_check_msg() function
          The mi_tab_check_is_recheck() accessor function
          The mi_tab_check_set_ask() accessor function
          The mi_tab_createdate() accessor function
          The mi_tab_isindex() accessor function
          The mi_tab_isolevel() accessor function
          The mi_tab_keydesc() accessor function
          The mi_tab_mode() accessor function
          The mi_tab_name() accessor function
          The mi_tab_nextrow() accessor function
          The mi_tab_niorows() accessor function
          The mi_tab_nparam_exist() accessor function
          The mi_tab_numfrags() accessor function
          The mi_tab_owner() accessor function
          The mi_tab_param_exist() accessor function
          The mi_tab_partnum() accessor function
          The mi_tab_rowdesc() accessor function
          The mi_tab_setnextrow() accessor function
          The mi_tab_setniorows() accessor function
          The mi_tab_setuserdata() accessor function
          The mi_tab_spaceloc() accessor function
          The mi_tab_spacename() accessor function
          The mi_tab_spacetype() accessor function
          The mi_tab_unique() accessor function
          The mi_tab_update_stat_mode() accessor function
          The mi_tab_userdata() accessor function
      SQL statements for access methods
        The ALTER ACCESS_METHOD (+) statement
        The CREATE ACCESS_METHOD (+) statement
        The DROP ACCESS_METHOD (+) statement
        Purpose options
      XA-compliant external data sources
        Create a virtual-index interface for XA data sources
  Informix extensions and DataBlade modules
    Database Extensions User's Guide
      What's New in Database Extensions for Informix database server, Version 12.10
      Large object management
        About Large Object Locator
          Large object requirements
        Large Object Locator data types
          The lld_locator data type
          The lld_lob data type
        Large Object Locator functions
          Interfaces
            API library
            ESQL/C library
            SQL interface
          Working with large objects
            The lld_close() function
            The lld_copy() function
            The lld_create() function
            The lld_delete() function
            The lld_open() function
            The lld_read() function
            The lld_seek() function
            The lld_tell() function
            The lld_write() function
          Client file support
            The lld_create_client() function
            The lld_delete_client() function
            The lld_from_client() function
            The lld_open_client() function
            The lld_to_client() function
          Error utility functions
            The lld_error_raise() function
            The lld_sqlstate() function
          Smart large object functions
            The LOCopy function
            The LOToFile function
            The LLD_LobType function
        Large Object Locator example code
          The SQL interface
            The lld_lob type
              Implicit lld_lob casts
              Explicit lld_lob casts
              The LLD_LobType function
            The lld_locator type
              Insert an lld_locator row into a table
              Create a smart large object
              Copy a client file to a large object
              Copy a large object to a large object
              Copy large object data to a client file
              Create and delete a server file
          The API interface
            Create the lld_copy_subset function
            The lld_copy_subset routine
        Large Object Locator error handling
          Large Object Locator errors
          Error handling exceptions
          Error codes
      MQ Messaging
        About MQ messaging
          Prepare to use MQ messaging
            Install and configure WMQ
            Prepare your database server for MQ messaging
            Sample code for setting up queue managers, queues, and channels
            Sample code for setting up the server for use with WMQ
            Switch between server-based and client-based messaging
              Switching from server-based to client-based messaging
              Switching from client-based to server-based messaging
          Verification
            Insert data into a queue
            Read an entry from a queue
            Receive an entry from a queue
            Publish and subscribe to a queue
              Subscribe to a queue
              Unsubscribe from a queue
              Publish to a queue
        MQ messaging tables
          Schema mapping
          General table behavior
          Create and bind a table
          Use INSERT and SELECT
          Retrieve the queue element
          Special considerations
          Table errors
        MQ messaging functions
          Service and policy tables
            The "informix".mqiservice table
            The "informix".mqipubsub table
            The "informix".mqipolicy table
          MQCreateVtiRead() function
          MQCreateVtiReceive() function
          MQCreateVtiWrite() function
          MQHasMessage() function
          MQInquire() function
          MQPublish() function
          MQPublishClob() function
          MQRead() function
          MQReadClob() function
          MQReceive() function
          MQReceiveClob() function
          MQSend() function
          MQSendClob() function
          MQSubscribe() function
          MQTrace() function
          MQUnsubscribe() function
          MQVersion() function
        MQ messaging configuration parameters
          MQSERVER configuration parameter
          MQCHLLIB configuration parameter
          MQCHLTAB configuration parameter
        MQ messaging error handling
        Sample MQ messaging code
      Binary data types
        Binary data types overview
        Store and index binary data
          Binary data types
            The binaryvar data type
            The binary18 data type
            ASCII representation of binary data types
            Binary data type examples
          Insert binary data
          Index binary data
        Binary data type functions
          Bitwise operation functions
            The bit_and() function
            The bit_complement() function
            The bit_or() function
            The bit_xor() function
          Support functions for binary data types
            The bdtrelease() function
            The bdttrace() function
            The LENGTH() function
            The OCTET_LENGTH() function
      Basic Text Search
        Preparing for basic text searching
          Basic text search requirements and restrictions
          Creating a default sbspace
          Creating a space for the bts index
          Creating a space for temporary data
          Creating a bts index
            bts access method syntax
              canonical_maps index parameter
              delete index parameter
              field_token_max index parameter
              max_clause_count index parameter
              query_default_field index parameter
              query_log index parameter
              stopwords index parameter
              thesaurus index parameters
              xact_memory index parameter
              xact_ramdirectory index parameter
        Basic text search queries
          Basic Text Search query syntax
          Basic Text Search query terms
          Basic text search index fields
          Basic Text Search query term modifiers
            Wildcard searches
            Fuzzy searches
            Proximity searches
            Range searches
            Boost a term
          Boolean operators
            AND operator
            OR operator
            NOT operator
        Basic text search JSON index parameters
          JSON index parameters syntax
          all_json_names index parameter
          ignore_json_format_errors index parameter
          include_contents index parameter
          json_array_processing index parameter
          json_names index parameter
          json_path_processing index parameter
          only_json_values index parameter
        Basic Text Search XML index parameters
          XML index parameters syntax
          The xmltags index parameter
            Example: Index specific XML tags
          The all_xmltags index parameter
            Example: Index all XML tags
          The all_xmlattrs index parameter
            Examples: Index XML attributes
          The xmlpath_processing index parameter
            Full paths and relative paths in path processing
            Example: Index XML paths
          The include_contents index parameter
            Example: Index XML tag values and XML tag names
          The strip_xmltags index parameter
            Example: Index XML tag values in a separate field
          The include_namespaces index parameter
            Example: Index namespaces in XML data
          The include_subtag_text index parameter
            Example: Index subtags in XML data
        Basic text search analyzers
          analyzer index parameter
          Analyzer support for query and index options
          Alnum analyzer
          CJK analyzer
          eSoundex analyzer
          Keyword analyzer
          Simple analyzer
          Soundex analyzer
          Snowball analyzer
          Standard analyzer
          Stopword analyzer
          User-defined analyzer
          Whitespace analyzer
        Basic text search functions
          bts_index_compact() function
          bts_index_fields() function
          bts_release() function
          bts_tracefile() function
          bts_tracelevel() function
        Basic text search performance
          Disk space for the bts index
          Adding BTS virtual processors to run multiple queries simultaneously
          Tune configuration parameters for basic text searching
        Basic text search error codes
      Hierarchical data type
        The node data type for querying hierarchical data
          Troubleshooting the node data type
        Node data type functions
          Ancestors() function
          Compare() function
          Depth() function
          Equal() function
          GetMember() function
          GetParent() function
          Graft() function
          GreaterThan() function
          GreaterThanOrEqual() function
          Increment() function
          IsAncestor() function
          IsChild() function
          IsDescendant() function
          IsParent() function
          Length() Node function
          LessThan() function
          LessThanOrEqual() function
          NewLevel() function
          NodeRelease() function
          NotEqual() function
      SQL Packages Extension
        DBMS_ALERT package
          REGISTER procedure
          REMOVE procedure
          REMOVEALL procedure
          SET_DEFAULTS procedure
          SIGNAL procedure
          WAITANY procedure
          WAITONE procedure
        DBMS_LOB package
          APPEND procedures
          COMPARE function
          COPY procedures
          ERASE procedures
          GETLENGTH function
          INSTR function
          READ procedures
          SUBSTR function
          TRIM procedures
          WRITE procedures
        DBMS_OUTPUT package
          DISABLE procedure
          ENABLE procedure
          GET_LINE procedure
          GET_LINES procedure
          NEW_LINE procedure
          PUT procedure
          PUT_LINE procedure
        DBMS_RANDOM package
          INITIALIZE procedure
          SEED procedure
          RANDOM function
          TERMINATE procedure
        UTL_FILE package
          FCLOSE procedure
          FCLOSE_ALL procedure
          FFLUSH procedure
          FOPEN function
          GET_LINE procedure
          NEW_LINE procedure
          PUT procedure
      Regex pattern matching
        Requirements and Restrictions
        Metacharacters
          Regex character names
        Regex Routines
          regex_match function
          regex_replace function
          regex_extract function
          regex_split function
          regex_set_trace procedure
          regex_release function
    Performing XML Publishing
      Publishing SQL result sets in XML
        XML publishing
        The idsxmlvp virtual processor class
        Special characters in XML functions
        The extract() and extractclob() XML functions
        The existsnode() XML function
        The extractvalue() and extractvalueclob() XML functions
        The genxml() and genxmlclob() XML functions
        The genxmlelem() and genxmlelemclob() XML functions
        The genxmlqueryhdr() and genxmlqueryhdrclob() XML functions
        The genxmlquery() and genxmlqueryclob() XML functions
        The genxmlschema() and genxmlschemaclob() XML functions
        The idsxmlparse() XML function
      Transforming documents with XSLT functions
        The xsltransform function
        The xsltransformAsClob function
        The xsltransformAsBlob function
    TimeSeries Data User's Guide
      What's new in TimeSeries data for Informix, Version 12.10
      Informix TimeSeries solution
        Informix TimeSeries solution architecture
        Time series concepts
          TimeSeries data type technical overview
          Regular time series
          Irregular time series
          Packed time series
            Hertz time series
            Compressed numeric time series
          JSON time series
          Calendar
          Time series storage
        Getting started with the Informix TimeSeries solution
          Planning for creating a time series
          Planning for data storage
          Planning for loading time series data
          Planning for replication of time series data
          Planning for accessing time series data
        Hardware and software requirements for the TimeSeries solution
          Installing the HCL Informix TimeSeries Plug-in for Data Studio
          Server and database requirements for time series data
          SQL restrictions for time series data
          Time series global language support
        Sample smart meter data
        Setting up stock data examples
      Data types and system tables
        CalendarPattern data type
        Calendar data type
        TimeSeries data type
          Buffer control
        Time series return types
        CalendarPatterns table
        CalendarTable table
        TSContainerTable table
        TSContainerWindowTable
          TSContainerUsageActiveWindowVTI Table
          TSContainerUsageDormantWindowVTI Table
        TSInstanceTable table
      Create and manage a time series through SQL
        Example for regular data: Create and load a regular time series
        Example for hertz data: Create and load a hertz time series
        Example for compressible data: Create and load a compressed time series
        Example for JSON data: Create and load a time series with JSON documents
        Defining a calendar
          Predefined calendars
        Create a time series column
          Creating a TimeSeries subtype
          Create the database table
        Creating containers
          Rules for rolling window containers
          Monitor containers
          Manage container pools
            Configuring additional container pools
              User-defined container pool policy
        Create a time series
          Creating a time series with metadata
          Time series input string
          Create a time series with the output of a function
        Load data into a time series
          HCL Informix TimeSeries Plug-in for Data Studio
            Creating a load job to load data from a file
            Create a load job to load data from a database
            Running a load job from the command line
            Command-line loader application
          Writing a loader program
          Methods for loading JSON data
            Loading JSON data through an external table
          Loading data from a file into a virtual table
          Load data with the BulkLoad function
            Data file formats for BulkLoad
            Example: Load data with BulkLoad
          Load small amounts of data with SQL functions
        Performance tips for time series
        Delete time series data
        Manage packed data
      Virtual tables for time series data
        Performance of queries on virtual tables
        The structure of virtual tables
        The display of data in virtual tables
        Insert data through virtual tables
        Creating a time series virtual table
        TSCreateVirtualTab procedure
          Example of creating a virtual table
          Example of creating a fragmented virtual table
        TSCreateExpressionVirtualTab procedure
        The TSVTMode parameter
        Drop a virtual table
        Trace functions
          The TSSetTraceFile function
          TSSetTraceLevel function
      Pattern matching searches
        Requirements for pattern matching searches
        Pattern matching criteria
        Indexes on patterns
        Pattern matching routines
          getPatternFromTS function
          TSCreatePatternIndex function
          TSPatternMatch function
          TSDropPatternIndex function
          TSPIndexCleanup procedure
          TSPIndexRelease function
          TSPMatchRelease function
          TSPMatchSetTraceFile function
          TSPMatchSetTraceLevel function
      Advanced analytics
        Requirements and restrictions for advanced analytics functions
        Advanced analytics functions
          Scan_Abnormal and Scan_Abnormal_Default functions
          Scan_DTW_Itakura_Parallelogram_Constraint function
          Scan_DTW_NonConstraint function
          Scan_DTW_Sakoe_Chiba_Constraint function
          Scan_Normal_LCSS and Scan_LCSS functions
          Scan_RangeQuery_LPNorm function
          Scan_RangeQuery_Pearson_Correlation function
          TSAFuncsTraceFile function
          TSAFuncsTraceLevel function
          TSAFuncsRelease function
          TSCompute_Itakura_Parallelogram_Constraint_Dist function
          TSCompute_LCSS_Dist and TSCompute_Normalized_LCSS_Dist functions
          TSCompute_LP_Dist function
          TSCompute_NonConstraint_Dist function
          TSCompute_Sakoe_Chiba_Constraint_Dist function
          TSGetValueList function
          TSPearson_Correlation_Score function
          ValueAsCollection function
      Calendar pattern routines
        AndOp function
        CalPattStartDate function
        Collapse function
        Expand function
        NotOp function
        OrOp function
      Calendar routines
        AndOp function
        CalIndex function
        CalRange function
        CalStamp function
        CalStartDate function
        OrOp function
      Time series SQL routines
        Time series SQL routines sorted by task
        Time series routines that run in parallel
        The flags argument values
        Abs function
        Acos function
        AggregateBy function
        AggregateRange function
        Apply function
        ApplyBinaryTsOp function
        ApplyCalendar function
        ApplyOpToTsSet function
        ApplyUnaryTsOp function
        Asin function
        Atan function
        Atan2 function
        Binary arithmetic functions
        BulkLoad function
        Clip function
        ClipCount function
        ClipGetCount function
        Cos function
        CountIf function
        DelClip function
        DelElem function
        DelRange function
        DelTrim function
        Divide function
        ElemIsHidden function
        ElemIsNull function
        Exp function
        FindHidden function
        GetCalendar function
        GetCalendarName function
        GetClosestElem function
        GetCompression function
        GetContainerName function
        GetElem function
        GetFirstElem function
        GetFirstElementStamp function
        GetHertz function
        GetIndex function
        GetInterval function
        GetLastElem function
        GetLastElementStamp function
        GetLastNonNull function
        GetLastValid function
        GetMetaData function
        GetMetaTypeName function
        GetNelems function
        GetNextNonNull function
        GetNextValid function
        GetNthElem function
        GetOrigin function
        GetPacked function
        GetPreviousValid function
        GetStamp function
        GetThreshold function
        HideElem function
        HideRange function
        InsElem function
        InsSet function
        InstanceId function
        Intersect function
        IsRegular function
        Lag function
        Logn function
        Minus function
        Mod function
        Negate function
        NullCleanup function
        Plus function
        Positive function
        Pow function
        ProjectedClip function
        PutElem function
        PutElemNoDups function
        PutNthElem function
        PutSet function
        PutTimeSeries function
        RevealElem function
        RevealRange function
        Round function
        SetContainerName function
        SetOrigin function
        Sin function
        Sqrt function
        Tan function
        Times function
        TimeSeriesRelease function
        Transpose function
        TSAddPrevious function
        TSCmp function
        TSColNameToList function
        TSColNumToList function
        TSContainerCreate procedure
        TSContainerDestroy procedure
        TSContainerLock procedure
        TSContainerManage function
        TSContainerNElems function
        TSContainerPctUsed function
        TSContainerPoolRoundRobin function
        TSContainerPurge function
        TSContainerSetPool procedure
        TSContainerTotalPages function
        TSContainerTotalUsed function
        TSContainerUsage function
        TSCreate function
        TSCreateIrr function
        TSDecay function
        TSInfo function
        TSL_ActiveHandles function
        TSL_Attach function
        TSL_Commit function
        TSL_Flush function
        TSL_FlushAll function
        TSL_FlushInfo function
        TSL_FlushStatus function
        TSL_GetFmtMessage function
        TSL_GetKeyContainer function
        TSL_GetLogMessage function
        TSL_Init function
        TSL_MessageSet function
        TSL_Put function
        TSL_PutJson function
        TSL_PutRow function
        TSL_PutSQL function
        TSL_SessionClose function
        TSL_SetLogMode function
        TSL_SetNewTS function
        TSL_Shutdown procedure
        TSPrevious function
        TSRollup function
        TSRowNameToList function
        TSRowNumToList function
        TSRowToList function
        TSRunningAvg function
        TSRunningCor function
        TSRunningMed function
        TSRunningSum function
        TSRunningVar function
        TSSetToList function
        TSToXML function
        Unary arithmetic functions
        Union function
        UpdElem function
        UpdMetaData function
        UpdSet function
        WithinC and WithinR functions
      Time series Java class library
        Java class files and sample programs
        Preparing the server for Java classes
        Mapping time series data types
        Querying time series data with the IfmxTimeSeries object
        Obtaining the time series Java class version
      Time series API routines
        Differences in using functions on the server and on the client
        Data structures for the time series API
          The ts_timeseries structure
          The ts_tscan structure
          The ts_tsdesc structure
          The ts_tselem structure
        Time series API routines sorted by task
        The ts_begin_scan() function
        The ts_cal_index() function
        The ts_cal_pattstartdate() function
        The ts_cal_range() function
        The ts_cal_range_index() function
        The ts_cal_stamp() function
        The ts_cal_startdate() function
        The ts_close() function
        The ts_closest_elem() function
        The ts_col_cnt() function
        The ts_col_id() function
        The ts_colinfo_name() function
        The ts_colinfo_number() function
        The ts_copy() function
        The ts_create() function
        The ts_create_with_metadata() function
        The ts_current_offset() function
        The ts_current_timestamp() function
        The ts_datetime_cmp() function
        The ts_del_elem() function
        The ts_elem() function
        The TS_ELEM_HIDDEN macro
        The TS_ELEM_NULL macro
        The ts_elem_to_row() function
        The ts_end_scan() procedure
        The ts_first_elem() function
        The ts_free() procedure
        The ts_free_elem() procedure
        The ts_get_all_cols() procedure
        The ts_get_calname() function
        The ts_get_col_by_name() function
        The ts_get_col_by_number() function
        The ts_get_compressed() function
        The ts_get_containername() function
        The ts_get_flags() function
        The ts_get_hertz() function
        The ts_get_metadata() function
        The ts_get_origin() function
        The ts_get_packed() function
        The ts_get_stamp_fields() procedure
        The ts_get_threshold() function
        The ts_get_ts() function
        The ts_get_typeid() function
        The ts_hide_elem() function
        The ts_index() function
        The ts_ins_elem() function
        The TS_IS_INCONTAINER macro
        The TS_IS_IRREGULAR macro
        The ts_last_elem() function
        The ts_last_valid() function
        The ts_make_elem() function
        The ts_make_elem_with_buf() function
        The ts_make_stamp() function
        The ts_nelems() function
        The ts_next() function
        The ts_next_valid() function
        The ts_nth_elem() function
        The ts_open() function
        The ts_previous_valid() function
        The ts_put_elem() function
        The ts_put_elem_no_dups() function
        The ts_put_last_elem() function
        The ts_put_nth_elem() function
        The ts_put_ts() function
        The ts_reveal_elem() function
        The ts_row_to_elem() function
        The ts_time() function
        The ts_tstamp_difference() function
        The ts_tstamp_minus() function
        The ts_tstamp_plus() function
        The ts_update_metadata() function
        The ts_upd_elem() function
      Appendixes
        The Interp function example
        The TSIncLoad procedure example
    Web DataBlade Module
  Creating extensions
    DataBlade API Programmer's Guide
      DataBlade API overview
        The DataBlade API
          The DataBlade API module
            User-defined routine (Server)
              Types of UDRs
              Differences between C UDRs and UDRs written in SPL
              Write a UDR in C
            The client LIBMI application
            Compatibility of client and server DataBlade API modules
          DataBlade API components
            Header files
              DataBlade API header files
              ESQL/C header files
              Informix GLS header file
              Private header files
            Public data types
              DataBlade API data types
              DataBlade API support data types
              DataBlade API data type structures
            Regular public functions
              DataBlade API functions
              Informix ESQL/C functions
              Informix GLS functions
            Advanced features (Server)
          Internationalization of DataBlade API modules (GLS)
        Access SQL data types
          Type identifiers
          Type descriptors
            Type-structure conversion
            Data type descriptors and column type descriptors
          Character data types
            The mi_char1 and mi_unsigned_char1 data types
            The mi_char and mi_string data types
            The mi_lvarchar data type
              The SQL LVARCHAR data type
              Character data in binary mode of a query
              Character data in C UDRs (Server)
              External representation of an opaque data type (Server)
            Character data in a smart large object
            Character processing
              Transfer character data (Server)
              Convert character data
                DataBlade API functions for string conversion
                ESQL/C functions for string conversion
              Operations on character values
              Character type information
          Varying-length data type structures
            A varying-length structure
            Memory management for a varying-length structure
              Create a varying-length structure
              Deallocate a varying-length structure
            Access a varying-length structure
              Varying-length data and null termination
              Storage of varying-length data
                Store data in a varying-length structure
                Store a null-terminated string
                Set the data pointer
              Information about varying-length data
                Obtain the data length
                Obtain data as a null-terminated string
                Copy data into a user-allocated buffer
                Copy data into a new varying-length structure
                Obtain the data pointer
          Byte data types
            The mi_bitvarying data type
            Byte data in a smart large object
            Byte processing
              Manipulate byte data
              Transfer byte data (Server)
          Boolean data types
            Boolean text representation
            Boolean binary representation
            Pointer data types (Server)
          Simple large objects
          The MI_DATUM data type
            Contents of an MI_DATUM structure
              MI_DATUM in a C UDR (Server)
              MI_DATUM in a client LIBMI application
            Address calculations with MI_DATUM values
            Uses of MI_DATUM structures
          The NULL constant
            SQL NULL value
            NULL-valued pointer
      Data manipulation
        Numeric data types
          Integer data
            Integer text representation
            Integer binary representations
              One-byte integers
              Two-byte integers
              Four-byte integers
              Eight-byte integers
                The int8.h header file
                  Internal INT8 format
                ESQL/C INT8-type functions
                Transfer eight-byte integers (Server)
                Convert INT8 values
                Perform operations on eight-byte values
          Fixed-point data
            Fixed-point text representations
              Decimal text representation
              Monetary text representation
            Fixed-point binary representations
              DECIMAL data type: Fixed-point data
              MONEY data type
              The decimal.h header file
                Internal fixed-point decimal format
                The decimal macros
                ESQL/C DECIMAL-type functions
            Transfer fixed-point data (Server)
            Convert decimal data
              DataBlade API functions for decimal conversion
              ESQL/C functions for decimal conversion
            Perform operations on decimal data
            Obtain fixed-point type information
          Floating-point data
            Floating-point text representation
            Floating-point binary representations
              DECIMAL data type: Floating-point data
              SMALLFLOAT data type
              The FLOAT data type
            Transfer floating-point data (Server)
            Convert floating-point decimal data
            Obtain floating-point type information
          Format numeric strings
        Date and time data types
          Date data
            Date text representation
            Date binary representation
            Transfers of date data (Server)
            Conversion of date representations
              DataBlade API functions for date conversion
              ESQL/C functions for date conversion
            Operations on date data
          Date-time or interval data
            Date-time or interval text representation
            Date-time or interval binary representation
              The DATETIME data type
              The INTERVAL data type
            The datetime.h header file
            Retrieval and insertion of DATETIME and INTERVAL values
              Fetch or Insert into an mi_datetime variable
              Fetch or insert into an mi_interval variable
              Implicit data conversion
            Transfers of date-time or interval data (Server)
            Conversion of date-time or interval representations
              DataBlade API functions for date-time or interval conversion
              ESQL/C functions for date, time, and interval conversion
                Data conversion for DATETIME values
                  Converting a DATETIME value to a DATE value
                  Converting a DATE value into a DATETIME value
                Data conversion for INTERVAL values
            Operations on date and time data
            Functions to obtain information on date and time data
              Qualifier of a date-time or interval data type
              Precision of a date-time or interval data type
              Scale of a date-time or interval data type
        Complex data types
          Collections
            Collection text representation
            Collection binary representation
              A collection structure
              A collection descriptor
            Create a Collection
            Open a collection
              Open a collection with mi_collection_open()
              Open a collection with mi_collection_open_with_options()
            Access the elements of a collection
              Position the cursor
              Insert an element
              Fetch an element
                Move through a cursor
                Obtain the element value
              Update a collection
              Delete an element
              Determine the cardinality of a collection
            Releasing collection resources
              Close a collection
              Free the collection structure
            The listpos() UDR
              SQL statements
              C-language implementation
              Sample listpos() trace output
          Row types
            Row-type text representation
            Row-type binary representation
              A row descriptor
              A row structure
            Create a row type
              Create the row descriptor
              Assign the field values
                Column-value array
                Column-value null array
              Example: Creating a row type
            Access a row type
            Copying a row structure
            Releasing row resources
              Free a row structure
              Free a row descriptor
        Smart large objects
          Smart large objects
            Parts of a smart large object
              The sbspace
              The LO handle
            Information about a smart large object
              Storage characteristics
                Disk-storage information
                Attribute information
                  Logging
                  Last-access time
                  Data integrity
                Open-mode information
                  Access modes
                  Access methods
                  Buffering modes
                  Locking modes
              Status information
          Storing a smart large object in a database
            Valid data types
              CLOB and BLOB data types
              Opaque data type
            Access to a smart large object
              Selecting a smart large object
              Storing a smart large object
          The smart-large-object interface
            Smart-large-object data type structures
              Lo-specification structure
              LO handle
              Lo file descriptor
              Lo-status structure
            Smart-large-object functions
              Functions that create a smart large object
              Functions that perform input and output on a smart large object
              Functions that manipulate an LO handle
              Functions that access an LO-specification structure
              Functions that access an LO-status structure
              Functions that move smart large objects to and from operating-system files
          Creating a smart large object
            Obtain the LO-specification structure
              Specify new storage characteristics
                Allocating memory for an LO-specification structure
                Initialize an LO-specification structure
              Copy storage characteristics from an existing smart large object
            Choosing storage characteristics
              Obtaining storage characteristics
              Storage-characteristics hierarchy
                System-specified storage characteristics
                Obtain column-level storage characteristics
                Define user-specified storage characteristics
                  Access disk-storage information
                  Access attributes
                  Access the default open flag
            Initialize an LO handle and an LO file descriptor
              Obtain an LO handle
                Implicitly allocating an LO handle
                Explicitly allocating an LO handle
              Obtain an LO file descriptor
            Write data to a smart large object
            Storing an LO handle
            Free resources
              Free an LO-specification structure
              Free an LO handle
            Sample code to create a new smart large object
          Accessing a smart large object
            Selecting the LO handle
              Validate an LO handle
            Open a smart large object
            Read data from a smart large object
            Free a smart large object
            Sample code to select an existing smart large object
          Modify a smart large object
            Updating a smart large object
              Updating an LO handle
              Updating the data of an existing smart large object
            Alter storage characteristics
          Obtaining status information for a smart large object
            Obtain a valid LO file descriptor
            Initialize an LO-status structure
              Obtain a valid LO-status structure
              Fill in the LO-status structure
            Obtain status information
            Free an LO-status structure
          Delete a smart large object
            Manage the reference count
              Reference counts for CLOB and BLOB columns
              Reference counts for opaque-type columns
              Reference counts for transient smart large objects
            Free LO file descriptors
          Convert a smart large object to a file or buffer
            Operating-system files
            User-defined buffers
          Convert an LO handle between binary and text
            Binary and text representations of an LO handle
            DataBlade API functions for LO-handle conversion
          Transfer an LO handle between computers (Server)
          Using byte-range locking
          Pass a NULL connection (Server)
      Database access
        Connection handling
          Session management
            Client connection
            UDR connection (Server)
            Connection descriptor
          Initializing a client connection
            Connection parameters
              Establish default connection parameters
                System-default connection parameters
                Overriding the system-default connection parameters
              Obtain current connection parameters
            Database parameters
              Establish default database parameters
                System-default database parameters
                Overriding the system-default database parameters
              Obtain current database parameters
            Session parameters
              System-default session parameters
              Overriding the system-default session parameters
            Set connection parameters for a client connection
          Establish a connection
            Establish a UDR connection (Server)
              Obtain a connection descriptor
              Obtain a session-duration connection descriptor
            Establish a client connection
              Connections with mi_open()
              Connections with mi_server_connect()
          Associate user data with a connection
          Initialize the DataBlade API
          Close a connection
        Execute SQL statements
          Execute SQL statements
            Choose a DataBlade API function
              Type of statement
              Prepared statements and input parameters
              Queries and implicit cursors
            Execute basic SQL statements
              Assemble a statement string
              Send an SQL statement
                The implicit row cursor
                Control modes for query data
                Example: The send_statement() function
            Execute prepared SQL statements
              Prepare an SQL statement
                Assemble a prepared statement
                  Assemble unparameterized statements
                  Assemble parameterized statements
                Assign an optional name
                Return a statement descriptor
              Obtain input-parameter information
              Send the prepared statement
                Statements with mi_exec_prepared_statement()
                Statements with mi_open_prepared_statement()
                  Define an explicit cursor
                  Define a cursor type
                  Define a cursor mode
                  Define a cursor life span
                  Fetch rows into a cursor
                Assign values to input parameters
                  Parameter-value array
                  Parameter-value length array
                  Parameter-value null array
                  Parameter-value type array
                Determine control mode for query data
              Release prepared-statement resources
                Closing a statement cursor
                Drop a prepared statement
            Execute multiple SQL statements
          Process statement results
            Execute the mi_get_result() loop
              Handling unsuccessful statements
              Handling a DDL statement
              Handling a DML Statement
              Handling query rows
              Handling no more results status
            Example: The get_results() function
          Retrieving query data
            Obtain row information
            Obtain column information
            Retrieve rows
              Access the current row
              Execute the mi_next_row() loop
            Obtain column values
              Execute the column-value loop
              Access the columns
                Pass in the value buffer
                Interpret column-value status
              Obtain normal values
                Column values passed back to a C UDR (Server)
                Column values passed back to a client LIBMI application
                Access smart large objects
              Obtain NULL values
              Obtain row values
                Obtain row types
                Obtain jagged rows
                  Retrieving jagged rows
              Obtain collection values
                A collection in text representation
                A collection in binary representation
              Example: The get_data() function
          Complete execution
            Finish execution
              Process remaining rows
              Release statement resources
            Interrupt execution
          Inserting data into the database
            Assemble an insert string
            Send the insert statement
            Process insert results
          Save sets
            Create a save set
            Inserting rows into a save set
            Building a save set
            Free a save set
        Execute user-defined routines
          Access MI_FPARAM routine-state information
            Check routine arguments
              Determine the data type of UDR arguments
              Handling NULL arguments with MI_FPARAM
            Access return-value information
              Determine the data type of UDR return values
              Return a NULL value
            Saving a user state
              Saving user-state information in the first invocation of a UDR
              Obtaining user-state information in subsequent invocations of the UDR
              The MI_FPARAM structure for holding private-state information
            Obtain additional routine information
          Call UDRs within a DataBlade API module
            Call a UDR through an SQL statement
            Call a UDR directly (Server)
            Named parameters and UDRs
          Call UDRs with the Fastpath interface
            Obtain a function descriptor
              Look up a UDR
              Look up cast functions
            Obtain information from a function descriptor
              Obtain the MI_FPARAM structure
              Obtain a routine identifier
              Determine if a UDR handles NULL arguments
              Determine if a routine is a variant function
              Determine if a function is a negator function
              Determine if a function is a commutator function
            Execute the routine
              Pass in argument values
              Receive the return value
              Sample mi_routine_exec() calls
              Execute a built-in cast function
              Reuse a function descriptor
                Function descriptors within an SQL command
                Function descriptors within a session (Server)
                  Cache a session-duration function descriptor
                  Reuse the session-duration function descriptor
                  Deallocate a session-duration function descriptor
            A user-allocated MI_FPARAM structure
              Create a user-allocated MI_FPARAM structure
              A user-allocated MI_FPARAM structure (Server)
              Pass a user-allocated MI_FPARAM structure
              Free a user-allocated MI_FPARAM
            Release routine resources
          Obtain trigger execution information and HDR database server status
            Trigger information
            HDR status information
        Exceptions and events
          DataBlade API event types
          Event-handling mechanisms
            Invoke a callback
              Register a callback
                Types of callbacks
                Connection descriptor
                Callback-function pointer
                Callback handle
                Registration duration
              Enable and disable a callback
              Retrieving a callback function
                Example of retrieving a callback function
            Default behavior
              Default behavior in a C UDR (Server)
              Default behavior in client LIBMI applications
          Callback functions
            Declare a callback function
              Return value of a callback function
              MI_PROC_CALLBACK modifier (Windows)
              Callback-function parameters
            Write a callback function
              Restrictions on content
              Event information
                An error descriptor
                  Access an error descriptor
                  Create a copy of an error descriptor
                A transition descriptor
          Database server exceptions
            Understanding database server exceptions
              Warnings and errors
              Status variables
                The SQLSTATE status value
                  Identify warnings with SQLSTATE
                  Identify runtime errors with SQLSTATE
                SQLCODE status value
                  Identify warnings with SQLCODE
                  Identify runtime errors with SQLCODE
            Overriding the default exception handling
              Exceptions in a C UDR (Server)
                Handling errors from DataBlade API functions
                Register an exception callback
                Determine how to handle the exception
                  Handling an exception in the callback
                  Continue with exception handling
              Exceptions in a client LIBMI application (Client)
            Return error information to the caller
              Define a user-defined error structure
              Implement the callback
                Associate a user-defined error structure with a callback
                Associate a user-defined error structure with the connection
            Handling multiple exceptions
            Raise an exception
              Specify the connection
              Specify the message
                Pass literal messages
                Raise custom messages
                  Search for custom messages
                  Specify parameter markers
                  Adding custom messages
                  Choose an SQLSTATE code
                  Add new messages
          State-transition events
            Understanding state-transition events
              Begin a transaction
              End a session (Server)
            Providing state-transition handling
              State transitions in a C UDR (Server)
                Manage memory allocations
                Manage the transaction
              State transitions in a client LIBMI application
          Client LIBMI errors
        XA-compliant external data sources
          Overview of integrating XA-compliant data sources in transactions
            Support for the two-phase commit protocol
            XA-compliant data sources and data source types
            Infrastructure for creating support routines for XA routines
            Global transaction IDs
            System catalog tables
            Files containing necessary components
          Create user-defined XA-support routines
            The xa_open() function
            The xa_close() function
            The xa_start() function
            The xa_end() function
            The xa_prepare() function
            The xa_rollback() function
            The xa_commit() function
            The xa_recover() function
            The xa_forget() function
            The xa_complete() function
          Create and drop XA data sources and data source types
            Create an XA data source type
            Drop an XA data source type
            Create an XA data source
            Drop an XA data source
          Register and unregister XA-compliant data sources
            The ax_reg() function
            The ax_unreg() function
            The mi_xa_register_xadatasource() function
            The mi_xa_unregister_xadatasource() function
            Get the XID structure
            Get the resource manager ID
          Monitor integrated transactions
      Create user-defined routines
        Develop a user-defined routine
          Designing a UDR
            Development tools
            Uses of a C UDR
            Portability
              DataBlade API data types
              Data conversion
            Insert and update operations
          Creating UDR code
            Variable declaration
            Session management
              Session restrictions
              Transaction management
            SQL statement execution
              Set input parameters
              Retrieve column values
            Routine-state information
            Event handling
            Well-behaved routines
          Compile a C UDR
            Compile options
            Creating a shared-object file
              Creating a shared-object file for a C UDR
              Creating a shared-object file on UNIX or Linux
              Creating a shared-object file on Windows:
          Register a C UDR
            EXTEND role required to register a C UDR
            The external name
              Specify the entry point
              Environment variables
            The UDR language
            Routine modifiers
            Parameters and return values
            Access privileges to run the UDR
          Execute a UDR
            Routine resolution
            The routine manager
              Load a shared-object file
              Create the routine sequence
              Push arguments onto the thread stack
                Mechanism for passing MI_DATUM values
                Argument promotion
              Manage UDR execution
              Return the value
              Release the routine sequence
          Debug a UDR
            Attaching to the database server process with the debugger
              Create a debugging version
              Connect to the database server from a client
              Load the shared-object file for debugging
              Identify the VP process
            Running a debugging session
              Breakpoints
              Debugging hints
              Possible memory errors
              Symbols in shared-object files
            Tracing
              Adding a tracepoint in code
                Choose a trace class
                  The built-in trace class
                  Create a new trace class
                Put trace messages into code
                  The DPRINTF macro
                  Trace blocks
                Define internationalized trace messages (GLS)
              Tracing at run time
                Turn on tracing
                Specify the trace-output file
                Create a UDR to turn tracing on
              The tracing output
          Change a UDR
            Alter a routine
            Unload a shared-object file
        Write a user-defined routine
          Code a C UDR
            Define routine parameters
              Routines with no arguments
              The MI_DATUM arguments
                Pass-arguments by-reference
                Pass-by-value parameters
              The MI_FPARAM argument
            Obtain argument values
              Handling character arguments
              Handling NULL arguments
              Handling opaque-type arguments
                Handling fixed-length opaque-type arguments
                Handling varying-length opaque-type arguments
              Modify argument values
            Define a return value
              Return a value
                Return a NULL value
                Return character values
                Return opaque-type values
              Return multiple values
                An OUT parameter
                The statement-local variable
            Code the routine body
          Virtual processors
            Create a well-behaved routine
              Preserving availability of the CPU VP
                Yield the CPU VP
                Avoid blocking I/O calls
              Write threadsafe code
                Restrict memory allocation
                Avoid modification of global and static variables
                Modify the global process state
              Avoid restricted system calls
                Unsafe operating-system calls
                External-library routines
                Safe operating-system calls
              Choose the user-defined VP class
                The yielding user-defined VP
                The nonyielding user-defined VP
                The single-instance user-defined VP
              Define a user-defined VP
                Define a yielding user-defined VP class
                Define a nonyielding user-defined VP class
                Define a single-instance user-defined VP class
              Assign a C UDR to a user-defined VP class
            Manage virtual processors
          Control the VP environment
            Obtain VP-environment information
              Identify the current VP
              Identify a VP class
            Change the VP environment
              Execute on another VP
              Fork and execute a process
            Lock a UDR
              Lock a routine instance to a VP
              Lock a shared-object file in memory
          Perform input and output
            Access to a stream (Server)
              Accessing a stream in your UDR
              Generic stream I/O functions
              Using predefined stream classes
                The file stream
                The string stream
                The varying-length-data stream
              Create a user-defined stream class
                The stream-open function
                  The stream-operations structure
                  The stream data
                  The stream descriptor
                Initialization of the stream descriptor
                Support for stream access
              Register a UDR that accesses a stream
              Release stream resources
            Access to operating-system files
              Open a file
                Specify a file name
                Call the operating-system open call
                  Specify open flags
                  Specify the open mode
                Share open files
              Close a file
              Copy a file
            Sample file-access UDR
          Access the UDR execution environment
            Access the session environment
            Access the server environment
        Manage memory
          Shared memory
            Access shared memory
            Choose the memory duration
              Public memory durations
                The PER_ROUTINE memory duration
                The PER_COMMAND memory duration
                The PER_STATEMENT memory duration
                The PER_STMT_EXEC memory duration
                  Examples of using PER_STMT_EXEC memory duration
                  Uses of PER_STMT_EXEC memory duration
                The PER_STMT_PREP memory duration
              Advanced memory durations
                The PER_TRANSACTION memory duration
                The PER_SESSION memory duration
                The PER_SYSTEM memory duration
              Memory-duration considerations
                Choose memory duration
                Save the memory address
          Manage shared memory
            Manage user memory
              Allocate user memory (Server)
              Manage the memory duration
                The current memory duration
                Change the memory duration
              Deallocate user memory
            Manage named memory
              Allocate named memory
              Obtain a block of allocated named memory
              Handling concurrency issues
                Sample code that allocates a named-memory
              Deallocate named memory
            Monitor shared memory
          Manage stack space
            Manage stack usage
            Increase stack space
        Create special-purpose UDRs
          Write an end-user routine
          Write a cast function
            Registering a C UDR as a cast function
          Write an iterator function
            Implementing an iterator function with a C user-defined function
            Initialize the iterations
            Return one active-set item
            Release iteration resources
            Call an iterator function from an SQL statement
              Register the iterator function
              Execute the iterator function
          Write an aggregate function
            Extending a built-in aggregate
              Choose the operator function
              Write the operator function
              Register the overloaded operator function
              The extended aggregate
            Creating a user-defined aggregate
              Implementing a user-defined aggregate function with C user-defined functions
              Determine the aggregate state
              Write the aggregate support functions
                The INIT function
                The ITER function
                The COMBINE function
                The FINAL function
              Defining the user-defined aggregate
              The user-defined aggregate
              Determine required aggregate support functions
                Aggregate support functions that the algorithm requires
                Aggregate support functions for the aggregate state
                  Handling a simple state
                  Handling a nonsimple state
                  Using a single-valued state for a UDA
                  Manage an opaque-type state
                  Handling state management for an opaque-type state
                  Using a pointer-valued state for a UDA
                  When to allocate and deallocate a state
                Implement a setup argument
                Return an aggregate result different from the aggregate state
                Execute a user-defined aggregate in parallel queries
              Sample user-defined aggregates
                The SUMSQ user-defined aggregate
                The SQSUM2 user-defined aggregate
                The PERCENT_GTR user-defined aggregate
                The X_PERCENTILE user-defined aggregate
          Provide UDR-optimization functions
            Write selectivity and cost functions
              Query selectivity
                Creating a selectivity function
              Query cost
                Creating a cost function
              The MI_FUNCARG data type
              Obtain information about constant arguments
              Obtain information about column arguments
            implementing a negator function with a C user-defined function
            Implementing a commutator function with a C user-defined function
            Creating parallelizable UDRs
              Write the parallelizable UDR
              Register the parallelizable UDR
              Execute the parallelizable UDR
              Debug the parallelizable UDR
        Extend data types
          Create an Opaque Data Type
            Design an opaque data type
              Determine external representation
              Determine internal representation
                Determine the size of an opaque type
                  Fixed-length opaque data type
                  Varying-length opaque data type
                Specify the memory alignment of an opaque type
                Determine the passing mechanism for an opaque type
            Write opaque-type support functions
              Support functions as casts
                The input and output support functions
                  The input support function
                  The output support function
                  Conversion of opaque-type data between text and binary representations
                The send and receive support functions
                  The receive support function
                  The send support function
                  Conversion of opaque-type data with computer-specific data types
                Bulk-copy support functions
                External unload representation
                  The import support function
                  The export support function
                Internal unload representation
                  The importbin support function
                  The exportbin support function
              Stream support functions
                The streamwrite() support function
                The streamread() support function
                Convert opaque-type data between stream and binary representations
              Disk-storage support functions
                The assign() support function
                The destroy() support function
              Handling locale-specific opaque-type data (GLS)
            Registering an opaque data type
              Register an opaque type in a database
              Register opaque-type support functions
              Register the opaque-type casts
          Provide statistics data for a column
            Collect statistics data
              Design the user-defined statistics
              Define the statistics-collection function
              Collect the statistics
                SET_INIT in statcollect()
                SET_RETONE in statcollect()
                SET_END in statcollect()
              Register the statcollect() function
              Execute the UPDATE STATISTICS statement
            User-defined statistics
              Display statistics data
                Define a statistics-display function
                Create the ASCII histogram
                Register the statprint() function
              User-defined statistics in a query
          Optimize queries
            Query plans
            Selectivity functions
      Appendix
        Write a client LIBMI application
          Manage memory in client LIBMI applications
            Allocate user memory
            Deallocate user memory
          Access operating-system files in client LIBMI applications
          Handling transactions
    DataBlade API Function Reference
      Categories of DataBlade API functions
        The DataBlade API function library
          Data handling
          Session, thread, and transaction management
          SQL statement processing
          User-defined routine execution
          Selectivity and cost functions
          Memory management
          Exception handling
          Smart-large-object interface
          Input and output operations
          Tracing (Server)
          Control of the Virtual-Processor environment (Server)
          Database management (Client)
          Miscellaneous information
          Database server version information
        The ESQL/C function library
      Function descriptions
        The ax_reg() function
        The ax_unreg() function
        The biginttoint2() function
        The bigintcvint2() function
        The biginttoint4() function
        The bigintcvint4() function
        The biginttoasc() function
        The bigintcvasc() function
        The bigintcvdec() function
        The biginttodec() function
        The biginttodbl() function
        The bigintcvdbl() function
        The biginttoflt() function
        The bigintcvflt() function
        The bigintcvifx_int8() function
        The biginttoifx_int8() function
        The bycmpr() function
        The bycopy() function
        The byfill() function
        The byleng() function
        The decadd() function
        The deccmp() function
        The deccopy() function
        The deccvasc() function
        The deccvdbl() function
        The deccvint() function
        The deccvlong() function
        The decdiv() function
        The dececvt() and decfcvt() functions
        The decmul() function
        The decround() function
        The decsub() function
        The dectoasc() function
        The dectodbl() function
        The dectoint() function
        The dectolong() function
        The dectrunc() function
        The dtaddinv() function
        The dtcurrent() function
        The dtcvasc() function
        The dtcvfmtasc() function
        The dtextend() function
        The dtsub() function
        The dtsubinv() function
        The dttoasc() function
        The dttofmtasc() function
        The ifx_int8add() function
        The ifx_int8cmp() function
        The ifx_int8copy() function
        The ifx_int8cvasc() function
        The ifx_int8cvdbl() function
        The ifx_int8cvdec() function
        The ifx_int8cvflt() function
        The ifx_int8cvint() function
        The ifx_int8cvlong() function
        The ifx_int8div() function
        The ifx_int8mul() function
        The ifx_int8sub() function
        The ifx_int8toasc() function
        The ifx_int8todbl() function
        The ifx_int8todec() function
        The ifx_int8toflt() function
        The ifx_int8toint() function
        The ifx_int8tolong() function
        The incvasc() function
        The incvfmtasc() function
        The intoasc() function
        The intofmtasc() function
        The invdivdbl() function
        The invdivinv() function
        The invextend() function
        The invmuldbl() function
        The ldchar() function
        The mi_alloc() function
        The mi_binary_to_date() function
        The mi_binary_to_datetime() function
        The mi_binary_to_decimal() function
        The mi_binary_to_money() function
        The mi_binary_query() function
        The mi_call() function
        The mi_call_on_vp() function
        The mi_cast_get() function
        The mi_class_id() function
        The mi_class_maxvps() function
        The mi_class_name() function
        The mi_class_numvp() function
        The mi_client() function
        The mi_client_locale() function
        The mi_close() function
        The mi_close_statement() function
        The mi_collection_card() function
        The mi_collection_close() function
        The mi_collection_copy() function
        The mi_collection_create() function
        The mi_collection_delete() function
        The mi_collection_fetch() function
        The mi_collection_free() function
        The mi_collection_insert() function
        The mi_collection_open() function
        The mi_collection_open_with_options() function
        The mi_collection_update() function
        The mi_column_count() function
        The mi_column_default() function
        The mi_column_default_string() function
        The mi_column_id() function
        The mi_column_name() function
        The mi_column_nullable() function
        The mi_column_precision() function
        The mi_column_scale() function
        The mi_column_type_id() function
        The mi_column_typedesc() function
        The mi_command_is_finished() function
        The mi_current_command_name() function
        The mi_dalloc() function
        The mi_date_to_binary() function
        The mi_date_to_string() function
        The mi_datetime_compare() function
        The mi_datetime_to_binary() function
        The mi_datetime_to_string() function
        The mi_db_error_raise() function
        The mi_dbcreate() function
        The mi_dbdrop() function
        The mi_decimal_to_binary() function
        The mi_decimal_to_string() function
        The mi_default_callback() function
        The mi_disable_callback() function
        The mi_drop_prepared_statement() function
        The mi_enable_callback() function
        The mi_errmsg() function
        The mi_error_desc_copy() function
        The mi_error_desc_destroy() function
        The mi_error_desc_finish() function
        The mi_error_desc_is_copy() function
        The mi_error_desc_next() function
        The mi_error_level() function
        The mi_error_sql_state() function
        The mi_error_sqlcode() function
        The mi_exec() function
        The mi_exec_prepared_statement() function
        The mi_fetch_statement() function
        The mi_file_allocate() function
        The mi_file_close() function
        The mi_file_errno() function
        The mi_file_open() function
        The mi_file_read() function
        The mi_file_seek() function
        The mi_file_seek8() function
        The mi_file_sync() function
        The mi_file_tell() function
        The mi_file_tell8() function
        The mi_file_to_file() function
        The mi_file_unlink() function
        The mi_file_write() function
        The mi_fix_integer() function
        The mi_fix_smallint() function
        The mi_fp_argisnull() function
        The mi_fp_arglen() function
        The mi_fp_argprec() function
        The mi_fp_argscale() function
        The mi_fp_argtype() function
        The mi_fp_funcname() function
        The mi_fp_funcstate() function
        The mi_fp_getcolid() function
        The mi_fp_getfuncid() function
        The mi_fp_getrow() function
        The mi_fp_nargs() function
        The mi_fp_nrets() function
        The mi_fp_request() function
        The mi_fp_retlen() function
        The mi_fp_retprec() function
        The mi_fp_retscale() function
        The mi_fp_rettype() function
        The mi_fp_returnisnull() function
        The mi_fp_setargisnull() function
        The mi_fp_setarglen() function
        The mi_fp_setargprec() function
        The mi_fp_setargscale() function
        The mi_fp_setargtype() function
        The mi_fp_setcolid() function
        The mi_fp_setfuncid() function
        The mi_fp_setfuncstate() function
        The mi_fp_setisdone() function
        The mi_fp_setnargs() function
        The mi_fp_setnrets() function
        The mi_fp_setretlen() function
        The mi_fp_setretprec() function
        The mi_fp_setretscale() function
        The mi_fp_setrettype() function
        The mi_fp_setreturnisnull() function
        The mi_fp_setrow() function
        The mi_fp_usr_fparam() function
        The mi_fparam_allocate() function
        The mi_fparam_copy() function
        The mi_fparam_free() function
        The mi_fparam_get() function
        The mi_fparam_get_current() function
        The mi_free() function
        The mi_func_commutator() function
        The mi_func_desc_by_typeid() function
        The mi_func_handlesnulls() function
        The mi_func_isvariant() function
        The mi_func_negator() function
        The mi_funcarg_get_argtype() function
        The mi_funcarg_get_colno() function
        The mi_funcarg_get_constant() function
        The mi_funcarg_get_datalen() function
        The mi_funcarg_get_datatype() function
        The mi_funcarg_get_distrib() function
        The mi_funcarg_get_routine_id() function
        The mi_funcarg_get_routine_name() function
        The mi_funcarg_get_tabid() function
        The mi_funcarg_isnull() function
        The mi_get_bigint() function
        The mi_get_bytes() function
        The mi_get_connection_info() function
        The mi_get_connection_option() function
        The mi_get_connection_user_data() function
        The mi_get_cursor_table() function
        The mi_get_database_info() function
        The mi_get_date() function
        The mi_get_datetime() function
        The mi_get_db_locale() function
        The mi_get_dbnames() function
        The mi_get_decimal() function
        The mi_get_default_connection_info() function
        The mi_get_default_database_info() function
        The mi_get_double_precision() function
        The mi_get_duration_size() function
        The mi_get_id() function
        The mi_get_int8() function
        The mi_get_integer() function
        The mi_get_interval() function
        The mi_get_lo_handle() function
        The mi_get_memptr_duration() function
        The mi_get_money() function
        The mi_get_next_sysname() function
        The mi_get_parameter_info() function
        The mi_get_real() function
        The mi_get_result() function
        The mi_get_row_desc() function
        The mi_get_row_desc_from_type_desc() function
        The mi_get_row_desc_without_row() function
        The mi_get_serverenv() function
        The mi_get_session_connection() function
        The mi_get_smallint() function
        The mi_get_statement_row_desc() function
        The mi_get_string() function
        The mi_get_type_source_type() function
        The mi_get_transaction_id() function
        The mi_get_vardata() function
        The mi_get_vardata_align() function
        The mi_get_varlen() function
        The mi_hdr_status() function
        The mi_init_library() function
        The mi_interrupt_check() function
        The mi_interval_compare() function
        The mi_interval_to_string() function
        The mi_issmall_data() function
        The mi_last_serial() function
        The mi_last_serial8() function
        The mi_library_version() function
        The mi_lo_alter() function
        The mi_lo_close() function
        The mi_lo_colinfo_by_ids() function
        The mi_lo_colinfo_by_name() function
        The mi_lo_copy() function
        The mi_lo_create() function
        The mi_lo_decrefcount() function
        The mi_lo_delete_immediate() function
        The mi_lo_expand() function
        The mi_lo_filename() function
        The mi_lo_from_buffer() function
        The mi_lo_from_file() function
        The mi_lo_from_file_by_lofd() function
        The mi_lo_from_string() function
        The mi_lo_increfcount() function
        The mi_lo_invalidate() function
        The mi_lo_lock() function
        The mi_lo_lolist_create() function
        The mi_lo_open() function
        The mi_lo_ptr_cmp() function
        The mi_lo_read() function
        The mi_lo_readwithseek() function
        The mi_lo_release() function
        The mi_lo_seek() function
        The mi_lo_spec_free() function
        The mi_lo_spec_init() function
        The mi_lo_specget_def_open_flags() function
        The mi_lo_specget_estbytes() function
        The mi_lo_specget_extsz() function
        The mi_lo_specget_flags() function
        The mi_lo_specget_maxbytes() function
        The mi_lo_specget_sbspace() function
        The mi_lo_specset_def_open_flags() function
        The mi_lo_specset_estbytes() function
        The mi_lo_specset_extsz() function
        The mi_lo_specset_flags() function
        The mi_lo_specset_maxbytes() function
        The mi_lo_specset_sbspace() function
        The mi_lo_stat() function
        The mi_lo_stat_atime() function
        The mi_lo_stat_cspec() function
        The mi_lo_stat_ctime() function
        The mi_lo_stat_free() function
        The mi_lo_stat_mtime_sec() function
        The mi_lo_stat_mtime_usec() function
        The mi_lo_stat_refcnt() function
        The mi_lo_stat_size() function
        The mi_lo_stat_uid() function
        The mi_lo_tell() function
        The mi_lo_to_buffer() function
        The mi_lo_to_file() function
        The mi_lo_to_string() function
        The mi_lo_truncate() function
        The mi_lo_unlock() function
        The mi_lo_utimes() function
        The mi_lo_validate() function
        The mi_lo_write() function
        The mi_lo_writewithseek() function
        The mi_lock_memory() function
        The mi_lvarchar_to_string() function
        The mi_module_lock() function
        The mi_money_to_binary() function
        The mi_money_to_string() function
        The mi_named_alloc() function
        The mi_named_free() function
        The mi_named_get() function
        The mi_named_zalloc() function
        The mi_new_var() function
        The mi_next_row() function
        The mi_open() function
        The mi_open_prepared_statement() function
        The mi_parameter_count() function
        The mi_parameter_nullable() function
        The mi_parameter_precision() function
        The mi_parameter_scale() function
        The mi_parameter_type_id() function
        The mi_parameter_type_name() function
        The mi_prepare() function
        The mi_process_exec() function
        The mi_put_bigint() function
        The mi_put_bytes() function
        The mi_put_date() function
        The mi_put_datetime() function
        The mi_put_decimal() function
        The mi_put_double_precision() function
        The mi_put_int8() function
        The mi_put_integer() function
        The mi_put_interval() function
        The mi_put_lo_handle() function
        The mi_put_money() function
        The mi_put_real() function
        The mi_put_smallint() function
        The mi_put_string() function
        The mi_query_finish() function
        The mi_query_interrupt() function
        The mi_realloc() function
        The mi_register_callback() function
        The mi_result_command_name() function
        The mi_result_reference() function
        The mi_result_row_count() function
        The mi_retrieve_callback() function
        The mi_routine_end() function
        The mi_routine_exec() function
        The mi_routine_get() function
        The mi_routine_get_by_typeid() function
        The mi_routine_id_get() function
        The mi_row_create() function
        The mi_row_desc_create() function
        The mi_row_desc_free() function
        The mi_row_free() function
        The mi_save_set_count() function
        The mi_save_set_create() function
        The mi_save_set_delete() function
        The mi_save_set_destroy() function
        The mi_save_set_get_first() function
        The mi_save_set_get_last() function
        The mi_save_set_get_next() function
        The mi_save_set_get_previous() function
        The mi_save_set_insert() function
        The mi_save_set_member() function
        The mi_server_connect() function
        The mi_server_library_version() function
        The mi_server_reconnect() function
        The mi_set_connection_user_data() function
        The mi_set_default_connection_info() function
        The mi_set_default_database_info() function
        The mi_set_large() function
        The mi_set_parameter_info() function
        The mi_set_vardata() function
        The mi_set_vardata_align() function
        The mi_set_varlen() function
        The mi_set_varptr() function
        The mi_stack_limit() function
        The mi_statement_command_name() function
        The mi_stream_clear_eof() function
        The mi_stream_close() function
        The mi_stream_eof() function
        The mi_stream_get_error() function
        The mi_stream_getpos() function
        The mi_stream_init() function
        The mi_stream_length() function
        The mi_stream_open_fio() function
        The mi_stream_open_mi_lvarchar() function
        The mi_stream_open_str() function
        The mi_stream_read() function
        The mi_stream_seek() function
        The mi_stream_set_eof() function
        The mi_stream_set_error() function
        The mi_stream_setpos() function
        The mi_stream_tell() function
        The mi_stream_write() function
        The mi_streamread_boolean() function
        The mi_streamread_collection() function
        The mi_streamread_date() function
        The mi_streamread_datetime() function
        The mi_streamread_decimal() function
        The mi_streamread_double() function
        The mi_streamread_int8() function
        The mi_streamread_integer() function
        The mi_streamread_interval() function
        The mi_streamread_lo() function
        The mi_streamread_lo_by_lofd() function
        The mi_streamread_lvarchar() function
        The mi_streamread_money() function
        The mi_streamread_real() function
        The mi_streamread_row() function
        The mi_streamread_smallint() function
        The mi_streamread_string() function
        The mi_streamwrite_boolean() function
        The mi_streamwrite_collection() function
        The mi_streamwrite_date() function
        The mi_streamwrite_datetime() function
        The mi_streamwrite_decimal() function
        The mi_streamwrite_double() function
        The mi_streamwrite_int8() function
        The mi_streamwrite_integer() function
        The mi_streamwrite_interval() function
        The mi_streamwrite_lo() function
        The mi_streamwrite_lvarchar() function
        The mi_streamwrite_money() function
        The mi_streamwrite_real() function
        The mi_streamwrite_row() function
        The mi_streamwrite_smallint() function
        The mi_streamwrite_string() function
        The mi_string_to_date() function
        The mi_string_to_datetime() function
        The mi_string_to_decimal() function
        The mi_string_to_interval() function
        The mi_string_to_lvarchar() function
        The mi_string_to_money() function
        The mi_switch_mem_duration() function
        The mi_sysname() function
        The mi_system() function
        The mi_td_cast_get() function
        The mi_tracefile_set() function
        The mi_tracelevel_set() function
        The mi_transaction_state() function (Server)
        The mi_transition_type() function
        The mi_trigger_event() function
        The mi_trigger_get_new_row() function
        The mi_trigger_get_old_row() function
        The mi_trigger_level() function
        The mi_trigger_name() function
        The mi_trigger_tabname() function
        The mi_try_lock_memory() function
        The mi_type_align() function
        The mi_type_byvalue() function
        The mi_type_constructor_typedesc() function
        The mi_type_element_typedesc() function
        The mi_type_full_name() function
        The mi_type_length() function
        The mi_type_maxlength() function
        The mi_type_owner() function
        The mi_type_precision() function
        The mi_type_qualifier() function
        The mi_type_scale() function
        The mi_type_typedesc() function
        The mi_type_typename() function
        The mi_typedesc_typeid() function
        The mi_typeid_equals() function
        The mi_typeid_is_builtin() function
        The mi_typeid_is_collection() function
        The mi_typeid_is_complex() function
        The mi_typeid_is_distinct() function
        The mi_typeid_is_list() function
        The mi_typeid_is_multiset() function
        The mi_typeid_is_row() function
        The mi_typeid_is_set() function
        The mi_typename_to_id() function
        The mi_typename_to_typedesc() function
        The mi_typestring_to_id() function
        The mi_typestring_to_typedesc() function
        The mi_udr_lock() function
        The mi_unlock_memory() function
        The mi_unregister_callback() function
        The mi_value() function
        The mi_value_by_name() function
        The mi_var_copy() function
        The mi_var_free() function
        The mi_var_to_buffer() function
        The mi_version_comparison() function
        The mi_vpinfo_classid() function
        The mi_vpinfo_isnoyield() function
        The mi_vpinfo_vpid() function
        The mi_xa_get_current_xid() function
        The mi_xa_get_xadatasource_rmid() function
        The mi_xa_register_xadatasource() function
        The mi_xa_unregister_xadatasource() function
        The mi_yield() function
        The mi_zalloc() function
        The rdatestr() function
        The rdayofweek() function
        The rdefmtdate() function
        The rdownshift() function
        The rfmtdate() function
        The rfmtdec() function
        The rfmtdouble() function
        The rfmtlong() function
        The rjulmdy() function
        The rleapyear() function
        The rmdyjul() function
        The rstod() function
        The rstoi() function
        The rstol() function
        The rstrdate() function
        The rtoday() function
        The rupshift() function
        The stcat() function
        The stchar() function
        The stcmpr() function
        The stcopy() function
        The stleng() function
    DataBlade Developers Kit
      DataBlade Module Development Overview
        DataBlade module concepts
          What are DataBlade modules?
            Why extend your Informix database server?
              Better performance
              Simpler applications
              Transaction control
              Scalability
            Why create a DataBlade module?
            Why use the DataBlade Developers Kit?
          DataBlade modules and the database server
            DataBlade module programming languages
              C language
              C++ language
              Java language
              Informix Stored Procedure Language
            Internal architecture of the database server
              DataBlade modules and virtual processors
              DataBlade module memory allocation
              Java virtual machine
            HCL Informix Client Software Development Kit
            Client objects and programs
          DataBlade module components
            Aggregates
            Data types
              Built-in data types
              Qualified built-in data types
              Distinct data types
              Collection data types
              Row data types
              Opaque data types
                Opaque data type support routines
            Routines
              Built-in functions and operator functions
              User-defined routines
            Casts
            Interfaces
            Errors
            Unit tests
            Functional tests
            Imported SQL files
            Imported client files
        Build a DataBlade module
          DataBlade Developers Kit tools
            BladeSmith
            BladePack
            BladeManager
            DBDK Visual C++ Add-In and IfxQuery
          How to create a DataBlade module
          DataBlade module development resources
            The DataBlade Developers Kit Tutorial
            Example DataBlade modules
        Appendixes
          DataBlade module documentation
            Publication overview
            Title-to-topic reference
            Topic-to-title reference
          Informix DataBlade modules
            IBM Informix Excalibur Text Search DataBlade Module
              Extensions to Informix
            IBM Informix Web DataBlade Module
              Extensions to Informix
      DataBlade Developers Kit User's Guide
        Getting started with DataBlade module development
          What is a DataBlade module?
          Informix DataBlade Developers Kit (DBDK) tools
          Prepare to develop DataBlade modules
            Become familiar with HCL Informix software and documentation
              Software requirements for DataBlade module development
              DataBlade Developers Kit Tutorial
              Create a practice DataBlade module
            Design your DataBlade module
              Write a functional specification
              Programming resources
              Write a design specification
              Create an iterative development plan
          Develop your DataBlade module
            Edit and compile DataBlade module code
            Debug your DataBlade module
            Package your DataBlade module
        Design DataBlade modules
          Data model
          Data type design
            Object accessibility
            Handling large objects
          Query language interface
            SQL query structure
            The target list
            The qualification
          Query processing
            Predicate evaluation
              Expensive routines
              User-defined statistics
              Aggregates
              Sort the results
            Grouping
            Casts
            Access path selection
              Unordered row processing
              Secondary access methods
            Plan for transaction semantics
          Interoperability
            Orthogonality
            Simple, clean interfaces
              Name your routines
              Take advantage of polymorphism
              Limit the number of arguments
              Avoid modal routines
        Programming guidelines
          Programming language options
            Options for opaque data types
              ActiveX value objects
              Combined languages in server and client implementations
              Limitations of opaque types for each language
              Embed opaque data types within opaque data types
            Options for routines
              Overload routines in different languages
              Handling opaque data types implemented in a different language
            Multilanguage DataBlade module issues
          C programming guidelines
          C++ programming guidelines
          Java programming guidelines
          DataBlade API programming guidelines
        Create DataBlade objects by using BladeSmith
          Prerequisite tasks
          Task overview
          BladeSmith project window
          Create a project
            DataBlade module project name
            New object prefix
            Server compatibility
            Description locale
            Project version numbers
            Vendor information
          Importing interfaces from another DataBlade module
          Create DataBlade module objects
            Database object name lengths
            Create aggregates
              Properties of aggregates
            Create casts
              Source and target data types
              Implicit and explicit casts
              Cast support functions
            Define errors
              SQL error code
              Error locale
              SQL error text
            Create interfaces
            Create routines
              Routine name
              Statement local variables
              Routine arguments
              Variant functions
              Parallelizable routines
              C routine name
              Routine behavior
              User-defined virtual processor class name
              Stack size
              Cost of routine
              Related functions
                Commutator and negator functions
                Selectivity functions
            Create data types
              Collection data type
                Properties of collection data types
              Distinct data type
              Opaque data type
                Opaque data type name lengths
                Server implementation
                Client implementation
                Accessor methods
                Definition of internal structure
                Fixed or variable size
                Member information
                Maximum size
                Memory alignment
                Support routines
                  Basic text input and output
                  Binary send and receive
                  Text import and export
                  Binary file import and export
                  Contains large objects (not available for C++)
                  Type insert and delete notification (not available for C++)
                  Type compare support
                  B-tree indexing support
                  R-tree indexing support
                  Type mathematic operators
                  More mathematic operators
                  Type concatenation operator
                  Type hash support
                  Statistics support (not available for C++ or Java)
              Qualified data type
              Row data type
                Properties of row data types
          Perform functional test data
            Test data for opaque type support routines
            Test data for user-defined routines
            Test data for cast support routines
          Add SQL files
            Import SQL text from a file
            Object dependencies
          Add client files
          Generate files
            Set generated file properties
              Changing a property of a generated file category
            Generating all files
            Generate SQL scripts
            Generate source files
            Generate test files
            Generate installation package files
            Regenerate files
              Merge changes in source code and unit test files
              Replace Visual C++ project, SQL, functional test, and installation files
            Opening the project file in Visual C++
        Programming DataBlade module routines in C
          Prerequisite tasks
          C programming task overview
          Source files generated by BladeSmith
            C header file
            C source code files
            Microsoft Visual C++ files
            Warning file
          Generated code
            Identify the source of generated code
            Comments in generated code
            The MI_FPARAM function argument
            Server connection handle
            Tracing and error handling
              How tracing works
              Add tracing and error handling
                The DBDK_TRACE_MSG() and DBDK_TRACE_ERROR() macros
                The DBDK_TRACE_ENTER() and DBDK_TRACE_EXIT() macros
              Enabling tracing in a DataBlade module
                Create a trace class
                Create the TraceSet_project() procedure
                  Syntax for the TraceSet_project() procedure
              Enabling tracing in a database session
                Set your locale
                Register tracing routines
                Set a trace output file and a trace threshold
              Standard error messages
            Utility functions generated by BladeSmith
              The Gen_sscanf() utility function
              The Gen_IsMMXMachine() utility function
          Edit opaque type support routines in opaque.c
            Text input and output functions
            Binary send and receive functions
            Text file import and export functions
            Binary file import and export functions
            The assign and destroy routines
            The LOhandles() function
            Comparison functions
              Compare function
              B-Tree Comparison Functions
              R-tree comparison functions
            Mathematical functions
            The Concat() Function
            Hash() Function
          Edit statistics routines in statistics.c
            The statistics collection function
            The statistics print function
            The statistics minimum, maximum, and distribution functions
          Edit routines in udr.c
            Most user-defined routines
            Cast support functions
            Aggregate functions
            Selectivity functions
            Iterator functions
          Compile DataBlade module code
            Compile with tracing support
            Compiling on a UNIX operating system
              Unresolved symbols (HCL Informix 9.14)
              Compile with debug support
            Compiling on a Windows operating system
        Create ActiveX value objects
          Prerequisite tasks
          ActiveX programming task overview
          Source files generated by BladeSmith
          Implement ActiveX value objects
            The generated code
            Add project-specific logic to the source code
            Files to edit
            ActiveX properties
            Access properties by using Visual Basic
          Compile client and server projects
            Compiling a Windows server project
            Compiling a client project
              Setting the include files and library file directories
              Compiling a Windows client project
          Support methods reference
            Internal object methods
            C++ support library
              The DkInStream class
              The DkOutStream class
              Memory management routines
        The ActiveX value objects
          Install and use ActiveX value objects
            Install ActiveX value objects
              Creating a reference to an ActiveX project
            ActiveX Value Objects
          The IRawObjectAccess custom interface
            Instantiating the ActiveX value object
          The ITDkValue custom interface
          ActiveX custom methods
        Programming DataBlade modules in Java
          Prerequisite tasks
          Java programming task overview
          Source files generated by BladeSmith
            Java source code files
            The SQLData interface method support code
            Warning file
          The generated code
            Comments in generated code
            Logging and error handling
            BladeSmith utility classes
          Edit methods
            Most user-defined methods
            Iterators
            Aggregates
            Cast support methods
          Compiling DataBlade module Java code
          Debug and test DataBlade Modules written in Java
            Preparing your environment
            Debugging a DataBlade module
              Installing a DataBlade module
              Register a DataBlade module
              Replace a DataBlade module JAR file
            Perform functional tests
        Debugging and testing DataBlade modules on UNIX
          Prerequisite tasks
          Prepare your environment on UNIX
          The shared object file
            Replace a shared object file
            Shared object file ownership and permissions
            Symbols in shared object files
          Install and register DataBlade modules
            Installing a DataBlade module
            Register a DataBlade module
          Debugging a DataBlade module
            Load the DataBlade module
            Identify the server process
            Run the Solaris debugger
            Set breakpoints
          Debugging a UNIX DataBlade module with Windows
          Performing functional tests
            Functional test overview
              Contents of the functional test directory
              Add custom test files
            Execute functional tests
              The functional test scripts
              Initialize reference files
        Debugging and testing DataBlade modules on Windows
          Prerequisite tasks
          Prepare your environment
          The DBDK Visual C++ Add-In and IfxQuery
            The Debug DataBlade Module command
            Other add-in commands
          Debugging a DataBlade module
            Manually loading the Add-In
            Specify properties for a project
            Setting breakpoints
            Edit unit test files
          Performing functional tests on DataBlade modules
        BladePack
          Prerequisite tasks
          BladePack overview
            BladePack projects
            BladePack online help
            BladePack windows
              Project view
                Files/Directories tab
                Components tab
                Customization tab
              Item view
            Registry keys for Windows
          Packaging for UNIX installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory
              Files and directories to be installed or deleted
                Local paths for files for multiple operating systems
                Specify a target directory
            Manage components
              Creating a component
              Creating a subcomponent
              Creating and copying a shared component
              Component properties
              Assigning items to components
            Customizing the installation
              Adding a custom program
              Adding a readme file
            Build the installation
              Installation type
            Create distribution media
          Packaging for InstallShield 3.1 installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory or change to the registry
              Files and directories to be installed or deleted
                Local paths for files for multiple operating systems
                Specify a target directory
                File sharing options
              Adding registry changes
            Manage components
              Creating a component
              Creating a subcomponent
              Creating and copying a shared component
              Component properties
              Assigning items to components
            Customize the installation
              Adding custom extensions
                Adding a custom routine, dialog box, or program
                Adding a readme file
            Build the installation
              Installation type
              Installation screen display text
            Create distribution media
          Packaging for InstallShield 5.1 installations
            Building an installation package with BladePack
            Establish content
              Adding a file or directory or a change to the registry
              Files and directories to be installed
                Local paths for files for multiple operating systems
                Specify a target directory
              Adding registry changes
            Manage components
              Creating a component
              Creating a subcomponent
              Component properties
              Assigning to components
            Customize the Installation
              Adding a readme file
            Build the installation
              Installation type
              Installation screen display text
            Create distribution media
        Appendixes
          Source files generated for DataBlade modules
            C source code files
            ActiveX/C++ source code files
              Client project files
                Support library files
                Project files
              Client files
              Common files
                Support library files
                Object files
              Server project files
              Server files
            Java source code files
            SQL script files
            Unit test files
            Functional test files
              Casting function tests
              Opaque data type support routines tests
              User-defined routine tests
            Installation packaging files
            Alphabetical list of generated files
          Complete BladeSmith-generated code
            Opaque data type support routines in C
            User-defined routines in C
            Opaque data type support routines in C++
            User-defined routines in Java
          Test for an sbspace
            Adding SYSBldTstSBSpace() to your registration script
      DBDK InfoShelf
        Example descriptions
        DataBlade Developers Kit Tutorial
          Tutorial exercise 1: Creating a simple user-defined routine
            Using BladeSmith to create the AddInts DataBlade module project
            Using BladeSmith to create the AddIntegers() function
            Using BladeSmith to generate the AddInts DataBlade module and open the project file in Visual C++
            Assigning a database server and a test database to the project
            Adding code for the AddInts() function to the code generated by BladeSmith
            Building the DataBlade module
            Setting a breakpoint for the AddInts() function
            Editing the AddInts.sql unit test file.
            Debugging the AddInts() function
          Tutorial exercise 2: Creating distinct data types and casts
            Casts
            DataBlade module objects
            Creating a project for the Mercury DataBlade module
            Creating the temperature distinct data type
            Creating the CTemp and FTemp data types
            Creating the user-defined routines
            Creating the decimal to temperature cast
            Creating the integer to temperature, CTemp to FTemp, and FTemp to CTemp casts
            Creating the error message raised if a user enters a temperature lower than absolute zero
            Generating the Mercury DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding your source code to the code generated by BladeSmith
            Building the DataBlade module
            Editing the Setup.sql unit test file
            Running the Mercury DataBlade module
          Tutorial exercise 3: Creating row data types
            Creating a project the RowCircle DataBlade module
            Creating the rciPoint data type
            Creating the rciDistance() function
            Creating the rciCircle data type
            Creating the rciContains() routine
            Generating the RowCircle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding source code to the templates generated by BladeSmith
            Building the DataBlade module
            Editing the rciContains.sql unit test file
            Running the RowCircle DataBlade module
          Tutorial exercise 4: Creating opaque data types
            Creating a project for the Circle DataBlade module
            Creating the Pnt data type
            Creating the Circ data type
            Creating the Distance() function
            Creating the Contains() function
            Generating the Circle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Adding your source code to the code generated by BladeSmith
            Building the DataBlade module
            Editing the Contains.sql unit test file
            Running the Circle DataBlade module
          Tutorial exercise 5: Using interfaces
            Creating the Point DataBlade module
            Creating the Point data type in the Point DataBlade module
            Creating the Distance() function in the Point DataBlade module
            Creating the Point interface in the Point DataBlade module
            Creating the project for the Circle DataBlade module
            Importing the Point data type and IPoint interface
            Creating the Circle data type in the Circle DataBlade module
            Creating the Contains() function in the Circle DataBlade module
            Generating the Point and Circle DataBlade modules and open the Point project in Visual C++
            Assigning a database server and a test database to the Point project
            Adding source code to the Point DataBlade module udr.c file
            Opening the Circle project and assign a local database server and a test database to it
            Adding source code to the Circle DataBlade module udr.c file
            Building the DataBlade modules
            Editing the Contains.sql unit test file
            Installing and registering the Point DataBlade module
            Running the Circle DataBlade module
          Tutorial exercise 6: Using smart large objects
            Creating a Poem project
            Creating the Poem data type
            Add custom SQL to test for an sbspace
            Generating the Circle DataBlade module and open the project in Visual C++
            Assigning a local database server and a test database to the project
            Modifying the source code
            Building the DataBlade module
            Installing the Poem DataBlade module
            Copying the XML files to the Poem.0 project directory.
            Editing the Poem.sql unit test file
            Running the Poem DataBlade module
          Glossary
            BladeSmith
            BladeManager
            Makefiles
            SQL scripts
            Registration
            Special stack requirements
            MI_FPARAM argument
            boolean
            double precision
            Buffered log
            cast support function
            SQL error code
            Behavior of routines
            ESQL/C conversion function
            implicit type conversion
            mi_lvarchar data type
            Text input and output functions
            Binary send and receive functions
            Binary file import and export functions
            Text file import and export functions
            Contains large objects routines
            Type compare functions
            MI_LO_HANDLE data type
            Cost of a routine
            Generating code
            Assign() functions
            Client implementation
            fixed size
            Internal structure
            Server Implementation
            Support routines
            Routine calling options
            Related routines
            Statement local variables
            Locale
            BladePack
            Opaque data types
            Row data types
            Server compatibility
            Building a DataBlade module
            Inheritance
            Distinct data types
            Casts
            Explicit cast
            mi_db_error_raise() function
            New object prefix
            mi_fp_setreturnisnull() function
            An sbspace
            Smart large objects
            Custom SQL file
            Objects dependent on SQL
            Impedance
            Pythagorean formula
            Wrapper function
            EXECUTE FUNCTION SYSBldTstSBSpace(" "); statement
            Registration failure with an sbspace test
            Object grant privileges
            Assigning a database server and test database to a project
            Debug DataBlade module
            Unit test files
            Installing the DBDK Visual C++ Add-In
            IfxQuery tool
            mi_integer data type
            Routine name
            Routine signature
            mercury.txt file
            udr.c routine
            CTempAssign.c routine
            CTempCast.c routine
            DecToTemp.c routine
            FTempAssign.c routine
            FTempCast.c routine
            IntToTempCast.c routine
            rowcircle.txt file with information for creating tables and rows
            Pnt.c source code file
            Circ.c source code file
            circle.txt file with information for creating tables and rows
            interface.txt file with information for creating a table with a circle column
            Poem.c generated source file
            poem.txt file with information for creating a table with a poem column
    J/Foundation Developer's Guide
      Concepts
        Features of Java user-defined routines
        Java virtual processors
        System catalog tables
      Prepare for Java support
        Configure Java support
          Create an sbspace
          Creating the JVP properties file
          Set configuration parameters
          Set environment variables
          GLS support
            NEWLOCALE and NEWCODESET connection properties
            DBCENTURY environment variable
      Configuration parameters
        JVPARGS configuration parameter
        JVPCLASSPATH configuration parameter
        JVPHOME configuration parameter
        JVPJAVAHOME configuration parameter
        JVPJAVALIB configuration parameter
        JVPJAVAVM configuration parameter
        JVPLOGFILE configuration parameter
        JVPPROPFILE configuration parameter
        SBSPACENAME configuration parameter
      Create Java user-defined routines
        Java user-defined routines
        Limitations for Java UDRs
        Creating a Java user-defined routine in the server
        Packages for Java user-defined routines
          The com.informix.udr package
          The com.informix.udr.UDRManager
          The com.informix.udr.UDREnv
          The com.informix.udr.UDRLog
          The com.informix.udr.UDRTraceable
        Creating UDT-to-Java mappings
        Registering Java user-defined routines
          Specify the JVP
          Routine modifiers
          Specify the external name
        A deployment descriptor
        A manifest file
        Compiling the Java code
        Install a JAR file
        Update JAR file names
        Execute the user-defined routine
        Debugging and tracing
          Generate log messages
          The administrative tool
          Debugging a Java user-defined routine
          Traceable events
        Find information about user-defined routines
        Comply with SQLJ
          Unsupported modifiers
          Unsupported optional modifiers
      The Informix JDBC Driver
        Public JDBC interfaces
        The informix-direct subprotocol
        An example that shows query results
      Opaque user-defined data types
        Using the SQLData interface
          Default input/output routines
          SQL definitions for default I/O user-defined routines
          Informix extensions to SQLInput and SQLOutput
            IfmxUDTSQLInput
            IfmxUDTSQLOutput
          The circle class example
        Override the default I/O methods
          I/O function sets and related types
            IfxDataPointer
            Stream implementations
          An example that overrides the default I/O methods
            Usage example
              Variable-length UDT including nondefault input and output methods
              SQL definitions for a variable-length UDT example
        Limitations to streams
    R-Tree Index User's Guide
      What's new in HCL Informix R-Tree Index User's Guide, Version 12.10
      R-tree secondary access method concepts
        About access methods
        The R-tree secondary access method
          R-tree index structure
            Bounding boxes
            Bounding-box-only R-tree indexes
            Hierarchical index structure
          Search with an R-tree index
          Nearest-neighbor searching
          Insertion into an R-tree index
          R-link trees and concurrency
        About operator classes
        R-tree functionality that HCL Informix provides
          R-tree functionality in HCL Informix
          R-tree secondary access method extension
            Additional R-tree components
            Registration
      The R-tree secondary access method
        Before you begin
        Create R-tree indexes
          Syntax
          R-tree index parameters
          Bottom-up building of R-tree indexes
          Using the NO_SORT index parameter
          R-tree index options
            The FRAGMENT clause
            The IN clause
          Examples of creating R-tree indexes
        When does the query optimizer use an R-tree index?
          Complex qualifications
        R-tree indexes and null values
          How an R-tree index internally handles null values
          How strategy functions handle null values
        Perform nearest-neighbor searches
          Limitations
        Database isolation levels and R-tree indexes
        Functional R-tree indexes
      Develop DataBlade modules that use the R-tree secondary access method
        Overview of DataBlade module development
        Decide whether to use the R-tree access method
        Design a user-defined data type
          Data objects and bounding boxes
            Operations on data objects
            Operations on bounding boxes
            Internal C structure for the user-defined data type
          Implementing data type hierarchy
            Example data type hierarchy
            Strategy functions in a data type hierarchy
            Union support function in a data type hierarchy
          Maximum size of the user-defined data type
          Loose bounding box calculations
          Other user-defined data type design considerations
        Creating a new operator class
          Support functions
            Internal uses of the support functions
            The Union function
            The Size function
              Size calculation of a bounding box
            The Inter function
            The RtreeInfo function
              Arguments of the RtreeInfo support function
              SQL definition of the RtreeInfo support function
              C code example for the RtreeInfo support function
            The SFCbits function
            The ObjectLength function
            The SFCvalue function
            The SetUnion function
            Implicit casts
            Example of creating a support function
          Strategy functions
            Internal uses of the strategy functions
              Searches
              Deletes and updates
            The Overlap function
            The Equal function
            The Contains function
            The Within function
            Other strategy functions
            Example of creating a strategy function
          Selectivity and cost functions
          Syntax for creating a new operator class
        Set up nearest-neighbor searching
          Set up a strategy function for nearest-neighbor searching
            The distance-measuring function
            Distance function: Bounding boxes
            Set RtreeInfo to indicate nearest-neighbor functions
        Create registration scripts for dependent DataBlade modules
          Importing the ifxrltree interface object
        Repairing R-tree indexes after migrating to a different version of a DataBlade module
      Manage databases that use the R-tree secondary access method
        Performance tips
          Update statistics
          Deletions
          Effectiveness of bounding box representation
          Clustering spatial data on the disk
        Return the coordinates of the root bounding box
          Syntax
          Example
        Estimate the size of an R-tree index
          Calculating index size based on number of rows
          Calculate index size using the oncheck utility
        R-tree index and logging
          Description of the R-tree-specific logical-log records
            Logical-log records of insertions of items into a leaf page
            Logical-log records of deletions of items from a leaf page
          Using the onlog utility to view R-tree logical-log records
        Cannot rename databases that use the secondary access method
        Drop R-tree indexes before truncating a table
        System catalogs
          The sysams system catalog
          The sysopclasses system catalog
          The sysindices system catalog
        Check R-tree indexes with the oncheck utility
          Check pages with the -ci and -cI options
          Check pages with the -pT option
          Check pages with the -pk and -pK options
          Check pages with the -pl and -pL options
          Other options with -u
      Appendix
        Shapes3 sample DataBlade module
          Description of the sample DataBlade module
            Data types
            Operators
            Operator class
          Sample C code
            The shape.h header file
            Overlap strategy function
            Equal strategy function
            Contains strategy function
            Within strategy function
            Union support function
            Size support function
            Inter support function
            SFCbits support function
            ObjectLength support function
            SFCValue support function
            SetUnion support function
    User-Defined Routines and Data Types Developer's Guide
      Extend the database server
        Create user-defined routines
        Extend built-in data types
        Extend operators
        Build opaque data types
        Extend operator classes
        Routine management
      A user-defined routine
        User-defined routines
          SPL routines
          External-language routines
          Information about user-defined routines
        Tasks that you can perform with user-defined routines
          Extend data type support
          Support user-defined data types
            Cast functions
              Cast between built-in data types
              Cast between other data types
            End-user routines
            Aggregate functions
            Operator functions
              Operators on built-in data types
              Operators on user-defined data types
            Operator-class functions
              Operator-class functions on built-in data types
              Operator classes on user-defined data types
            Optimization functions
            Opaque data type support functions
            Access-method purpose functions
          Create an end-user routine
            Encapsulate multiple SQL statements
            Create triggered actions
            Restrict access to a table (SPL)
            Create iterators
          Invoke a user-defined routine
            Explicit invocation
            Implicit invocation
      Run a user-defined routine
        Invoke a UDR in an SQL statement
          Invoke a UDR with an EXECUTE statement
            Invoke a function
            A SELECT statement in a function argument
            Invoke a procedure
          Invoke a user-defined function in an expression
          Invoke a function that is bound to an operator
          Named parameters and UDRs
        Invoke a UDR in an SPL routine
        Execute a user-defined routine
          Parse the SQL statement
          Optimize the SQL statement
          Execute a UDR across databases of the same database server instance
          Execute the routine
            Execute an SPL routine
            Execute an external language routine
              Load an executable code into memory
              Create the routine sequence
              Manage routine execution
        Understanding routine resolution
          The routine signature
            ANSI and non-ANSI routine signatures
            The routine signature to perform DBA tasks
          Routine overloading
            Create overloaded routines
            Assign a specific routine name
            Specify overloaded routines during invocation
            Overload built-in SQL functions
          The routine-resolution process
            The routine signature
            Candidate list of routines
            Precedence list of data types
            Precedence list for built-in data types
          Routine resolution with user-defined data types
            Routine resolution in a type hierarchy
            Routine resolution with distinct data types
              Routine resolution with two different distinct data types
              Alternate SELECT statements for different distinct data types
            Routine resolution with built-in data types as source
            Routine resolution with collection data types
          Null arguments in overloaded routines
      Develop a user-defined routine
        Plan the routine
          Name the routine
          Define routine parameters
            Number of arguments
            Declare routine parameters
          Return values
            Return a variant or nonvariant value
            OUT parameters and statement-local variables (SLVs)
              Statement-local variables (SLVs)
              SPL procedures with no return values
            The INOUT parameters
          Name return parameters
          An iterator function
            Create an iterator function
            Register an iterator function
            Invoke an iterator function
            An iterator function in the FROM clause of a SELECT statement
              Syntax and usage
              Allocate memory
              Run parallel queries
              Restrictions
              Example SPL iterator function
              Example C iterator function
              Example Java iterator function
          Adhere to coding standards
        Write the routine
          Create a user-defined interface for XA data sources
        Registering a user-defined routine
          Privileges required to create a routine
            Database-level privileges needed for creating a routine
            Language-level privileges needed for creating
            Routine-level privilege
          Create an SPL routine
          Create an external-language routine
            Register a routine written in C
            Register a routine written in Java
            Register an external routine with modifiers
              Modifiers in a C UDR
              Modifiers in a Java UDR
            Register parameters and a return value
          Review information about user-defined routines
        A UDR with HDR
      Extend data types
        Understanding the data type system
        Understanding data types
          Built-in data types
          Extended data types
            Complex data types
            User-defined data types
              Distinct data type
              Opaque data type
            HCL Informix DataBlade modules
        Extend the data type system
          Operations
          Casts
          Operator classes
            Provide additional operator classes
            Extend operator classes
          Optimizer information
      Extend operators and built-in functions
        Operators and operator functions
          Arithmetic operators
          Text operators
          Relational operators
          Overload an operator function
        Built-in functions
          Built-in functions that you can overload
          Built-in functions that you cannot overload
          Overload a built-in function
      Create user-defined casts
        Understanding casts
          Built-in casts
          User-defined casts
            Opaque data types
            Distinct data types
            Named row types
          Casts that you cannot create
        Create a user-defined cast
          Choose the kind of user-defined cast
            Implicit cast
            Explicit cast
          Choose the cast mechanism
            Straight cast
            Creating a cast that has a cast function
            Example of a cast function
          Define the direction of the cast
        Drop a cast
      Create user-defined aggregates
        Extend existing aggregates
          Overload operators for built-in aggregates
          Extending a built-in aggregate
          Example of extending a built-in aggregate
        Create user-defined aggregates
          Support functions
            The INIT function
              Omit the INIT function
              The optional second argument
            The ITER function
            The FINAL function
            The COMBINE function
          Resolve the support functions
          Support-function states
          Using C or Java support functions
          Example of a user-defined aggregate
            User-defined data types with user-defined aggregates
            Omit support functions
              Difference between SUMSQ and SSQ2 aggregates
              Overload the support functions for SSQ2
        Manage aggregates
          Parallel execution of aggregates
          Privileges for user-defined aggregates
          Aggregate information in the system catalog
          Aggregate information from the command line
        Drop an aggregate
      Create an opaque data type
        Opaque data types
          The internal structure
            A fixed-length opaque data type
            A varying-length opaque data type
          Support functions
            Operator functions
            Built-in functions
            Aggregate functions
            Statistics-collecting routines
            End-user routines
          Advantages of opaque data types
        Creating an opaque data type
          Create the internal structure in C
            Data type size
              A fixed-length opaque data type
              A varying-length opaque data type
            Memory alignment
            Parameter passing
          Creating UDT-to-Java mappings
          Write and register the support functions
          Register the opaque data type with the database
            Register the opaque data type
            Create casts for opaque data types
            Non in-row storage
          Grant privileges for an opaque data type
          Create SQL-invoked functions
            Arithmetic and text operator functions for opaque data types
            Built-in functions for opaque data types
            Aggregate functions for opaque data types
            Conditional operators for opaque data types
            Relational operators for opaque data types
              Hashable data types
              Nonhashable data types
            Comparison function for opaque data types
        Customize access methods
          The generic B-tree
          Other access methods
            Index spatial data
            Index other types of data
        Other operations on opaque data types
          Access an opaque data type
          Drop an opaque data type
      Write support functions
        Write support functions
          Identify support functions
          Choose function parameters
          Set privileges for support functions
        Data types for support functions
          The LVARCHAR data type
          The SENDRECV data type
        Handle the external representation
          Input support function
          Output support function
        Handle the internal representation
          The send and receive support functions
            The SENDRECV data type
            Receive support function
            Send support function
        Perform bulk copies
          Import and export support functions
            The IMPEXP data type
            Import support function
            Export support function
          Importbinary and exportbinary support functions
            The IMPEXPBIN data type
            Importbinary support function
            Exportbinary support function
          The stream support functions
        Insert and delete data
          The assign() function
          The destroy() function
          The update() function
          The deepcopy() function
        Handle smart large objects
        Compare data
        Handle locale-sensitive data (GLS)
          Locale-sensitive input and output support functions
          Locale-sensitive receive and send support functions
        Operating system functions
      Extend an operator class
        Operator classes
          Secondary-access methods
            Generic B-tree index
            R-tree index
            Other user-defined secondary-access methods
          Operator classes
            Generic B-tree operator class
              B-tree strategy functions
              B-tree support function
            R-tree index operator class
        Extending an existing operator class
          Extensions of the btree_ops operator class
          Reasons for extending btree_ops
            Generate a single value for a new data type
            Change the sort order
        Create an operator class
          Creating a new B-tree operator class
          Create an absolute-value operator class
          Define an operator class for other secondary-access methods
        Drop an operator class
      Manage a user-defined routine
        Assign the execute privilege to a routine
          Grant and revoke the execute privilege
          Privileges on objects associated with a UDR
          Run a UDR as DBA
          DBA privileges with objects and nested UDRs
        Modify a user-defined routine
          Modify a C UDR
            Remove routines from the shared library
          Modify a Java UDR
        Alter a user-defined routine
        Drop a user-defined routine
      Improve UDR performance
        Improve performance of C user-defined routines
        Optimize a user-defined routine
          Optimize an SPL routine
            Optimization levels
            Automatic optimization
          Update statistics for an SPL routine
        Optimize functions in SQL statements
          Calculate the query plan
          Specify cost and selectivity
            Constant cost and selectivity values
            Dynamic cost and selectivity values
          Calculating cost
          Selectivity and cost examples
        Extend UPDATE STATISTICS
          The UPDATE STATISTICS statement
          Support functions for UPDATE STATISTICS
            The stat data type
            The statcollect() function
            The statprint() function
            Example of user-defined statistics functions
        Negator functions
        A virtual-processor class
          Choose a virtual-processor class
            CPU virtual-processor class
            User-defined virtual-processor class (C)
            JVM virtual-processor class (Java)
          Using virtual processors with UDRs written in C
          Manage virtual processors
            Add and drop virtual processors
            Monitor virtual-processor classes
        Parallel UDRs
          Executing UDRs in parallel
            Execution of a UDR in a query expression
              Parallel UDR in WHERE clause
              Parallel UDR in a join
              Parallel UDR in the select list
              Parallel UDR with GROUP BY
              Parallel UDR in select list for parallel insert
            FastPath execution of a UDR in a DataBlade API (C)
            Implicit UDR execution of a user-defined aggregate
            Implicit UDR execution of a comparison operator
            Implicit execution of an assign UDR
            Execution of a comparison UDR for sort
            Execution of a UDR by an index on a UDT column
          Enable parallel UDRs
            Specify the PARALLELIZABLE modifier
            Write PDQ threadsafe UDRs
            Turn on PDQ and review other configuration parameters
            Enabling parallel UDRs
          Set the number of virtual processors
          Monitor parallel UDRs
        Memory considerations
          Memory durations for C UDRs
          Stack-size considerations (Ext)
          Virtual-memory cache for routines
            The sysprocedures system catalog table
            UDR cache
        I/O considerations
          Isolate system catalog tables
          Balancing the I/O activities
    Virtual-Table Interface Guide
      What's new in the virtual table interface, Version 12.10
      Access methods
        Built-in access methods
        User-defined access methods
          Access to storage spaces
          Seamless use of SQL
        Access-method components
          Components that the Informix database server provides
            Virtual-Table Interface
              Purpose functions
              Descriptors
              Accessor functions
            DataBlade API
            SQL extensions
              Register the access method in a database
              Specify an access method for a virtual table
            API libraries
          Components that you provide
            Purpose functions
            User-defined routines and header files
            User messages and documentation
        Access method flow
          Locate purpose functions
          Execute purpose functions
          Call functions from a purpose function
          Improve an access method
      Develop an access method
        Choose features for the access method
        Write purpose functions
          Start and end processing
          Create and drop database objects
          Provide optimum access method performance
            Provide optimizer information
            Split a scan
          Insert, delete, and update data
        Register purpose functions
          Supply routine modifiers
        Register the access method
        Testing the access method
          Create and specify storage spaces
            Testing the access method with an sbspace
              Create an sbspace
              Specify the logical sbspace name
            Storing virtual data in an extspace
              Specify a logical name
              Specify the physical location for external storage
              Provide a default extspace
            Test the access method for fragmentation support
            Avoid storage-space errors
          Insert, query, and update data
          Check data integrity
        Drop an access method
        Cannot rename databases that have virtual tables
      Design decisions
        Store data in shared memory
          Functions that allocate and free memory
          Memory-duration options
          Persistent user data
        Access database and system catalog tables
        No label-based access control on virtual tables
        Execute a UDR across databases of the same database server instance
        Handle the unexpected
          Callback functions
          Error messages
        Data definition statements
          Interpret the table descriptor
          Manage storage spaces
            Choose DataBlade API functions
            Set the am_sptype value
            Creating a default storage space
              Creating a default sbspace
              Create a default extspace
            Ensure data integrity
              Activate automatic controls in sbspaces
              Add controls for extspaces
            Check storage-space type
            Fragmentation support
          Provide configuration keywords
          Leverage indexes on virtual tables
        Process queries that involve a virtual table
          Interpret the scan descriptor
          Interpret the qualification descriptor
            Interpret the parameter descriptor
            Simple functions
            Runtime values as arguments
            Negation
            Complex expressions
          Qualifying data
            Qualification by the database server
            Qualification by the access method
              Guidelines for implementation
              Execute qualification functions
              Process complex qualifications
            Qualification by external software
            Support for query plan evaluation
              Calculate statement-specific costs
              Update statistics
        Enhancing performance
          Executing in parallel
          Buffering multiple results
        Support for data retrieval, manipulation, and return
          Check isolation levels
          Converting to and from a row format
          Determine transaction success or failure
        Supply error messages and a user guide
          Avoid database server exceptions
            Statements that the access method does not support
            Keywords that the access method does not support
            Storage spaces and fragmentation
            SQL restrictions
          Notify the user about access-method constraints
          Document nonstandard features
      Purpose-function reference
        Purpose-function flow
          The ALTER FRAGMENT statement interface
          The CREATE statement interface
          The DROP statement interface
          The INSERT, DELETE, and UPDATE statement interface
          The SELECT...WHERE statement interface
          The oncheck utility interface
        Purpose-function syntax
          The am_beginscan purpose function
          The am_check purpose function
          The am_close purpose function
          The am_create purpose function
          The am_delete purpose function
          The am_drop purpose function
          The am_endscan purpose function
          The am_getbyid purpose function
          The am_getnext purpose function
          The am_insert purpose function
          The am_open purpose function
          The am_rescan purpose function
          The am_scancost purpose function
          The am_stats purpose function
          The am_truncate purpose function
          The am_update purpose function
      Descriptor function reference
        Descriptor reference
          Qualification descriptor
          Parameter descriptor
          Row descriptor
          Scan descriptor
          Statistics descriptor
          Table descriptor
          Files to include in the access-method build
        Accessor functions
          The mi_eval_am_qual() accessor function
          The mi_init_am_qual() accessor function
          The mi_qual_boolop() accessor function
          The mi_qual_column() accessor function
          The mi_qual_commuteargs() accessor function
          The mi_qual_constant() accessor function
          The mi_qual_constant_nohostvar() accessor function
          The mi_qual_constant_typeid() accessor function
          The mi_qual_constisnull() accessor function
          The mi_qual_constisnull_nohostvar() accessor function
          The mi_qual_const_depends_hostvar() accessor function
          The mi_qual_const_depends_outer() accessor function
          The mi_qual_funcid() accessor function
          The mi_qual_funcname() accessor function
          The mi_qual_handlenull() accessor function
          The mi_qual_issimple() accessor function
          The mi_qual_needoutput() accessor function
          The mi_qual_negate() accessor function
          The mi_qual_nparams() accessor function
          The mi_qual_nquals() accessor function
          The mi_qual_qual() accessor function
          The mi_qual_setoutput() accessor function
          The mi_qual_setreopt() accessor function
          The mi_qual_setvalue() accessor function
          The mi_qual_value() accessor function
          The mi_qual_param() accessor function
          The mi_qual_param_column() accessor function
          The mi_qual_param_constant() accessor function
          The mi_qual_param_constant_typeid() accessor function
          The mi_qual_param_constisnull() accessor function
          The mi_qual_param_expression() accessor function
          The mi_qual_param_iscolumn() accessor function
          The mi_qual_param_isconstant() accessor function
          The mi_qual_param_isexpression() accessor function
          The mi_qual_param_issimple() accessor function
          The mi_scan_forupdate() accessor function
          The mi_scan_isolevel() accessor function
          The mi_scan_locktype() accessor function
          The mi_scan_newquals() accessor function
          The mi_scan_nprojs() accessor function
          The mi_scan_projs() accessor function
          The mi_scan_quals() accessor function
          The mi_scan_setuserdata() accessor function
          The mi_scan_table() accessor function
          The mi_scan_userdata() accessor function
          The mi_tab_amparam() accessor function
          The mi_tab_check_msg() function
          The mi_tab_createdate() accessor function
          The mi_tab_id() accessor function
          The mi_tab_isolevel() accessor function
          The mi_tab_istable() accessor function
          The mi_tab_mode() accessor function
          The mi_tab_name() accessor function
          The mi_tab_niorows() accessor function
          The mi_tab_numfrags() accessor function
          The mi_tab_owner() accessor function
          The mi_tab_partnum() accessor function
          The mi_tab_rowdesc() accessor function
          The mi_tab_setnextrow() accessor function
          The mi_tab_setniorows() accessor function
          The mi_tab_setuserdata() accessor function
          The mi_tab_spaceloc() accessor function
          The mi_tab_spacename() accessor function
          The mi_tab_spacetype() accessor function
          The mi_tab_update_stat_mode() accessor function
          The mi_tab_userdata() accessor function
          The mi_tstats_setnpages() accessor function
          The mi_tstats_setnrows() accessor function
      SQL statements for access methods
        The ALTER ACCESS_METHOD (+) statement
        The CREATE ACCESS_METHOD (+) statement
        The DROP ACCESS_METHOD (+) statement
        Purpose options
      XA-compliant external data sources
        Create a virtual-table interface for XA data sources
    Virtual-Index Interface Guide
      Access methods
        Built-in access methods
        User-defined access methods
          Access to storage spaces
          Seamless use of SQL
        Access-method components
          Components that the Informix database server provides
            Virtual-Index Interface
              Purpose functions
              Descriptors
              Accessor functions
            DataBlade API
            SQL extensions
              Register the access method in a database
              Specify an access method for a virtual index
            API libraries
          Components that you provide
            Purpose functions
            User-defined routines and header files
            Operator class
            User messages and documentation
        Access method flow
          Locate purpose functions
          Execute purpose functions
          Call functions from a purpose function
          Improve an access method
      Develop an access method
        Choose features for the access method
        Write purpose functions
          Start and end processing
          Create and drop database objects
          Provide optimum access method performance
            Provide optimizer information
            Split a scan
          Insert, delete, and update data
        Register purpose functions
        Register the access method
        Specify an operator class
          Supplying an operator class for a secondary access method
          Write or choose strategy and support functions
          Register strategy and support functions
            Make a function nonvariant
            Grant privileges
          Register the operator class
          Add a default operator class to the access method
        Testing the access method
          Create and specify storage spaces
            Testing the access method with an sbspace
              Create an sbspace
              Specify the logical sbspace name
            Storing virtual data in an extspace
              Specify a logical name
              Specify the physical location for external storage
              Provide a default extspace
            Test the access method for fragmentation support
            Avoid storage-space errors
          Insert, query, and update data
          Check data integrity
        Drop an access method
        Cannot rename databases that have virtual indexes
      Design decisions
        Store data in shared memory
          Functions that allocate and free memory
          Memory-duration options
          Persistent user data
        Access database and system catalog tables
        No label-based access control on virtual indexes
        Execute a UDR across databases of the same database server instance
        Handle the unexpected
          Callback functions
          Error messages
        Data definition statements
          Interpret the table descriptor
          Manage storage spaces
            Choose DataBlade API functions
            Set the am_sptype value
            Creating a default storage space
              Creating a default sbspace
              Create a default extspace
            Ensure data integrity
              Activate automatic controls in sbspaces
              Add controls for extspaces
            Check storage-space type
            Fragmentation support
          Provide configuration keywords
          Build new indexes efficiently
          Enable alternative indexes
        Support multiple-column index keys
          Accessing support functions for a multiple-column key
          Accessing strategy functions for a multiple-column key
        Using FastPath
          Obtaining the routine identifier
          Reuse the function descriptor
        Process queries that involve a virtual index
          Interpret the scan descriptor
          Interpret the qualification descriptor
            Simple functions
            Runtime values as arguments
            Negation
            Complex Boolean expressions
          Qualify data
            Execute qualification functions
            Guidelines for implementation
            Process complex qualifications
            Support for query plan evaluation
              Calculate statement-specific costs
              Update statistics
        Enhancing performance
          Executing in parallel
          Bypass table scans
          Buffering multiple results
        Support for data retrieval, manipulation, and return
          Enforcing unique-index constraints
          Check isolation levels
          Converting to and from a row format
          Determine transaction success or failure
        Supply error messages and a user guide for your functions
          Avoid database server exceptions
            Statements that the access method does not support
            Keywords that the access method does not support
            Storage spaces and fragmentation
            SQL restrictions
          Notify the user about access-method constraints
            Data integrity limitations
            WHERE clause limitations
          Document nonstandard features
      Purpose-function reference
        Purpose-function flow
          The ALTER FRAGMENT statement interface
          The CREATE statement interface
          The DROP statement interface
          The INSERT, DELETE, and UPDATE statement interface
          The SELECT...WHERE statement interface
          The oncheck utility interface
        Purpose-function syntax
          The am_beginscan purpose function
          The am_check purpose function
          The am_close purpose function
          The am_create purpose function
          The am_delete purpose function
          The am_drop purpose function
          The am_endscan purpose function
          The am_getnext purpose function
          The am_insert purpose function
          The am_open purpose function
          The am_rescan purpose function
          The am_scancost purpose function
          The am_stats purpose function
          The am_truncate purpose function
          The am_update purpose function
      Descriptor function reference
        Descriptors
          Key descriptor
          Qualification descriptor
          Row descriptor
          Row-ID descriptor
          Scan descriptor
          Statistics descriptor
          Table descriptor
          Files to include in the access-method build
        Accessor functions
          The mi_id_fragid() accessor function
          The mi_id_rowid() accessor function
          The mi_id_setfragid() accessor function
          The mi_id_setrowid() accessor function
          The mi_istats_setclust() accessor function
          The mi_istats_set2lval() accessor function
          The mi_istats_set2sval() accessor function
          The mi_istats_setnlevels() accessor function
          The mi_istats_setnleaves() accessor function
          The mi_istats_setnunique() accessor function
          The mi_key_funcid() accessor function
          The mi_key_nkeys() accessor function
          The mi_key_opclass() and mi_key_opclass_name() accessor functions
          The mi_key_opclass_nstrat() accessor function
          The mi_key_opclass_nsupt() accessor function
          The mi_key_opclass_strat() accessor function
          The mi_key_opclass_supt() accessor function
          The mi_qual_boolop() accessor function
          The mi_qual_column() accessor function
          The mi_qual_commuteargs() accessor function
          The mi_qual_constant() accessor function
          The mi_qual_constant_nohostvar() accessor function
          The mi_qual_constisnull() accessor function
          The mi_qual_constisnull_nohostvar() accessor function
          The mi_qual_const_depends_hostvar() accessor function
          The mi_qual_const_depends_outer() accessor function
          The mi_qual_funcid() accessor function
          The mi_qual_funcname() accessor function
          The mi_qual_handlenull() accessor function
          The mi_qual_issimple() accessor function
          The mi_qual_needoutput() accessor function
          The mi_qual_negate() accessor function
          The mi_qual_nquals() accessor function
          The mi_qual_qual() accessor function
          The mi_qual_setoutput() accessor function
          The mi_qual_setreopt() accessor function
          The mi_qual_stratnum() accessor function
          The mi_scan_forupdate() accessor function
          The mi_scan_isolevel() accessor function
          The mi_scan_locktype() accessor function
          The mi_scan_newquals() accessor function
          The mi_scan_nprojs() accessor function
          The mi_scan_projs() accessor function
          The mi_scan_quals() accessor function
          The mi_scan_setuserdata() accessor function
          The mi_scan_table() accessor function
          The mi_scan_userdata() accessor function
          The mi_tab_amparam() accessor function
          The mi_tab_check_msg() function
          The mi_tab_check_is_recheck() accessor function
          The mi_tab_check_set_ask() accessor function
          The mi_tab_createdate() accessor function
          The mi_tab_isindex() accessor function
          The mi_tab_isolevel() accessor function
          The mi_tab_keydesc() accessor function
          The mi_tab_mode() accessor function
          The mi_tab_name() accessor function
          The mi_tab_nextrow() accessor function
          The mi_tab_niorows() accessor function
          The mi_tab_nparam_exist() accessor function
          The mi_tab_numfrags() accessor function
          The mi_tab_owner() accessor function
          The mi_tab_param_exist() accessor function
          The mi_tab_partnum() accessor function
          The mi_tab_rowdesc() accessor function
          The mi_tab_setnextrow() accessor function
          The mi_tab_setniorows() accessor function
          The mi_tab_setuserdata() accessor function
          The mi_tab_spaceloc() accessor function
          The mi_tab_spacename() accessor function
          The mi_tab_spacetype() accessor function
          The mi_tab_unique() accessor function
          The mi_tab_update_stat_mode() accessor function
          The mi_tab_userdata() accessor function
      SQL statements for access methods
        The ALTER ACCESS_METHOD (+) statement
        The CREATE ACCESS_METHOD (+) statement
        The DROP ACCESS_METHOD (+) statement
        Purpose options
      XA-compliant external data sources
        Create a virtual-index interface for XA data sources
Glossary
  Glossary
  Glossary
HCL Informix V12.10 documentation
  Notices
  Links to non-IBM websites
  Complete HCL Informix library
  Translated documentation
  Documentation updates
  Example code conventions
  Syntax diagrams
    Dotted decimal syntax diagrams
  Notices
  Links to non-IBM websites
  Complete HCL Informix library
  Translated documentation
  Documentation updates
  Example code conventions
  Syntax diagrams
    Dotted decimal syntax diagrams
IBM OpenAdmin Tool for Informix
  HCL OpenAdmin Tool (OAT) for Informix
    How do I connect to a database server?
      Logging in to a database server
      Logging in to a database server in an OAT group
      Switching to another server in an OAT group
    How do I monitor database server activity?
      Monitoring database server status
      Customizing the dashboard
      Modifying the dashboard thresholds
      Monitoring alerts and event alarms
      Reviewing the admin command history
      Monitoring the online message log
      Deleting the online message log
      Rotating the online message log
      Monitoring the ON-Bar activity log
      Deleting the ON-Bar activity log
      Rotating the ON-Bar activity log
    How do I manage system space?
      Monitoring space usage
      Managing space usage
        Creating a space
        Modifying a space
        Dropping a space
        Adding a chunk
        Modifying a chunk
        Dropping a chunk
      Adding storage space automatically
        Configuring the server to add storage space
        Adding a storage pool entry
        Modifying a storage pool entry
        Deleting storage pool entries
        Expanding a space
        Extending a chunk
      Optimizing storage space
        Optimizing storage space automatically
        Estimating compression
        Compressing data
        Uncompressing tables and table fragments
        Consolidating free space
        Returning free space to the dbspace
        Defragmenting extents
      Managing recovery logs
        Viewing checkpoint history
        Forcing checkpoints
        Viewing logical log statistics
        Adding logical logs
        Switching logical logs
        Dropping logical logs
        Viewing physical log statistics
        Moving physical logs
    How do I administer the database server?
      Managing server memory
      Managing high availability clusters
        Configuring connectivity for high availability clusters
        Finding high availability clusters
        Viewing the topology of a cluster
        Viewing the status of servers in a cluster
        Adding an SDS server
        Starting or stopping a server in a cluster
      Managing time series
      Managing configuration parameters
      Running system validation checks
        Validating one or more databases or tables at the current server
        Validating the extents of one or more dbspaces on the current server
      Managing virtual processors
      Granting and limiting user privileges
        Granting database-level privileges to a user
        Modifying the database-level privileges of a user
        Revoking the database-level privileges of a user
        Granting table-level privileges to a user
        Modifying the table-level privileges of a user
        Revoking the table-level privileges of a user
      Managing internal users (UNIX, Linux)
        Setting the privileges for internal users on a server (UNIX, Linux)
        Adding an internal user (UNIX, Linux)
        Editing an internal user (UNIX, Linux)
        Deleting an internal user (UNIX, Linux)
      Creating a trusted context
        Managing a trusted context
      Managing Auto Update Statistics
        Configuring and enabling Auto Update Statistics
        Viewing refreshes and evaluations at the server
        Requesting an immediate evaluation of statistics
        Determining when statistics are updated next
        Viewing the current Auto Update Statistics settings
        Monitoring the Auto Update Statistics settings
        Viewing alerts generated by Auto Update Statistics
        Cleaning up abnormal runs of Auto Update Statistics
      Backing up database server data
        Backing up data with ontape
        Changing the backup configuration and schedule
        Performing a backup on demand
    How do I manage Scheduler tasks?
      Adding Scheduler tasks
        Adding a new task
        Adding a new sensor
      Enabling Scheduler tasks
      Changing the Scheduler task allowable time interval
      Deleting a Scheduler task
    How do I explore performance information?
      Analyzing query performance with SQL Explorer
        Turning on SQL tracing
        Turning off SQL tracing
        Specifying options for SQL tracing
          Trace Mode
        Suspending SQL tracing
        Resuming SQL tracing from a suspended state
        Switching between Live and Saved Data
        Drilling down from the activity summary
        Drilling down by transaction
        Drilling down by SQL statement type
      Optimizing SQL statements
      Exploring user sessions
        Stopping a user session
      Viewing performance history
      Running system performance reports
      Monitoring extents
      Monitoring the buffer pool
      Monitoring servers with the onstat utility
    How do I manage databases and tables?
      Reviewing the databases on a server
      Connecting to a database
      Viewing schemas
      Reviewing procedures and routines for a database
      Performing standard SQL operations: query, insert, update, delete
        Performing a query
        Updating a table row
        Deleting a table row
        Inserting a table row
    How do I set up access to a server?
      Adding an OAT group
      Creating a server connection
      Exporting connection information
      Importing connection information
      Accessing a database with a nondefault locale
    How do I configure security for OAT?
      Creating an OAT group with read-only privileges
        Read-only group restrictions
      Limiting access to the Admin configuration pages
      Providing password protection for the Admin configuration pages: Apache example
      Configuring HTTPS for OAT (Linux)
      Configuring HTTPS for OAT (Windows)
      Disabling or enabling password protection for SQL Toolbox
    How do I manage plug-ins for OAT?
      Installing a plug-in for OAT
      Enabling a plug-in for OAT
      Upgrading a plug-in for OAT
      Disabling a plug-in for OAT
      Uninstalling a plug-in for OAT
      idsadmin class functions
        isreadonly function
        get_database function
        load_lang function
        lang function
        error function
        status function
        format_units function
        setCurrMenuItem function
      output class
        set_pagetitle function
        add_to_output function
    How do I customize the main menu for OAT?
  HCL OpenAdmin Tool (OAT) for Informix
    How do I connect to a database server?
      Logging in to a database server
      Logging in to a database server in an OAT group
      Switching to another server in an OAT group
    How do I monitor database server activity?
      Monitoring database server status
      Customizing the dashboard
      Modifying the dashboard thresholds
      Monitoring alerts and event alarms
      Reviewing the admin command history
      Monitoring the online message log
      Deleting the online message log
      Rotating the online message log
      Monitoring the ON-Bar activity log
      Deleting the ON-Bar activity log
      Rotating the ON-Bar activity log
    How do I manage system space?
      Monitoring space usage
      Managing space usage
        Creating a space
        Modifying a space
        Dropping a space
        Adding a chunk
        Modifying a chunk
        Dropping a chunk
      Adding storage space automatically
        Configuring the server to add storage space
        Adding a storage pool entry
        Modifying a storage pool entry
        Deleting storage pool entries
        Expanding a space
        Extending a chunk
      Optimizing storage space
        Optimizing storage space automatically
        Estimating compression
        Compressing data
        Uncompressing tables and table fragments
        Consolidating free space
        Returning free space to the dbspace
        Defragmenting extents
      Managing recovery logs
        Viewing checkpoint history
        Forcing checkpoints
        Viewing logical log statistics
        Adding logical logs
        Switching logical logs
        Dropping logical logs
        Viewing physical log statistics
        Moving physical logs
    How do I administer the database server?
      Managing server memory
      Managing high availability clusters
        Configuring connectivity for high availability clusters
        Finding high availability clusters
        Viewing the topology of a cluster
        Viewing the status of servers in a cluster
        Adding an SDS server
        Starting or stopping a server in a cluster
      Managing time series
      Managing configuration parameters
      Running system validation checks
        Validating one or more databases or tables at the current server
        Validating the extents of one or more dbspaces on the current server
      Managing virtual processors
      Granting and limiting user privileges
        Granting database-level privileges to a user
        Modifying the database-level privileges of a user
        Revoking the database-level privileges of a user
        Granting table-level privileges to a user
        Modifying the table-level privileges of a user
        Revoking the table-level privileges of a user
      Managing internal users (UNIX, Linux)
        Setting the privileges for internal users on a server (UNIX, Linux)
        Adding an internal user (UNIX, Linux)
        Editing an internal user (UNIX, Linux)
        Deleting an internal user (UNIX, Linux)
      Creating a trusted context
        Managing a trusted context
      Managing Auto Update Statistics
        Configuring and enabling Auto Update Statistics
        Viewing refreshes and evaluations at the server
        Requesting an immediate evaluation of statistics
        Determining when statistics are updated next
        Viewing the current Auto Update Statistics settings
        Monitoring the Auto Update Statistics settings
        Viewing alerts generated by Auto Update Statistics
        Cleaning up abnormal runs of Auto Update Statistics
      Backing up database server data
        Backing up data with ontape
        Changing the backup configuration and schedule
        Performing a backup on demand
    How do I manage Scheduler tasks?
      Adding Scheduler tasks
        Adding a new task
        Adding a new sensor
      Enabling Scheduler tasks
      Changing the Scheduler task allowable time interval
      Deleting a Scheduler task
    How do I explore performance information?
      Analyzing query performance with SQL Explorer
        Turning on SQL tracing
        Turning off SQL tracing
        Specifying options for SQL tracing
          Trace Mode
        Suspending SQL tracing
        Resuming SQL tracing from a suspended state
        Switching between Live and Saved Data
        Drilling down from the activity summary
        Drilling down by transaction
        Drilling down by SQL statement type
      Optimizing SQL statements
      Exploring user sessions
        Stopping a user session
      Viewing performance history
      Running system performance reports
      Monitoring extents
      Monitoring the buffer pool
      Monitoring servers with the onstat utility
    How do I manage databases and tables?
      Reviewing the databases on a server
      Connecting to a database
      Viewing schemas
      Reviewing procedures and routines for a database
      Performing standard SQL operations: query, insert, update, delete
        Performing a query
        Updating a table row
        Deleting a table row
        Inserting a table row
    How do I set up access to a server?
      Adding an OAT group
      Creating a server connection
      Exporting connection information
      Importing connection information
      Accessing a database with a nondefault locale
    How do I configure security for OAT?
      Creating an OAT group with read-only privileges
        Read-only group restrictions
      Limiting access to the Admin configuration pages
      Providing password protection for the Admin configuration pages: Apache example
      Configuring HTTPS for OAT (Linux)
      Configuring HTTPS for OAT (Windows)
      Disabling or enabling password protection for SQL Toolbox
    How do I manage plug-ins for OAT?
      Installing a plug-in for OAT
      Enabling a plug-in for OAT
      Upgrading a plug-in for OAT
      Disabling a plug-in for OAT
      Uninstalling a plug-in for OAT
      idsadmin class functions
        isreadonly function
        get_database function
        load_lang function
        lang function
        error function
        status function
        format_units function
        setCurrMenuItem function
      output class
        set_pagetitle function
        add_to_output function
    How do I customize the main menu for OAT?
Informix community
  International Informix Users Group
  Informix Exchange
  Forums and wikis
  Blogs
  International Informix Users Group
  Informix Exchange
  Forums and wikis
  Blogs
Informix Health Advisor Plug-in for OAT
  Informix Health Advisor Plug-in for OAT context help
    Health Advisor: Profile
    Health Advisor: Alarms
    Health Advisor: Modify Thresholds
    Health Advisor: Schedule
    Health Advisor: Notification
  Informix Health Advisor Plug-in for OAT context help
    Health Advisor: Profile
    Health Advisor: Alarms
    Health Advisor: Modify Thresholds
    Health Advisor: Schedule
    Health Advisor: Notification
Informix Health Advisor Plug-in for OAT
  Informix Health Advisor Plug-in for OAT
    Running the Health Advisor
    Adding a profile
    Setting up alarms for a profile
    Scheduling a task for a profile
    Configuring email notification
  Informix Health Advisor Plug-in for OAT
    Running the Health Advisor
    Adding a profile
    Setting up alarms for a profile
    Scheduling a task for a profile
    Configuring email notification
Informix Schema Manager Plug-in for OAT
  Informix Schema Manager Plug-in for OAT
    Viewing database objects
    Viewing table objects
    Reviewing table statistics
    Creating a database
    Dropping a database
    Managing tables and indexes
      Creating a table
      Dropping a table
      Truncating a table
      Creating an index
      Disabling or enabling an index
      Dropping an index
    Loading and unloading data with external tables
      Loading data with an external table
      Unloading data to an external table
      Creating an external table
      Viewing external table information
      Viewing the status of load and unload tasks
      Running saved load and unload tasks
      Deleting load and unload tasks
      Creating a group of saved load or unload tasks
  Informix Schema Manager Plug-in for OAT
    Viewing database objects
    Viewing table objects
    Reviewing table statistics
    Creating a database
    Dropping a database
    Managing tables and indexes
      Creating a table
      Dropping a table
      Truncating a table
      Creating an index
      Disabling or enabling an index
      Dropping an index
    Loading and unloading data with external tables
      Loading data with an external table
      Unloading data to an external table
      Creating an external table
      Viewing external table information
      Viewing the status of load and unload tasks
      Running saved load and unload tasks
      Deleting load and unload tasks
      Creating a group of saved load or unload tasks
Informix Spatial DataBlade Module User's Guide
  Spatial Data User's Guide
    Getting started with spatial data
      Overview of spatial data
        Geographic coordinate system
        Projected coordinate system
      Informix spatial solution architecture
        Spatial data replication
      Preparing for spatial data
        The spatial_references table
          Predefined spatial reference systems
          False origin and system units
        Units of measure
          The st_units_of_measure table
        Spatial tables
      Loading spatial data
        The geometry_columns table
        The spatial index
      Query spatial data
        Optimize spatial queries
      Update values in a spatial column
    Spatial data types
      Properties of spatial data types
      ST_Point data type
      ST_LineString data type
      ST_Polygon data type
      ST_MultiPoint data type
      ST_MultiLineString data type
      ST_MultiPolygon data type
      Locale override
      Spatial data types with SPL
      Casts between spatial data types
    Data exchange formats
      Well-known text representation
      Well-known binary representation
      ESRI shape representation
      Geography Markup Language representation
      Keyhole Markup Language representation
    R-tree indexes
      Syntax for creating an R-tree index
        Bottom-up versus top-down index builds
        Functional R-tree indexes
        Verify that the index is correctly built
      The spatial operator class ST_Geometry_Ops
      How spatial operators use R-tree indexes
    Run parallel queries
      Parallel query execution infrastructure
      Resolve problems with SE_MetadataInit()
      Execute parallel queries
    Estimate your spatial data
      Estimating the storage space for the table
        Estimate the size of the spatial column
        Estimate the size of non-spatial columns
        Estimate dbspace overhead requirements
      Estimating the smart large object storage space
      Estimating the size of spatial indexes
    Spatial functions
      The Dimensionally Extended 9 Intersection Model
      Summary of spatial functions by task type
      The ST_Area() function
      The ST_AsBinary() function
      The SE_AsBSON() function
      The SE_AsGML() function
      The ST_AsGML() function
      The SE_AsKML() function
      The ST_AsKML() function
      The SE_AsShape() function
      The ST_AsText() function
      The SE_BBoxFromBSON() function
      The ST_Boundary() function
      The SE_BoundingBox() function
      The ST_Buffer() function
      The ST_Centroid() function
      The ST_Contains() function
      The ST_ConvexHull() function
      The ST_CoordDim() function
      The SE_CreateSRID() function
      The SE_CreateSrtext() function
      The SE_CreateSrtextCount() function
      The SE_CreateSrtextList() function
      The ST_Crosses() function
      The ST_Difference() function
      The ST_Dimension() function
      The ST_Disjoint() function
      The SE_Dissolve() function
      The ST_Distance() function
      The ST_DistanceToPoint() function
      The ST_EndPoint() function
      The ST_Envelope() function
      The ST_EnvelopeAsGML() function
      The SE_EnvelopeAsKML() function
      The ST_EnvelopeFromGML() function
      The SE_EnvelopeFromKML() function
      The SE_EnvelopesIntersect() function
      The ST_Equals() function
      The ST_ExteriorRing() function
      The SE_Generalize() function
      The ST_GeometryN() function
      The ST_GeometryType() function
      The SE_GeomFromBSON() function
      The ST_GeomFromGML() function
      The ST_GeomFromKML() function
      The SE_GeomFromShape() function
      The ST_GeomFromText() function
      The ST_GeomFromWKB() function
      The SE_InRowSize() function
      The ST_InteriorRingN() function
      The ST_Intersection() function
      The ST_Intersects() function
      The ST_Is3D() function
      The ST_IsClosed() function
      The ST_IsEmpty() function
      The ST_IsMeasured() function
      The ST_IsRing() function
      The ST_IsSimple() function
      The ST_IsValid() function
      The ST_Length() function
      The SE_LineFromBSON() function
      The ST_LineFromGML() function
      The ST_LineFromKML() function
      The SE_LineFromShape() function
      The ST_LineFromText() function
      The ST_LineFromWKB() function
      The ST_LocateAlong() function
      The ST_LocateBetween() function
      The ST_M() function
      The ST_MaxM() and ST_MinM() functions
      The ST_MaxX() and ST_MinX() functions
      The ST_MaxY() and ST_MinY() functions
      The ST_MaxZ() and ST_MinZ() functions
      The SE_MetadataInit() function
      The SE_Midpoint() function
      The SE_MLineFromBSON() function
      The ST_MLineFromGML() function
      The ST_MLineFromKML() function
      The SE_MLineFromShape() function
      The ST_MLineFromText() function
      The ST_MLineFromWKB() function
      The SE_MPointFromBSON() function
      The ST_MPointFromGML() function
      The ST_MPointFromKML() function
      The SE_MPointFromShape() function
      The ST_MPointFromText() function
      The ST_MPointFromWKB() function
      The SE_MPolyFromBSON() function
      The ST_MPolyFromGML() function
      The ST_MPolyFromKML() function
      The SE_MPolyFromShape() function
      The ST_MPolyFromText() function
      The ST_MPolyFromWKB() function
      The SE_Nearest() and SE_NearestBbox() functions
      The ST_NumGeometries() function
      The ST_NumInteriorRing() function
      The ST_NumPoints() function
      The SE_OutOfRowSize() function
      The ST_Overlaps() function
      The SE_ParamGet() function
      The SE_ParamSet() function
      The ST_Perimeter() function
      The SE_PerpendicularPoint() function
      The ST_Point() function
      The ST_PointAtDistance() function
      The SE_PointFromBSON() function
      The ST_PointFromGML() function
      The ST_PointFromKML() function
      The SE_PointFromShape() function
      The ST_PointFromText() function
      The ST_PointFromWKB() function
      The ST_PointN() function
      The ST_PointOnSurface() function
      The SE_PolyFromBSON() function
      The ST_PolyFromGML() function
      The ST_PolyFromKML() function
      The SE_PolyFromShape() function
      The ST_PolyFromText() function
      The ST_PolyFromWKB() function
      The ST_Polygon() function
      The ST_Relate() function
      The SE_Release() function
      The SE_ShapeToSQL() function
      The SE_SpatialKey() function
      The ST_SRID() function
      The SE_SRID_Authority() function
      The ST_StartPoint() function
      The ST_SymDifference() function
      The SE_TotalSize() function
      The ST_Touches() function
      The SE_Trace() function
      The ST_Transform() function
      The ST_Union() function
      The SE_VertexAppend() function
      The SE_VertexDelete() function
      The SE_VertexUpdate() function
      The ST_Within() function
      The ST_WKBToSQL() function
      The ST_WKTToSQL() function
      The ST_X() function
      The ST_Y() function
      The ST_Z function
    Spatial Java API
      Compatibility with the ESRI ArcSDE Java API
      Overview of the Java API
        Geometries
        Uses for the Java API
        The CoordRefManager Class
        The SpatialManager Class
      Overview of a Spatial Java API Application
        Using Logging
        Assigning a Connection to CoordRefManager
        Querying and Displaying Geometries
        Reading Coordinate Data
      Preparing to Run a Program
        Running the Programs
      Example 1: Retrieving a Point From a Table
      Examples 2, 3, and 4: How to Use the Java API
        GeometryToWKT
        GeometryToArray
        CoordRefCreate
    Appendixes
      Load and unload shapefile data
        The infoshp utility
        The loadshp utility
        The unloadshp utility
      OGC well-known text representation of spatial reference systems
        The text representation of a spatial system
        Linear units
        Angular units
        Geodetic spheroids
        Horizontal datums (spheroid only)
        Horizontal datums
        Prime meridians
        Projection parameters
        Map projections
      OGC well-known text representation of geometry
        Well-known text representation in a C program
        Well-known text representation in an SQL editor
        Modified well-known text representation
      OGC well-known binary representation of geometry
        Numeric type definitions
        XDR (big endian) encoding of numeric types
        NDR (little endian) encoding of numeric types
        Conversion between the NDR and XDR representations of WKB geometry
        Description of WKBGeometry byte streams
        Assertions for well-known binary representation for geometry
      ESRI shape representation
        Shape type values
        Shape types in XY space
          Point
          MultiPoint
          PolyLine
          Polygon
            A sample polygon instance
        Measured shape types in XY space
          PointM
          MultiPointM
          PolyLineM
          PolygonM
        Shape types in XYZ space
          PointZ
          MultiPointZ
          PolyLineZ
          PolygonZ
        Measured shape types in XYZ space
          PointZM
          MultiPointZM
          PolyLineZM
          PolygonZM
      Error messages
        Error messages and their explanations
          USE01
          7USE02
          USE03
          USE04
          USE05
          USE06
          USE07
          USE08
          USE09
          USE10
          USE11
          USE12
          USE13
          USE14
          USE15
          USE16
          USE17
          USE18
          USE19
          USE20
          USE21
          USE22
          USE23
          USE24
          USE25
          USE26
          USE27
          USE28
          USE29
          USE30
          USE31
          USE32
          USE33
          USE34
          USE35
          USE36
          USE37
          USE38
          USE39
          USE40
          USE41
          USE42
          USE43
          USE44
          USE45
          USE46
          USE47
          USE48
          USE49
          USE50
          USE51
          USE52
          USE53
          USE54
          -674
  Spatial Data User's Guide
    Getting started with spatial data
      Overview of spatial data
        Geographic coordinate system
        Projected coordinate system
      Informix spatial solution architecture
        Spatial data replication
      Preparing for spatial data
        The spatial_references table
          Predefined spatial reference systems
          False origin and system units
        Units of measure
          The st_units_of_measure table
        Spatial tables
      Loading spatial data
        The geometry_columns table
        The spatial index
      Query spatial data
        Optimize spatial queries
      Update values in a spatial column
    Spatial data types
      Properties of spatial data types
      ST_Point data type
      ST_LineString data type
      ST_Polygon data type
      ST_MultiPoint data type
      ST_MultiLineString data type
      ST_MultiPolygon data type
      Locale override
      Spatial data types with SPL
      Casts between spatial data types
    Data exchange formats
      Well-known text representation
      Well-known binary representation
      ESRI shape representation
      Geography Markup Language representation
      Keyhole Markup Language representation
    R-tree indexes
      Syntax for creating an R-tree index
        Bottom-up versus top-down index builds
        Functional R-tree indexes
        Verify that the index is correctly built
      The spatial operator class ST_Geometry_Ops
      How spatial operators use R-tree indexes
    Run parallel queries
      Parallel query execution infrastructure
      Resolve problems with SE_MetadataInit()
      Execute parallel queries
    Estimate your spatial data
      Estimating the storage space for the table
        Estimate the size of the spatial column
        Estimate the size of non-spatial columns
        Estimate dbspace overhead requirements
      Estimating the smart large object storage space
      Estimating the size of spatial indexes
    Spatial functions
      The Dimensionally Extended 9 Intersection Model
      Summary of spatial functions by task type
      The ST_Area() function
      The ST_AsBinary() function
      The SE_AsBSON() function
      The SE_AsGML() function
      The ST_AsGML() function
      The SE_AsKML() function
      The ST_AsKML() function
      The SE_AsShape() function
      The ST_AsText() function
      The SE_BBoxFromBSON() function
      The ST_Boundary() function
      The SE_BoundingBox() function
      The ST_Buffer() function
      The ST_Centroid() function
      The ST_Contains() function
      The ST_ConvexHull() function
      The ST_CoordDim() function
      The SE_CreateSRID() function
      The SE_CreateSrtext() function
      The SE_CreateSrtextCount() function
      The SE_CreateSrtextList() function
      The ST_Crosses() function
      The ST_Difference() function
      The ST_Dimension() function
      The ST_Disjoint() function
      The SE_Dissolve() function
      The ST_Distance() function
      The ST_DistanceToPoint() function
      The ST_EndPoint() function
      The ST_Envelope() function
      The ST_EnvelopeAsGML() function
      The SE_EnvelopeAsKML() function
      The ST_EnvelopeFromGML() function
      The SE_EnvelopeFromKML() function
      The SE_EnvelopesIntersect() function
      The ST_Equals() function
      The ST_ExteriorRing() function
      The SE_Generalize() function
      The ST_GeometryN() function
      The ST_GeometryType() function
      The SE_GeomFromBSON() function
      The ST_GeomFromGML() function
      The ST_GeomFromKML() function
      The SE_GeomFromShape() function
      The ST_GeomFromText() function
      The ST_GeomFromWKB() function
      The SE_InRowSize() function
      The ST_InteriorRingN() function
      The ST_Intersection() function
      The ST_Intersects() function
      The ST_Is3D() function
      The ST_IsClosed() function
      The ST_IsEmpty() function
      The ST_IsMeasured() function
      The ST_IsRing() function
      The ST_IsSimple() function
      The ST_IsValid() function
      The ST_Length() function
      The SE_LineFromBSON() function
      The ST_LineFromGML() function
      The ST_LineFromKML() function
      The SE_LineFromShape() function
      The ST_LineFromText() function
      The ST_LineFromWKB() function
      The ST_LocateAlong() function
      The ST_LocateBetween() function
      The ST_M() function
      The ST_MaxM() and ST_MinM() functions
      The ST_MaxX() and ST_MinX() functions
      The ST_MaxY() and ST_MinY() functions
      The ST_MaxZ() and ST_MinZ() functions
      The SE_MetadataInit() function
      The SE_Midpoint() function
      The SE_MLineFromBSON() function
      The ST_MLineFromGML() function
      The ST_MLineFromKML() function
      The SE_MLineFromShape() function
      The ST_MLineFromText() function
      The ST_MLineFromWKB() function
      The SE_MPointFromBSON() function
      The ST_MPointFromGML() function
      The ST_MPointFromKML() function
      The SE_MPointFromShape() function
      The ST_MPointFromText() function
      The ST_MPointFromWKB() function
      The SE_MPolyFromBSON() function
      The ST_MPolyFromGML() function
      The ST_MPolyFromKML() function
      The SE_MPolyFromShape() function
      The ST_MPolyFromText() function
      The ST_MPolyFromWKB() function
      The SE_Nearest() and SE_NearestBbox() functions
      The ST_NumGeometries() function
      The ST_NumInteriorRing() function
      The ST_NumPoints() function
      The SE_OutOfRowSize() function
      The ST_Overlaps() function
      The SE_ParamGet() function
      The SE_ParamSet() function
      The ST_Perimeter() function
      The SE_PerpendicularPoint() function
      The ST_Point() function
      The ST_PointAtDistance() function
      The SE_PointFromBSON() function
      The ST_PointFromGML() function
      The ST_PointFromKML() function
      The SE_PointFromShape() function
      The ST_PointFromText() function
      The ST_PointFromWKB() function
      The ST_PointN() function
      The ST_PointOnSurface() function
      The SE_PolyFromBSON() function
      The ST_PolyFromGML() function
      The ST_PolyFromKML() function
      The SE_PolyFromShape() function
      The ST_PolyFromText() function
      The ST_PolyFromWKB() function
      The ST_Polygon() function
      The ST_Relate() function
      The SE_Release() function
      The SE_ShapeToSQL() function
      The SE_SpatialKey() function
      The ST_SRID() function
      The SE_SRID_Authority() function
      The ST_StartPoint() function
      The ST_SymDifference() function
      The SE_TotalSize() function
      The ST_Touches() function
      The SE_Trace() function
      The ST_Transform() function
      The ST_Union() function
      The SE_VertexAppend() function
      The SE_VertexDelete() function
      The SE_VertexUpdate() function
      The ST_Within() function
      The ST_WKBToSQL() function
      The ST_WKTToSQL() function
      The ST_X() function
      The ST_Y() function
      The ST_Z function
    Spatial Java API
      Compatibility with the ESRI ArcSDE Java API
      Overview of the Java API
        Geometries
        Uses for the Java API
        The CoordRefManager Class
        The SpatialManager Class
      Overview of a Spatial Java API Application
        Using Logging
        Assigning a Connection to CoordRefManager
        Querying and Displaying Geometries
        Reading Coordinate Data
      Preparing to Run a Program
        Running the Programs
      Example 1: Retrieving a Point From a Table
      Examples 2, 3, and 4: How to Use the Java API
        GeometryToWKT
        GeometryToArray
        CoordRefCreate
    Appendixes
      Load and unload shapefile data
        The infoshp utility
        The loadshp utility
        The unloadshp utility
      OGC well-known text representation of spatial reference systems
        The text representation of a spatial system
        Linear units
        Angular units
        Geodetic spheroids
        Horizontal datums (spheroid only)
        Horizontal datums
        Prime meridians
        Projection parameters
        Map projections
      OGC well-known text representation of geometry
        Well-known text representation in a C program
        Well-known text representation in an SQL editor
        Modified well-known text representation
      OGC well-known binary representation of geometry
        Numeric type definitions
        XDR (big endian) encoding of numeric types
        NDR (little endian) encoding of numeric types
        Conversion between the NDR and XDR representations of WKB geometry
        Description of WKBGeometry byte streams
        Assertions for well-known binary representation for geometry
      ESRI shape representation
        Shape type values
        Shape types in XY space
          Point
          MultiPoint
          PolyLine
          Polygon
            A sample polygon instance
        Measured shape types in XY space
          PointM
          MultiPointM
          PolyLineM
          PolygonM
        Shape types in XYZ space
          PointZ
          MultiPointZ
          PolyLineZ
          PolygonZ
        Measured shape types in XYZ space
          PointZM
          MultiPointZM
          PolyLineZM
          PolygonZM
      Error messages
        Error messages and their explanations
          USE01
          7USE02
          USE03
          USE04
          USE05
          USE06
          USE07
          USE08
          USE09
          USE10
          USE11
          USE12
          USE13
          USE14
          USE15
          USE16
          USE17
          USE18
          USE19
          USE20
          USE21
          USE22
          USE23
          USE24
          USE25
          USE26
          USE27
          USE28
          USE29
          USE30
          USE31
          USE32
          USE33
          USE34
          USE35
          USE36
          USE37
          USE38
          USE39
          USE40
          USE41
          USE42
          USE43
          USE44
          USE45
          USE46
          USE47
          USE48
          USE49
          USE50
          USE51
          USE52
          USE53
          USE54
          -674
Informix TimeSeries Plug-in for OAT
  Informix TimeSeries Plug-in for OAT
    Reviewing time series
    Creating a container
    Creating a calendar
    Creating a virtual table
  Informix TimeSeries Plug-in for OAT
    Reviewing time series
    Creating a container
    Creating a calendar
    Creating a virtual table
Informix TimeSeries Plug-in for OpenAdmin Tool (OAT)
  Informix TimeSeries Plug-in for OAT context help
    TimeSeries
    Database Information
    TimeSeries Subtypes
    Containers
    Calendars
    Tables and Indexes
    Table Information
    Columns
    Virtual Tables
    Create a Container
    Create a Calendar
    Create a Virtual Table
  Informix TimeSeries Plug-in for OAT context help
    TimeSeries
    Database Information
    TimeSeries Subtypes
    Containers
    Calendars
    Tables and Indexes
    Table Information
    Columns
    Virtual Tables
    Create a Container
    Create a Calendar
    Create a Virtual Table
Informix V12.10 documentation
  HCL Informix V12.10 documentation
  HCL Informix V12.10 documentation
Informix virtual images
  IBM Informix Enterprise Hypervisor Edition
    Components of IBM Informix Enterprise Hypervisor Edition
      IBM Informix Enterprise Hypervisor Edition for AIX
      IBM Informix Enterprise Hypervisor Edition for Red Hat Enterprise Linux Server
    Preparing to deploy the Informix pattern
    Deploying the Informix pattern by using the PureApplication System Workload Console
    Deploying an Informix pattern by using IBM Workload Deployer
    Connecting to the deployed HCL Informix instance or a virtual HCL Informix database
    Pattern modification and creation
      Adding script packages
  Informix Virtual Appliance
    Welcome to the HCL Informix Virtual Appliance
    Installing and running the HCL Informix Virtual Appliance
    Installing the HCL Informix Virtual Appliance in a VMware infrastructure environment
    First steps
    Configuring the HCL Informix Virtual Appliance
    High-availability cluster
    OpenAdmin Tool (OAT) for Informix
    Scripts
    Using the Informix JDBC Driver and the JDBC Common Client
    Using PHP with Informix
    Introduction to Data Studio
    Enhanced error message lookup using the basic text search (BTS) extension
    Using HCL Informix Spatial Data
    Using HCL Informix embeddability features
  IBM Informix Enterprise Hypervisor Edition
    Components of IBM Informix Enterprise Hypervisor Edition
      IBM Informix Enterprise Hypervisor Edition for AIX
      IBM Informix Enterprise Hypervisor Edition for Red Hat Enterprise Linux Server
    Preparing to deploy the Informix pattern
    Deploying the Informix pattern by using the PureApplication System Workload Console
    Deploying an Informix pattern by using IBM Workload Deployer
    Connecting to the deployed HCL Informix instance or a virtual HCL Informix database
    Pattern modification and creation
      Adding script packages
  Informix Virtual Appliance
    Welcome to the HCL Informix Virtual Appliance
    Installing and running the HCL Informix Virtual Appliance
    Installing the HCL Informix Virtual Appliance in a VMware infrastructure environment
    First steps
    Configuring the HCL Informix Virtual Appliance
    High-availability cluster
    OpenAdmin Tool (OAT) for Informix
    Scripts
    Using the Informix JDBC Driver and the JDBC Common Client
    Using PHP with Informix
    Introduction to Data Studio
    Enhanced error message lookup using the basic text search (BTS) extension
    Using HCL Informix Spatial Data
    Using HCL Informix embeddability features
Installing
  Informix server
    Installing Informix
      What's new in installation for HCL Informix, Version 12.10
      Preparing for installation
        Informix components
        System requirements
        Installation owner
          Creating the group informix and user informix (UNIX, Linux)
        Database server upgrades
        Installation directory
        Installation options
        Event auditing
        Exclude database server components
        Database server configuration during installation
      Running an interactive installation
      Running non-interactive installations
        Preparing a response file
        Running a silent installation
        Redistributing Informix with scripts (UNIX, Linux, Mac OS X)
      Installation command syntax
      Installation troubleshooting
      Creating a database server after installation
        Setting configuration parameters
        Preparing connectivity files
        Setting environment variables
      Stopping and starting the database server
      Microsoft failover clustering support (Windows)
      Multiresidency
        Creating multiresident database servers (Windows)
          Server instance manager command-line options (Windows)
        Creating multiresident database servers (UNIX, Linux, Mac OS X)
      Removing or modifying Informix installations
        Removing or modifying installations (UNIX, Linux)
        Removing or modifying installations (Mac OS X)
        Removing or modifying installations (Windows)
  Client products
    Informix Client SDK
      Installing Informix Client Products
        What's new in installation for HCL Informix client products, Version 4.10
        Preparing to install Client SDK
          HCL Informix Client Software Development Kit components
            Products that are installed with the HCL OpenAdmin Tool (OAT) for Informix
          System requirements for client products
            System requirements for HCL OpenAdmin Tool (OAT) for Informix
          Installation methods
          Installation owner
          Installation directory
        Installing client products
          Running an interactive installation
          Running a silent installation (UNIX, Linux, Windows)
          Redistributing client products with scripts (UNIX, Linux)
        Client products installation command syntax
        Post-installation tasks for client products
          Environment variables for clients
          Configuring client products on Windows systems
          Connectivity protocols
          Starting the HCL OpenAdmin Tool (OAT) for Informix
        Removing client products
          Removing client products
          Running a silent uninstallation (UNIX, Linux)
          Removing a scripted installation (UNIX, Linux)
          Removing the HCL OpenAdmin Tool (OAT) for Informix
        Client installation troubleshooting
    Open source drivers
      PHP
      Ruby
  DataBlade modules
    DataBlade Module Installation and Registration Guide
      Installing DataBlade modules
        Using a DataBlade module in your database
        Installing your DataBlade module on UNIX
          Installing a newer DataBlade module on UNIX
          Installing a pre-2007 DataBlade module on a UNIX computer
        Installing your DataBlade module on Windows
          Installing your newer DataBlade module on a Windows computer
          Installing your pre-2007 DataBlade module on a Windows computer
        Uninstalling your DataBlade module on UNIX
        Uninstalling your DataBlade module on Windows
      Registering with the SYSBldPrepare( ) function
        Preparing to call the SYSBldPrepare( ) function
        Register a DataBlade module
        Register a set of DataBlade modules
        Unregister a DataBlade module
        Upgrade or revert a DataBlade module
          Upgrade to a higher version
          Revert to an earlier version
        View version information of SYSBldPrepare( )
      Registering with the BladeManager graphical user interface
        Preparing to use the BladeManager graphical user interface
        Managing DataBlade modules
          Connecting to a database
          Registering a DataBlade module
          Upgrading a DataBlade module
          Unregistering a DataBlade module
        Managing client files
          Installing client files
          Uninstalling client files
        Viewing log files
          Viewing a log file
          Deleting a log file
        View module information
      Registering with the BladeManager command-line interface
        Preparing to use the BladeManager command-line interface
        Start and stop BladeManager
        Obtain help for commands
        Set confirmation
        Execute BladeManager commands automatically at startup
        Execute multiple BladeManager commands
        Preparation for database-server reversion
        Connection information
          Connect to your database server
          Connect to databases
        Register a DataBlade module
        Upgrade a DataBlade module
        Unregister a DataBlade module
        Manage client files
          Install client files
          Uninstall client files
        View log files
        View module information
        Command reference
      Troubleshooting registration problems
        Exceptions in calls to SYSBldPrepare( )
        Connection problems
        Preparation failure
        Registration problems
  Informix warehouse accelerator
    Installation
      Informix Warehouse Accelerator prerequisites
      Accelerator directory structure
      Preparing the Informix database server
      Installing the accelerator
      Verifying the Informix database server environment
      Uninstalling the accelerator
      Updating Informix Warehouse Accelerator
  Informix server
    Installing Informix
      What's new in installation for HCL Informix, Version 12.10
      Preparing for installation
        Informix components
        System requirements
        Installation owner
          Creating the group informix and user informix (UNIX, Linux)
        Database server upgrades
        Installation directory
        Installation options
        Event auditing
        Exclude database server components
        Database server configuration during installation
      Running an interactive installation
      Running non-interactive installations
        Preparing a response file
        Running a silent installation
        Redistributing Informix with scripts (UNIX, Linux, Mac OS X)
      Installation command syntax
      Installation troubleshooting
      Creating a database server after installation
        Setting configuration parameters
        Preparing connectivity files
        Setting environment variables
      Stopping and starting the database server
      Microsoft failover clustering support (Windows)
      Multiresidency
        Creating multiresident database servers (Windows)
          Server instance manager command-line options (Windows)
        Creating multiresident database servers (UNIX, Linux, Mac OS X)
      Removing or modifying Informix installations
        Removing or modifying installations (UNIX, Linux)
        Removing or modifying installations (Mac OS X)
        Removing or modifying installations (Windows)
  Client products
    Informix Client SDK
      Installing Informix Client Products
        What's new in installation for HCL Informix client products, Version 4.10
        Preparing to install Client SDK
          HCL Informix Client Software Development Kit components
            Products that are installed with the HCL OpenAdmin Tool (OAT) for Informix
          System requirements for client products
            System requirements for HCL OpenAdmin Tool (OAT) for Informix
          Installation methods
          Installation owner
          Installation directory
        Installing client products
          Running an interactive installation
          Running a silent installation (UNIX, Linux, Windows)
          Redistributing client products with scripts (UNIX, Linux)
        Client products installation command syntax
        Post-installation tasks for client products
          Environment variables for clients
          Configuring client products on Windows systems
          Connectivity protocols
          Starting the HCL OpenAdmin Tool (OAT) for Informix
        Removing client products
          Removing client products
          Running a silent uninstallation (UNIX, Linux)
          Removing a scripted installation (UNIX, Linux)
          Removing the HCL OpenAdmin Tool (OAT) for Informix
        Client installation troubleshooting
    Open source drivers
      PHP
      Ruby
  DataBlade modules
    DataBlade Module Installation and Registration Guide
      Installing DataBlade modules
        Using a DataBlade module in your database
        Installing your DataBlade module on UNIX
          Installing a newer DataBlade module on UNIX
          Installing a pre-2007 DataBlade module on a UNIX computer
        Installing your DataBlade module on Windows
          Installing your newer DataBlade module on a Windows computer
          Installing your pre-2007 DataBlade module on a Windows computer
        Uninstalling your DataBlade module on UNIX
        Uninstalling your DataBlade module on Windows
      Registering with the SYSBldPrepare( ) function
        Preparing to call the SYSBldPrepare( ) function
        Register a DataBlade module
        Register a set of DataBlade modules
        Unregister a DataBlade module
        Upgrade or revert a DataBlade module
          Upgrade to a higher version
          Revert to an earlier version
        View version information of SYSBldPrepare( )
      Registering with the BladeManager graphical user interface
        Preparing to use the BladeManager graphical user interface
        Managing DataBlade modules
          Connecting to a database
          Registering a DataBlade module
          Upgrading a DataBlade module
          Unregistering a DataBlade module
        Managing client files
          Installing client files
          Uninstalling client files
        Viewing log files
          Viewing a log file
          Deleting a log file
        View module information
      Registering with the BladeManager command-line interface
        Preparing to use the BladeManager command-line interface
        Start and stop BladeManager
        Obtain help for commands
        Set confirmation
        Execute BladeManager commands automatically at startup
        Execute multiple BladeManager commands
        Preparation for database-server reversion
        Connection information
          Connect to your database server
          Connect to databases
        Register a DataBlade module
        Upgrade a DataBlade module
        Unregister a DataBlade module
        Manage client files
          Install client files
          Uninstall client files
        View log files
        View module information
        Command reference
      Troubleshooting registration problems
        Exceptions in calls to SYSBldPrepare( )
        Connection problems
        Preparation failure
        Registration problems
  Informix warehouse accelerator
    Installation
      Informix Warehouse Accelerator prerequisites
      Accelerator directory structure
      Preparing the Informix database server
      Installing the accelerator
      Verifying the Informix database server environment
      Uninstalling the accelerator
      Updating Informix Warehouse Accelerator
JSON compatibility
  HCL Informix JSON compatibility
    What's new in JSON, Version 12.10
    About the Informix JSON compatibility
      Getting started with Informix JSON
      Requirements for JSON compatibility
      MongoDB to Informix term mapping
      Support for dots in field names
      Manipulate BSON data with SQL statements
    Wire listener
      Configuring the wire listener for the first time
      The wire listener configuration file
        Modifying the wire listener configuration file
      Wire listener command line options
        Starting the wire listener
        Running multiple wire listeners
        Stopping the wire listener
        Wire listener logging
      User authentication with the wire listener
        Configuring MongoDB authentication
        Configuring database server authentication with PAM (UNIX, Linux)
      Encryption for wire listener communications
        Configuring SSL connections between the wire listener and the database server
        Configuring SSL connections between the wire listener and client applications
      High availability support in the wire listener
    JSON data sharding
      Preparing shard servers
      Creating a shard cluster with MongoDB commands
      Shard-cluster definitions for distributing data
        Defining a sharding schema with a hash algorithm
        Defining a sharding schema with an expression
      Shard cluster management
        Changing the definition for a shard cluster
        Viewing shard-cluster participants
    MongoDB API and commands
      Language drivers
      Command utilities and tools
      Collection methods
      Index creation
      Database commands
      Informix JSON commands
      Running Informix queries through the MongoDB API
        Running SQL commands by using the MongoDB API
        Running MongoDB operations on relational tables
        Running join queries by using the wire listener
      Operators
        Query and projection operators
        Update operators
        Informix query operators and modifier
        Aggregation framework operators
    REST API
      REST API syntax
      Running SQL passthrough queries through REST
      Running join queries through REST
    MQTT protocol
      MQTT packet syntax
    Manage time series through the wire listener
      Creating a time series through the wire listener
        Time series collections and table formats
        Example: Create a time series through the wire listener
      Example queries of time series data by using the wire listener
      Aggregate or slice time series data
      Loading time series data with the MQTT protocol
    Monitoring collections
    Troubleshooting Informix JSON compatibility
  HCL Informix JSON compatibility
    What's new in JSON, Version 12.10
    About the Informix JSON compatibility
      Getting started with Informix JSON
      Requirements for JSON compatibility
      MongoDB to Informix term mapping
      Support for dots in field names
      Manipulate BSON data with SQL statements
    Wire listener
      Configuring the wire listener for the first time
      The wire listener configuration file
        Modifying the wire listener configuration file
      Wire listener command line options
        Starting the wire listener
        Running multiple wire listeners
        Stopping the wire listener
        Wire listener logging
      User authentication with the wire listener
        Configuring MongoDB authentication
        Configuring database server authentication with PAM (UNIX, Linux)
      Encryption for wire listener communications
        Configuring SSL connections between the wire listener and the database server
        Configuring SSL connections between the wire listener and client applications
      High availability support in the wire listener
    JSON data sharding
      Preparing shard servers
      Creating a shard cluster with MongoDB commands
      Shard-cluster definitions for distributing data
        Defining a sharding schema with a hash algorithm
        Defining a sharding schema with an expression
      Shard cluster management
        Changing the definition for a shard cluster
        Viewing shard-cluster participants
    MongoDB API and commands
      Language drivers
      Command utilities and tools
      Collection methods
      Index creation
      Database commands
      Informix JSON commands
      Running Informix queries through the MongoDB API
        Running SQL commands by using the MongoDB API
        Running MongoDB operations on relational tables
        Running join queries by using the wire listener
      Operators
        Query and projection operators
        Update operators
        Informix query operators and modifier
        Aggregation framework operators
    REST API
      REST API syntax
      Running SQL passthrough queries through REST
      Running join queries through REST
    MQTT protocol
      MQTT packet syntax
    Manage time series through the wire listener
      Creating a time series through the wire listener
        Time series collections and table formats
        Example: Create a time series through the wire listener
      Example queries of time series data by using the wire listener
      Aggregate or slice time series data
      Loading time series data with the MQTT protocol
    Monitoring collections
    Troubleshooting Informix JSON compatibility
JSON plug-in for OAT
  Informix JSON plug-in for OAT context help
    JSON
    JSON store objects
      Database Information
      Stored Procedures and Functions
      Database Privileges
      Casts
    Collection objects
      Collection Information
      Indexes
      Collection Privileges
  Informix JSON plug-in for OAT context help
    JSON
    JSON store objects
      Database Information
      Stored Procedures and Functions
      Database Privileges
      Casts
    Collection objects
      Collection Information
      Indexes
      Collection Privileges
Migrating and upgrading
  Migrating Informix database systems
    What's new in migration for Informix, Version 12.10
    Overview of migration
      Overview of Informix migration
        The migration process
          Migration effort
          Migration skills
          Migration plans
          Types of migration
          Migration tools
        Upgrading Informix (in-place migration)
        Migrating Informix (non-in-place migration)
        Hardware and operating system requirements
        Fix pack naming conventions
        Paths for migration to the new version
      Overview of moving data
        Prerequisites before moving data
        Data-migration tools
          High-Performance Loader performance advantages for large databases
          When TEXT and BYTE data is scanned, not compressed
        Moving data between computers and dbspaces
          Importing data from a non-Informix source
          Importing data with Enterprise Gateway products
        Moving data by using distributed SQL
    Migration to and reversion from Version 12.10
      Preparing for migration to Version 12.10
        Preparing for migration
          Reviewing changes in Informix product functionality
          Checking and configuring available space
          Configuring for recovery of restore point data in case an upgrade fails
          Saving copies of the current configuration files
          Preparing 12.10.xC2 BSON columns with DATE fields for upgrade
          Closing all transactions and shutting down the source database server
          Initiating fast recovery to verify that no open transactions exist
          Verifying the integrity of the data
          Verifying that the database server is in quiescent mode
          Making a final backup of the source database server
          Verifying that the source database server is offline
        Pre-migration checklist of diagnostic information
        Migrating from 32-bit to 64-bit database servers
      Enterprise Replication and migration
        Preparing to migrate with Enterprise Replication
        Migrating with Enterprise Replication
        Reverting with Enterprise Replication
      High-availability cluster migration
        Preparing to migrate, upgrade, or revert clusters
        Rolling upgrade of an online cluster to the next fix pack or PID (UNIX, Linux)
        Upgrading an offline cluster to a fix pack or PID
        Migrating an offline cluster to a new major version
        Rolling upgrade of an online cluster with Enterprise Replication
          Errors and warnings generated by the sec2er command
        Reverting clusters
        Restoring clusters to a consistent point
        Restoring a cluster from a backup archive
        Restoring a cluster from the HDR secondary server
      Migrating to Informix Version 12.10
        Migrating to the new version of Informix
          Installing the new version of Informix
            Migration status messages
          Setting environment variables
          Customizing configuration files
          Adding Communications Support Modules
          Installing or upgrading any DataBlade modules
          Starting the new version of Informix
          Restoring to a previous consistent state after a failed upgrade
        Completing required post-migration tasks
          For ON-Bar, copy the sm_versions file
          Finish preparing earlier versions of 12.10 databases for JSON compatibility
          Optionally update statistics on your tables after migrating
          Review client applications and registry keys
          Verify the integrity of migrated data
          Back up Informix after migrating to the new version
          Tune the new version for performance and adjust queries
          Register DataBlade modules
      Reverting from Informix Version 12.10
        Preparing to revert
          Review the database schema prior to reversion
          Reversion requirements and limitations
          Check and configure available space for reversion
          Save copies of the current configuration files
          Save system catalog information
          Verify the integrity of the Version 12.10 data
          Back up Informix Version 12.10
          Resolve outstanding in-place alter operations
          Remove unsupported features
          Remove new BladeManager extensions
        Reverting from Informix Version 12.10
          Run the reversion utility
          Restore original configuration parameters
          Restore original environment variables
          Remove Any Communications Support Module Settings
          Recompile Java user-defined routines
          Reinstall and start the earlier database server
          Add JSON compatibility to databases that were created in 12.10.xC1
          Optionally update statistics on your tables after reverting
          Verify the integrity of the reverted data
          Back up the database server after reversion
          Return the database server to online mode
          Register DataBlade modules
    Migration of data between database servers
      Migrating database servers to a new operating system
        Choosing a tool for moving data before migrating between operating systems
        Adjusting database tables for file-system variations
        Moving data to a database server on a different operating system
        Adapting your programs for a different operating system
        Ensuring the successful creation of system databases
    Data migration utilities
      External tables
      The dbexport and dbimport utilities
        Syntax of the dbexport Command
          Termination of the dbexport utility
          dbexport errors
          dbexport server-specific information
          dbexport destination options
          Exporting time series data in rolling window containers
        Contents of the schema file that dbexport creates
        Syntax of the dbimport command
          Termination of the dbimport utility
          dbimport errors and warnings
          dbimport input-file location options
          dbimport create options
          Database-logging mode
          Database renaming
        Changing the database locale with dbimport
        Simple large objects
      The dbload utility
        Syntax of the dbload command
          Table locking during a load operation
          Rows to ignore during a load operation
          Bad-row limit during a load operation
          Termination of the dbload utility
          Name and object guidelines for the dbload utility
        Command file for the dbload utility
          Delimiter form of the FILE and INSERT statements
            Syntax for the delimiter form
            How to write a dbload command file in delimiter form
          Character-position form of the FILE and INSERT statements
            Syntax for the character-position form
            How to write a dbload command file in character-position form
        Command file to load complex data types
          Using the dbload utility with named row types
          Using the dbload utility with unnamed row types
          Using the dbload utility with collection data types
            SET data type example
            LIST data type example
      The dbschema utility
        Object modes and violation detection in dbschema output
        Guidelines for using the dbschema utility
        Syntax of the dbschema command
          Database schema creation
            Creating schemas for databases across a UNIX or Linux network
            Changing the owner of an object
          dbschema server-specific information
          User-defined and complex data types
          Sequence creation
          Synonym creation
          Table, view, or procedure creation
          Table information
          Storage space, chunk, and log creation
            Sample output for the creation of storage spaces, chunks, and logs
          Role creation
          Privileges
            Granting privileges
            Displaying privilege information for a role
          Distribution information for tables in dbschema output
            Example of dbschema output showing distribution information
            Distribution information in dbschema output
            Overflow information in dbschema output
        Use dbschema output as DB-Access input
          Inserting a table into a dbschema output file
          Re-creating the schema of a database
      The LOAD and UNLOAD statements
        Syntax of the UNLOAD statement
        Syntax of the LOAD statement
        Load and unload statements for locales that support multibyte code sets
        Load and unload statements for nondefault locales and the GL_DATETIME and USE_DTENV environment variables
      The onunload and onload utilities
        Guidelines for when to use the onunload and onload utilities
        Requirements for using the onload and onunload utilities
        How the onunload and onload utilities work
        Syntax of the onunload command
          onunload destination parameters
          Constraints that affect onunload
          Privileges for database or table unloading
          Tables that are unloaded with a database
          Data that is unloaded with a table
          Locking during unload operation
        Logging mode
        Syntax of the onload command
          onload source parameters
          onload create options
          Constraints that affect onload
          Logging during loading
          Movement of simple large objects to a blobspace
          Ownership and privileges
          Exclusive locking during a load operation
        Moving a database between computers with the onunload and onload utilities
        Moving a table between computers with the onunload and onload utilities
        Moving a table between dbspaces with the onunload and onload utilities
      The onmode utility reversion option
        What the onmode -b command does
        Preparation for using the onmode -b command
        Syntax of the onmode -b command
      The onrestorept utility
        Syntax of the onrestorept command
    New and changed features
      Environment variable changes by version
      Configuration parameter changes by version
        Deprecated and discontinued configuration parameters
        Configuration parameter changes in Version 12.10
        Configuration parameter changes in Version 11.70
        Configuration parameter changes in Version 11.50
        Configuration parameter changes in Versions 11.10, 10.00, and earlier
      SQL keyword changes by version
      System catalog and system database changes by version
        Changes for version 12.10
        Changes for version 11.70
        Changes for version 11.50
        Changes for version 11.10
        Changes for version 10.00
      Server library name changes by version
  Migrating Informix database systems
    What's new in migration for Informix, Version 12.10
    Overview of migration
      Overview of Informix migration
        The migration process
          Migration effort
          Migration skills
          Migration plans
          Types of migration
          Migration tools
        Upgrading Informix (in-place migration)
        Migrating Informix (non-in-place migration)
        Hardware and operating system requirements
        Fix pack naming conventions
        Paths for migration to the new version
      Overview of moving data
        Prerequisites before moving data
        Data-migration tools
          High-Performance Loader performance advantages for large databases
          When TEXT and BYTE data is scanned, not compressed
        Moving data between computers and dbspaces
          Importing data from a non-Informix source
          Importing data with Enterprise Gateway products
        Moving data by using distributed SQL
    Migration to and reversion from Version 12.10
      Preparing for migration to Version 12.10
        Preparing for migration
          Reviewing changes in Informix product functionality
          Checking and configuring available space
          Configuring for recovery of restore point data in case an upgrade fails
          Saving copies of the current configuration files
          Preparing 12.10.xC2 BSON columns with DATE fields for upgrade
          Closing all transactions and shutting down the source database server
          Initiating fast recovery to verify that no open transactions exist
          Verifying the integrity of the data
          Verifying that the database server is in quiescent mode
          Making a final backup of the source database server
          Verifying that the source database server is offline
        Pre-migration checklist of diagnostic information
        Migrating from 32-bit to 64-bit database servers
      Enterprise Replication and migration
        Preparing to migrate with Enterprise Replication
        Migrating with Enterprise Replication
        Reverting with Enterprise Replication
      High-availability cluster migration
        Preparing to migrate, upgrade, or revert clusters
        Rolling upgrade of an online cluster to the next fix pack or PID (UNIX, Linux)
        Upgrading an offline cluster to a fix pack or PID
        Migrating an offline cluster to a new major version
        Rolling upgrade of an online cluster with Enterprise Replication
          Errors and warnings generated by the sec2er command
        Reverting clusters
        Restoring clusters to a consistent point
        Restoring a cluster from a backup archive
        Restoring a cluster from the HDR secondary server
      Migrating to Informix Version 12.10
        Migrating to the new version of Informix
          Installing the new version of Informix
            Migration status messages
          Setting environment variables
          Customizing configuration files
          Adding Communications Support Modules
          Installing or upgrading any DataBlade modules
          Starting the new version of Informix
          Restoring to a previous consistent state after a failed upgrade
        Completing required post-migration tasks
          For ON-Bar, copy the sm_versions file
          Finish preparing earlier versions of 12.10 databases for JSON compatibility
          Optionally update statistics on your tables after migrating
          Review client applications and registry keys
          Verify the integrity of migrated data
          Back up Informix after migrating to the new version
          Tune the new version for performance and adjust queries
          Register DataBlade modules
      Reverting from Informix Version 12.10
        Preparing to revert
          Review the database schema prior to reversion
          Reversion requirements and limitations
          Check and configure available space for reversion
          Save copies of the current configuration files
          Save system catalog information
          Verify the integrity of the Version 12.10 data
          Back up Informix Version 12.10
          Resolve outstanding in-place alter operations
          Remove unsupported features
          Remove new BladeManager extensions
        Reverting from Informix Version 12.10
          Run the reversion utility
          Restore original configuration parameters
          Restore original environment variables
          Remove Any Communications Support Module Settings
          Recompile Java user-defined routines
          Reinstall and start the earlier database server
          Add JSON compatibility to databases that were created in 12.10.xC1
          Optionally update statistics on your tables after reverting
          Verify the integrity of the reverted data
          Back up the database server after reversion
          Return the database server to online mode
          Register DataBlade modules
    Migration of data between database servers
      Migrating database servers to a new operating system
        Choosing a tool for moving data before migrating between operating systems
        Adjusting database tables for file-system variations
        Moving data to a database server on a different operating system
        Adapting your programs for a different operating system
        Ensuring the successful creation of system databases
    Data migration utilities
      External tables
      The dbexport and dbimport utilities
        Syntax of the dbexport Command
          Termination of the dbexport utility
          dbexport errors
          dbexport server-specific information
          dbexport destination options
          Exporting time series data in rolling window containers
        Contents of the schema file that dbexport creates
        Syntax of the dbimport command
          Termination of the dbimport utility
          dbimport errors and warnings
          dbimport input-file location options
          dbimport create options
          Database-logging mode
          Database renaming
        Changing the database locale with dbimport
        Simple large objects
      The dbload utility
        Syntax of the dbload command
          Table locking during a load operation
          Rows to ignore during a load operation
          Bad-row limit during a load operation
          Termination of the dbload utility
          Name and object guidelines for the dbload utility
        Command file for the dbload utility
          Delimiter form of the FILE and INSERT statements
            Syntax for the delimiter form
            How to write a dbload command file in delimiter form
          Character-position form of the FILE and INSERT statements
            Syntax for the character-position form
            How to write a dbload command file in character-position form
        Command file to load complex data types
          Using the dbload utility with named row types
          Using the dbload utility with unnamed row types
          Using the dbload utility with collection data types
            SET data type example
            LIST data type example
      The dbschema utility
        Object modes and violation detection in dbschema output
        Guidelines for using the dbschema utility
        Syntax of the dbschema command
          Database schema creation
            Creating schemas for databases across a UNIX or Linux network
            Changing the owner of an object
          dbschema server-specific information
          User-defined and complex data types
          Sequence creation
          Synonym creation
          Table, view, or procedure creation
          Table information
          Storage space, chunk, and log creation
            Sample output for the creation of storage spaces, chunks, and logs
          Role creation
          Privileges
            Granting privileges
            Displaying privilege information for a role
          Distribution information for tables in dbschema output
            Example of dbschema output showing distribution information
            Distribution information in dbschema output
            Overflow information in dbschema output
        Use dbschema output as DB-Access input
          Inserting a table into a dbschema output file
          Re-creating the schema of a database
      The LOAD and UNLOAD statements
        Syntax of the UNLOAD statement
        Syntax of the LOAD statement
        Load and unload statements for locales that support multibyte code sets
        Load and unload statements for nondefault locales and the GL_DATETIME and USE_DTENV environment variables
      The onunload and onload utilities
        Guidelines for when to use the onunload and onload utilities
        Requirements for using the onload and onunload utilities
        How the onunload and onload utilities work
        Syntax of the onunload command
          onunload destination parameters
          Constraints that affect onunload
          Privileges for database or table unloading
          Tables that are unloaded with a database
          Data that is unloaded with a table
          Locking during unload operation
        Logging mode
        Syntax of the onload command
          onload source parameters
          onload create options
          Constraints that affect onload
          Logging during loading
          Movement of simple large objects to a blobspace
          Ownership and privileges
          Exclusive locking during a load operation
        Moving a database between computers with the onunload and onload utilities
        Moving a table between computers with the onunload and onload utilities
        Moving a table between dbspaces with the onunload and onload utilities
      The onmode utility reversion option
        What the onmode -b command does
        Preparation for using the onmode -b command
        Syntax of the onmode -b command
      The onrestorept utility
        Syntax of the onrestorept command
    New and changed features
      Environment variable changes by version
      Configuration parameter changes by version
        Deprecated and discontinued configuration parameters
        Configuration parameter changes in Version 12.10
        Configuration parameter changes in Version 11.70
        Configuration parameter changes in Version 11.50
        Configuration parameter changes in Versions 11.10, 10.00, and earlier
      SQL keyword changes by version
      System catalog and system database changes by version
        Changes for version 12.10
        Changes for version 11.70
        Changes for version 11.50
        Changes for version 11.10
        Changes for version 10.00
      Server library name changes by version
OpenAdmin Tool (OAT) Context Help
  OpenAdmin Tool (OAT) Context Help
    Admin
      OAT Config
      OAT Admin
      Connection Admin
        Connection Admin
        Connection List
        Add a Group
        Edit a Group
        Add a Connection to an OAT Group
        Edit a Connection
      Plug-in Manager
      Menu Manager
      Dashboard Manager
    Login
    OpenAdmin Tool (OAT) for Informix
    OpenAdmin Tool (OAT) for Informix
    Alerts
    Dashboard
    Group Summary Dashboard
    Logs
      Online Message Log
      Online Message Log Rotation
      ON-Bar Activity Log
      ON-Bar Activity Log Rotation
    Task Scheduler
    New Task Setup
    Delete a Task
    Task Details: Cron Task List
    Task Details
    Edit Task Parameter
    Task Runtimes
    Space
      Storage
      Information
      Spaces
      Create a Space
      Expand a Space
      Modify the Space
      Storage Pool
      Add a Storage Pool Entry
      Modify a Storage Pool Entry
      Chunks
      Add a Chunk
      Modify a Chunk
      Extend a Chunk
      Tables and Indexes
      Optimize Space
      Server Optimization Policies
      Task Status
      Information
    Recovery Logs
      Logical Logs
      Physical Log
      Recovery Logs Admin
      Recovery Policies
    Backup
      Backup Wizard
      Status
      Administration
      Configuration
      Logs
    Server Configuration
    Onconfig Parameter Details
    Trusted hosts
    System Validation
    Virtual Processors
      Virtual Processors
      Class Details
    User Privileges
      Database-Level Privileges
      Table-Level Privileges
      Internal Users (UNIX, Linux)
      Add Internal User (UNIX, Linux)
      Edit Internal User (UNIX, Linux)
      SQL Admin API Privileges
    Auto Update Statistics
    Auto Update Statistics: Info
    Auto Update Statistics: Alerts
    Auto Update Statistics: List
    Auto Update Statistics: Configuration
    Trusted Context
      Trusted Context
      Create Trusted Context Wizard
      Modify Trusted Context Wizard
    Memory Manager
    High Availability Clusters
      High-Availability Clusters
      Find Clusters
      Add SDS Server
    Warehouse Accelerator
      Warehouse Accelerator
    SQL Explorer
      Activity Summary
      SQL Type Summary
      SQL List
      Recent Transactions
      Transaction Statistics Summary with SQL List
      SQL Profile
      Tracing Admin
      SQL Explorer: SQL Type
    Performance History
    System Reports
      Current Reports
      Historical Reports
      Graphs
      Disk Space Usage Report
      Disk I/O Levels Report
      Logical Logs Report
      Physical Log Report
      System Backups Report
      View Checkpoints
      Virtual Processors Report
      Server Configuration
      View SQL Cache Report
      Server Memory Usage Report
      Memory Pools Report
      Network Overview Report
      Server Admin Commands
      Computer Resource Information Report
      Computer OS Information Report
      SQL Statement Summary Report
      Slowest SQL Statements Report
      SQL with the Most I/O Time Report
      SQL with the Most Buffer Activity Report
      Show Databases Report
      Table Actions Report
      Session List Report
      Waiting Session Report
      Lock List
      Locks per Table
      Locks per Session
      Locks with Waiters
    Session Explorer
    Session Explorer: Locks
    Session Explorer: Threads
    Session Explorer: Memory
    Session Explorer: Network
    Session Explorer - Environment
    Session Explorer: Profile
    Session Explorer - SQL
    onstat Utility
    Databases
    SQL ToolBox: Tables
    SQL Toolbox - Stored Procedures
    SQL Toolbox - Column Info
    SQLToolbox: Browse Table
    SQLToolbox: Table Fragments
    SQL Editor
    Query Tree
    Query Result
    Query By Example
      Query By Example
      Query Results in Query By Example
      Insert in Query By Example
    Tenancy
      Chunks
      Tenant database information
      Space usage
      Spaces
      Tenancy
      Tables and Indexes
      Tenant Virtual Processors
  OpenAdmin Tool (OAT) Context Help
    Admin
      OAT Config
      OAT Admin
      Connection Admin
        Connection Admin
        Connection List
        Add a Group
        Edit a Group
        Add a Connection to an OAT Group
        Edit a Connection
      Plug-in Manager
      Menu Manager
      Dashboard Manager
    Login
    OpenAdmin Tool (OAT) for Informix
    OpenAdmin Tool (OAT) for Informix
    Alerts
    Dashboard
    Group Summary Dashboard
    Logs
      Online Message Log
      Online Message Log Rotation
      ON-Bar Activity Log
      ON-Bar Activity Log Rotation
    Task Scheduler
    New Task Setup
    Delete a Task
    Task Details: Cron Task List
    Task Details
    Edit Task Parameter
    Task Runtimes
    Space
      Storage
      Information
      Spaces
      Create a Space
      Expand a Space
      Modify the Space
      Storage Pool
      Add a Storage Pool Entry
      Modify a Storage Pool Entry
      Chunks
      Add a Chunk
      Modify a Chunk
      Extend a Chunk
      Tables and Indexes
      Optimize Space
      Server Optimization Policies
      Task Status
      Information
    Recovery Logs
      Logical Logs
      Physical Log
      Recovery Logs Admin
      Recovery Policies
    Backup
      Backup Wizard
      Status
      Administration
      Configuration
      Logs
    Server Configuration
    Onconfig Parameter Details
    Trusted hosts
    System Validation
    Virtual Processors
      Virtual Processors
      Class Details
    User Privileges
      Database-Level Privileges
      Table-Level Privileges
      Internal Users (UNIX, Linux)
      Add Internal User (UNIX, Linux)
      Edit Internal User (UNIX, Linux)
      SQL Admin API Privileges
    Auto Update Statistics
    Auto Update Statistics: Info
    Auto Update Statistics: Alerts
    Auto Update Statistics: List
    Auto Update Statistics: Configuration
    Trusted Context
      Trusted Context
      Create Trusted Context Wizard
      Modify Trusted Context Wizard
    Memory Manager
    High Availability Clusters
      High-Availability Clusters
      Find Clusters
      Add SDS Server
    Warehouse Accelerator
      Warehouse Accelerator
    SQL Explorer
      Activity Summary
      SQL Type Summary
      SQL List
      Recent Transactions
      Transaction Statistics Summary with SQL List
      SQL Profile
      Tracing Admin
      SQL Explorer: SQL Type
    Performance History
    System Reports
      Current Reports
      Historical Reports
      Graphs
      Disk Space Usage Report
      Disk I/O Levels Report
      Logical Logs Report
      Physical Log Report
      System Backups Report
      View Checkpoints
      Virtual Processors Report
      Server Configuration
      View SQL Cache Report
      Server Memory Usage Report
      Memory Pools Report
      Network Overview Report
      Server Admin Commands
      Computer Resource Information Report
      Computer OS Information Report
      SQL Statement Summary Report
      Slowest SQL Statements Report
      SQL with the Most I/O Time Report
      SQL with the Most Buffer Activity Report
      Show Databases Report
      Table Actions Report
      Session List Report
      Waiting Session Report
      Lock List
      Locks per Table
      Locks per Session
      Locks with Waiters
    Session Explorer
    Session Explorer: Locks
    Session Explorer: Threads
    Session Explorer: Memory
    Session Explorer: Network
    Session Explorer - Environment
    Session Explorer: Profile
    Session Explorer - SQL
    onstat Utility
    Databases
    SQL ToolBox: Tables
    SQL Toolbox - Stored Procedures
    SQL Toolbox - Column Info
    SQLToolbox: Browse Table
    SQLToolbox: Table Fragments
    SQL Editor
    Query Tree
    Query Result
    Query By Example
      Query By Example
      Query Results in Query By Example
      Insert in Query By Example
    Tenancy
      Chunks
      Tenant database information
      Space usage
      Spaces
      Tenancy
      Tables and Indexes
      Tenant Virtual Processors
Product overview
  What's new in Informix
  Getting started
  Tutorials and examples
  Product versions
  Accessibility features for HCL Informix products
  Compliance with industry standards
  Java technology dependencies
  Assumptions about your locale
  Demonstration databases
  Education
  Release information
    Informix
      12.10.xC14
        Release notes for HCL Informix for AIX and Linux 12.10.xC14
      12.10.xC13
        Release notes for HCL Informix for AIX and Linux 12.10.xC13
      12.10.xC12
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC12
          Notices
      12.10.xC11
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC11
          Notices
      12.10.xC10
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC10
          Notices
      12.10.xC9
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
      12.10.xC8
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
      12.10.xC7
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          IBM AIX 6.1 64 bit
          HEWLETT PACKARD HP-UX Itanium
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux Power Series (little endian)
          Linux ARMv6
          Linux ARMv7
          Linux ARM64
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
      12.10.xC6
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux Power Series (little endian)
          Linux ARMv7
          Linux ARMv6
          Linux ARM64
          Mac OS X Server x86_64
          SOLARIS 64bit
          Windows x32
          Windows x64
        Linux zSeries
      12.10.xC5
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux ARMv6
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
          Linux zSeries
      12.10.xC4
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux ARMv7
          Linux zSeries
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC4
      12.10.xC3
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux zSeries
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC3
      12.10.xC2
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux zSeries
          SOLARIS 64bit
          Solaris x64Bit
          Windows x32
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC2
      12.10.xC1
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
    Client SDK
      4.10.xC14
        Release notes for HCL Informix Client Software Development Kit for AIX and Linux, 4.10.xC14
      4.10.xC13
        Release notes for HCL Informix Client Software Development Kit for AIX and Linux, 4.10.xC13
      4.10.xC12
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC12
        GLS API Machine Notes
        Release notes for HCL Informix JDBC Driver, 4.10.JC12
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC11
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC11
        Release notes for HCL Informix Global Language Support (GLS), 6.00.xC11
        Release notes for HCL Informix JDBC Driver, 4.10.JC11
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC10
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC10
        Release notes for HCL Informix Global Language Support (GLS), 6.00.xC10
        Release notes for HCL Informix JDBC Driver, 4.10.JC10
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC8
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC9 Release notes
        Informix JDBC Driver 4.10.JC8 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC7
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC8 Release notes
        Informix JDBC Driver 4.10.JC7 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC6
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC6 Release notes
        Informix JDBC Driver 4.10.JC6 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC5
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC6 Release notes
        Informix JDBC Driver 4.10.JC5 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC4
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC4 Release notes
        Informix JDBC Driver 4.10.JC4 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC3
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC3 Release notes
        Informix JDBC Driver 4.10.JC3 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC2
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC2 Release notes
        Informix JDBC Driver 4.10.JC2 Release notes
        Fixed defects
        Known defects
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC1
        CSDK and ICONNECT Release and documentation notes
        Connection Manager Release and documentation notes
        ESQL/C Release and documentation notes
        GLS 6.00.xC1 Release and documentation notes
        Informix JDBC Driver 4.10.JC1 Release and documentation notes
        Informix .NET Provider Release and documentation notes
        ODBC Driver Release and documentation notes
        OLE DB Provider Release and documentation notes
        Fixed defects
        Known defects
        Machine notes
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
    Informix JDBC Driver
      4.10.JC11
        Release notes for HCL Informix JDBC Driver, 4.10.JC11
      4.10.JC10
        Release notes for HCL Informix JDBC Driver, 4.10.JC10
      4.10.JC8
        Release notes for HCL Informix JDBC Driver, 4.10.JC8
      4.10.JC6
        Release notes for HCL Informix JDBC Driver, 4.10.JC6
      4.10.JC5
        Release notes for HCL Informix JDBC Driver, 4.10.JC5
      4.10.JC4
        Release notes for HCL Informix JDBC Driver, 4.10.JC4
      4.10.JC3
        Release notes for HCL Informix JDBC Driver, 4.10.JC3
      4.10.JC2
        Release notes for HCL Informix JDBC Driver, 4.10.JC2
        Fixed defects
        Known defects
      4.10.JC1
        Release notes for HCL Informix JDBC Driver, 4.10.JC1
        Fixed defects
        Known defects
  GDPR Compliance Information
    Notice
    Overview
    Product Configuration for GDPR
    Data Life Cycle
    Data Collection
    Data Storage
    Data Access
    Data Processing
    Data Deletion
    Data Monitoring
    Responding to Data Subject Rights
  What's new in Informix
  Getting started
  Tutorials and examples
  Product versions
  Accessibility features for HCL Informix products
  Compliance with industry standards
  Java technology dependencies
  Assumptions about your locale
  Demonstration databases
  Education
  Release information
    Informix
      12.10.xC14
        Release notes for HCL Informix for AIX and Linux 12.10.xC14
      12.10.xC13
        Release notes for HCL Informix for AIX and Linux 12.10.xC13
      12.10.xC12
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC12
          Notices
      12.10.xC11
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC11
          Notices
      12.10.xC10
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC10
          Notices
      12.10.xC9
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
      12.10.xC8
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux Power Series (little endian)
          Linux x86_64
          Linux ARMv7
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
      12.10.xC7
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          IBM AIX 6.1 64 bit
          HEWLETT PACKARD HP-UX Itanium
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux Power Series (little endian)
          Linux ARMv6
          Linux ARMv7
          Linux ARM64
          Linux zSeries
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
      12.10.xC6
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux Power Series (little endian)
          Linux ARMv7
          Linux ARMv6
          Linux ARM64
          Mac OS X Server x86_64
          SOLARIS 64bit
          Windows x32
          Windows x64
        Linux zSeries
      12.10.xC5
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux ARMv6
          Mac OS X Server x86_64
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
          Linux zSeries
      12.10.xC4
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux x86_64
          Linux Power Series
          Linux ARMv7
          Linux zSeries
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC4
      12.10.xC3
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Documentation notes for IBM Informix
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux zSeries
          SOLARIS 64bit
          Solaris x86 64Bit
          Windows x32
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC3
      12.10.xC2
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
        Machine notes
          HEWLETT PACKARD HP-UX Itanium
          IBM AIX 6.1 64 bit
          Linux Intel
          Linux Power Series
          Linux x86_64
          Linux zSeries
          SOLARIS 64bit
          Solaris x64Bit
          Windows x32
          Windows x64
        Developer Edition
          Release notes (Windows)
          Release notes for HCL Informix Developer Edition for UNIX, Linux, and Mac OS X, 12.10.xC2
      12.10.xC1
        Release notes (Windows)
        Release notes (UNIX, Linux, and Mac OS X)
    Client SDK
      4.10.xC14
        Release notes for HCL Informix Client Software Development Kit for AIX and Linux, 4.10.xC14
      4.10.xC13
        Release notes for HCL Informix Client Software Development Kit for AIX and Linux, 4.10.xC13
      4.10.xC12
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC12
        GLS API Machine Notes
        Release notes for HCL Informix JDBC Driver, 4.10.JC12
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC11
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC11
        Release notes for HCL Informix Global Language Support (GLS), 6.00.xC11
        Release notes for HCL Informix JDBC Driver, 4.10.JC11
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC10
        Release notes for HCL Informix Client Software Development Kit for UNIX, Linux, and Mac OS X, 4.10.xC10
        Release notes for HCL Informix Global Language Support (GLS), 6.00.xC10
        Release notes for HCL Informix JDBC Driver, 4.10.JC10
        Machine notes
          C++ Interface
          ESQL/C Machine Notes
          GLS API Machine Notes
          Informix .NET Provider Machine Notes
          ODBC Driver Machine Notes
          OLE DB Provider Machine Notes
      4.10.xC8
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC9 Release notes
        Informix JDBC Driver 4.10.JC8 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC7
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC8 Release notes
        Informix JDBC Driver 4.10.JC7 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC6
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC6 Release notes
        Informix JDBC Driver 4.10.JC6 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC5
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC6 Release notes
        Informix JDBC Driver 4.10.JC5 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC4
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC4 Release notes
        Informix JDBC Driver 4.10.JC4 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC3
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC3 Release notes
        Informix JDBC Driver 4.10.JC3 Release notes
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC2
        Release notes (Windows)
        Release notes (UNIX, Linux, Mac OS X)
        GLS 6.00.xC2 Release notes
        Informix JDBC Driver 4.10.JC2 Release notes
        Fixed defects
        Known defects
        Machine notes
          C++ Interface
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
      4.10.xC1
        CSDK and ICONNECT Release and documentation notes
        Connection Manager Release and documentation notes
        ESQL/C Release and documentation notes
        GLS 6.00.xC1 Release and documentation notes
        Informix JDBC Driver 4.10.JC1 Release and documentation notes
        Informix .NET Provider Release and documentation notes
        ODBC Driver Release and documentation notes
        OLE DB Provider Release and documentation notes
        Fixed defects
        Known defects
        Machine notes
          ESQL/C
          GLS API
          Informix .NET Provider
          ODBC Driver
          OLE DB Provider
        Informix ILS 3.50.MC7 Readme
    Informix JDBC Driver
      4.10.JC11
        Release notes for HCL Informix JDBC Driver, 4.10.JC11
      4.10.JC10
        Release notes for HCL Informix JDBC Driver, 4.10.JC10
      4.10.JC8
        Release notes for HCL Informix JDBC Driver, 4.10.JC8
      4.10.JC6
        Release notes for HCL Informix JDBC Driver, 4.10.JC6
      4.10.JC5
        Release notes for HCL Informix JDBC Driver, 4.10.JC5
      4.10.JC4
        Release notes for HCL Informix JDBC Driver, 4.10.JC4
      4.10.JC3
        Release notes for HCL Informix JDBC Driver, 4.10.JC3
      4.10.JC2
        Release notes for HCL Informix JDBC Driver, 4.10.JC2
        Fixed defects
        Known defects
      4.10.JC1
        Release notes for HCL Informix JDBC Driver, 4.10.JC1
        Fixed defects
        Known defects
  GDPR Compliance Information
    Notice
    Overview
    Product Configuration for GDPR
    Data Life Cycle
    Data Collection
    Data Storage
    Data Access
    Data Processing
    Data Deletion
    Data Monitoring
    Responding to Data Subject Rights
Replication Plug-in for OAT Context Help
  Informix Replication Plug-in for OAT Context Help
    Grid
      Grid
      Create Grid
      Add Members
      Change Users
      Status
    Domain
      Domain
      Modify Server
      Connect Server
      Disconnect Server
      Suspend Replication
      Resume Replication
      Disable Replication
      Enable Replication
      Start Replication
      Stop Replication
      Clean Start Replication
    Define a Server for ER
      Define a server for Enterprise Replication
      Step 2: Select the ER domain and set the node options
      Step 3: Configure ER disk usage
      Step 4: Review your choices and define the server for ER
    Node Details
      Summary
      Capture
      Send Queue
      Network
      Disk
      Apply
      Aborted Transaction Spooling (ATS) Files
      Row Information Spooling (RIS) Files
      Errors
      Configuration
      Threshold Configuration
    Templates
      Templates
      Define Template
      Realize Template
    Replicate Sets
      Replicate Sets
      Define Replicate Set
      Define Replicate Set: Advanced Options
      Modify Replicate Set
      Start Replicate Set
      Stop Replicate Set
      Suspend Replicate Set
      Resume Replicate Set
      Check or Sync Replicate Set
      Task Status for Replicate Sets
    Replicates
      Replicates
      Define Replicate
      Define Replicate: Advanced Options
      Modify Replicate
      Modify Replicate: Advanced Options
      Start Replicate
      Stop Replicate
      Suspend Replicate
      Resume Replicate
      Check or Sync Replicate
      Task Status for Replicates
    Connection Manager
      Connection Manager
      Cluster
      Grid
      Replicate Set
      Server Set
      Disjoint
      Create a Connection Manager
      Add a Connection Unit
      Modify a Connection Unit: Cluster
      Create an SLA
      Modify an SLA
  Informix Replication Plug-in for OAT Context Help
    Grid
      Grid
      Create Grid
      Add Members
      Change Users
      Status
    Domain
      Domain
      Modify Server
      Connect Server
      Disconnect Server
      Suspend Replication
      Resume Replication
      Disable Replication
      Enable Replication
      Start Replication
      Stop Replication
      Clean Start Replication
    Define a Server for ER
      Define a server for Enterprise Replication
      Step 2: Select the ER domain and set the node options
      Step 3: Configure ER disk usage
      Step 4: Review your choices and define the server for ER
    Node Details
      Summary
      Capture
      Send Queue
      Network
      Disk
      Apply
      Aborted Transaction Spooling (ATS) Files
      Row Information Spooling (RIS) Files
      Errors
      Configuration
      Threshold Configuration
    Templates
      Templates
      Define Template
      Realize Template
    Replicate Sets
      Replicate Sets
      Define Replicate Set
      Define Replicate Set: Advanced Options
      Modify Replicate Set
      Start Replicate Set
      Stop Replicate Set
      Suspend Replicate Set
      Resume Replicate Set
      Check or Sync Replicate Set
      Task Status for Replicate Sets
    Replicates
      Replicates
      Define Replicate
      Define Replicate: Advanced Options
      Modify Replicate
      Modify Replicate: Advanced Options
      Start Replicate
      Stop Replicate
      Suspend Replicate
      Resume Replicate
      Check or Sync Replicate
      Task Status for Replicates
    Connection Manager
      Connection Manager
      Cluster
      Grid
      Replicate Set
      Server Set
      Disjoint
      Create a Connection Manager
      Add a Connection Unit
      Modify a Connection Unit: Cluster
      Create an SLA
      Modify an SLA
Schema Manager Plug-in for OAT
  Informix Schema Manager Plug-in for OAT Context Help
    Schema Manager
    Database Objects
      Database Objects
      Database Information
      Stored Procedures and Functions
      Sequences
      Database User-Defined Data Types (UDTs)
      Database Privileges
      DataBlade Modules
      Aggregates
      Casts
      Operator Classes
      Data Mart
    Table Objects
      Table Objects
      Table Information
      Columns
      Indexes
      References
      Table Privileges
      Table Statistics
      Fragment Statistics
      Constraints
      Fragments
      Triggers
    Create Database Wizard
    Create a Demo Database
    Create Table Wizard
      Create Table Wizard - Table Information and Columns
      Create Table Wizard - Primary, Foreign, and Unique Keys
      Create Table Wizard - Table Options
      Create Table Wizard - External Table Options
      Create Table Wizard - Extent Size and Storage Scheme
      Create Table Wizard - SQL Statements
      Create Table Wizard - Results
    Create Index Wizard
      Create Index Wizard - Index Type and Columns
      Create Index Wizard - Index Options and Storage
      Create Index Wizard - SQL Statements
      Create Index Wizard - Results
    Load Table
      Load Table
      Load Table - Map Columns
      Load Table - External Table Options
      Load Table - SQL Statements
    Unload Table
      Unload Table
      Unload Table - Map Columns
      Unload Table - External Table Options
      Unload Table - SQL Statements
    Create a Data Mart
    Edit the Load Schedule
    Tasks
    Task Status
  Informix Schema Manager Plug-in for OAT Context Help
    Schema Manager
    Database Objects
      Database Objects
      Database Information
      Stored Procedures and Functions
      Sequences
      Database User-Defined Data Types (UDTs)
      Database Privileges
      DataBlade Modules
      Aggregates
      Casts
      Operator Classes
      Data Mart
    Table Objects
      Table Objects
      Table Information
      Columns
      Indexes
      References
      Table Privileges
      Table Statistics
      Fragment Statistics
      Constraints
      Fragments
      Triggers
    Create Database Wizard
    Create a Demo Database
    Create Table Wizard
      Create Table Wizard - Table Information and Columns
      Create Table Wizard - Primary, Foreign, and Unique Keys
      Create Table Wizard - Table Options
      Create Table Wizard - External Table Options
      Create Table Wizard - Extent Size and Storage Scheme
      Create Table Wizard - SQL Statements
      Create Table Wizard - Results
    Create Index Wizard
      Create Index Wizard - Index Type and Columns
      Create Index Wizard - Index Options and Storage
      Create Index Wizard - SQL Statements
      Create Index Wizard - Results
    Load Table
      Load Table
      Load Table - Map Columns
      Load Table - External Table Options
      Load Table - SQL Statements
    Unload Table
      Unload Table
      Unload Table - Map Columns
      Unload Table - External Table Options
      Unload Table - SQL Statements
    Create a Data Mart
    Edit the Load Schedule
    Tasks
    Task Status
Security
  Security in HCL Informix
    What's new for security in Informix, Version 12.10
    Securing data
      HCL Informix directory security
        Utilities for checking directory security (UNIX)
          Installation path security requirements (UNIX)
            Trusted users and groups (UNIX)
            Secure directory permissions (UNIX)
          The onsecurity utility (UNIX)
          Securing $INFORMIXDIR and its subdirectories
            Disabling the security check of INFORMIXDIR and subdirectories
        Security warnings and error messages at server startup (UNIX)
        Users and group membership for running utilities
        Security of the chunk files
        Security for loading external modules
      Network data encryption
        Communication support modules for data transmission encryption
          Enabling encryption with communication support modules
          CSM configuration file
          Encryption ciphers and modes
          MAC key files
          Generating a new MAC key file
          MAC levels
          Switch frequency
          Network data encryption syntax
            Specifying network encryption options in concsm.cfg
            Invoking an encryption parameters file in concsm.cfg
              ENCCSM_CIPHERS parameter
              ENCCSM_MAC parameter
              ENCCSM_MACFILES parameter
              ENCCSM_SWITCH parameter
              Example of encryption parameter file
        Enterprise replication and high availability network data encryption
        Secure sockets layer protocol
          IBM Global Security Kit (GSKit)
          Configuring a server instance for secure sockets layer connections
          Configuring a client for SSL connections
      Column-level encryption
        Encrypting column data
          Example showing how to determine the size of an encrypted column
          Example showing how to encrypt a column
          Example showing how to query encrypted data
      Connection security
        Authentication mechanisms
        Internal users (UNIX, Linux)
          Mapped users (UNIX, Linux)
          Mapped user surrogates in the allowed.surrogates file (UNIX, Linux)
          Specifying surrogates for mapped users (UNIX, Linux)
          Internally authenticated users (UNIX, Linux)
          Location and file names for mapped users' generated files (UNIX, Linux)
          Connections to a non-root installation (UNIX, Linux)
          Creating database server users (UNIX, Linux)
          Maintaining database server users (UNIX, Linux)
          User mapping tables (UNIX, Linux)
        Guest account (Windows)
        Trusted-context objects and trusted connections
          The three-tier application model
          Requirements for trusted-context objects and trusted connections
          Creating a trusted-context object
            Examples of defining trusted locations
            Examples of specifying authentication requirements for trusted connections
            Example of assigning a default role in a trusted-context object
            Example of assigning user-specific privileges in a trusted-context object
          Creating a trusted connection
          Switching the user ID on a trusted connection
          Rules for switching the user ID on a trusted connection
        Pluggable authentication modules (UNIX or Linux)
          The name of the PAM service
          Authentication modes with PAM
          PAM required stack size
          Configuring a connection to use PAM
          Define a PAM service
        LDAP authentication support on Windows
          Installing and customizing the LDAP authentication support module
          Configuring the LDAP module
          Configuring HCL Informix for LDAP
          Authentication mode with the LDAP module
        Authentication module deployment
          Implicit connections with authentication modules
          Application development for authentication modules
          Distributed transactions and authentication modules
          Client APIs and authentication support modules
          Compatibility issues with authentication modules
        Simple password encryption
          CSM configuration file
          Configuring password encryption
          SMI tables and concsm.cfg setting
          Example concsm.cfg entries for password encryption
        Single sign-on
          Kerberos authentication
          Setting up an SSO authentication environment
          Clients supporting SSO
          Preparing the Informix DBMS for Kerberos authentication
          Configuring the HCL Informix instance for SSO
            Set SQLHOSTS information for SSO
            Set up the concsm.cfg file for SSO
            Ensure keytab file has the required key (UNIX and Linux)
              The keytab file (UNIX and Linux)
            Verify Informix uses Kerberos authentication for SSO
          Configuring ESQL/C and ODBC drivers for SSO
          Configuring JDBC Driver for SSO
        Securing local connections to a host
        Limiting denial-of-service flood attacks
          LISTEN_TIMEOUT and MAX_INCOMPLETE_CONNECTIONS configuration parameters
      Discretionary access control
        User roles
          Role separation
          Default roles
          Granting privileges for a default role
        Setting permission to create databases
        Security for external routines (UDRs)
        Enabling non-DBSA users to view SQL statements in an active session
      Label-Based Access Control
        Configuring Label-Based Access Control
        How security labels control access
        DBSECADM role in LBAC
          Granting the DBSECADM Role
          Revoking the DBSECADM Role
        Security label components
          ARRAY component
          SET component
          TREE component
          Creating security label components
          Altering security label components
        Security policies
          Creating security policies
        Security labels
          Creating security labels
          Granting security labels
          Revoking security labels
          Security label support functions
        Protecting Rows and Columns
          Applying row-level protection
          Applying column-level protection
        Exemptions
          Granting exemptions
          Revoking exemptions
        Maintaining a label-based access-control implementation
          Dropping security objects
          Renaming security objects
        HCL Informix Security Considerations
        LBAC and other HCL Informix features
      Storage space encryption
        Creating encrypted or unencrypted storage spaces
        Changing storage space encryption during a restore
        Monitoring the encryption of storage spaces
        Changing the master key for the keystore
    Auditing data security
      Auditing with IBM Security Guardium (UNIX, Linux)
        ifxguard configuration file
        ifxguard utility syntax
        IFXGUARD configuration parameter
      Overview of auditing with the Informix secure auditing facility
        Secure-auditing facility
          Audit events
          Audit masks
          Selective row-level auditing
          Audit process
          Audit trail
        Roles for database server and audit administration
        Audit masks and audit instructions
          User masks
          Template masks
          Audit instructions
            Resource and performance implications
            Special auditing considerations
            Level of auditing granularity
            Use of various masks
        Audit configuration
          Auditing on or off
          The ADTCFG file
          Properties of audit files
          Windows Message Server
          Error modes for writing to an audit file
          Access to the audit trail
            Access to audit files on UNIX
            Access to audit records on Windows
        Audit analysis overview
          Importance of audit analysis
          Preparation for audit analysis
          Strategies for audit analysis
          Responses to identified security problems
        DBMS security threats
          Primary threats
          Privileged activity threats
          Shared-memory connection threats on UNIX
          Threats from malicious software
          Remote-access threats
          Obsolete-user threats
          Untrusted software used in a privileged environment
          Distributed database configuration threats
      Audit administration
        Administrative roles and role separation
          Database Server Administrator
          Database System Security Officer
          Audit Analysis Officer
          Other administrative roles and users
          Using role separation
            Assigning roles
            Configuring and enforcing role separation
        Auditing setup
          Setting up the default and global masks
          Specifying a directory for the audit trail (UNIX)
          Setting the error mode
          Setting the audit level
          Setting up selective row-level auditing
          Activating auditing
        Audit mask maintenance
          Creating audit masks
            Creating a template mask
            Creating a user mask from a template mask
            Creating a user mask without a template mask
            Adding one or more masks using an input file
          Displaying audit masks
          Modifying audit masks
          Deleting audit masks
        Audit configuration maintenance
          Displaying the audit configuration
          Starting a new audit file
          Changing audit levels
          Changing the audit error mode
          Turning off auditing
      Audit analysis
        Audit-record format
        Audit analysis without SQL
        Audit analysis with SQL
          Planning for SQL audit analysis
          Revoking and granting privileges to protect audit data
          Preparing audit analysis records for SQL access
            Creating a data file for dbload
            Creating a database for audit data
            Creating a table for audit data
            Creating a command file for dbload
            Loading audit data into a database
          Interpreting data extracted from audit records
      The onaudit utility
        The onaudit utility: Configure audit masks
        The onaudit utility: Configure auditing
      The onshowaudit utility
      Audit event codes and fields
      The ADTCFG file
        ADTCFG file conventions
        ADTERR configuration parameter
        ADTMODE configuration parameter
        ADTPATH configuration parameter
        ADTROWS configuration parameter
        ADTSIZE configuration parameter
  Security in HCL Informix
    What's new for security in Informix, Version 12.10
    Securing data
      HCL Informix directory security
        Utilities for checking directory security (UNIX)
          Installation path security requirements (UNIX)
            Trusted users and groups (UNIX)
            Secure directory permissions (UNIX)
          The onsecurity utility (UNIX)
          Securing $INFORMIXDIR and its subdirectories
            Disabling the security check of INFORMIXDIR and subdirectories
        Security warnings and error messages at server startup (UNIX)
        Users and group membership for running utilities
        Security of the chunk files
        Security for loading external modules
      Network data encryption
        Communication support modules for data transmission encryption
          Enabling encryption with communication support modules
          CSM configuration file
          Encryption ciphers and modes
          MAC key files
          Generating a new MAC key file
          MAC levels
          Switch frequency
          Network data encryption syntax
            Specifying network encryption options in concsm.cfg
            Invoking an encryption parameters file in concsm.cfg
              ENCCSM_CIPHERS parameter
              ENCCSM_MAC parameter
              ENCCSM_MACFILES parameter
              ENCCSM_SWITCH parameter
              Example of encryption parameter file
        Enterprise replication and high availability network data encryption
        Secure sockets layer protocol
          IBM Global Security Kit (GSKit)
          Configuring a server instance for secure sockets layer connections
          Configuring a client for SSL connections
      Column-level encryption
        Encrypting column data
          Example showing how to determine the size of an encrypted column
          Example showing how to encrypt a column
          Example showing how to query encrypted data
      Connection security
        Authentication mechanisms
        Internal users (UNIX, Linux)
          Mapped users (UNIX, Linux)
          Mapped user surrogates in the allowed.surrogates file (UNIX, Linux)
          Specifying surrogates for mapped users (UNIX, Linux)
          Internally authenticated users (UNIX, Linux)
          Location and file names for mapped users' generated files (UNIX, Linux)
          Connections to a non-root installation (UNIX, Linux)
          Creating database server users (UNIX, Linux)
          Maintaining database server users (UNIX, Linux)
          User mapping tables (UNIX, Linux)
        Guest account (Windows)
        Trusted-context objects and trusted connections
          The three-tier application model
          Requirements for trusted-context objects and trusted connections
          Creating a trusted-context object
            Examples of defining trusted locations
            Examples of specifying authentication requirements for trusted connections
            Example of assigning a default role in a trusted-context object
            Example of assigning user-specific privileges in a trusted-context object
          Creating a trusted connection
          Switching the user ID on a trusted connection
          Rules for switching the user ID on a trusted connection
        Pluggable authentication modules (UNIX or Linux)
          The name of the PAM service
          Authentication modes with PAM
          PAM required stack size
          Configuring a connection to use PAM
          Define a PAM service
        LDAP authentication support on Windows
          Installing and customizing the LDAP authentication support module
          Configuring the LDAP module
          Configuring HCL Informix for LDAP
          Authentication mode with the LDAP module
        Authentication module deployment
          Implicit connections with authentication modules
          Application development for authentication modules
          Distributed transactions and authentication modules
          Client APIs and authentication support modules
          Compatibility issues with authentication modules
        Simple password encryption
          CSM configuration file
          Configuring password encryption
          SMI tables and concsm.cfg setting
          Example concsm.cfg entries for password encryption
        Single sign-on
          Kerberos authentication
          Setting up an SSO authentication environment
          Clients supporting SSO
          Preparing the Informix DBMS for Kerberos authentication
          Configuring the HCL Informix instance for SSO
            Set SQLHOSTS information for SSO
            Set up the concsm.cfg file for SSO
            Ensure keytab file has the required key (UNIX and Linux)
              The keytab file (UNIX and Linux)
            Verify Informix uses Kerberos authentication for SSO
          Configuring ESQL/C and ODBC drivers for SSO
          Configuring JDBC Driver for SSO
        Securing local connections to a host
        Limiting denial-of-service flood attacks
          LISTEN_TIMEOUT and MAX_INCOMPLETE_CONNECTIONS configuration parameters
      Discretionary access control
        User roles
          Role separation
          Default roles
          Granting privileges for a default role
        Setting permission to create databases
        Security for external routines (UDRs)
        Enabling non-DBSA users to view SQL statements in an active session
      Label-Based Access Control
        Configuring Label-Based Access Control
        How security labels control access
        DBSECADM role in LBAC
          Granting the DBSECADM Role
          Revoking the DBSECADM Role
        Security label components
          ARRAY component
          SET component
          TREE component
          Creating security label components
          Altering security label components
        Security policies
          Creating security policies
        Security labels
          Creating security labels
          Granting security labels
          Revoking security labels
          Security label support functions
        Protecting Rows and Columns
          Applying row-level protection
          Applying column-level protection
        Exemptions
          Granting exemptions
          Revoking exemptions
        Maintaining a label-based access-control implementation
          Dropping security objects
          Renaming security objects
        HCL Informix Security Considerations
        LBAC and other HCL Informix features
      Storage space encryption
        Creating encrypted or unencrypted storage spaces
        Changing storage space encryption during a restore
        Monitoring the encryption of storage spaces
        Changing the master key for the keystore
    Auditing data security
      Auditing with IBM Security Guardium (UNIX, Linux)
        ifxguard configuration file
        ifxguard utility syntax
        IFXGUARD configuration parameter
      Overview of auditing with the Informix secure auditing facility
        Secure-auditing facility
          Audit events
          Audit masks
          Selective row-level auditing
          Audit process
          Audit trail
        Roles for database server and audit administration
        Audit masks and audit instructions
          User masks
          Template masks
          Audit instructions
            Resource and performance implications
            Special auditing considerations
            Level of auditing granularity
            Use of various masks
        Audit configuration
          Auditing on or off
          The ADTCFG file
          Properties of audit files
          Windows Message Server
          Error modes for writing to an audit file
          Access to the audit trail
            Access to audit files on UNIX
            Access to audit records on Windows
        Audit analysis overview
          Importance of audit analysis
          Preparation for audit analysis
          Strategies for audit analysis
          Responses to identified security problems
        DBMS security threats
          Primary threats
          Privileged activity threats
          Shared-memory connection threats on UNIX
          Threats from malicious software
          Remote-access threats
          Obsolete-user threats
          Untrusted software used in a privileged environment
          Distributed database configuration threats
      Audit administration
        Administrative roles and role separation
          Database Server Administrator
          Database System Security Officer
          Audit Analysis Officer
          Other administrative roles and users
          Using role separation
            Assigning roles
            Configuring and enforcing role separation
        Auditing setup
          Setting up the default and global masks
          Specifying a directory for the audit trail (UNIX)
          Setting the error mode
          Setting the audit level
          Setting up selective row-level auditing
          Activating auditing
        Audit mask maintenance
          Creating audit masks
            Creating a template mask
            Creating a user mask from a template mask
            Creating a user mask without a template mask
            Adding one or more masks using an input file
          Displaying audit masks
          Modifying audit masks
          Deleting audit masks
        Audit configuration maintenance
          Displaying the audit configuration
          Starting a new audit file
          Changing audit levels
          Changing the audit error mode
          Turning off auditing
      Audit analysis
        Audit-record format
        Audit analysis without SQL
        Audit analysis with SQL
          Planning for SQL audit analysis
          Revoking and granting privileges to protect audit data
          Preparing audit analysis records for SQL access
            Creating a data file for dbload
            Creating a database for audit data
            Creating a table for audit data
            Creating a command file for dbload
            Loading audit data into a database
          Interpreting data extracted from audit records
      The onaudit utility
        The onaudit utility: Configure audit masks
        The onaudit utility: Configure auditing
      The onshowaudit utility
      Audit event codes and fields
      The ADTCFG file
        ADTCFG file conventions
        ADTERR configuration parameter
        ADTMODE configuration parameter
        ADTPATH configuration parameter
        ADTROWS configuration parameter
        ADTSIZE configuration parameter
SQL programming
  Guide to SQL: Syntax
    What's new in SQL Syntax for Informix, Version 12.10
    Overview of SQL syntax
      How to Enter SQL Statements
        Using Syntax Diagrams and Syntax Tables
        Using Examples
        Using Related Information
      How to Enter SQL Comments
        Examples of SQL Comments
        Non-ASCII Characters in SQL Comments
      Categories of SQL Statements
        Data Definition Language Statements
        Data Manipulation Language Statements
        Data Integrity Statements
        Cursor Manipulation Statements
        Dynamic Management Statements
        Data Access Statements
        Optimization Statements
        Routine Definition Statements
        Auxiliary Statements
        Client/Server Connection Statements
      ANSI/ISO Compliance and Extensions
        ANSI/ISO-Compliant Statements
        ANSI/ISO-Compliant Statements with Informix Extensions
        Statements that are Extensions to the ANSI/ISO Standard
    SQL statements
      ALLOCATE COLLECTION statement
      ALLOCATE DESCRIPTOR statement
        WITH MAX Clause
      ALLOCATE ROW statement
      ALTER ACCESS_METHOD statement
      ALTER FRAGMENT statement
        Restrictions on the ALTER FRAGMENT Statement
        ALTER FRAGMENT and Transaction Logging
        Determining the Number of Rows in the Fragment
        The ONLINE keyword in ALTER FRAGMENT operations
          Automatic renaming of interval fragment identifiers
        ATTACH Clause
          General Restrictions for the ATTACH Clause
            Additional Restrictions on the ATTACH Clause
          Using the BEFORE, AFTER, and REMAINDER options
          Combining Nonfragmented Tables to Create a Fragmented Table
          Attaching a Table to a Fragmented Table
          Using the ONLINE keyword in ATTACH operations
          Effect of the ATTACH Clause
            What Happens to Indexes?
            What Happens to BYTE and TEXT Columns?
            What Happens to Triggers and Views?
            What Happens with the Distribution Scheme?
            Round-Robin Distribution Scheme
            Expression Distribution Scheme
        DETACH Clause
          Using the ONLINE keyword in DETACH operations
          Detach with BYTE and TEXT Columns
          Detach from a Protected Table
          Detach That Results in a Nonfragmented Table
        INIT Clause
          WITH ROWIDS Option
          Converting a Fragmented Table to a Nonfragmented Table
          FRAGMENT BY Clause for Tables
            Changing an Existing Fragmentation Strategy on a Table
            Defining a Fragmentation Strategy on a Nonfragmented Table
          FRAGMENT BY clause for indexes
            Detaching an Index from a Table-Fragmentation Strategy
            Fragmenting Unique and System Indexes
        ADD Clause
          Adding a New Dbspace to a Round-Robin Distribution Scheme
          Adding a New Named Fragment to a Round-Robin Distribution Scheme
          Adding an expression-based fragment
          Using the BEFORE and AFTER Options
          Using the REMAINDER Option
        DROP Clause
        MODIFY Clause
          Restrictions on the MODIFY clause for range interval fragments
          Rolling Window clause of ALTER FRAGMENT
          Using the MODIFY INTERVAL TRANSITION option
          Using the ONLINE keyword in MODIFY operations
          Examples of the MODIFY clause with interval fragments
          Examples of the MODIFY clause for list fragments
        Examples of ALTER FRAGMENT ON INDEX statements
      ALTER FUNCTION statement
        Keywords That Introduce Modifications
      ALTER INDEX statement
        TO CLUSTER Option
        TO NOT CLUSTER Option
      ALTER PROCEDURE statement
      ALTER ROUTINE statement
        Restrictions
        Keywords That Introduce Modifications
        Example of Altering Routine Modifiers
      ALTER SECURITY LABEL COMPONENT statement
        The ADD ARRAY Clause
        The ADD SET Clause
        The ADD TREE Clause
      ALTER SEQUENCE statement
        INCREMENT BY Option
        RESTART WITH Option
        MAXVALUE or NOMAXVALUE Option
        MINVALUE or NOMINVALUE Option
        CYCLE or NOCYCLE Option
        CACHE or NOCACHE Option
        ORDER or NOORDER Option
      ALTER TABLE statement
        Add or drop specialized columns
        ADD Column Clause
          Logical Character Support in Character Columns
          BEFORE Clause
          DEFAULT clause of ALTER TABLE
            DEFAULT security labels
          Single-Column Constraint Format
            Using NOT NULL Constraints with ADD COLUMN
            Constraint Definition
            REFERENCES Clause
            Restrictions on Referential Constraints
            Default Column for the References Clause
            Using the ON DELETE CASCADE Option
            Locks Held During Creation of a Referential Constraint
            CHECK Clause
          Add column SECURED WITH label clause
        ADD AUDIT Clause
        ADD CONSTRAINT Clause
          Multiple-Column Constraint Format
            Creating foreign-key constraints when an index exists on the referenced table
            Using the INDEX DISABLED keywords in a foreign key definition
            Creating foreign-key constraints in NOVALIDATE modes
            Adding a Primary-Key or Unique Constraint
            Recovery from Constraint Violations
        ADD TYPE Clause
        DROP AUDIT Clause
        DROP CONSTRAINT Clause
        DROP Column Clause
          How Dropping a Column Affects Constraints
          How Dropping a Column Affects Triggers
          How Dropping a Column Affects Views
        LOCK MODE Clause
          Precedence and Default Behavior
        Logging TYPE Options
        MODIFY Clause
          Altering BYTE and TEXT columns
          Altering the Next Serial Value
            Altering the Next Serial Value in a Typed Table
          Altering character columns
          Altering the Structure of Tables
          Modifying Tables for NULL Values
          Adding a Constraint on a Non-Opaque Column
          Modify Column Security clause
          Adding a Constraint That Existing Rows Violate
          How Modifying a Column Affects Triggers
          How Modifying a Column Affects Views
        MODIFY EXTENT SIZE
        MODIFY NEXT SIZE clause
        PUT Clause
        SECURITY POLICY Clause
        Statistics options of the ALTER TABLE statement
      ALTER TRUSTED CONTEXT
      ALTER USER statement (UNIX, Linux)
      BEGIN WORK statement
        BEGIN WORK and ANSI-Compliant Databases
        BEGIN WORK WITHOUT REPLICATION (ESQL/C)
        Example of BEGIN WORK
      CLOSE statement
        Closing a Select or Function Cursor
        Closing an Insert Cursor
        Closing a Collection Cursor
        Using End of Transaction to Close a Cursor
      CLOSE DATABASE statement
      COMMIT WORK statement
        Issuing COMMIT WORK in a Database That Is Not ANSI Compliant
          Explicit DB-Access Transactions
        Issuing COMMIT WORK in an ANSI-Compliant Database
      CONNECT statement
        Privileges for Executing the CONNECT Statement
        Connection Context
        Database Environment
          Restrictions on dbservername
          Specifying the Database Environment
            Only Database Server Specified
            Database Server and Database Specified
            Only Database Specified
        Declaring a Connection Name
          Connection Identifiers
        USER Authentication Clause
          Restrictions on the Validation Variable Parameter
          Restrictions on the User Identifier Parameter
          Use of the Default User ID
        The DEFAULT Connection Specification
          The Implicit Connection with DATABASE Statements
        WITH CONCURRENT TRANSACTION Option
        TRUSTED clause
      CREATE ACCESS_METHOD statement
      CREATE AGGREGATE statement
        Extending the Functionality of Aggregates
          Example of Creating a User-Defined Aggregate
        Parallel Execution
      CREATE CAST statement
        Source and Target Data Types
        Explicit and Implicit Casts
          Explicit Casts
          Implicit Casts
        WITH Clause
      CREATE DATABASE statement
        Logging Options
        Specifying Buffered Logging
        ANSI-Compliant Databases
        Specifying NLSCASE case sensitivity
      CREATE DEFAULT USER statement (UNIX, Linux)
      CREATE DISTINCT TYPE statement
        Privileges on Distinct Types
        Support Functions and Casts
        Manipulating Distinct Types
      CREATE EXTERNAL TABLE Statement
        Column Definition
          Using the SAMEAS Clause
          Using the EXTERNAL Keyword
            Defining NULL Values
          Manipulating Data in Fixed Format Files
        DATAFILES Clause
          Using Formatting Characters with External Tables
        Table options
        Reject Files
        External Table Examples
          Loading Data from External Tables into Informix
            Loading Data in Express Mode
            Loading data in DELUXE mode
            Loading from a Delimited File to a Database Table with the Same Schema
            Loading from a Fixed Text File
            Loading Between Tables That Have the Same Schema
            Loading Values into Serial Columns
            Loading Data Warehousing Tables
              Loading Initially
              Refreshing Periodically
              Initial Loading of OLTP Data from Other Database Servers
          Unloading Data to External Tables from Informix
            Unloading to a Delimited File
            Unloading to Informix Data Files
            Unloading to a Fixed-Text File
            Adding an End-of-Line Character to a Fixed Text File
              Using a Program or Script
              Adding a Newline Field in a SELECT Statement
        Restrictions on External Tables
      CREATE FUNCTION statement
        Privileges necessary for using CREATE FUNCTION
        DBA keyword and Execute privilege on the created function
        The REFERENCING and FOR Clauses
        Overloading the Name of a Function
          Using the SPECIFIC Clause to Specify a Specific Name
        DOCUMENT Clause
        WITH LISTING IN Clause
        SPL Functions
        External Functions
          Example of Registering a C User-Defined Function
          Example of Registering a UDR Written in the Java Language
          Ownership of Created Database Objects
      CREATE FUNCTION FROM statement
      CREATE INDEX statement
        Index-type options
          How indexes affect primary-key, unique, and referential constraints
        Index-key specification
          Indexing a BSON field
          Restrictions on columns as index keys
          Using the return value of a function as an index key
        Creating Composite Indexes
        Using the ASC and DESC Sort-Order Options
          Effects of Unique Constraints on Sort Order Options
          Bidirectional Traversal of Indexes
          Restrictions on the Number of Indexes on a Set of Columns
          Using an Operator Class
        USING access-method clause
        HASH ON clause
        FILLFACTOR Option
          Providing a Low Percentage Value
          Providing a High Percentage Value
        Storage options
        COMPRESSED option for indexes
        Extent Size Options
        IN Clause
          Storing an Index in a dbspace
          Storing an Index Fragment in a Named Partition
          Storing Data in an extspace
          Creating an Index with the IN TABLE Keywords
        FRAGMENT BY Clause for Indexes
          Storing an Index Fragment in a Named Partition
          Restrictions on fragmentation expressions
          Fragmentation of System Indexes
          Fragmentation of Unique Indexes
          Fragmentation of Indexes on Temporary Tables
        Index modes
          Specifying Modes for Unique Indexes
            Adding a Unique Index When Duplicate Values Exist in the Column
          Specifying Modes for Duplicate Indexes
        How the Database Server Treats Disabled Indexes
        The ONLINE keyword of CREATE INDEX
        Automatic Calculation of Distribution Statistics
      CREATE OPAQUE TYPE statement
        Declaring a Name for an Opaque Type
        INTERNALLENGTH Modifier
          Fixed-Length Opaque Types
          Varying-Length Opaque Types
        Opaque-Type Modifier
        Defining an Opaque Type
      CREATE OPCLASS statement
        STRATEGIES Clause
        Strategy Specification
        Indexes on Side-Effect Data
        SUPPORT Clause
        Default Operator Classes
      CREATE PROCEDURE statement
        Using CREATE PROCEDURE Versus CREATE FUNCTION
        Relationship Between Routines, Functions, and Procedures
        Privileges Necessary for Using CREATE PROCEDURE
        DBA Keyword and Privileges on the Procedure
        The REFERENCING and FOR Clauses
        Procedure names in Informix
          Using the SPECIFIC Clause to Specify a Specific Name
        DOCUMENT Clause
        Using the WITH LISTING IN Option
        SPL Procedures
        External Procedures
          Registering a User-Defined Procedure
          Ownership of Created Database Objects
      CREATE PROCEDURE FROM statement
        Default Directory That Holds the File
      CREATE ROLE statement
      CREATE ROUTINE FROM statement
      CREATE ROW TYPE statement
        Privileges on named ROW data types
        Inheritance and Named ROW Types
        Creating a Subtype
        Type Hierarchies
        Procedure for Creating a Subtype
        Restrictions on Serial and Simple-Large-Object Data Types
      CREATE SCHEMA statement
        Creating Database Objects Within CREATE SCHEMA
      CREATE SECURITY LABEL statement
        Components and Elements of a Security Label
      CREATE SECURITY LABEL COMPONENT statement
        Types and Elements of Security Label Components
        ARRAY Components
        SET Components
        TREE Components
      CREATE SECURITY POLICY statement
        Security Label Components of a Security Policy
        Rules Associated with a Security Policy
      CREATE SEQUENCE statement
        INCREMENT BY Option
        START WITH Option
        MAXVALUE or NOMAXVALUE Option
        MINVALUE or NOMINVALUE Option
        CYCLE or NOCYCLE Option
        CACHE or NOCACHE Option
        ORDER or NOORDER Option
      CREATE SYNONYM statement
        Synonyms for objects outside the current database
        PUBLIC and PRIVATE Synonyms
        Synonyms with the Same Name
        Chaining Synonyms
      CREATE TABLE statement
        AS SELECT clause
        Logging Options
        Column definition
          Column SECURED WITH label clause
          DEFAULT clause of CREATE TABLE
          Single-Column Constraint Format
            Restrictions on Using the Single-Column Constraint Format
            Using the NOT NULL Constraint
            Using the NULL Constraint
            Using UNIQUE or DISTINCT Constraints
            Differences Between a Unique Constraint and a Unique Index
            Using the PRIMARY KEY Constraint
            REFERENCES Clause
              Restrictions on Referential Constraints
              Default Values for the Referenced Column
              Referential Relationships Within a Table
              Locking Implications of Creating a Referential Constraint
              Examples of the Single-Column Constraint format
              Using the ON DELETE CASCADE Option
            CHECK Clause
              Using a Search Condition
              Restrictions When Using the Single-Column Constraint Format
            Constraint Definition
              Declaring a Constraint Name
                Constraint Names That the Database Server Generates
              Choosing a Constraint-Mode Option
        Multiple-Column Constraint Format
          Restrictions with the Multiple-Column Constraint Format
            Using Large-Object Types in Constraints
          Using the FOREIGN KEY Constraint
          Examples of the Multiple-Column Constraint Format
            Defining Check Constraints Across Columns
            Defining Composite Primary and Foreign Keys
          Default Index Creation Strategy for Constraints
        OF TYPE Clause
          Using Large-Object Data in Typed Tables
          Using the UNDER Clause
            Restrictions on Table Hierarchies
          Access Privileges on Tables
          System Catalog Information
        Specialized columns
          Using the WITH AUDIT Clause
          Using the WITH CRCOLS Option
          Using the WITH ERKEY Keywords
          Using the WITH REPLCHECK Keywords
          Using the WITH VERCOLS Option
        SECURITY POLICY Clause
        Storage options
          Using the IN Clause
          PUT Clause
          FRAGMENT BY clause
            Using the WITH ROWIDS Option
            Fragmenting by ROUND ROBIN
            Expression Fragment Clause
              User-Defined Functions in Fragment Expressions
            List fragment clause
            Interval fragment clause
              Rolling Window clause of CREATE TABLE
          EXTENT SIZE Options
          COMPRESSED option for tables
        LOCK MODE Options
          Precedence and Default Behavior
        USING Access-Method Clause
        Statistics options of the CREATE TABLE statement
      CREATE TEMP TABLE statement
        Declaring a name for a temporary table
        Column definition specification of the CREATE TEMP TABLE statement
        Single-Column Constraint Format
        Multiple-Column Constraint Format
        Using the WITH NO LOG option
        Storage options for temporary tables
          Where temporary tables are stored
        Differences between temporary and permanent tables
        Duration of temporary tables
      CREATE TRIGGER statement
        Defining a Trigger Event and Action
        Restrictions on Triggers
        Trigger Modes
        Trigger Inheritance in a Table Hierarchy
        Triggers and SPL Routines
        Trigger Events
          Trigger Events with Cursors
          Privileges on the Trigger Event
          Performance Impact of Triggers
        INSERT Events and DELETE Events
        UPDATE Event
        Defining Multiple Update Triggers
        SELECT Event
        Circumstances When a Select Trigger Is Activated
        Stand-alone SELECT Statements
        SELECT Statements Within UDRs in the Select List
        UDRs that EXECUTE PROCEDURE or EXECUTE FUNCTION call
        Subqueries in the Select List
        Subqueries in the FROM Clause of SELECT
        Subqueries in the WHERE Clause of DELETE or UPDATE
        Select Triggers in Table Hierarchies
        Circumstances When a Select Trigger Is Not Activated
        Action Clause
          BEFORE Actions
          FOR EACH ROW Actions
          AFTER Actions
          Actions of Multiple Triggers
        Guaranteeing Row-Order Independence
        REFERENCING Clauses
          REFERENCING Clause for Delete
          REFERENCING Clause for Insert triggers
          REFERENCING Clause for Update
          REFERENCING Clause for Select
        Correlated Table Action
        Triggered Action on a Table
          WHEN Condition
          Action Statements
            UDRs as Triggered Actions
            Achieving a Consistent Result
            Declaring keywords of SQL as correlation names
        Using Correlation Names in Triggered Actions
          When to Use Correlation Names
          Qualified Versus Unqualified Value
        Re-Entrancy of Triggers
          Re-Entrancy and Cascading Triggers
        Rules for SPL Routines
        Privileges to Execute Trigger Actions
          Creating a Trigger Action That Anyone Can Use
        Cascading Triggers
          Constraint Checking
          Preventing Triggers from Overriding Each Other
        Tables in Remote Databases
        Logging and Recovery
        INSTEAD OF Triggers on Views
          The Action Clause of INSTEAD OF Triggers
          Restrictions on INSTEAD OF Triggers on Views
          Updating Views
      CREATE TRUSTED CONTEXT
      CREATE USER statement (UNIX, Linux)
      CREATE VIEW statement
        Typed Views
        Subset of SELECT syntax valid in view definitions
        Union Views
        Naming View Columns
        Using a View in the SELECT Statement
        WITH CHECK OPTION Keywords
        Updating Through Views
      CREATE XADATASOURCE statement
      CREATE XADATASOURCE TYPE statement
      DATABASE statement
        SQLCA.SQLWARN Settings Immediately after DATABASE Executes (ESQL/C)
        EXCLUSIVE keyword
      DEALLOCATE COLLECTION statement
      DEALLOCATE DESCRIPTOR statement
      DEALLOCATE ROW statement
      DECLARE statement
        Overview of Cursor Types
        Select Cursor or Function Cursor
          Using the FOR READ ONLY Option
          Using the FOR UPDATE Option
            Using FOR UPDATE with a List of Columns
            Locking with an Update Cursor
              Locking with concurrent 4GL cursors in unlogged databases
          Subset of INSERT Statement with a Sequential Cursor
          Insert Cursor
        Cursor Characteristics
          Creating a Sequential Cursor by Default
          Using the SCROLL Keyword to Create a Scroll Cursor
          Using the WITH HOLD keywords to create a hold cursor
            Using an Insert Cursor with Hold
          Subset of SELECT statements associated with cursors
          Examples of Cursors in Non-ANSI Compliant Databases
          Examples of Cursors in ANSI-Compliant Databases
        Associating a Cursor with a Prepared Statement
          Select with a Collection-Derived Table
            Using a Select Cursor with a Collection Variable
          Insert with a Collection-Derived Table
        Using Cursors with Transactions
        Declaring a Dynamic Cursor in an SPL Routine
      DELETE statement
        Using the ONLY keyword with typed tables
        Considerations When Tables Have Cascading Deletes
          Restrictions on DELETE When Tables Have Cascading Deletes
          Locking and Logging Implications of Cascading Deletes
        Using the WHERE Keyword to Specify a Condition
        Subqueries in the WHERE Clause of DELETE
        Declaring an alias for the table
        Using the WHERE CURRENT OF Keywords (ESQL/C, SPL)
        Deleting Rows That Contain Opaque Data Types
        Deleting Rows That Contain Collection Data Types
        Data Types in Distributed DELETE Operations
        SQLSTATE Values in an ANSI-Compliant Database
        SQLSTATE Values in a Database That Is Not ANSI-Compliant
      DESCRIBE statement
        The OUTPUT Keyword
        Describing the Statement Type
        Checking for the Existence of a WHERE Clause
        Describing a Statement with Runtime Parameters
        Using the SQL DESCRIPTOR Keywords
        Using the INTO sqlda Pointer Clause
        Describing a Collection Variable
      DESCRIBE INPUT statement
        Describing the Statement Type
        Checking for Existence of a WHERE Clause
        Describing a Statement with Dynamic Runtime Parameters
        Using the SQL DESCRIPTOR Keywords
        Using the INTO sqlda Pointer Clause
        Describing a Collection Variable
      DISCONNECT statement
        DEFAULT Option
        Specifying the CURRENT Keyword
        When a Transaction is Active
        Disconnecting in a Thread-Safe Environment
        Specifying the ALL Option
      DROP ACCESS_METHOD statement
      DROP AGGREGATE statement
      DROP CAST statement
      DROP DATABASE statement
      DROP FUNCTION statement
        Dropping External Functions
      DROP INDEX statement
        The ONLINE keyword of DROP INDEX
      DROP OPCLASS statement
      DROP PROCEDURE statement
        Dropping an External Procedure
      DROP ROLE statement
      DROP ROUTINE statement
        Restrictions
        Dropping an External Routine
      DROP ROW TYPE statement
        The RESTRICT Keyword
      DROP SECURITY statement
        Dropping security objects in RESTRICT mode or in CASCADE mode
      DROP SEQUENCE statement
      DROP SYNONYM statement
      DROP TABLE statement
        Effects of the DROP TABLE Statement
        Specifying CASCADE Mode
        Specifying RESTRICT Mode
        Dropping a Table That Contains Opaque Data Types
        Tables That Cannot Be Dropped
      DROP TRIGGER statement
      DROP TRUSTED CONTEXT statement
      DROP TYPE statement
      DROP USER statement (UNIX, Linux)
      DROP VIEW statement
      DROP XADATASOURCE statement
      DROP XADATASOURCE TYPE statement
      EXECUTE statement
        Scope of Statement Identifiers
        Restrictions with the INTO Clause
        Replacing Placeholders with Parameters
        Saving Values In Host or Program Variables
        Saving Values in a System-Descriptor Area
        Saving Values in an sqlda Structure (ESQL/C)
        The sqlca Record and EXECUTE
        Returned SQLCODE Values with EXECUTE
        Supplying Parameters Through Host or Program Variables
        Supplying Parameters Through a System Descriptor
        Supplying Parameters Through an sqlda Structure (ESQL/C)
      EXECUTE FUNCTION statement
        Negator Functions and Their Companions
        How the EXECUTE FUNCTION Statement Works
        Data Variables
        INTO Clause with Indicator Variables (ESQL/C)
        INTO Clause with Cursors
        Alternatives to PREPARE ... EXECUTE FUNCTION ... INTO
        Dynamic Routine-Name Specification of SPL Functions
      EXECUTE IMMEDIATE statement
        EXECUTE IMMEDIATE and Restricted Statements
        Restrictions on Valid Statements
        Handling Exceptions from EXECUTE IMMEDIATE Statements
        Examples of the EXECUTE IMMEDIATE Statement
      EXECUTE PROCEDURE statement
        Causes of Errors
        Using the INTO Clause
        The WITH TRIGGER REFERENCES Keywords
          Example of Invoking a Trigger Procedure
        Dynamic Routine-Name Specification of SPL Procedures
      FETCH statement
        FETCH with a Sequential Cursor
        FETCH with a Scroll Cursor
        How the Database Server Implements Scroll Cursors
        Specifying Where Values Go in Memory
        Using the INTO Clause
        Using Indicator Variables
        When the INTO Clause of FETCH is Required
        Using a System-Descriptor Area (X/Open)
        Using sqlda Structures
        Fetching a Row for Update
        Fetching from a Collection Cursor
        Checking the Result of FETCH
      FLUSH statement
        Error Checking FLUSH Statements
      FREE statement
      GET DESCRIPTOR statement
        Using the COUNT Keyword
        Using the VALUE Clause
          Using the VALUE Clause After a DESCRIBE
          Using the VALUE Clause After a FETCH
          Fetching a NULL Value
        Using LENGTH or ILENGTH
        Describing an Opaque-Type Column
        Describing a Distinct-Type Column
      GET DIAGNOSTICS statement
        Using the SQLSTATE Error Status Code
          Class and Subclass Codes
          SQLSTATE Support for the ANSI/ISO Standard for SQL
          List of SQLSTATE Codes
          Using SQLSTATE in Applications
        Statement Clause
          Using the MORE Keyword
          Using the ROW_COUNT Keyword
          Using the NUMBER Keyword
        EXCEPTION Clause
          Using the RETURNED_SQLSTATE Keyword
          Using the INFORMIX_SQLCODE Keyword
          Using the CLASS_ORIGIN Keyword
          Using the SUBCLASS_ORIGIN Keyword
          Using the MESSAGE_TEXT Keyword
          Using the MESSAGE_LENGTH Keyword
          Using the SERVER_NAME Keyword
        The Contents of the SERVER_NAME Field
          Using the CONNECTION_NAME Keyword
          When the CONNECTION_NAME Keyword Is Updated
          When the CONNECTION_NAME Is Not Updated
        The contents of the CONNECTION_NAME field
        Using GET DIAGNOSTICS for Error Checking
      GRANT statement
        Database-Level Privileges
        Table-Level Privileges
          Effect of the ALL Keyword
        Table Reference
          Privileges on Tables and Synonyms
          Privileges on a View
        Type-Level Privileges
          USAGE Privilege
          UNDER Privilege
        Routine-Level Privileges
          Granting the Execute privilege to PUBLIC
          Revoking the Execute privilege from PUBLIC
        Language-Level Privileges
          Usage Privilege in Stored Procedure Language
        Sequence-Level Privileges
          Alter Privilege
          Select Privilege
          ALL Keyword
          The User List
        Role Name
          Granting a Role to a User or to Another Role
          Granting privileges to a role
          Granting a Default Role
          Granting the EXTEND Role
        WITH GRANT OPTION keywords
        AS grantor clause
        Security Administration Options
          DBSECADM Clause
          EXEMPTION Clause
            Rules on Which Exemptions Are Granted
            Security Policies and Grantees of Exemptions
          SECURITY LABEL Clause
            Access Specifications
            Rules for User Security Labels
            Examples of Granting User Security Labels
          SETSESSIONAUTH Clause
        Surrogate user properties (UNIX, Linux)
      GRANT FRAGMENT statement
        Fragment-Level Privileges
          Definition of Fragment-Level Authorization
          Effect of Fragment-Level Authorization in Statement Validation
          Duration of Fragment-Level Privileges
          Specifying Fragments
          The TO Clause
        Granting Privileges to One User or a List of Users
        Granting One Privilege or a List of Privileges
        WITH GRANT OPTION Clause
        AS grantor Clause
          Omitting the AS grantor Clause
      INFO statement
      INSERT statement
        Specifying Columns
        Using the AT Clause (ESQL/C, SPL)
        Inserting Rows Through a View
        Inserting Rows with a Cursor
        Inserting Rows into a Database Without Transactions
        Inserting Rows into a Database with Transactions
        VALUES Clause
          Considering Data Types
          Inserting Values into Serial Columns
          Inserting Values into Opaque-Type Columns
          Inserting Values into Collection Columns
          Inserting Values into ROW-Type Columns
          Data Types in Distributed INSERT Operations
          Using Expressions in the VALUES Clause
          Inserting NULL Values
          Inserting Values into Protected Tables
          Truncated CHAR Values
          Subset of SELECT Statement
        Execute Routine Clause
          Number of Values Returned by SPL, C, and Java Functions
          Inserting into a Row Variable (ESQL/C, SPL)
          Using INSERT as a Dynamic Management Statement
      LOAD statement
        LOAD FROM File
        Loading Simple Large Objects
        Loading Smart Large Objects
        Loading Complex Data Types
        Loading Opaque-Type Columns
        DELIMITER Clause
        INSERT INTO Clause
      LOCK TABLE statement
        Concurrent Access to Tables with Shared Locks
        Concurrent Access to Tables with Exclusive Locks
        Databases with transaction logging
        Databases without transaction logging
        Locking Granularity
      MERGE statement
        Restrictions on Source and Target Tables
        Handling Duplicate Rows
        Examples of MERGE Statements
      OPEN statement
        Opening a Select Cursor
        Opening an Update Cursor Inside a Transaction
        Opening a Function Cursor
        Reopening a Select or Function Cursor
        Errors Associated with Select and Function Cursors
        Opening an Insert Cursor (ESQL/C)
          Example of Opening an Insert Cursor
          Reopening an Insert Cursor
        Opening a Collection Cursor (ESQL/C)
        USING Clause
        Specifying a System Descriptor Area (ESQL/C)
        Specifying a Pointer to an sqlda Structure (ESQL/C)
          Example of Specifying a Pointer to an sqlda Structure
        Using the WITH REOPTIMIZATION Option (ESQL/C)
        Relationship Between OPEN and FREE
        DDL Operations on Tables Referenced by Cursors
      OUTPUT statement
        Sending Query Results to a File
        Displaying Query Results Without Column Headings
        Sending Query Results to Another Program
      PREPARE statement
        Restrictions
        Declaring a Statement Identifier
          Scope of Statement Identifiers
        Releasing a Statement Identifier
        Statement Text
          Example of a PREPARE statement in an SPL routine
        Preparing and Executing User-Defined Routines
        Restricted Statements in Single-Statement Prepares
        Preparing Statements When Parameters Are Known
        Preparing Statements That Receive Parameters
        Preparing Statements with SQL Identifiers
          Obtaining SQL Identifiers from User Input
        Preparing Multiple SQL Statements
          Restricted Statements in Multistatement Prepared Objects
        Using Prepared Statements for Efficiency
          DDL Operations on Tables Referenced in Prepared Objects
      PUT statement
        Supplying Inserted Values
          Using Constant Values in INSERT
          Naming Program Variables in INSERT
          Naming Program Variables in PUT
        Using the USING Clause
          Specifying a System-Descriptor Area
          Specifying an sqlda Structure
        Inserting into a Collection Cursor
        Writing Buffered Rows
        Error Checking
      RELEASE SAVEPOINT statement
      RENAME COLUMN statement
        How Views and Check Constraints Are Affected
        How Triggers Are Affected
      RENAME CONSTRAINT statement
      RENAME DATABASE statement
      RENAME INDEX statement
      RENAME SECURITY statement
      RENAME SEQUENCE statement
      RENAME TABLE statement
      RENAME TRUSTED CONTEXT statement
      RENAME USER statement (UNIX, Linux)
      REVOKE statement
        Revoking database server access from mapped users (UNIX, Linux)
        Database-level privileges
        Table-Level Privileges
          When to Use REVOKE Before GRANT
            Replacing PUBLIC with Specified Users
            Restricting Access to Specific Columns
          Effect of the ALL Keyword
            Effect of the ALL Keyword on UNDER Privilege
        Effect of Uncommitted Transactions
        Type-Level Privileges
          Usage Privilege
          Under Privilege
        Routine-Level Privileges
        Language-Level Privileges
        Sequence-Level Privileges
          Alter Privilege
          Select Privilege
          ALL Keyword
        User List
        Role Name
          Revoking a Default Role
          Revoking the EXTEND Role
        Revoking privileges granted WITH GRANT OPTION
        The AS Clause
          Effect of CASCADE Keyword on UNDER Privileges
        Controlling the Scope of REVOKE with the RESTRICT Option
        Security Administration Options
          DBSECADM Clause
          EXEMPTION Clause
            Rules on Which Exemptions Are Revoked
            Security Policies and Grantees of Exemptions
          SECURITY LABEL Clause
            Access Specifications
            Examples of Revoking User Security Labels
          SETSESSIONAUTH Clause
      REVOKE FRAGMENT statement
        Specifying Fragments
        The FROM Clause
        Fragment-Level Privileges
        The AS Clause
        Examples of the REVOKE FRAGMENT Statement
          Revoking Privileges on One Fragment
          Revoking Privileges on More Than One Fragment
          Revoking Privileges from More Than One User
          Revoking Privileges Without Specifying Fragments
      ROLLBACK WORK statement
        WORK Keyword
        TO SAVEPOINT Clause
      SAVE EXTERNAL DIRECTIVES statement
        External optimizer directives
        Enabling or disabling external directives for a session
        The directive Specification
        The ACTIVE, INACTIVE, and TEST ONLY Keywords
        The query Specification
      SAVEPOINT statement
      SELECT statement
        Projection Clause
          Restricting return values with the SKIP, LIMIT, and FIRST options
            Sorting results from SKIP, LIMIT, or FIRST queries
          Controlling duplicate return values
            Duplicate rows in NLSCASE INSENSITIVE databases
          Data Types in Distributed Queries
            Data Types in Cross-Database Transactions
            Data Types in Cross-Server Transactions
          Expressions in the Select List
            Selecting Columns
            Selecting Constants
            Selecting Built-In Function Expressions
            Selecting Aggregate Function Expressions
            Selecting OLAP window expressions
            Selecting correlated aggregates in subqueries
            Selecting User-Defined Function Expressions
            Selecting Expressions That Use Arithmetic Operators
            Selecting ROW Fields
          Declaring a Display Label
          Declaring a Column Alias
        INTO Clause
          INTO Clause with Cursors
          Preparing a SELECT ... INTO Query
          Using Array Variables with the INTO Clause
        FROM Clause
          Aliases for Tables or Views
          Table expressions
          Lateral derived tables
          Restrictions on External Tables in Joins and Subqueries
          The ONLY Keyword
          Selecting from a Collection Variable
          Selecting from a Row Variable (ESQL/C)
          Iterator Functions
          ANSI Joins
            Using the ON Clause
              Specifying a Post-Join Filter
              Using a Join as the Dominant or Subordinate Part of an Outer Join
          Informix-Extension Outer Joins
        GRID clause
        WHERE clause of SELECT
          Using a Condition in the WHERE Clause
            Relational-Operator Condition
            IN Condition
            BETWEEN Condition
            Using IS NULL and IS NOT NULL Conditions
            LIKE or MATCHES Condition
            IN Subquery
            EXISTS Subquery
            ALL, ANY, SOME Subqueries
          Specifying a Join in the WHERE Clause
        Hierarchical Clause
          START WITH Clause
          CONNECT BY Clause
          Conditions in the CONNECT BY Clause
          Dependency patterns that are not a simple graph
        GROUP BY Clause
          Dependencies between the GROUP BY and Projection clauses
        HAVING Clause
        Set operators in combined queries
          Restrictions on a Combined SELECT
          UNION Operator
          INTERSECT Operator
          MINUS operator
        ORDER BY Clause
          Ordering by a Column or by an Expression
          Ordering by a Substring
          Ordering by a CASE expression
          Ascending and Descending Orders
          Nested Ordering
          Using Select Numbers
          Ordering by Rowids
          ORDER BY Clause with DECLARE
          Placing Indexes on ORDER BY Columns
          ORDER SIBLINGS BY Clause
          OLAP window functions in the ORDER BY clause of SELECT statements
          Ordering STANDARD or RAW result tables
        LIMIT Clause
        FOR UPDATE Clause
        FOR READ ONLY Clause
        INTO table clauses
          INTO TEMP clause
          INTO STANDARD and INTO RAW Clauses
          INTO EXTERNAL clause
      SET AUTOFREE statement
        Globally Affecting Cursors with SET AUTOFREE
        Using the FOR Clause to Specify a Specific Cursor
        Associated and Detached Statements
        Closing Cursors Implicitly
      SET COLLATION statement
        Specifying a Collating Order with SET COLLATION
        Restrictions on SET COLLATION
        Collation Performed by Database Objects
      SET CONNECTION statement
        Making a dormant connection as the current connection
        Making a current connection as the dormant connection
        Dormant Connections in a Single-Threaded Environment
        Dormant Connections in a Thread-Safe Environment
        Identifying the Connection
        DEFAULT Option
        CURRENT Keyword
        When a Transaction is Active
      SET CONSTRAINTS statement
      SET Database Object Mode statement
        Privileges Required for Changing Database Object Modes
        Object-List Format
        Table Format
        Modes for constraints and unique indexes
          Enabling foreign-key constraints when an index exists on the referenced table
        Modes for Triggers and Duplicate Indexes
        Definitions of Database Object Modes
          Enabled Mode
          Disabled Mode
          Filtering Modes
            Starting and Stopping the Violations and Diagnostics Tables
            Error Options for Filtering Mode
            Effect of Filtering Mode on the Database
      SET DATASKIP statement
        Circumstances When a Dbspace Cannot Be Skipped
      SET DEBUG FILE statement
        Using the WITH APPEND Option
        Closing the Output File
        Redirecting Trace Output
        Location of the Output File
      SET DEFERRED_PREPARE statement
        Example of SET DEFERRED_PREPARE
        Using Deferred-Prepare with OPTOFC
      SET DESCRIPTOR statement
        Using the COUNT Clause
        Using the VALUE Clause
        Item Descriptor
          Setting the TYPE or ITYPE Field
            Compiling Without the -xopen Option
            Setting the TYPE Field in X/Open Programs
            Using DECIMAL or MONEY Data Types
            Using DATETIME or INTERVAL Data Types
          Setting the DATA or IDATA Field
          Setting the LENGTH or ILENGTH Field
          Setting the INDICATOR Field
          Setting Opaque-Type Fields
          Setting Distinct-Type Fields
        Modifying Values Set by the DESCRIBE Statement
      SET ENCRYPTION PASSWORD statement
        Storage Requirements for Encryption
        Specifying a Session Password and Hint
        Levels of Encryption
        Protecting Passwords
      SET ENVIRONMENT statement
        AUTOLOCATE session environment option
        AUTO_READAHEAD session environment option
        AUTO_STAT_MODE session environment option
        BOUND_IMPL_PDQ session environment option
        CLUSTER_TXN_SCOPE session environment option
        DEFAULTESCCHAR session environment option
        EXTDIRECTIVES session environment option
        FORCE_DDL_EXEC session environment option
        GRID_NODE_SKIP session environment option
        HDR_TXN_SCOPE session environment option
        IFX_AUTO_REPREPARE session environment option
        IFX_BATCHEDREAD_INDEX session environment option
        IFX_BATCHEDREAD_TABLE session environment option
        IFX_FOLDVIEW session environment option
        IFX_SESSION_LIMIT_LOCKS session environment option
        IMPLICIT_PDQ session environment option
        INFORMIXCONRETRY session environment option
        INFORMIXCONTIME session environment option
        NOVALIDATE session environment option
        OPTCOMPIND session environment option
        RETAINUPDATELOCKS session environment option
        SELECT_GRID session environment option
        SELECT_GRID_ALL session environment option
        STATCHANGE session environment option
        USELASTCOMMITTED session environment option
        USE_SHARDING session environment option
        USE_DWA session environment options
        USTLOW_SAMPLE environment option
      SET EXPLAIN statement
        Using the AVOID_EXECUTE Option
        Using the FILE TO option
        Default name and location of the explain output file on UNIX
        Default name and location of the output file on Windows
        SET EXPLAIN output
          Complete-Connection Level Settings and Output Examples
          External Table Operations in SET EXPLAIN Output
      SET INDEXES statement
      SET ISOLATION statement
        Complete-Connection Level Settings
        Informix Isolation Levels
          Using the Dirty Read Isolation Level
          Using the Committed Read Isolation Level
            The LAST COMMITTED Option to Committed Read
          Using the Cursor Stability Isolation Level
          Using the Repeatable Read Isolation Level
          Default Isolation Levels
          Using the RETAIN UPDATE LOCKS Option
            Turning the Option OFF During a Transaction
        Effects of Isolation Levels
        Isolation Levels for Secondary Data Replication Servers
      SET LOCK MODE statement
        WAIT Clause
          Complete-Connection Level Settings
      SET LOG statement
      SET OPTIMIZATION statement
        HIGH and LOW Options
        FIRST_ROWS and ALL_ROWS Options
        Optimizing SPL Routines
        ENVIRONMENT Options
      SET PDQPRIORITY statement
        Allocating Database Server Resources
      SET ROLE statement
        Setting the Default Role
      SET SESSION AUTHORIZATION statement
        SET SESSION AUTHORIZATION and Transactions
      SET STATEMENT CACHE statement
        Precedence and Default Behavior
        Turning the Cache ON
          Restrictions on Matching Entries in the SQL Statement Cache
        Turning the Cache OFF
        SQL statement cache qualifying criteria
          Requiring Re-Execution Before Cache Insertion
          Enabling or Disabling Insertions After Size Exceeds Configured Limit
          Prepared Statements and the Statement Cache
      SET TRANSACTION statement
        Comparing SET TRANSACTION with SET ISOLATION
        Informix Isolation Levels
          Using the Read Uncommitted Option
          Using the Read Committed Option
          Using the Repeatable Read and Serializable Options
        Default Isolation Levels
        Access Modes
        Effects of Isolation Levels
      SET Transaction Mode statement
        Statement-Level Checking
        Transaction-Level Checking
        Duration of Transaction Modes
        Specifying All Constraints or a List of Constraints
        Specifying Remote Constraints
        Examples of Setting the Transaction Mode for Constraints
      SET TRIGGERS statement
      SET USER PASSWORD statement (UNIX, Linux)
      START VIOLATIONS TABLE statement
        Relationship to the SET Database Object Mode statement
        Effect on concurrent transactions
        Stopping the Violations and Diagnostics Tables
        USING Clause
        Using the MAX ROWS clause
        Specifying the maximum number of rows in the diagnostics table
        Privileges required for starting violations or diagnostics tables
        Structure of the violations table
        Examples of START VIOLATIONS TABLE Statements
          Violations and Diagnostics Tables with Default Names
          Violations and Diagnostics Tables with Explicit Names
        Relationships Among the Target, Violations, and Diagnostics Tables
        Initial Privileges on the Violations Table
        Example of Privileges on the Violations Table
        Using the Violations Table
        Example of a Violations Table
        Structure of the diagnostics table
        Initial privileges on the diagnostics table
        Using the Diagnostics Table
      STOP VIOLATIONS TABLE statement
        Example of Stopping the Violations and Diagnostics Tables
        Example of Dropping the Violations and Diagnostics Tables
        Privileges Required for Stopping a Violations Table
      TRUNCATE statement
        The TABLE Keyword
        The Table Specification
        The STORAGE specification
        The AM_TRUNCATE Purpose Function
        Performance Advantages of TRUNCATE
        Restrictions on the TRUNCATE statement
      UNLOAD statement
        UNLOAD TO File
          Unloading Character Columns
          Unloading Simple Large Objects
          Unloading Smart Large Objects
          Unloading Complex Types
        DELIMITER Clause
      UNLOCK TABLE statement
      UPDATE statement
        Using the ONLY Keyword
        Updating Rows Through a View
        Updating Rows in a Database Without Transactions
        Updating Rows in a Database with Transactions
        Locking Considerations
        Declaring an alias for the target table
        SET Clause
          Single-Column Format
          Using a Subquery to Update a Single Column
          Updating a Column to NULL
          Updating the Same Column Twice
          Multiple-Column Format
          Using a Subquery to Update Multiple Column Values
          Updating ROW-Type Columns
          Updating Collection Columns
        Updating Values in Opaque-Type Columns
        Data Types in Distributed UPDATE Operations
        WHERE Clause of UPDATE
          SQLSTATE Values When Updating an ANSI-Compliant Database
          SQLSTATE Values When Updating a Non-ANSI Database
          Subqueries in the WHERE Clause of UPDATE
          Using the WHERE CURRENT OF Clause (ESQL/C, SPL)
        Updating a Row Variable (ESQL/C)
      UPDATE STATISTICS statement
        The scope of UPDATE STATISTICS statements
        Updating Statistics for Tables
          Automated Table Statistics Maintenance
          Using the FOR TABLE ONLY Keywords
          Updating Statistics for Columns
          Examining Index Pages
        Updating Statistics for Columns of User-Defined Types
          Requirements for Statistics on Opaque Columns
        Using the FORCE and AUTO keywords
        Using the LOW mode option
          Using the DROP DISTRIBUTIONS Option
          Using the DROP DISTRIBUTIONS ONLY Option
        Using the MEDIUM mode option
        Using the HIGH mode option
        Resolution Clause
          Specifying the SAMPLING SIZE
          Using the DISTRIBUTIONS ONLY Option to Suppress Index Information
          Using DBUPSPACE Settings to Suppress Index Information
          Output for UPDATE STATISTICS from the SET EXPLAIN Statement
        Routine Statistics
          Altered tables that are referenced indirectly in SPL routines
        Updating statistics when you upgrade the database server
        Performance considerations of UPDATE STATISTICS statements
      WHENEVER statement
        The Scope of WHENEVER
        SQLERROR Keyword
        ERROR Keyword
        SQLWARNING Keyword
        NOT FOUND Keywords
        CONTINUE Keyword
        STOP Keyword
        GOTO Keyword
        CALL Clause
    SPL statements
      Debugging SPL routines
        Starting an SPL debugging session with Optim Development Studio
        Debugging SPL procedures with IBM Database Add-Ins for Visual Studio
      << Label >> statement
        Examples of Labels
      CALL
        Specifying Arguments
        Receiving input from the called UDR
      CASE
      CONTINUE
      DEFINE
        Referencing TEXT and BYTE Variables
        Redeclaration or Redefinition
        Declaring Global Variables
          Default Value
          CURRENT
          SYSDATE
          USER
          TODAY
          BYTE and TEXT
          SITENAME or DBSERVERNAME
        Declaring Local Variables
          Subset of Complex Data Types
          Declaring Collection Variables
          Declaring ROW Variables
          Declaring Opaque-Type Variables
          Declaring Variables LIKE Columns
          Defining Variables with Logical Character Semantics
          Declaring Variables as the PROCEDURE Type
          Declaring Variables for BYTE and TEXT Data
      EXIT
        EXIT From FOREACH Statements
          EXIT From FOR, LOOP, and WHILE Loops
      FOR
        Using the TO Keyword to Define a Range
          Specifying Two or More Ranges in a Single FOR Statement
        Using an Expression List as the Range
        Mixing Range and Expression Lists in the Same FOR Statement
        Specifying a Labelled FOR Loop
      FOREACH
        Using a SELECT ... INTO Statement
        Using the ORDER BY Clause of the SELECT Statement
        Using Hold Cursors
        Updating or Deleting Rows Identified by Cursor Name
        Using Collection Variables
          Restrictions on collection cursors
          Modifying Elements in a Collection Variable
        Using Select Cursors with FOREACH
        Calling a UDR in the FOREACH Loop
      GOTO
      IF
        ELIF Clause
        ELSE Clause
        Conditions in an IF Statement
        Subset of SPL Statements Allowed in the IF Statement List
        SQL Statements Not Valid in an IF Statement
      LET
        Using a SELECT Statement in a LET Statement
        Calling a Function in a LET Statement
      LOOP
        Simple LOOP Statements
        FOR LOOP Statements
        WHILE LOOP Statements
        Labeled LOOP Statements
      ON EXCEPTION
        Placement of the ON EXCEPTION statement
        Using the IN Clause to Trap Specific Exceptions
        Receiving Error Information in the SET Clause
        Forcing Continuation of the Routine
          Continuing Execution After an Exception Occurs
      RAISE EXCEPTION
        Special Error Number -746
      RETURN
        WITH RESUME Keyword
          Returning Values from Another Database
            External Functions and Iterator Functions
      SYSTEM
        Executing the SYSTEM statement on UNIX
        Executing the SYSTEM statement on Windows
        Setting Environment Variables in SYSTEM Commands
      TRACE
        TRACE ON
        TRACE OFF
        TRACE PROCEDURE
        Displaying Expressions
        Example Showing Different Forms of TRACE
        Looking at the Traced Output
      WHILE
        Example of WHILE Loops in an SPL Routine
        Labeled WHILE Loops
    Data types and expressions
      Scope of Segment Descriptions
      Use of Segment Descriptions
      Data type and expression segments
      Collection Subquery
        Table expressions in the FROM clause
      Condition
        Comparison Conditions (Boolean Expressions)
        Column Name
        Quotation Marks in Conditions
        Relational-Operator Condition
        BETWEEN Condition
        IN Condition
          Using the IN operator with collection data types
        IS NULL and IS NOT NULL Conditions
        Trigger-Type Boolean Operator
        LIKE and MATCHES Condition
          NOT Operator
          LIKE Operator
          MATCHES Operator
          ESCAPE with LIKE
          ESCAPE with MATCHES
        Stand-Alone Condition
        Condition with Subquery
          IN Subquery
          EXISTS Subquery condition
          ALL, ANY, and SOME Subqueries
            Using the ALL Keyword
            Using the ANY or SOME Keywords
            Omitting the ANY, ALL, or SOME Keywords
        NOT Operator
        Conditions with AND or OR
      Data Type
        Built-In Data Types
          BOOLEAN and other built-in opaque data types
          BSON and JSON built-in opaque data types
          Character Data Types
            Single-byte and multi-byte characters and locales
            Fixed- and Varying-Length Character Data Types
            LVARCHAR Data Type
            NCHAR and NVARCHAR data types
              NCHAR and NVARCHAR expressions in case-insensitive databases
          IDSSECURITYLABEL Data Type
          Numeric Data Types
          Exact Numeric Data Types
            DECIMAL(p,s) Data Types
            Serial Data Types
          Approximate Numeric Data Types
          Large-Object Data Types
            Simple-large-object data types
            Storing BYTE and TEXT Data
            Smart-large-object data types
          Time Data Types
        User-Defined Data Type
          Distinct Data Types
            DISTINCT Types in Distributed Operations
          Opaque Data Types
        Complex Data Type
          ROW Data Types
          Collection Data Types
            Duplicate Elements in DML Operations on SET Columns
            Defining the Element Type
      DATETIME Field Qualifier
      Expression
        List of Expressions
        Arithmetic Operators
        Bitwise Logical Functions
          BITAND Function
          BITOR Function
          BITXOR Function
          BITANDNOT Function
          BITNOT Function
        Concatenation Operator
        CAST Expressions
          Rules for the Target Data Type
          Examples of Cast Expressions
          The Keyword NULL in Cast Expressions
        Column Expressions
          Using Dot Notation
            Selecting All Fields of a ROW Column with Asterisk Notation
            Selecting Nested Fields
            Rules of Precedence
            Using Dot Notation with Row-Type Expressions
          Using the Substring Operator
          Using Rowids
          Using Smart Large Objects
        Conditional Expressions
          CASE Expressions
            CASE expressions data type compatibility
            Generic CASE Expressions
            Linear CASE Expressions
          COALESCE Function
          NVL Function
          NULLIF Function
          DECODE Function
        Constant Expressions
          Quoted String
          Literal Number
          USER or CURRENT_USER Operator
          CURRENT_ROLE Operator
          DEFAULT_ROLE Operator
          DBSERVERNAME and SITENAME Operators
          TODAY Operator
          CURRENT Operator
          SYSDATE Operator
          Literal DATETIME
          Literal INTERVAL
          UNITS Operator
          NEXTVAL and CURRVAL Operators
            Using NEXTVAL
            Using CURRVAL
            Concurrent Access to a Sequence
            Restrictions on sequence operators
          Literal Row
          Literal Collection
        Constructor Expressions
          ROW constructors
          Collection Constructors
            Examples of Collection Constructors
        NULL Keyword
        Function Expressions
          Algebraic Functions
            ABS Function
            CEIL Function
            FLOOR Function
            GREATEST function
            LEAST function
            MOD Function
            POW Function
            ROOT Function
            SQRT Function
            ROUND Function
            TRUNC Function
          CARDINALITY Function
          SQLCODE Function (SPL)
          DBINFO Function
            DBINFO Options
            Using the ('dbspace', tblspace_num) Option
            Using the 'sqlca.sqlerrd1' Option
            Using the 'sqlca.sqlerrd2' Option
            Using the 'sessionid' Option
            Using the 'cdrsession' option
            Using the 'dbname' Option
            Using the 'dbhostname' Option
            Using the 'version' Option
            Using the 'serial8' and 'bigserial' options
            Using the 'get_tz' Option
            Using the 'utc_current' Option
            Using the 'utc_to_datetime' Option
          Encryption and decryption functions
            Column Level and Cell Level Encryption
            The Password and Hint Specifications
            Data Types, Encoding, and Size of Encrypted Values
            Example of Column Level Encryption
              Calculating storage requirements for encrypted data
              Implementing column-level encryption
          DECRYPT_CHAR Function
          DECRYPT_BINARY Function
          ENCRYPT_AES Function
          ENCRYPT_TDES Function
          GETHINT Function
          Exponential and Logarithmic Functions
            EXP Function
            LN function
            LOG10 Function
            LOGN Function
          NVL2 Function
          HEX Function
          Length functions
            LENGTH Function
            OCTET_LENGTH Function
            CHAR_LENGTH Function
          Security Label Support Functions
            SECLABEL_BY_NAME Function
            SECLABEL_BY_COMP Function
            SECLABEL_TO_CHAR Function
          SIGN function
          Smart-Large-Object Functions
            FILETOBLOB and FILETOCLOB Functions
            Pathnames with Commas
            LOTOFILE Function
            LOCOPY Function
          Time Functions
            ADD_MONTHS Function
            DATE Function
            DAY Function
            MONTH Function
            QUARTER Function
            WEEKDAY Function
            YEAR Function
            MONTHS_BETWEEN Function
            LAST_DAY Function
            NEXT_DAY Function
            EXTEND Function
            MDY Function
            TO_CHAR Function
            TO_DATE Function
          TO_NUMBER Function
          Trigonometric Functions
            COS Function
            COSH function
            SIN Function
            SINH function
            TAN Function
            TANH Function
            ACOS Function
            ACOSH Function
            ASIN Function
            ASINH Function
            ATAN Function
            ATANH Function
            ATAN2 Function
            DEGREES function
            RADIANS function
          String-Manipulation Functions
            CONCAT Function
            Return Types from CONCAT and String Functions
              Data-type promotion in NLSCASE INSENSITIVE databases
            Return String Types in Distributed Transactions
            ASCII Function
            TRIM Function
              Fixed Character Columns
            LTRIM Function
            RTRIM Function
            SPACE function
            REVERSE function
            REPLACE Function
            LPAD Function
            RPAD Function
            CHR Function
          Case-Conversion Functions
            UPPER Function
            LOWER Function
            INITCAP Function
            Case-conversion functions in NLSCASE INSENSITIVE databases
          Substring functions
            CHARINDEX function
            INSTR function
            LEFT function
            RIGHT function
            SUBSTR function
            SUBSTRB function
            SUBSTRING function
            SUBSTRING_INDEX function
          FORMAT_UNITS Function
          IFX_ALLOW_NEWLINE Function
          User-Defined Functions
            Statement-Local Variable Declaration
        Statement-Local Variable Expressions
        Aggregate Expressions
          Types of Aggregate Expressions
            Built-in Aggregates
            User-Defined Aggregates
          Subset of Expressions Valid in an Aggregate Expression
          Including or excluding duplicates in the result set
          AVG Function
          Overview of COUNT Functions
          COUNT(*) function
          COUNT DISTINCT and COUNT UNIQUE functions
          COUNT column Function
          Arguments to the COUNT Functions
            Examples of the COUNT(*) Function
            Examples of the COUNT DISTINCT Function
            Examples of the COUNT column Function
          MAX Function
          MIN Function
          SUM Function
          RANGE Function
          STDEV Function
          VARIANCE Function
          Error Checking in ESQL/C
          Summary of Aggregate Function Behavior
          User-Defined Aggregates
          Aggregate expressions in grid queries
      OLAP window expressions
        OLAP numbering function expression
        OLAP ranking function expressions
          LAG and LEAD functions
          RANK function
          DENSE_RANK function
          PERCENT_RANK function
          CUME_DIST function
          NTILE function
        OLAP aggregation function expressions
          FIRST_VALUE function
          LAST_VALUE function
          RATIO_TO_REPORT function
          OLAP window aggregate functions
        OVER clause for OLAP window expressions
      INTERVAL Field Qualifier
      Literal Collection
        Element Literal Value
        Nested Quotation Marks
      Literal DATETIME
        Precedence of DATE and DATETIME format specifications
        Casting Numeric Date and Time Strings to DATE Data Types
      Literal INTERVAL
      Literal Number
        Integer Literals
        Fixed-Point Decimal Literals
        Floating-Point Decimal Literals
        Literal Numbers and the MONEY Data Type
      Literal Row
        Literals of an Unnamed Row Type
        Literals of a Named Row Type
        Literals for Nested Rows
      Quoted String
        Restrictions on Specifying Characters in Quoted Strings
        The DELIMIDENT Environment Variable
        Newline Characters in Quoted Strings
        Using Quotation Marks in Strings
        DATETIME and INTERVAL Values as Strings
        LIKE and MATCHES in a Condition
        Inserting Values as Quoted Strings
        Numeric Operations on Character Columns
      Relational Operator
        Using Operator Functions in Place of Relational Operators
        Collating Order for U.S. English Data
        Support for ASCII Characters in Nondefault Code Sets (GLS)
        Literal Numbers as Operands
    Other syntax segments
      Arguments
        Comparing Arguments to the Parameter List
        Subset of Expressions Valid as an Argument
        Arguments to UDRs in Remote Databases
      Collection-Derived Table
        Accessing a Collection Through a Virtual Table
        Table Expressions in the FROM Clause
        Restrictions with the Collection-Expression Format
          Additional Restrictions That Apply to ESQL/C
        Row Type of the Resulting Collection-Derived Table
        Accessing a Collection Through a Collection Variable
        Using a Collection Variable to Manipulate Collection Elements
          Example of Deleting from a Collection in ESQL/C
          Example of Deleting from a Collection
          Example of Updating a Collection
          Example of Inserting a Value into a Multiset Collection
        Accessing a Nested Collection
        Accessing a Row Variable
      Database Name
        Using Keywords as Table Names
          Using the @ Symbol
          Using a Path-Type Naming Notation
          Using a Host Variable
      Database Object Name
        Specifying a Database Object in an External Database
          Specifying a Database Object in a Cross-Database Query
          Specifying a Database Object in a Cross-Server Query
        Routine Overloading and Routine Signatures
          Specifying an Existing UDR
        Owners of Objects Created by UDRs
      External Routine Reference
        VARIANT or NOT VARIANT Option
        Example of a C User-Defined Function
      Identifier
        Use of Uppercase Characters
        Use of Keywords as Identifiers
        Support for Non-ASCII Characters in Identifiers
        Delimited Identifiers
          Support for Nonalphanumeric Characters
          Support for Non-ASCII Characters in Delimited Identifiers (GLS)
        Enabling Delimited Identifiers
          Examples of Delimited Identifiers
          Using Double Quotation Marks in a Delimited Identifier
        Potential Ambiguities and Syntax Errors
        Using the Names of Built-In Functions as Column Names
        Using Keywords as Column Names
        Using ALL, DISTINCT, or UNIQUE as a Column Name
        Using INTERVAL or DATETIME as a Column Name
        Using rowid as a Column Name
        Using keywords as table names
          Workarounds that Use the Keyword AS
          Using AS with Column Labels
          Using AS with Table Aliases
          Fetching Cursors that have Keywords as Names
          Declaring keywords as names for variables in UDRs
          Using CURRENT, DATETIME, INTERVAL, and NULL in INSERT
          Using NULL and SELECT in a Condition
          Declaring Keywords or Routine Names as SPL Variables
          Variables that Conflict with Column Names
          Using ON, OFF, or PROCEDURE with TRACE
          Using GLOBAL as the Name of a Variable
          Using EXECUTE, SELECT, or WITH as Cursor Names
          SELECT Statements in WHILE and FOR Statements
          SET keyword in the ON EXCEPTION statement of SPL
      Jar Name
      Optimizer Directives
        Optimizer Directives as Comments
        Restrictions on Optimizer Directives
        Access-Method Directives
        Join-Order Directive
        Join-Method Directives
        Star-Join Directives
        Optimization-Goal Directives
        Explain-Mode Directives
        Statement cache directive
        External Directives
      Owner name
        Using Quotation Marks
        Referencing Tables Owned by User informix
        ANSI-Compliant Database Restrictions and Case Sensitivity
        Setting ANSIOWNER for an ANSI-Compliant Database
        Default Owner Names
        Summary of Lettercase Rules for Owner Names
      Purpose Options
        Purpose Options for Access Methods
        Purpose Functions, Flags, and Values
        Purpose Options for XA Data Source Types
      Return Clause
        Limits on Returned Values
        Subset of SQL Data Types
        Using the REFERENCES Clause to Point to a Simple Large Object
        Returning a value from another database
        Named Return Parameters
        Cursor and Noncursor Functions
      Routine modifier
        Adding or Modifying a Routine Modifier
        Modifier Descriptions
          CLASS
          COSTFUNC (C)
          HANDLESNULLS
          INTERNAL
          ITERATOR
          NEGATOR
          PARALLELIZABLE
          PERCALL_COST (C)
          SELCONST (C)
          SELFUNC (C)
            Concept of Selectivity
            Restrictions on the SELFUNC Modifier
          STACK (C)
          VARIANT and NOT VARIANT
      Routine Parameter List
        Subset of SQL Data Types
        Using the LIKE Clause
        Using the REFERENCES Clause
        Using the DEFAULT Clause
        Specifying OUT Parameters for User-Defined Routines
        Specifying INOUT Parameters for a User-Defined Routine
      Shared-Object Filename
        C Shared-Object File
        Java Shared-Object File
      Specific Name
        Restrictions on the Owner Name
        Restrictions on the Specific Name
      Statement Block
        Subset of SPL Statements Valid in the Statement Block
        SQL Statements Valid in SPL Statement Blocks
        Nested Statement Blocks
          Scope of Reference of SPL Variables and Exception Handlers
        Restrictions on SPL Routines in Data-Manipulation Statements
        Transactions in SPL Routines
        Support for roles and user identity
    Built-in routines
      Interval functions
        TO_DSINTERVAL function
        TO_YMINTERVAL function
      Session Configuration Procedures
        Using SYSDBOPEN and SYSDBCLOSE Procedures
        Configure session properties at connection or access time
        Configuring session properties
      BSON processing functions
        BSON_GET function
        BSON_SIZE function
        BSON_UPDATE function
        BSON_VALUE_BIGINT function
        BSON_VALUE_BOOLEAN function
        BSON_VALUE_DATE function
        BSON_VALUE_DOUBLE function
        BSON_VALUE_INT function
        BSON_VALUE_LVARCHAR function
        BSON_VALUE_OBJECTID function
        BSON_VALUE_TIMESTAMP function
        BSON_VALUE_VARCHAR function
        genBSON function
      DataBlade Module Management Functions
        The SYSBldPrepare Function
        The SYSBldRelease Function
      The EXPLAIN_SQL Routine
      UDR Definition Routines
        IFX_REPLACE_MODULE Function
        IFX_UNLOAD_MODULE Function
      jvpcontrol Function
        Using the MEMORY Keyword
        Using the THREADS Keyword
      SQLJ Driver Built-In Procedures
        sqlj.install_jar
          File Permissions on Jar Files
        sqlj.replace_jar
        sqlj.remove_jar
        sqlj.alter_java_path
        sqlj.setUDTextName
        sqlj.unsetUDTextName
      DRDA Support Functions
        Metadata Function
        sysibm.SQLCAMessage Function
    Appendixes
      Keywords of SQL for HCL Informix
  Guide to SQL: Reference
    What's new in SQL Reference for Informix, Version 12.10
    System catalog tables
      Objects that the system catalog tables track
      Using the system catalog
        Accessing the system catalog
        Update system catalog data
      Structure of the System Catalog
      SYSAGGREGATES
      SYSAMS
      SYSATTRTYPES
      SYSAUTOLOCATE
      SYSBLOBS
      SYSCASTS
      SYSCHECKS
      SYSCHECKUDRDEP
      SYSCOLATTRIBS
      SYSCOLAUTH
      SYSCOLDEPEND
      SYSCOLUMNS
        Storing column length
        Storing Maximum and Minimum Values
      SYSCONSTRAINTS
      SYSDEFAULTS
      SYSDEPEND
      SYSDIRECTIVES
      SYSDISTRIB
      SYSDOMAINS
      SYSERRORS
      SYSEXTCOLS
      SYSEXTDFILES
      SYSEXTERNAL
      SYSFRAGAUTH
      SYSFRAGDIST
      SYSFRAGMENTS
      SYSINDEXES
      SYSINDICES
      SYSINHERITS
      SYSLANGAUTH
      SYSLOGMAP
      SYSOBJSTATE
      SYSOPCLASSES
      SYSPROCAUTH
      SYSPROCBODY
      SYSPROCCOLUMNS
      SYSPROCEDURES
      SYSPROCPLAN
      SYSREFERENCES
      SYSROLEAUTH
      SYSROUTINELANGS
      SYSSECLABELAUTH
      SYSSECLABELCOMPONENTS
      SYSSECLABELCOMPONENTELEMENTS
      SYSSECLABELNAMES
      SYSSECLABELS
      SYSSECPOLICIES
      SYSSECPOLICYCOMPONENTS
      SYSSECPOLICYEXEMPTIONS
      SYSSEQUENCES
      SYSSURROGATEAUTH
      SYSSYNONYMS
      SYSSYNTABLE
      SYSTABAMDATA
      SYSTABAUTH
      SYSTABLES
      SYSTRACECLASSES
      SYSTRACEMSGS
      SYSTRIGBODY
      SYSTRIGGERS
      SYSUSERS
      SYSVIEWS
      SYSVIOLATIONS
      SYSXADATASOURCES
      SYSXASOURCETYPES
      SYSXTDDESC
      SYSXTDTYPEAUTH
      SYSXTDTYPES
      Information Schema
        Generating the Information Schema Views
        Accessing the Information Schema Views
        Structure of the Information Schema Views
          The tables Information Schema View
          The columns Information Schema View
          The sql_languages Information Schema View
          The server_info Information Schema View
    Data types
      Summary of data types
      **** MISSING FILE ****
      Description of Data Types
        BIGINT data type
        BIGSERIAL data type
          Using SERIAL8 and BIGSERIAL with INT8 or BIGINT
        BLOB data type
        BOOLEAN data type
        BYTE data type
        CHAR(n) data type
          Treating CHAR Values as Numeric Values
          Sorting and Relational Comparisons
          Nonprintable Characters with CHAR
        CHARACTER(n) data type
        CHARACTER VARYING(m,r) data type
        CLOB data type
          Multibyte characters with CLOB
        DATE data type
        DATETIME data type
        DEC data type
        DECIMAL
          DECIMAL(p) Floating Point
          DECIMAL (p,s) Fixed Point
          DECIMAL Storage
        DISTINCT data types
        DOUBLE PRECISION data types
        FLOAT(n)
        IDSSECURITYLABEL data type
        INT data type
        INT8
        INTEGER data type
        INTERVAL data type
        LIST(e) data type
        LVARCHAR(m) data type
        MONEY(p,s) data type
        MULTISET(e) data type
        Named ROW
        NCHAR(n) data type
        NUMERIC(p,s) data type
        NVARCHAR(m,r) data type
        OPAQUE data types
        REAL data type
        ROW data type, Named
        ROW data type, Unnamed
          Creating unnamed ROW types
          Inserting Values into Unnamed ROW Type Columns
        SERIAL(n) data type
        SERIAL8(n) data type
          Assigning a Starting Value for SERIAL8
        SET(e) data type
        SMALLFLOAT
        SMALLINT data type
        TEXT data type
          Nonprintable Characters in TEXT Values
        Unnamed ROW
        VARCHAR(m,r) data type
      Built-In Data Types
        Character Data Types
        Large-Object Data Types
          Simple Large Objects
          Smart large objects
        Time Data Types
          Manipulating DATETIME Values
          Manipulating DATETIME with INTERVAL Values
          Manipulating DATE with DATETIME and INTERVAL Values
          Manipulating INTERVAL Values
          Multiplying or Dividing INTERVAL Values
      Extended Data Types
        Complex data types
          Collection Data Types
            Accessing collection data
          ROW Data Types
        Distinct Data Types
        Opaque Data Types
      Data Type Casting and Conversion
        Using Built-in Casts
          Converting from number to number
          Converting Between Number and Character
          Converting Between INTEGER and DATE
          Converting Between DATE and DATETIME
        Using User-Defined Casts
          Implicit Casts
          Explicit Casts
        Determining Which Cast to Apply
        Casts for distinct types
        What Extended Data Types Can Be Cast?
      Operator Precedence
    Environment variables
      Types of environment variables
      Limitations on environment variables
      Using environment variables on UNIX
        Setting environment variables in a configuration file
        Setting environment variables at login time
        Syntax for setting environment variables
        Unsetting environment variables
        Modifying an environment-variable setting
        Viewing your environment-variable settings
        Checking environment variables with the chkenv utility
        Rules of precedence for environment variables
      Using environment variables on Windows
        Where to set environment variables on Windows
        Setting environment variables on Windows
          Using the system applet to change environment variables
          Using the command prompt to change environment variables
          Using dbservername.cmd to initialize a command-prompt environment
        Rules of precedence for Windows environment variables
      Environment variables in Informix products
        Environment variable portal
        ANSIOWNER environment variable
        CPFIRST environment variable
        CMCONFIG environment variable
        CLIENT_LABEL environment variable
        DBACCNOIGN environment variable
          LOAD statement example when DBACCNOIGN is set
        DBANSIWARN environment variable
        DBBLOBBUF environment variable
        DBCENTURY environment variable
          Examples of expanding year values
          Abbreviated years and expressions in database objects
        DBDATE environment variable
          DATE expressions in database objects
        DBDELIMITER environment variable
        DBEDIT environment variable
        DBFLTMASK environment variable
        DBLANG environment variable
        DBMONEY environment variable
        DBONPLOAD environment variable
        DBPATH environment variable
          Using DBPATH with DB-Access
          Searching local directories
          Searching networked computers for databases
          Specifying a servername
        DBPRINT environment variable
        DBREMOTECMD environment variable (UNIX)
        DBSPACETEMP environment variable
        DBTEMP environment variable
        DBTIME environment variable
        DBUPSPACE environment variable
        DEFAULT_ATTACH environment variable
        DELIMIDENT environment variable
        ENVIGNORE environment variable (UNIX)
        FET_BUF_SIZE environment variable
        IFMXMONGOAUTH environment variable
        IFX_DEF_TABLE_LOCKMODE environment variable
        IFX_DIRECTIVES environment variable
        IFX_EXTDIRECTIVES environment variable
        IFX_LARGE_PAGES environment variable
        IFX_LOB_XFERSIZE environment variable
        IFX_LONGID environment variable
        IFX_NETBUF_PVTPOOL_SIZE environment variable (UNIX)
        IFX_NETBUF_SIZE environment variable
        IFX_NO_SECURITY_CHECK environment variable (UNIX)
        IFX_NO_TIMELIMIT_WARNING environment variable
        IFX_NODBPROC environment variable
        IFX_NOT_STRICT_THOUS_SEP environment variable
        IFX_ONTAPE_FILE_PREFIX environment variable
        IFX_PAD_VARCHAR environment variable
        IFX_UNLOAD_EILSEQ_MODE environment variable
        IFX_UPDDESC environment variable
        IFX_XASTDCOMPLIANCE_XAEND environment variable
        IFX_XFER_SHMBASE environment variable
        IMCADMIN environment variable
        IMCCONFIG environment variable
        IMCSERVER environment variable
        INFORMIXC environment variable (UNIX)
        INFORMIXCMNAME environment variable
        INFORMIXCMCONUNITNAME environment variable
        INFORMIXCONCSMCFG environment variable
        INFORMIXCONRETRY environment variable
        INFORMIXCONTIME environment variable
        INFORMIXCPPMAP environment variable
        INFORMIXDIR environment variable
        INFORMIXSERVER environment variable
        INFORMIXSHMBASE environment variable (UNIX)
        INFORMIXSQLHOSTS environment variable
        INFORMIXSTACKSIZE environment variable
        INFORMIXTERM environment variable (UNIX)
        INF_ROLE_SEP environment variable
        INTERACTIVE_DESKTOP_OFF environment variable (Windows)
        JAR_TEMP_PATH environment variable
        JAVA_COMPILER environment variable
        JVM_MAX_HEAP_SIZE environment variable
        LD_LIBRARY_PATH environment variable (UNIX)
        LIBPATH environment variable (UNIX)
        NODEFDAC environment variable
        ONCONFIG environment variable
        ONINIT_STDOUT environment variable (Windows)
        OPTCOMPIND environment variable
        OPTMSG environment variable
        OPTOFC environment variable
        OPT_GOAL environment variable (UNIX)
        PATH environment variable
        PDQPRIORITY environment variable
          Using PDQPRIORITY with Informix
        PLCONFIG environment variable
        PLOAD_LO_PATH environment variable
        PLOAD_SHMBASE environment variable
        PSM_ACT_LOG environment variable
        PSM_CATALOG_PATH environment variable
        PSM_DBS_POOL environment variable
        PSM_DEBUG environment variable
        PSM_DEBUG_LOG environment variable
        PSM_LOG_POOL environment variable
        PSORT_DBTEMP environment variable
        PSORT_NPROCS environment variable
          Default PSORT_NPROCS values for detached indexes
          Default PSORT_NPROCS values for attached indexes
        RTREE_COST_ADJUST_VALUE environment variable
        SHLIB_PATH environment variable (UNIX)
        SRV_FET_BUF_SIZE environment variable
        STMT_CACHE environment variable
        TERM environment variable (UNIX)
        TERMCAP environment variable (UNIX)
        TERMINFO environment variable (UNIX)
        THREADLIB environment variable (UNIX)
        TZ environment variable
        USETABLENAME environment variable
    Appendixes
      The stores_demo Database
        The stores_demo Database Map
      The superstores_demo database
        Structure of the superstores_demo Tables
        User-defined routines and extended data types
        Table Hierarchies
  Guide to SQL: Tutorial
    Database concepts
      Illustration of a data model
        Store data
        Query data
        Modify data
      Concurrent use and security
        Control database use
          Access-management strategies
            Creating and granting a role
            Defining and granting privileges for a default role
            Built-in roles
        Centralized management
      Important database terms
        The relational database model
        Tables
        Columns
        Rows
        Views
        Sequences
        Operations on tables
        The object-relational model
      Structured Query Language
        Standard SQL
        Informix SQL and ANSI SQL
        Interactive SQL
        General programming
        ANSI-compliant databases
        Global Language Support
      Summary
    Compose SELECT statements
      SELECT statement overview
        Output from SELECT statements
          Output from large object data types
          Output from user-defined data types
          Output in non-default code sets
        Some basic concepts
          Privileges
          Relational operations
          Selection and projection
          Join
      Single-table SELECT statements
        The asterisk symbol (*)
          Reorder the columns
        The ORDER BY clause to sort the rows
          Ascending order
          Descending order
          Sorting on multiple columns
        Select specific columns
          Select substrings
          ORDER BY and non-English data
        The WHERE clause
        Create a comparison condition
          Include rows
          Exclude rows
          Specify a range of rows
          Exclude a range of rows
          Use a WHERE clause to find a subset of values
          Identify NULL values
          Form compound conditions
          Exact-text comparisons
          Variable-text searches
          A single-character wildcard
            WHERE clause to specify a range of initial characters
            WHERE clause with variable-length wildcard
          MATCHES clause and non-default locales
          Protect special characters
          Subscripting in a WHERE clause
        FIRST clause to select specific rows
          FIRST clause without an ORDER BY clause
          FIRST clause with an ORDER BY clause
        Expressions and derived values
          Arithmetic expressions
            Display labels
          CASE expressions
          Sorting on derived columns
        Rowid values in SELECT statements
      Multiple-table SELECT statements
        Create a Cartesian product
        Create a join
          Cross join
          Equi-join
          Natural join
          Multiple-table join
        Some query shortcuts
          Aliases
          The INTO TEMP clause
      Summary
    Select data from complex types
      Select row-type data
        Select columns of a typed table
        Select columns that contain row-type data
          Field projections
          Field projections to select nested fields
            Select individual fields of a row type
          Asterisk notation to access all fields of a row type
      Select from a collection
        Select nested collections
        The IN keyword to search for elements in a collection
      Select rows within a table hierarchy
        Select rows of the supertable without the ONLY keyword
        Select rows from a supertable with the ONLY keyword
        An alias for a supertable
      Summary
    Functions in SELECT statements
      Functions in SELECT statements
        Aggregate functions
          The AVG function
          The COUNT function
          The MAX and MIN functions
          The RANGE function
          The STDEV function
          The SUM function
          The VARIANCE function
          Apply aggregate functions to expressions
        Time functions
          The DAY and CURRENT functions
          The MONTH function
          The WEEKDAY function
          The YEAR function
          Format DATETIME values
        Date-conversion functions
          The DATE function
          The TO_CHAR function
          The TO_DATE function
        Cardinality function
        Smart large object functions
        String-manipulation functions
          The LOWER function
          The UPPER function
          The INITCAP function
          The REPLACE function
          The SUBSTRING and SUBSTR functions
          The SUBSTRING function
          The SUBSTR function
          The LPAD function
          The RPAD function
        Other functions
          The LENGTH function
          The USER function
          The TODAY function
          The DBSERVERNAME and SITENAME functions
          The HEX function
          The DBINFO function
          The DECODE function
          The NVL function
      SPL routines in SELECT statements
      Data encryption functions
        Using column-level data encryption to secure credit card data
      Summary
    Compose advanced SELECT statements
      The GROUP BY and HAVING clauses
        The GROUP BY clause
        The HAVING clause
      Create advanced joins
        Self-joins
        Outer joins
          HCL Informix extension to outer join syntax
          ANSI join syntax
          Left outer join
          Right outer join
          Simple join
          Simple outer join on two tables
          Outer join for a simple join to a third table
          Outer join of two tables to a third table
          Joins that combine outer joins
      Subqueries in SELECT statements
        Correlated subqueries
        Using subqueries to combine SELECT statements
        Subqueries in a Projection clause
        Subqueries in the FROM clause
        Subqueries in WHERE clauses
          The ALL keyword
          The ANY keyword
          Single-valued subqueries
          Correlated subqueries
          The EXISTS keyword
        Subqueries in DELETE and UPDATE statements
      Handle collections in SELECT statements
        Collection subqueries
          Omit the ITEM keyword in a collection subquery
          Specify the ITEM keyword in a collection subquery
          Collection subqueries in the FROM clause
        Collection-derived tables
        ISO-compliant syntax for collection derived tables
      Set operations
        Union
          ORDER BY clause with UNION
          The UNION ALL keywords
          Different column names
          UNION with multiple tables
          A literal in the Projection clause
          A FIRST clause
        Intersection
        Difference
      Summary
    Modify data
      Modify data in your database
      Delete rows
        Delete all rows of a table
        Delete all rows using TRUNCATE
        Delete specified rows
        Delete selected rows
        Delete rows that contain row types
        Delete rows that contain collection types
        Delete rows from a supertable
        Complicated delete conditions
        The Delete clause of MERGE
      Insert rows
        Single rows
          Possible column values
          Restrictions on column values
          Serial data types
          List specific column names
        Insert rows into typed tables
        Syntax rules for inserts on columns
          Rows that contain named row types
          Rows that contain unnamed row types
          Specify NULL values for row types
        Insert rows into supertables
        Insert collection values into columns
          Insert values into simple collections and nested collections
          Insert NULL values into a collection that contains a row type
        Insert smart large objects
        Multiple rows and expressions
        Restrictions on the insert selection
      Update rows
        Select rows to update
        Update with uniform values
        Restrictions on updates
        Update with selected values
        Update row types
          Update rows that contain named row types
          Update rows that contain unnamed row types
          Specify Null values for the fields of a row type
        Update collection types
        Update rows of a supertable
        CASE expression to update a column
        SQL functions to update smart large objects
        The MERGE statement to update a table
      Privileges on a database and on its objects
        Database-level privileges
        Table-level privileges
        Display table privileges
        Grant privileges to roles
      Data integrity
        Entity integrity
        Semantic integrity
        Referential integrity
          The ON DELETE CASCADE option
          Example of cascading deletes
          Restrictions on cascading deletes
        Object modes and violation detection
          Definitions of object modes
            Enabled mode
            Disabled mode
            Filtering mode
          Example of modes with data manipulation statements
            Results of the insert operation when the constraint is enabled
            Results of the insert operation when the constraint is disabled
            Results of the insert when constraint is in filtering mode
            Multiple diagnostic rows for one violations row
          Violations and diagnostics tables
            Relationship of violations tables and database object modes
            Examples of START VIOLATIONS TABLE statements
            Example of privileges on the violations table
            Example of privileges on the diagnostics table
      Interrupted modifications
        Transactions
        Transaction logging
          Logging and cascading deletes
        Specify transactions
      Backups and logs with HCL Informix database servers
      Concurrency and locks
      HCL Informix data replication
      Summary
    Access and modify data in an external database
      Access other database servers
        Access ANSI databases
        Create joins between external database servers
        Access external routines
      Restrictions for remote database access
        SQL statements that access more than one database
        Access external database objects
    SQL programming
      SQL in programs
        SQL in SQL APIs
        SQL in application languages
        Static embedding
        Dynamic statements
        Program variables and host variables
      Call the database server
        SQL Communications Area
        SQLCODE field
          End of data
          Negative Codes
        SQLERRD array
        SQLWARN array
        SQLERRM character string
        SQLSTATE value
      Retrieve single rows
        Data type conversion
        What if the program retrieves a NULL value?
        Dealing with errors
          End of data
          End of data with databases that are not ANSI compliant
          Serious errors
          Interpret end of data with aggregate functions
          Default values
      Retrieve multiple rows
        Declare a cursor
        Open a cursor
        Fetch rows
          Detect end of data
          Locate the INTO clause
        Cursor input modes
        Active set of a cursor
          Create the active set
          Active set for a sequential cursor
          Active set for a SCROLL cursor
          Active set and concurrency
        Parts-explosion problem
      Dynamic SQL
        Prepare a statement
        Execute prepared SQL
        Dynamic host variables
        Free prepared statements
        Quick execution
      Embed data-definition statements
      Grant and revoke privileges in applications
        Assign roles
      Summary
    Modify data through SQL programs
      The DELETE statement
        Direct deletions
          Errors during direct deletions
          Transaction logging
          Coordinated deletions
        Delete with a cursor
      The INSERT statement
        An insert cursor
          Declare an insert cursor
          Insert with a cursor
          Status codes after PUT and FLUSH
        Rows of constants
        An insert example
          How many rows were affected?
      The UPDATE statement
        An update cursor
          The purpose of the keyword UPDATE
          Update specific columns
          UPDATE keyword not always needed
        Cleanup a table
      Summary
    Programming for a multiuser environment
      Concurrency and performance
      Locks and integrity
      Locks and performance
      Concurrency issues
      How locks work
        Kinds of locks
        Lock scope
          Database locks
          Table locks
            Lock a table with the LOCK TABLE statement
            When the database server automatically locks a table
            Avoid table locking with the ONLINE keyword
          Row and key locks
          Page locks
            Set the row or page lock mode for all CREATE TABLE statements
              Single-user lock mode
              Multiple-user lock mode
              Rules of precedence
          Coarse index locks
          Smart-large-object locks
            Byte-range locks
        Duration of a lock
        Locks while modifying
      Lock with the SELECT statement
        Set the isolation level
          SET TRANSACTION versus SET ISOLATION
            SET ISOLATION
            SET TRANSACTION
          ANSI Read Uncommitted and HCL Informix Dirty Read isolation
          ANSI Read Committed and HCL Informix Committed Read isolation
          HCL Informix Cursor Stability isolation
          ANSI Serializable, ANSI Repeatable Read, and HCL Informix Repeatable Read isolation
        Update cursors
      Retain update locks
      Exclusive locks that occur with some SQL statements
      The behavior of the lock types
      Control data modification with access modes
      Set the lock mode
        Waiting for locks
        Not waiting for locks
        Limited time wait
        Handle a deadlock
        Handling external deadlock
      Simple concurrency
      Hold cursors
      The SQL statement cache
      Summary
    Create and use SPL routines
      Introduction to SPL routines
        What you can do with SPL routines
      SPL routines format
        The CREATE PROCEDURE or CREATE FUNCTION statement
          Begin and end the routine
          Specify a routine name
          Add a specific name
          Add a parameter list
            Simple large objects as parameters
            Undefined arguments
          Add a return clause
          Add display labels
          Specify whether the SPL function is variant
          Add a modifier
            The COMMUTATOR modifier
            The NEGATOR modifier
          Specify a DOCUMENT clause
          Specify a listing file
          Add comments
        Example of a complete routine
        Create an SPL routine in a program
        Dropping a routine in a local or remote database
      Define and use variables
        Declare local variables
          Scope of local variables
          Declare variables of built-in data types
          Declare variables for smart large objects
          Declare variables for simple large objects
          Declare collection variables
          Declare row-type variables
          Declare opaque- and distinct-type variables
          Declare variables for column data with the LIKE clause
          Declare PROCEDURE type variables
          Subscripts with variables
          Variable and keyword ambiguity
            Variables and column names
            Variables and SQL functions
        Declare global variables
        Assign values to variables
          The LET statement
          Other ways to assign values to variables
      Expressions in SPL routines
      Writing the statement block
        Implicit and explicit statement blocks
        The FOREACH loop
        The FOREACH loop to define cursors
          Restriction for FOREACH loops
        An IF - ELIF - ELSE structure
        Add WHILE and FOR loops
        Exit a loop
      Return values from an SPL function
        Return a single value
        Return multiple values
      Handle row-type data
        Precedence of dot notation
        Update a row-type expression
      Handle collections
        Collection data types
        Prepare for collection data types
          Declare a collection variable
          Declare an element variable
          Select a collection into a collection variable
        Insert elements into a collection variable
          Insert into a SET or MULTISET
          Insert into a LIST
          Check the cardinality of a LIST collection
          Syntax of the VALUES clause
        Select elements from a collection
          The collection query
          Add the collection query to the SPL routine
        Delete a collection element
          Update the collection in the database
          Delete the entire collection
        Update a collection element
          Update a collection with a variable
        Update the entire collection
          Update a collection of row types
          Update a nested collection
        Insert into a collection
          Insert into a nested collection
            Insert a collection into the outer collection
            Insert a value into the inner collection
      Executing routines
        The EXECUTE statements
        The CALL statement
        Execute routines in expressions
        Execute an external function with the RETURN statement
        Execute cursor functions from an SPL routine
        Dynamic routine-name specification
          Rules for dynamic routine-name specification
      Privileges on routines
        Privileges for registering a routine
        Privileges for executing a routine
          Grant and revoke the Execute privilege
          Execute privileges with COMMUTATOR and NEGATOR functions
        Privileges on objects associated with a routine
        DBA privileges for executing a routine
      Find errors in an SPL routine
        Compile-time warnings
        Generate the text of the routine
      Debug an SPL routine
      Exception handling
        Error trapping and recovering
        Scope of control of an ON EXCEPTION statement
        User-generated exceptions
          Simulate SQL errors
          RAISE EXCEPTION to exit nested code
      Check the number of rows processed in an SPL routine
      Summary
    Create and use triggers
      When to use triggers
      How to create a trigger
        Declare a trigger name
        Specify the trigger event
        Define the triggered actions
        A complete CREATE TRIGGER statement
      Triggered actions
        BEFORE and AFTER triggered actions
        FOR EACH ROW triggered actions
          The REFERENCING clause
          The WHEN condition
        SPL routines as triggered actions
          Pass data to an SPL routine
          Using SPL
          Update nontriggering columns with data from an SPL routine
      Trigger routines
      Triggers in a table hierarchy
      Select triggers
        SELECT statements that execute triggered actions
          Stand-alone SELECT statements
          Collection subqueries in the projection list of a query
          SELECT statements embedded in user-defined routines
          Views
        Restrictions on execution of Select triggers
        Select triggers on tables in a table hierarchy
      Re-entrant triggers
      INSTEAD OF triggers on views
        INSTEAD OF trigger to update on a view
      Trace triggered actions
        Example of TRACE statements in an SPL routine
        Example of TRACE output
      Generate error messages
        Apply a fixed error message
        Generate a variable error message
      Summary
  Guide to SQL: Syntax
    What's new in SQL Syntax for Informix, Version 12.10
    Overview of SQL syntax
      How to Enter SQL Statements
        Using Syntax Diagrams and Syntax Tables
        Using Examples
        Using Related Information
      How to Enter SQL Comments
        Examples of SQL Comments
        Non-ASCII Characters in SQL Comments
      Categories of SQL Statements
        Data Definition Language Statements
        Data Manipulation Language Statements
        Data Integrity Statements
        Cursor Manipulation Statements
        Dynamic Management Statements
        Data Access Statements
        Optimization Statements
        Routine Definition Statements
        Auxiliary Statements
        Client/Server Connection Statements
      ANSI/ISO Compliance and Extensions
        ANSI/ISO-Compliant Statements
        ANSI/ISO-Compliant Statements with Informix Extensions
        Statements that are Extensions to the ANSI/ISO Standard
    SQL statements
      ALLOCATE COLLECTION statement
      ALLOCATE DESCRIPTOR statement
        WITH MAX Clause
      ALLOCATE ROW statement
      ALTER ACCESS_METHOD statement
      ALTER FRAGMENT statement
        Restrictions on the ALTER FRAGMENT Statement
        ALTER FRAGMENT and Transaction Logging
        Determining the Number of Rows in the Fragment
        The ONLINE keyword in ALTER FRAGMENT operations
          Automatic renaming of interval fragment identifiers
        ATTACH Clause
          General Restrictions for the ATTACH Clause
            Additional Restrictions on the ATTACH Clause
          Using the BEFORE, AFTER, and REMAINDER options
          Combining Nonfragmented Tables to Create a Fragmented Table
          Attaching a Table to a Fragmented Table
          Using the ONLINE keyword in ATTACH operations
          Effect of the ATTACH Clause
            What Happens to Indexes?
            What Happens to BYTE and TEXT Columns?
            What Happens to Triggers and Views?
            What Happens with the Distribution Scheme?
            Round-Robin Distribution Scheme
            Expression Distribution Scheme
        DETACH Clause
          Using the ONLINE keyword in DETACH operations
          Detach with BYTE and TEXT Columns
          Detach from a Protected Table
          Detach That Results in a Nonfragmented Table
        INIT Clause
          WITH ROWIDS Option
          Converting a Fragmented Table to a Nonfragmented Table
          FRAGMENT BY Clause for Tables
            Changing an Existing Fragmentation Strategy on a Table
            Defining a Fragmentation Strategy on a Nonfragmented Table
          FRAGMENT BY clause for indexes
            Detaching an Index from a Table-Fragmentation Strategy
            Fragmenting Unique and System Indexes
        ADD Clause
          Adding a New Dbspace to a Round-Robin Distribution Scheme
          Adding a New Named Fragment to a Round-Robin Distribution Scheme
          Adding an expression-based fragment
          Using the BEFORE and AFTER Options
          Using the REMAINDER Option
        DROP Clause
        MODIFY Clause
          Restrictions on the MODIFY clause for range interval fragments
          Rolling Window clause of ALTER FRAGMENT
          Using the MODIFY INTERVAL TRANSITION option
          Using the ONLINE keyword in MODIFY operations
          Examples of the MODIFY clause with interval fragments
          Examples of the MODIFY clause for list fragments
        Examples of ALTER FRAGMENT ON INDEX statements
      ALTER FUNCTION statement
        Keywords That Introduce Modifications
      ALTER INDEX statement
        TO CLUSTER Option
        TO NOT CLUSTER Option
      ALTER PROCEDURE statement
      ALTER ROUTINE statement
        Restrictions
        Keywords That Introduce Modifications
        Example of Altering Routine Modifiers
      ALTER SECURITY LABEL COMPONENT statement
        The ADD ARRAY Clause
        The ADD SET Clause
        The ADD TREE Clause
      ALTER SEQUENCE statement
        INCREMENT BY Option
        RESTART WITH Option
        MAXVALUE or NOMAXVALUE Option
        MINVALUE or NOMINVALUE Option
        CYCLE or NOCYCLE Option
        CACHE or NOCACHE Option
        ORDER or NOORDER Option
      ALTER TABLE statement
        Add or drop specialized columns
        ADD Column Clause
          Logical Character Support in Character Columns
          BEFORE Clause
          DEFAULT clause of ALTER TABLE
            DEFAULT security labels
          Single-Column Constraint Format
            Using NOT NULL Constraints with ADD COLUMN
            Constraint Definition
            REFERENCES Clause
            Restrictions on Referential Constraints
            Default Column for the References Clause
            Using the ON DELETE CASCADE Option
            Locks Held During Creation of a Referential Constraint
            CHECK Clause
          Add column SECURED WITH label clause
        ADD AUDIT Clause
        ADD CONSTRAINT Clause
          Multiple-Column Constraint Format
            Creating foreign-key constraints when an index exists on the referenced table
            Using the INDEX DISABLED keywords in a foreign key definition
            Creating foreign-key constraints in NOVALIDATE modes
            Adding a Primary-Key or Unique Constraint
            Recovery from Constraint Violations
        ADD TYPE Clause
        DROP AUDIT Clause
        DROP CONSTRAINT Clause
        DROP Column Clause
          How Dropping a Column Affects Constraints
          How Dropping a Column Affects Triggers
          How Dropping a Column Affects Views
        LOCK MODE Clause
          Precedence and Default Behavior
        Logging TYPE Options
        MODIFY Clause
          Altering BYTE and TEXT columns
          Altering the Next Serial Value
            Altering the Next Serial Value in a Typed Table
          Altering character columns
          Altering the Structure of Tables
          Modifying Tables for NULL Values
          Adding a Constraint on a Non-Opaque Column
          Modify Column Security clause
          Adding a Constraint That Existing Rows Violate
          How Modifying a Column Affects Triggers
          How Modifying a Column Affects Views
        MODIFY EXTENT SIZE
        MODIFY NEXT SIZE clause
        PUT Clause
        SECURITY POLICY Clause
        Statistics options of the ALTER TABLE statement
      ALTER TRUSTED CONTEXT
      ALTER USER statement (UNIX, Linux)
      BEGIN WORK statement
        BEGIN WORK and ANSI-Compliant Databases
        BEGIN WORK WITHOUT REPLICATION (ESQL/C)
        Example of BEGIN WORK
      CLOSE statement
        Closing a Select or Function Cursor
        Closing an Insert Cursor
        Closing a Collection Cursor
        Using End of Transaction to Close a Cursor
      CLOSE DATABASE statement
      COMMIT WORK statement
        Issuing COMMIT WORK in a Database That Is Not ANSI Compliant
          Explicit DB-Access Transactions
        Issuing COMMIT WORK in an ANSI-Compliant Database
      CONNECT statement
        Privileges for Executing the CONNECT Statement
        Connection Context
        Database Environment
          Restrictions on dbservername
          Specifying the Database Environment
            Only Database Server Specified
            Database Server and Database Specified
            Only Database Specified
        Declaring a Connection Name
          Connection Identifiers
        USER Authentication Clause
          Restrictions on the Validation Variable Parameter
          Restrictions on the User Identifier Parameter
          Use of the Default User ID
        The DEFAULT Connection Specification
          The Implicit Connection with DATABASE Statements
        WITH CONCURRENT TRANSACTION Option
        TRUSTED clause
      CREATE ACCESS_METHOD statement
      CREATE AGGREGATE statement
        Extending the Functionality of Aggregates
          Example of Creating a User-Defined Aggregate
        Parallel Execution
      CREATE CAST statement
        Source and Target Data Types
        Explicit and Implicit Casts
          Explicit Casts
          Implicit Casts
        WITH Clause
      CREATE DATABASE statement
        Logging Options
        Specifying Buffered Logging
        ANSI-Compliant Databases
        Specifying NLSCASE case sensitivity
      CREATE DEFAULT USER statement (UNIX, Linux)
      CREATE DISTINCT TYPE statement
        Privileges on Distinct Types
        Support Functions and Casts
        Manipulating Distinct Types
      CREATE EXTERNAL TABLE Statement
        Column Definition
          Using the SAMEAS Clause
          Using the EXTERNAL Keyword
            Defining NULL Values
          Manipulating Data in Fixed Format Files
        DATAFILES Clause
          Using Formatting Characters with External Tables
        Table options
        Reject Files
        External Table Examples
          Loading Data from External Tables into Informix
            Loading Data in Express Mode
            Loading data in DELUXE mode
            Loading from a Delimited File to a Database Table with the Same Schema
            Loading from a Fixed Text File
            Loading Between Tables That Have the Same Schema
            Loading Values into Serial Columns
            Loading Data Warehousing Tables
              Loading Initially
              Refreshing Periodically
              Initial Loading of OLTP Data from Other Database Servers
          Unloading Data to External Tables from Informix
            Unloading to a Delimited File
            Unloading to Informix Data Files
            Unloading to a Fixed-Text File
            Adding an End-of-Line Character to a Fixed Text File
              Using a Program or Script
              Adding a Newline Field in a SELECT Statement
        Restrictions on External Tables
      CREATE FUNCTION statement
        Privileges necessary for using CREATE FUNCTION
        DBA keyword and Execute privilege on the created function
        The REFERENCING and FOR Clauses
        Overloading the Name of a Function
          Using the SPECIFIC Clause to Specify a Specific Name
        DOCUMENT Clause
        WITH LISTING IN Clause
        SPL Functions
        External Functions
          Example of Registering a C User-Defined Function
          Example of Registering a UDR Written in the Java Language
          Ownership of Created Database Objects
      CREATE FUNCTION FROM statement
      CREATE INDEX statement
        Index-type options
          How indexes affect primary-key, unique, and referential constraints
        Index-key specification
          Indexing a BSON field
          Restrictions on columns as index keys
          Using the return value of a function as an index key
        Creating Composite Indexes
        Using the ASC and DESC Sort-Order Options
          Effects of Unique Constraints on Sort Order Options
          Bidirectional Traversal of Indexes
          Restrictions on the Number of Indexes on a Set of Columns
          Using an Operator Class
        USING access-method clause
        HASH ON clause
        FILLFACTOR Option
          Providing a Low Percentage Value
          Providing a High Percentage Value
        Storage options
        COMPRESSED option for indexes
        Extent Size Options
        IN Clause
          Storing an Index in a dbspace
          Storing an Index Fragment in a Named Partition
          Storing Data in an extspace
          Creating an Index with the IN TABLE Keywords
        FRAGMENT BY Clause for Indexes
          Storing an Index Fragment in a Named Partition
          Restrictions on fragmentation expressions
          Fragmentation of System Indexes
          Fragmentation of Unique Indexes
          Fragmentation of Indexes on Temporary Tables
        Index modes
          Specifying Modes for Unique Indexes
            Adding a Unique Index When Duplicate Values Exist in the Column
          Specifying Modes for Duplicate Indexes
        How the Database Server Treats Disabled Indexes
        The ONLINE keyword of CREATE INDEX
        Automatic Calculation of Distribution Statistics
      CREATE OPAQUE TYPE statement
        Declaring a Name for an Opaque Type
        INTERNALLENGTH Modifier
          Fixed-Length Opaque Types
          Varying-Length Opaque Types
        Opaque-Type Modifier
        Defining an Opaque Type
      CREATE OPCLASS statement
        STRATEGIES Clause
        Strategy Specification
        Indexes on Side-Effect Data
        SUPPORT Clause
        Default Operator Classes
      CREATE PROCEDURE statement
        Using CREATE PROCEDURE Versus CREATE FUNCTION
        Relationship Between Routines, Functions, and Procedures
        Privileges Necessary for Using CREATE PROCEDURE
        DBA Keyword and Privileges on the Procedure
        The REFERENCING and FOR Clauses
        Procedure names in Informix
          Using the SPECIFIC Clause to Specify a Specific Name
        DOCUMENT Clause
        Using the WITH LISTING IN Option
        SPL Procedures
        External Procedures
          Registering a User-Defined Procedure
          Ownership of Created Database Objects
      CREATE PROCEDURE FROM statement
        Default Directory That Holds the File
      CREATE ROLE statement
      CREATE ROUTINE FROM statement
      CREATE ROW TYPE statement
        Privileges on named ROW data types
        Inheritance and Named ROW Types
        Creating a Subtype
        Type Hierarchies
        Procedure for Creating a Subtype
        Restrictions on Serial and Simple-Large-Object Data Types
      CREATE SCHEMA statement
        Creating Database Objects Within CREATE SCHEMA
      CREATE SECURITY LABEL statement
        Components and Elements of a Security Label
      CREATE SECURITY LABEL COMPONENT statement
        Types and Elements of Security Label Components
        ARRAY Components
        SET Components
        TREE Components
      CREATE SECURITY POLICY statement
        Security Label Components of a Security Policy
        Rules Associated with a Security Policy
      CREATE SEQUENCE statement
        INCREMENT BY Option
        START WITH Option
        MAXVALUE or NOMAXVALUE Option
        MINVALUE or NOMINVALUE Option
        CYCLE or NOCYCLE Option
        CACHE or NOCACHE Option
        ORDER or NOORDER Option
      CREATE SYNONYM statement
        Synonyms for objects outside the current database
        PUBLIC and PRIVATE Synonyms
        Synonyms with the Same Name
        Chaining Synonyms
      CREATE TABLE statement
        AS SELECT clause
        Logging Options
        Column definition
          Column SECURED WITH label clause
          DEFAULT clause of CREATE TABLE
          Single-Column Constraint Format
            Restrictions on Using the Single-Column Constraint Format
            Using the NOT NULL Constraint
            Using the NULL Constraint
            Using UNIQUE or DISTINCT Constraints
            Differences Between a Unique Constraint and a Unique Index
            Using the PRIMARY KEY Constraint
            REFERENCES Clause
              Restrictions on Referential Constraints
              Default Values for the Referenced Column
              Referential Relationships Within a Table
              Locking Implications of Creating a Referential Constraint
              Examples of the Single-Column Constraint format
              Using the ON DELETE CASCADE Option
            CHECK Clause
              Using a Search Condition
              Restrictions When Using the Single-Column Constraint Format
            Constraint Definition
              Declaring a Constraint Name
                Constraint Names That the Database Server Generates
              Choosing a Constraint-Mode Option
        Multiple-Column Constraint Format
          Restrictions with the Multiple-Column Constraint Format
            Using Large-Object Types in Constraints
          Using the FOREIGN KEY Constraint
          Examples of the Multiple-Column Constraint Format
            Defining Check Constraints Across Columns
            Defining Composite Primary and Foreign Keys
          Default Index Creation Strategy for Constraints
        OF TYPE Clause
          Using Large-Object Data in Typed Tables
          Using the UNDER Clause
            Restrictions on Table Hierarchies
          Access Privileges on Tables
          System Catalog Information
        Specialized columns
          Using the WITH AUDIT Clause
          Using the WITH CRCOLS Option
          Using the WITH ERKEY Keywords
          Using the WITH REPLCHECK Keywords
          Using the WITH VERCOLS Option
        SECURITY POLICY Clause
        Storage options
          Using the IN Clause
          PUT Clause
          FRAGMENT BY clause
            Using the WITH ROWIDS Option
            Fragmenting by ROUND ROBIN
            Expression Fragment Clause
              User-Defined Functions in Fragment Expressions
            List fragment clause
            Interval fragment clause
              Rolling Window clause of CREATE TABLE
          EXTENT SIZE Options
          COMPRESSED option for tables
        LOCK MODE Options
          Precedence and Default Behavior
        USING Access-Method Clause
        Statistics options of the CREATE TABLE statement
      CREATE TEMP TABLE statement
        Declaring a name for a temporary table
        Column definition specification of the CREATE TEMP TABLE statement
        Single-Column Constraint Format
        Multiple-Column Constraint Format
        Using the WITH NO LOG option
        Storage options for temporary tables
          Where temporary tables are stored
        Differences between temporary and permanent tables
        Duration of temporary tables
      CREATE TRIGGER statement
        Defining a Trigger Event and Action
        Restrictions on Triggers
        Trigger Modes
        Trigger Inheritance in a Table Hierarchy
        Triggers and SPL Routines
        Trigger Events
          Trigger Events with Cursors
          Privileges on the Trigger Event
          Performance Impact of Triggers
        INSERT Events and DELETE Events
        UPDATE Event
        Defining Multiple Update Triggers
        SELECT Event
        Circumstances When a Select Trigger Is Activated
        Stand-alone SELECT Statements
        SELECT Statements Within UDRs in the Select List
        UDRs that EXECUTE PROCEDURE or EXECUTE FUNCTION call
        Subqueries in the Select List
        Subqueries in the FROM Clause of SELECT
        Subqueries in the WHERE Clause of DELETE or UPDATE
        Select Triggers in Table Hierarchies
        Circumstances When a Select Trigger Is Not Activated
        Action Clause
          BEFORE Actions
          FOR EACH ROW Actions
          AFTER Actions
          Actions of Multiple Triggers
        Guaranteeing Row-Order Independence
        REFERENCING Clauses
          REFERENCING Clause for Delete
          REFERENCING Clause for Insert triggers
          REFERENCING Clause for Update
          REFERENCING Clause for Select
        Correlated Table Action
        Triggered Action on a Table
          WHEN Condition
          Action Statements
            UDRs as Triggered Actions
            Achieving a Consistent Result
            Declaring keywords of SQL as correlation names
        Using Correlation Names in Triggered Actions
          When to Use Correlation Names
          Qualified Versus Unqualified Value
        Re-Entrancy of Triggers
          Re-Entrancy and Cascading Triggers
        Rules for SPL Routines
        Privileges to Execute Trigger Actions
          Creating a Trigger Action That Anyone Can Use
        Cascading Triggers
          Constraint Checking
          Preventing Triggers from Overriding Each Other
        Tables in Remote Databases
        Logging and Recovery
        INSTEAD OF Triggers on Views
          The Action Clause of INSTEAD OF Triggers
          Restrictions on INSTEAD OF Triggers on Views
          Updating Views
      CREATE TRUSTED CONTEXT
      CREATE USER statement (UNIX, Linux)
      CREATE VIEW statement
        Typed Views
        Subset of SELECT syntax valid in view definitions
        Union Views
        Naming View Columns
        Using a View in the SELECT Statement
        WITH CHECK OPTION Keywords
        Updating Through Views
      CREATE XADATASOURCE statement
      CREATE XADATASOURCE TYPE statement
      DATABASE statement
        SQLCA.SQLWARN Settings Immediately after DATABASE Executes (ESQL/C)
        EXCLUSIVE keyword
      DEALLOCATE COLLECTION statement
      DEALLOCATE DESCRIPTOR statement
      DEALLOCATE ROW statement
      DECLARE statement
        Overview of Cursor Types
        Select Cursor or Function Cursor
          Using the FOR READ ONLY Option
          Using the FOR UPDATE Option
            Using FOR UPDATE with a List of Columns
            Locking with an Update Cursor
              Locking with concurrent 4GL cursors in unlogged databases
          Subset of INSERT Statement with a Sequential Cursor
          Insert Cursor
        Cursor Characteristics
          Creating a Sequential Cursor by Default
          Using the SCROLL Keyword to Create a Scroll Cursor
          Using the WITH HOLD keywords to create a hold cursor
            Using an Insert Cursor with Hold
          Subset of SELECT statements associated with cursors
          Examples of Cursors in Non-ANSI Compliant Databases
          Examples of Cursors in ANSI-Compliant Databases
        Associating a Cursor with a Prepared Statement
          Select with a Collection-Derived Table
            Using a Select Cursor with a Collection Variable
          Insert with a Collection-Derived Table
        Using Cursors with Transactions
        Declaring a Dynamic Cursor in an SPL Routine
      DELETE statement
        Using the ONLY keyword with typed tables
        Considerations When Tables Have Cascading Deletes
          Restrictions on DELETE When Tables Have Cascading Deletes
          Locking and Logging Implications of Cascading Deletes
        Using the WHERE Keyword to Specify a Condition
        Subqueries in the WHERE Clause of DELETE
        Declaring an alias for the table
        Using the WHERE CURRENT OF Keywords (ESQL/C, SPL)
        Deleting Rows That Contain Opaque Data Types
        Deleting Rows That Contain Collection Data Types
        Data Types in Distributed DELETE Operations
        SQLSTATE Values in an ANSI-Compliant Database
        SQLSTATE Values in a Database That Is Not ANSI-Compliant
      DESCRIBE statement
        The OUTPUT Keyword
        Describing the Statement Type
        Checking for the Existence of a WHERE Clause
        Describing a Statement with Runtime Parameters
        Using the SQL DESCRIPTOR Keywords
        Using the INTO sqlda Pointer Clause
        Describing a Collection Variable
      DESCRIBE INPUT statement
        Describing the Statement Type
        Checking for Existence of a WHERE Clause
        Describing a Statement with Dynamic Runtime Parameters
        Using the SQL DESCRIPTOR Keywords
        Using the INTO sqlda Pointer Clause
        Describing a Collection Variable
      DISCONNECT statement
        DEFAULT Option
        Specifying the CURRENT Keyword
        When a Transaction is Active
        Disconnecting in a Thread-Safe Environment
        Specifying the ALL Option
      DROP ACCESS_METHOD statement
      DROP AGGREGATE statement
      DROP CAST statement
      DROP DATABASE statement
      DROP FUNCTION statement
        Dropping External Functions
      DROP INDEX statement
        The ONLINE keyword of DROP INDEX
      DROP OPCLASS statement
      DROP PROCEDURE statement
        Dropping an External Procedure
      DROP ROLE statement
      DROP ROUTINE statement
        Restrictions
        Dropping an External Routine
      DROP ROW TYPE statement
        The RESTRICT Keyword
      DROP SECURITY statement
        Dropping security objects in RESTRICT mode or in CASCADE mode
      DROP SEQUENCE statement
      DROP SYNONYM statement
      DROP TABLE statement
        Effects of the DROP TABLE Statement
        Specifying CASCADE Mode
        Specifying RESTRICT Mode
        Dropping a Table That Contains Opaque Data Types
        Tables That Cannot Be Dropped
      DROP TRIGGER statement
      DROP TRUSTED CONTEXT statement
      DROP TYPE statement
      DROP USER statement (UNIX, Linux)
      DROP VIEW statement
      DROP XADATASOURCE statement
      DROP XADATASOURCE TYPE statement
      EXECUTE statement
        Scope of Statement Identifiers
        Restrictions with the INTO Clause
        Replacing Placeholders with Parameters
        Saving Values In Host or Program Variables
        Saving Values in a System-Descriptor Area
        Saving Values in an sqlda Structure (ESQL/C)
        The sqlca Record and EXECUTE
        Returned SQLCODE Values with EXECUTE
        Supplying Parameters Through Host or Program Variables
        Supplying Parameters Through a System Descriptor
        Supplying Parameters Through an sqlda Structure (ESQL/C)
      EXECUTE FUNCTION statement
        Negator Functions and Their Companions
        How the EXECUTE FUNCTION Statement Works
        Data Variables
        INTO Clause with Indicator Variables (ESQL/C)
        INTO Clause with Cursors
        Alternatives to PREPARE ... EXECUTE FUNCTION ... INTO
        Dynamic Routine-Name Specification of SPL Functions
      EXECUTE IMMEDIATE statement
        EXECUTE IMMEDIATE and Restricted Statements
        Restrictions on Valid Statements
        Handling Exceptions from EXECUTE IMMEDIATE Statements
        Examples of the EXECUTE IMMEDIATE Statement
      EXECUTE PROCEDURE statement
        Causes of Errors
        Using the INTO Clause
        The WITH TRIGGER REFERENCES Keywords
          Example of Invoking a Trigger Procedure
        Dynamic Routine-Name Specification of SPL Procedures
      FETCH statement
        FETCH with a Sequential Cursor
        FETCH with a Scroll Cursor
        How the Database Server Implements Scroll Cursors
        Specifying Where Values Go in Memory
        Using the INTO Clause
        Using Indicator Variables
        When the INTO Clause of FETCH is Required
        Using a System-Descriptor Area (X/Open)
        Using sqlda Structures
        Fetching a Row for Update
        Fetching from a Collection Cursor
        Checking the Result of FETCH
      FLUSH statement
        Error Checking FLUSH Statements
      FREE statement
      GET DESCRIPTOR statement
        Using the COUNT Keyword
        Using the VALUE Clause
          Using the VALUE Clause After a DESCRIBE
          Using the VALUE Clause After a FETCH
          Fetching a NULL Value
        Using LENGTH or ILENGTH
        Describing an Opaque-Type Column
        Describing a Distinct-Type Column
      GET DIAGNOSTICS statement
        Using the SQLSTATE Error Status Code
          Class and Subclass Codes
          SQLSTATE Support for the ANSI/ISO Standard for SQL
          List of SQLSTATE Codes
          Using SQLSTATE in Applications
        Statement Clause
          Using the MORE Keyword
          Using the ROW_COUNT Keyword
          Using the NUMBER Keyword
        EXCEPTION Clause
          Using the RETURNED_SQLSTATE Keyword
          Using the INFORMIX_SQLCODE Keyword
          Using the CLASS_ORIGIN Keyword
          Using the SUBCLASS_ORIGIN Keyword
          Using the MESSAGE_TEXT Keyword
          Using the MESSAGE_LENGTH Keyword
          Using the SERVER_NAME Keyword
        The Contents of the SERVER_NAME Field
          Using the CONNECTION_NAME Keyword
          When the CONNECTION_NAME Keyword Is Updated
          When the CONNECTION_NAME Is Not Updated
        The contents of the CONNECTION_NAME field
        Using GET DIAGNOSTICS for Error Checking
      GRANT statement
        Database-Level Privileges
        Table-Level Privileges
          Effect of the ALL Keyword
        Table Reference
          Privileges on Tables and Synonyms
          Privileges on a View
        Type-Level Privileges
          USAGE Privilege
          UNDER Privilege
        Routine-Level Privileges
          Granting the Execute privilege to PUBLIC
          Revoking the Execute privilege from PUBLIC
        Language-Level Privileges
          Usage Privilege in Stored Procedure Language
        Sequence-Level Privileges
          Alter Privilege
          Select Privilege
          ALL Keyword
          The User List
        Role Name
          Granting a Role to a User or to Another Role
          Granting privileges to a role
          Granting a Default Role
          Granting the EXTEND Role
        WITH GRANT OPTION keywords
        AS grantor clause
        Security Administration Options
          DBSECADM Clause
          EXEMPTION Clause
            Rules on Which Exemptions Are Granted
            Security Policies and Grantees of Exemptions
          SECURITY LABEL Clause
            Access Specifications
            Rules for User Security Labels
            Examples of Granting User Security Labels
          SETSESSIONAUTH Clause
        Surrogate user properties (UNIX, Linux)
      GRANT FRAGMENT statement
        Fragment-Level Privileges
          Definition of Fragment-Level Authorization
          Effect of Fragment-Level Authorization in Statement Validation
          Duration of Fragment-Level Privileges
          Specifying Fragments
          The TO Clause
        Granting Privileges to One User or a List of Users
        Granting One Privilege or a List of Privileges
        WITH GRANT OPTION Clause
        AS grantor Clause
          Omitting the AS grantor Clause
      INFO statement
      INSERT statement
        Specifying Columns
        Using the AT Clause (ESQL/C, SPL)
        Inserting Rows Through a View
        Inserting Rows with a Cursor
        Inserting Rows into a Database Without Transactions
        Inserting Rows into a Database with Transactions
        VALUES Clause
          Considering Data Types
          Inserting Values into Serial Columns
          Inserting Values into Opaque-Type Columns
          Inserting Values into Collection Columns
          Inserting Values into ROW-Type Columns
          Data Types in Distributed INSERT Operations
          Using Expressions in the VALUES Clause
          Inserting NULL Values
          Inserting Values into Protected Tables
          Truncated CHAR Values
          Subset of SELECT Statement
        Execute Routine Clause
          Number of Values Returned by SPL, C, and Java Functions
          Inserting into a Row Variable (ESQL/C, SPL)
          Using INSERT as a Dynamic Management Statement
      LOAD statement
        LOAD FROM File
        Loading Simple Large Objects
        Loading Smart Large Objects
        Loading Complex Data Types
        Loading Opaque-Type Columns
        DELIMITER Clause
        INSERT INTO Clause
      LOCK TABLE statement
        Concurrent Access to Tables with Shared Locks
        Concurrent Access to Tables with Exclusive Locks
        Databases with transaction logging
        Databases without transaction logging
        Locking Granularity
      MERGE statement
        Restrictions on Source and Target Tables
        Handling Duplicate Rows
        Examples of MERGE Statements
      OPEN statement
        Opening a Select Cursor
        Opening an Update Cursor Inside a Transaction
        Opening a Function Cursor
        Reopening a Select or Function Cursor
        Errors Associated with Select and Function Cursors
        Opening an Insert Cursor (ESQL/C)
          Example of Opening an Insert Cursor
          Reopening an Insert Cursor
        Opening a Collection Cursor (ESQL/C)
        USING Clause
        Specifying a System Descriptor Area (ESQL/C)
        Specifying a Pointer to an sqlda Structure (ESQL/C)
          Example of Specifying a Pointer to an sqlda Structure
        Using the WITH REOPTIMIZATION Option (ESQL/C)
        Relationship Between OPEN and FREE
        DDL Operations on Tables Referenced by Cursors
      OUTPUT statement
        Sending Query Results to a File
        Displaying Query Results Without Column Headings
        Sending Query Results to Another Program
      PREPARE statement
        Restrictions
        Declaring a Statement Identifier
          Scope of Statement Identifiers
        Releasing a Statement Identifier
        Statement Text
          Example of a PREPARE statement in an SPL routine
        Preparing and Executing User-Defined Routines
        Restricted Statements in Single-Statement Prepares
        Preparing Statements When Parameters Are Known
        Preparing Statements That Receive Parameters
        Preparing Statements with SQL Identifiers
          Obtaining SQL Identifiers from User Input
        Preparing Multiple SQL Statements
          Restricted Statements in Multistatement Prepared Objects
        Using Prepared Statements for Efficiency
          DDL Operations on Tables Referenced in Prepared Objects
      PUT statement
        Supplying Inserted Values
          Using Constant Values in INSERT
          Naming Program Variables in INSERT
          Naming Program Variables in PUT
        Using the USING Clause
          Specifying a System-Descriptor Area
          Specifying an sqlda Structure
        Inserting into a Collection Cursor
        Writing Buffered Rows
        Error Checking
      RELEASE SAVEPOINT statement
      RENAME COLUMN statement
        How Views and Check Constraints Are Affected
        How Triggers Are Affected
      RENAME CONSTRAINT statement
      RENAME DATABASE statement
      RENAME INDEX statement
      RENAME SECURITY statement
      RENAME SEQUENCE statement
      RENAME TABLE statement
      RENAME TRUSTED CONTEXT statement
      RENAME USER statement (UNIX, Linux)
      REVOKE statement
        Revoking database server access from mapped users (UNIX, Linux)
        Database-level privileges
        Table-Level Privileges
          When to Use REVOKE Before GRANT
            Replacing PUBLIC with Specified Users
            Restricting Access to Specific Columns
          Effect of the ALL Keyword
            Effect of the ALL Keyword on UNDER Privilege
        Effect of Uncommitted Transactions
        Type-Level Privileges
          Usage Privilege
          Under Privilege
        Routine-Level Privileges
        Language-Level Privileges
        Sequence-Level Privileges
          Alter Privilege
          Select Privilege
          ALL Keyword
        User List
        Role Name
          Revoking a Default Role
          Revoking the EXTEND Role
        Revoking privileges granted WITH GRANT OPTION
        The AS Clause
          Effect of CASCADE Keyword on UNDER Privileges
        Controlling the Scope of REVOKE with the RESTRICT Option
        Security Administration Options
          DBSECADM Clause
          EXEMPTION Clause
            Rules on Which Exemptions Are Revoked
            Security Policies and Grantees of Exemptions
          SECURITY LABEL Clause
            Access Specifications
            Examples of Revoking User Security Labels
          SETSESSIONAUTH Clause
      REVOKE FRAGMENT statement
        Specifying Fragments
        The FROM Clause
        Fragment-Level Privileges
        The AS Clause
        Examples of the REVOKE FRAGMENT Statement
          Revoking Privileges on One Fragment
          Revoking Privileges on More Than One Fragment
          Revoking Privileges from More Than One User
          Revoking Privileges Without Specifying Fragments
      ROLLBACK WORK statement
        WORK Keyword
        TO SAVEPOINT Clause
      SAVE EXTERNAL DIRECTIVES statement
        External optimizer directives
        Enabling or disabling external directives for a session
        The directive Specification
        The ACTIVE, INACTIVE, and TEST ONLY Keywords
        The query Specification
      SAVEPOINT statement
      SELECT statement
        Projection Clause
          Restricting return values with the SKIP, LIMIT, and FIRST options
            Sorting results from SKIP, LIMIT, or FIRST queries
          Controlling duplicate return values
            Duplicate rows in NLSCASE INSENSITIVE databases
          Data Types in Distributed Queries
            Data Types in Cross-Database Transactions
            Data Types in Cross-Server Transactions
          Expressions in the Select List
            Selecting Columns
            Selecting Constants
            Selecting Built-In Function Expressions
            Selecting Aggregate Function Expressions
            Selecting OLAP window expressions
            Selecting correlated aggregates in subqueries
            Selecting User-Defined Function Expressions
            Selecting Expressions That Use Arithmetic Operators
            Selecting ROW Fields
          Declaring a Display Label
          Declaring a Column Alias
        INTO Clause
          INTO Clause with Cursors
          Preparing a SELECT ... INTO Query
          Using Array Variables with the INTO Clause
        FROM Clause
          Aliases for Tables or Views
          Table expressions
          Lateral derived tables
          Restrictions on External Tables in Joins and Subqueries
          The ONLY Keyword
          Selecting from a Collection Variable
          Selecting from a Row Variable (ESQL/C)
          Iterator Functions
          ANSI Joins
            Using the ON Clause
              Specifying a Post-Join Filter
              Using a Join as the Dominant or Subordinate Part of an Outer Join
          Informix-Extension Outer Joins
        GRID clause
        WHERE clause of SELECT
          Using a Condition in the WHERE Clause
            Relational-Operator Condition
            IN Condition
            BETWEEN Condition
            Using IS NULL and IS NOT NULL Conditions
            LIKE or MATCHES Condition
            IN Subquery
            EXISTS Subquery
            ALL, ANY, SOME Subqueries
          Specifying a Join in the WHERE Clause
        Hierarchical Clause
          START WITH Clause
          CONNECT BY Clause
          Conditions in the CONNECT BY Clause
          Dependency patterns that are not a simple graph
        GROUP BY Clause
          Dependencies between the GROUP BY and Projection clauses
        HAVING Clause
        Set operators in combined queries
          Restrictions on a Combined SELECT
          UNION Operator
          INTERSECT Operator
          MINUS operator
        ORDER BY Clause
          Ordering by a Column or by an Expression
          Ordering by a Substring
          Ordering by a CASE expression
          Ascending and Descending Orders
          Nested Ordering
          Using Select Numbers
          Ordering by Rowids
          ORDER BY Clause with DECLARE
          Placing Indexes on ORDER BY Columns
          ORDER SIBLINGS BY Clause
          OLAP window functions in the ORDER BY clause of SELECT statements
          Ordering STANDARD or RAW result tables
        LIMIT Clause
        FOR UPDATE Clause
        FOR READ ONLY Clause
        INTO table clauses
          INTO TEMP clause
          INTO STANDARD and INTO RAW Clauses
          INTO EXTERNAL clause
      SET AUTOFREE statement
        Globally Affecting Cursors with SET AUTOFREE
        Using the FOR Clause to Specify a Specific Cursor
        Associated and Detached Statements
        Closing Cursors Implicitly
      SET COLLATION statement
        Specifying a Collating Order with SET COLLATION
        Restrictions on SET COLLATION
        Collation Performed by Database Objects
      SET CONNECTION statement
        Making a dormant connection as the current connection
        Making a current connection as the dormant connection
        Dormant Connections in a Single-Threaded Environment
        Dormant Connections in a Thread-Safe Environment
        Identifying the Connection
        DEFAULT Option
        CURRENT Keyword
        When a Transaction is Active
      SET CONSTRAINTS statement
      SET Database Object Mode statement
        Privileges Required for Changing Database Object Modes
        Object-List Format
        Table Format
        Modes for constraints and unique indexes
          Enabling foreign-key constraints when an index exists on the referenced table
        Modes for Triggers and Duplicate Indexes
        Definitions of Database Object Modes
          Enabled Mode
          Disabled Mode
          Filtering Modes
            Starting and Stopping the Violations and Diagnostics Tables
            Error Options for Filtering Mode
            Effect of Filtering Mode on the Database
      SET DATASKIP statement
        Circumstances When a Dbspace Cannot Be Skipped
      SET DEBUG FILE statement
        Using the WITH APPEND Option
        Closing the Output File
        Redirecting Trace Output
        Location of the Output File
      SET DEFERRED_PREPARE statement
        Example of SET DEFERRED_PREPARE
        Using Deferred-Prepare with OPTOFC
      SET DESCRIPTOR statement
        Using the COUNT Clause
        Using the VALUE Clause
        Item Descriptor
          Setting the TYPE or ITYPE Field
            Compiling Without the -xopen Option
            Setting the TYPE Field in X/Open Programs
            Using DECIMAL or MONEY Data Types
            Using DATETIME or INTERVAL Data Types
          Setting the DATA or IDATA Field
          Setting the LENGTH or ILENGTH Field
          Setting the INDICATOR Field
          Setting Opaque-Type Fields
          Setting Distinct-Type Fields
        Modifying Values Set by the DESCRIBE Statement
      SET ENCRYPTION PASSWORD statement
        Storage Requirements for Encryption
        Specifying a Session Password and Hint
        Levels of Encryption
        Protecting Passwords
      SET ENVIRONMENT statement
        AUTOLOCATE session environment option
        AUTO_READAHEAD session environment option
        AUTO_STAT_MODE session environment option
        BOUND_IMPL_PDQ session environment option
        CLUSTER_TXN_SCOPE session environment option
        DEFAULTESCCHAR session environment option
        EXTDIRECTIVES session environment option
        FORCE_DDL_EXEC session environment option
        GRID_NODE_SKIP session environment option
        HDR_TXN_SCOPE session environment option
        IFX_AUTO_REPREPARE session environment option
        IFX_BATCHEDREAD_INDEX session environment option
        IFX_BATCHEDREAD_TABLE session environment option
        IFX_FOLDVIEW session environment option
        IFX_SESSION_LIMIT_LOCKS session environment option
        IMPLICIT_PDQ session environment option
        INFORMIXCONRETRY session environment option
        INFORMIXCONTIME session environment option
        NOVALIDATE session environment option
        OPTCOMPIND session environment option
        RETAINUPDATELOCKS session environment option
        SELECT_GRID session environment option
        SELECT_GRID_ALL session environment option
        STATCHANGE session environment option
        USELASTCOMMITTED session environment option
        USE_SHARDING session environment option
        USE_DWA session environment options
        USTLOW_SAMPLE environment option
      SET EXPLAIN statement
        Using the AVOID_EXECUTE Option
        Using the FILE TO option
        Default name and location of the explain output file on UNIX
        Default name and location of the output file on Windows
        SET EXPLAIN output
          Complete-Connection Level Settings and Output Examples
          External Table Operations in SET EXPLAIN Output
      SET INDEXES statement
      SET ISOLATION statement
        Complete-Connection Level Settings
        Informix Isolation Levels
          Using the Dirty Read Isolation Level
          Using the Committed Read Isolation Level
            The LAST COMMITTED Option to Committed Read
          Using the Cursor Stability Isolation Level
          Using the Repeatable Read Isolation Level
          Default Isolation Levels
          Using the RETAIN UPDATE LOCKS Option
            Turning the Option OFF During a Transaction
        Effects of Isolation Levels
        Isolation Levels for Secondary Data Replication Servers
      SET LOCK MODE statement
        WAIT Clause
          Complete-Connection Level Settings
      SET LOG statement
      SET OPTIMIZATION statement
        HIGH and LOW Options
        FIRST_ROWS and ALL_ROWS Options
        Optimizing SPL Routines
        ENVIRONMENT Options
      SET PDQPRIORITY statement
        Allocating Database Server Resources
      SET ROLE statement
        Setting the Default Role
      SET SESSION AUTHORIZATION statement
        SET SESSION AUTHORIZATION and Transactions
      SET STATEMENT CACHE statement
        Precedence and Default Behavior
        Turning the Cache ON
          Restrictions on Matching Entries in the SQL Statement Cache
        Turning the Cache OFF
        SQL statement cache qualifying criteria
          Requiring Re-Execution Before Cache Insertion
          Enabling or Disabling Insertions After Size Exceeds Configured Limit
          Prepared Statements and the Statement Cache
      SET TRANSACTION statement
        Comparing SET TRANSACTION with SET ISOLATION
        Informix Isolation Levels
          Using the Read Uncommitted Option
          Using the Read Committed Option
          Using the Repeatable Read and Serializable Options
        Default Isolation Levels
        Access Modes
        Effects of Isolation Levels
      SET Transaction Mode statement
        Statement-Level Checking
        Transaction-Level Checking
        Duration of Transaction Modes
        Specifying All Constraints or a List of Constraints
        Specifying Remote Constraints
        Examples of Setting the Transaction Mode for Constraints
      SET TRIGGERS statement
      SET USER PASSWORD statement (UNIX, Linux)
      START VIOLATIONS TABLE statement
        Relationship to the SET Database Object Mode statement
        Effect on concurrent transactions
        Stopping the Violations and Diagnostics Tables
        USING Clause
        Using the MAX ROWS clause
        Specifying the maximum number of rows in the diagnostics table
        Privileges required for starting violations or diagnostics tables
        Structure of the violations table
        Examples of START VIOLATIONS TABLE Statements
          Violations and Diagnostics Tables with Default Names
          Violations and Diagnostics Tables with Explicit Names
        Relationships Among the Target, Violations, and Diagnostics Tables
        Initial Privileges on the Violations Table
        Example of Privileges on the Violations Table
        Using the Violations Table
        Example of a Violations Table
        Structure of the diagnostics table
        Initial privileges on the diagnostics table
        Using the Diagnostics Table
      STOP VIOLATIONS TABLE statement
        Example of Stopping the Violations and Diagnostics Tables
        Example of Dropping the Violations and Diagnostics Tables
        Privileges Required for Stopping a Violations Table
      TRUNCATE statement
        The TABLE Keyword
        The Table Specification
        The STORAGE specification
        The AM_TRUNCATE Purpose Function
        Performance Advantages of TRUNCATE
        Restrictions on the TRUNCATE statement
      UNLOAD statement
        UNLOAD TO File
          Unloading Character Columns
          Unloading Simple Large Objects
          Unloading Smart Large Objects
          Unloading Complex Types
        DELIMITER Clause
      UNLOCK TABLE statement
      UPDATE statement
        Using the ONLY Keyword
        Updating Rows Through a View
        Updating Rows in a Database Without Transactions
        Updating Rows in a Database with Transactions
        Locking Considerations
        Declaring an alias for the target table
        SET Clause
          Single-Column Format
          Using a Subquery to Update a Single Column
          Updating a Column to NULL
          Updating the Same Column Twice
          Multiple-Column Format
          Using a Subquery to Update Multiple Column Values
          Updating ROW-Type Columns
          Updating Collection Columns
        Updating Values in Opaque-Type Columns
        Data Types in Distributed UPDATE Operations
        WHERE Clause of UPDATE
          SQLSTATE Values When Updating an ANSI-Compliant Database
          SQLSTATE Values When Updating a Non-ANSI Database
          Subqueries in the WHERE Clause of UPDATE
          Using the WHERE CURRENT OF Clause (ESQL/C, SPL)
        Updating a Row Variable (ESQL/C)
      UPDATE STATISTICS statement
        The scope of UPDATE STATISTICS statements
        Updating Statistics for Tables
          Automated Table Statistics Maintenance
          Using the FOR TABLE ONLY Keywords
          Updating Statistics for Columns
          Examining Index Pages
        Updating Statistics for Columns of User-Defined Types
          Requirements for Statistics on Opaque Columns
        Using the FORCE and AUTO keywords
        Using the LOW mode option
          Using the DROP DISTRIBUTIONS Option
          Using the DROP DISTRIBUTIONS ONLY Option
        Using the MEDIUM mode option
        Using the HIGH mode option
        Resolution Clause
          Specifying the SAMPLING SIZE
          Using the DISTRIBUTIONS ONLY Option to Suppress Index Information
          Using DBUPSPACE Settings to Suppress Index Information
          Output for UPDATE STATISTICS from the SET EXPLAIN Statement
        Routine Statistics
          Altered tables that are referenced indirectly in SPL routines
        Updating statistics when you upgrade the database server
        Performance considerations of UPDATE STATISTICS statements
      WHENEVER statement
        The Scope of WHENEVER
        SQLERROR Keyword
        ERROR Keyword
        SQLWARNING Keyword
        NOT FOUND Keywords
        CONTINUE Keyword
        STOP Keyword
        GOTO Keyword
        CALL Clause
    SPL statements
      Debugging SPL routines
        Starting an SPL debugging session with Optim Development Studio
        Debugging SPL procedures with IBM Database Add-Ins for Visual Studio
      << Label >> statement
        Examples of Labels
      CALL
        Specifying Arguments
        Receiving input from the called UDR
      CASE
      CONTINUE
      DEFINE
        Referencing TEXT and BYTE Variables
        Redeclaration or Redefinition
        Declaring Global Variables
          Default Value
          CURRENT
          SYSDATE
          USER
          TODAY
          BYTE and TEXT
          SITENAME or DBSERVERNAME
        Declaring Local Variables
          Subset of Complex Data Types
          Declaring Collection Variables
          Declaring ROW Variables
          Declaring Opaque-Type Variables
          Declaring Variables LIKE Columns
          Defining Variables with Logical Character Semantics
          Declaring Variables as the PROCEDURE Type
          Declaring Variables for BYTE and TEXT Data
      EXIT
        EXIT From FOREACH Statements
          EXIT From FOR, LOOP, and WHILE Loops
      FOR
        Using the TO Keyword to Define a Range
          Specifying Two or More Ranges in a Single FOR Statement
        Using an Expression List as the Range
        Mixing Range and Expression Lists in the Same FOR Statement
        Specifying a Labelled FOR Loop
      FOREACH
        Using a SELECT ... INTO Statement
        Using the ORDER BY Clause of the SELECT Statement
        Using Hold Cursors
        Updating or Deleting Rows Identified by Cursor Name
        Using Collection Variables
          Restrictions on collection cursors
          Modifying Elements in a Collection Variable
        Using Select Cursors with FOREACH
        Calling a UDR in the FOREACH Loop
      GOTO
      IF
        ELIF Clause
        ELSE Clause
        Conditions in an IF Statement
        Subset of SPL Statements Allowed in the IF Statement List
        SQL Statements Not Valid in an IF Statement
      LET
        Using a SELECT Statement in a LET Statement
        Calling a Function in a LET Statement
      LOOP
        Simple LOOP Statements
        FOR LOOP Statements
        WHILE LOOP Statements
        Labeled LOOP Statements
      ON EXCEPTION
        Placement of the ON EXCEPTION statement
        Using the IN Clause to Trap Specific Exceptions
        Receiving Error Information in the SET Clause
        Forcing Continuation of the Routine
          Continuing Execution After an Exception Occurs
      RAISE EXCEPTION
        Special Error Number -746
      RETURN
        WITH RESUME Keyword
          Returning Values from Another Database
            External Functions and Iterator Functions
      SYSTEM
        Executing the SYSTEM statement on UNIX
        Executing the SYSTEM statement on Windows
        Setting Environment Variables in SYSTEM Commands
      TRACE
        TRACE ON
        TRACE OFF
        TRACE PROCEDURE
        Displaying Expressions
        Example Showing Different Forms of TRACE
        Looking at the Traced Output
      WHILE
        Example of WHILE Loops in an SPL Routine
        Labeled WHILE Loops
    Data types and expressions
      Scope of Segment Descriptions
      Use of Segment Descriptions
      Data type and expression segments
      Collection Subquery
        Table expressions in the FROM clause
      Condition
        Comparison Conditions (Boolean Expressions)
        Column Name
        Quotation Marks in Conditions
        Relational-Operator Condition
        BETWEEN Condition
        IN Condition
          Using the IN operator with collection data types
        IS NULL and IS NOT NULL Conditions
        Trigger-Type Boolean Operator
        LIKE and MATCHES Condition
          NOT Operator
          LIKE Operator
          MATCHES Operator
          ESCAPE with LIKE
          ESCAPE with MATCHES
        Stand-Alone Condition
        Condition with Subquery
          IN Subquery
          EXISTS Subquery condition
          ALL, ANY, and SOME Subqueries
            Using the ALL Keyword
            Using the ANY or SOME Keywords
            Omitting the ANY, ALL, or SOME Keywords
        NOT Operator
        Conditions with AND or OR
      Data Type
        Built-In Data Types
          BOOLEAN and other built-in opaque data types
          BSON and JSON built-in opaque data types
          Character Data Types
            Single-byte and multi-byte characters and locales
            Fixed- and Varying-Length Character Data Types
            LVARCHAR Data Type
            NCHAR and NVARCHAR data types
              NCHAR and NVARCHAR expressions in case-insensitive databases
          IDSSECURITYLABEL Data Type
          Numeric Data Types
          Exact Numeric Data Types
            DECIMAL(p,s) Data Types
            Serial Data Types
          Approximate Numeric Data Types
          Large-Object Data Types
            Simple-large-object data types
            Storing BYTE and TEXT Data
            Smart-large-object data types
          Time Data Types
        User-Defined Data Type
          Distinct Data Types
            DISTINCT Types in Distributed Operations
          Opaque Data Types
        Complex Data Type
          ROW Data Types
          Collection Data Types
            Duplicate Elements in DML Operations on SET Columns
            Defining the Element Type
      DATETIME Field Qualifier
      Expression
        List of Expressions
        Arithmetic Operators
        Bitwise Logical Functions
          BITAND Function
          BITOR Function
          BITXOR Function
          BITANDNOT Function
          BITNOT Function
        Concatenation Operator
        CAST Expressions
          Rules for the Target Data Type
          Examples of Cast Expressions
          The Keyword NULL in Cast Expressions
        Column Expressions
          Using Dot Notation
            Selecting All Fields of a ROW Column with Asterisk Notation
            Selecting Nested Fields
            Rules of Precedence
            Using Dot Notation with Row-Type Expressions
          Using the Substring Operator
          Using Rowids
          Using Smart Large Objects
        Conditional Expressions
          CASE Expressions
            CASE expressions data type compatibility
            Generic CASE Expressions
            Linear CASE Expressions
          COALESCE Function
          NVL Function
          NULLIF Function
          DECODE Function
        Constant Expressions
          Quoted String
          Literal Number
          USER or CURRENT_USER Operator
          CURRENT_ROLE Operator
          DEFAULT_ROLE Operator
          DBSERVERNAME and SITENAME Operators
          TODAY Operator
          CURRENT Operator
          SYSDATE Operator
          Literal DATETIME
          Literal INTERVAL
          UNITS Operator
          NEXTVAL and CURRVAL Operators
            Using NEXTVAL
            Using CURRVAL
            Concurrent Access to a Sequence
            Restrictions on sequence operators
          Literal Row
          Literal Collection
        Constructor Expressions
          ROW constructors
          Collection Constructors
            Examples of Collection Constructors
        NULL Keyword
        Function Expressions
          Algebraic Functions
            ABS Function
            CEIL Function
            FLOOR Function
            GREATEST function
            LEAST function
            MOD Function
            POW Function
            ROOT Function
            SQRT Function
            ROUND Function
            TRUNC Function
          CARDINALITY Function
          SQLCODE Function (SPL)
          DBINFO Function
            DBINFO Options
            Using the ('dbspace', tblspace_num) Option
            Using the 'sqlca.sqlerrd1' Option
            Using the 'sqlca.sqlerrd2' Option
            Using the 'sessionid' Option
            Using the 'cdrsession' option
            Using the 'dbname' Option
            Using the 'dbhostname' Option
            Using the 'version' Option
            Using the 'serial8' and 'bigserial' options
            Using the 'get_tz' Option
            Using the 'utc_current' Option
            Using the 'utc_to_datetime' Option
          Encryption and decryption functions
            Column Level and Cell Level Encryption
            The Password and Hint Specifications
            Data Types, Encoding, and Size of Encrypted Values
            Example of Column Level Encryption
              Calculating storage requirements for encrypted data
              Implementing column-level encryption
          DECRYPT_CHAR Function
          DECRYPT_BINARY Function
          ENCRYPT_AES Function
          ENCRYPT_TDES Function
          GETHINT Function
          Exponential and Logarithmic Functions
            EXP Function
            LN function
            LOG10 Function
            LOGN Function
          NVL2 Function
          HEX Function
          Length functions
            LENGTH Function
            OCTET_LENGTH Function
            CHAR_LENGTH Function
          Security Label Support Functions
            SECLABEL_BY_NAME Function
            SECLABEL_BY_COMP Function
            SECLABEL_TO_CHAR Function
          SIGN function
          Smart-Large-Object Functions
            FILETOBLOB and FILETOCLOB Functions
            Pathnames with Commas
            LOTOFILE Function
            LOCOPY Function
          Time Functions
            ADD_MONTHS Function
            DATE Function
            DAY Function
            MONTH Function
            QUARTER Function
            WEEKDAY Function
            YEAR Function
            MONTHS_BETWEEN Function
            LAST_DAY Function
            NEXT_DAY Function
            EXTEND Function
            MDY Function
            TO_CHAR Function
            TO_DATE Function
          TO_NUMBER Function
          Trigonometric Functions
            COS Function
            COSH function
            SIN Function
            SINH function
            TAN Function
            TANH Function
            ACOS Function
            ACOSH Function
            ASIN Function
            ASINH Function
            ATAN Function
            ATANH Function
            ATAN2 Function
            DEGREES function
            RADIANS function
          String-Manipulation Functions
            CONCAT Function
            Return Types from CONCAT and String Functions
              Data-type promotion in NLSCASE INSENSITIVE databases
            Return String Types in Distributed Transactions
            ASCII Function
            TRIM Function
              Fixed Character Columns
            LTRIM Function
            RTRIM Function
            SPACE function
            REVERSE function
            REPLACE Function
            LPAD Function
            RPAD Function
            CHR Function
          Case-Conversion Functions
            UPPER Function
            LOWER Function
            INITCAP Function
            Case-conversion functions in NLSCASE INSENSITIVE databases
          Substring functions
            CHARINDEX function
            INSTR function
            LEFT function
            RIGHT function
            SUBSTR function
            SUBSTRB function
            SUBSTRING function
            SUBSTRING_INDEX function
          FORMAT_UNITS Function
          IFX_ALLOW_NEWLINE Function
          User-Defined Functions
            Statement-Local Variable Declaration
        Statement-Local Variable Expressions
        Aggregate Expressions
          Types of Aggregate Expressions
            Built-in Aggregates
            User-Defined Aggregates
          Subset of Expressions Valid in an Aggregate Expression
          Including or excluding duplicates in the result set
          AVG Function
          Overview of COUNT Functions
          COUNT(*) function
          COUNT DISTINCT and COUNT UNIQUE functions
          COUNT column Function
          Arguments to the COUNT Functions
            Examples of the COUNT(*) Function
            Examples of the COUNT DISTINCT Function
            Examples of the COUNT column Function
          MAX Function
          MIN Function
          SUM Function
          RANGE Function
          STDEV Function
          VARIANCE Function
          Error Checking in ESQL/C
          Summary of Aggregate Function Behavior
          User-Defined Aggregates
          Aggregate expressions in grid queries
      OLAP window expressions
        OLAP numbering function expression
        OLAP ranking function expressions
          LAG and LEAD functions
          RANK function
          DENSE_RANK function
          PERCENT_RANK function
          CUME_DIST function
          NTILE function
        OLAP aggregation function expressions
          FIRST_VALUE function
          LAST_VALUE function
          RATIO_TO_REPORT function
          OLAP window aggregate functions
        OVER clause for OLAP window expressions
      INTERVAL Field Qualifier
      Literal Collection
        Element Literal Value
        Nested Quotation Marks
      Literal DATETIME
        Precedence of DATE and DATETIME format specifications
        Casting Numeric Date and Time Strings to DATE Data Types
      Literal INTERVAL
      Literal Number
        Integer Literals
        Fixed-Point Decimal Literals
        Floating-Point Decimal Literals
        Literal Numbers and the MONEY Data Type
      Literal Row
        Literals of an Unnamed Row Type
        Literals of a Named Row Type
        Literals for Nested Rows
      Quoted String
        Restrictions on Specifying Characters in Quoted Strings
        The DELIMIDENT Environment Variable
        Newline Characters in Quoted Strings
        Using Quotation Marks in Strings
        DATETIME and INTERVAL Values as Strings
        LIKE and MATCHES in a Condition
        Inserting Values as Quoted Strings
        Numeric Operations on Character Columns
      Relational Operator
        Using Operator Functions in Place of Relational Operators
        Collating Order for U.S. English Data
        Support for ASCII Characters in Nondefault Code Sets (GLS)
        Literal Numbers as Operands
    Other syntax segments
      Arguments
        Comparing Arguments to the Parameter List
        Subset of Expressions Valid as an Argument
        Arguments to UDRs in Remote Databases
      Collection-Derived Table
        Accessing a Collection Through a Virtual Table
        Table Expressions in the FROM Clause
        Restrictions with the Collection-Expression Format
          Additional Restrictions That Apply to ESQL/C
        Row Type of the Resulting Collection-Derived Table
        Accessing a Collection Through a Collection Variable
        Using a Collection Variable to Manipulate Collection Elements
          Example of Deleting from a Collection in ESQL/C
          Example of Deleting from a Collection
          Example of Updating a Collection
          Example of Inserting a Value into a Multiset Collection
        Accessing a Nested Collection
        Accessing a Row Variable
      Database Name
        Using Keywords as Table Names
          Using the @ Symbol
          Using a Path-Type Naming Notation
          Using a Host Variable
      Database Object Name
        Specifying a Database Object in an External Database
          Specifying a Database Object in a Cross-Database Query
          Specifying a Database Object in a Cross-Server Query
        Routine Overloading and Routine Signatures
          Specifying an Existing UDR
        Owners of Objects Created by UDRs
      External Routine Reference
        VARIANT or NOT VARIANT Option
        Example of a C User-Defined Function
      Identifier
        Use of Uppercase Characters
        Use of Keywords as Identifiers
        Support for Non-ASCII Characters in Identifiers
        Delimited Identifiers
          Support for Nonalphanumeric Characters
          Support for Non-ASCII Characters in Delimited Identifiers (GLS)
        Enabling Delimited Identifiers
          Examples of Delimited Identifiers
          Using Double Quotation Marks in a Delimited Identifier
        Potential Ambiguities and Syntax Errors
        Using the Names of Built-In Functions as Column Names
        Using Keywords as Column Names
        Using ALL, DISTINCT, or UNIQUE as a Column Name
        Using INTERVAL or DATETIME as a Column Name
        Using rowid as a Column Name
        Using keywords as table names
          Workarounds that Use the Keyword AS
          Using AS with Column Labels
          Using AS with Table Aliases
          Fetching Cursors that have Keywords as Names
          Declaring keywords as names for variables in UDRs
          Using CURRENT, DATETIME, INTERVAL, and NULL in INSERT
          Using NULL and SELECT in a Condition
          Declaring Keywords or Routine Names as SPL Variables
          Variables that Conflict with Column Names
          Using ON, OFF, or PROCEDURE with TRACE
          Using GLOBAL as the Name of a Variable
          Using EXECUTE, SELECT, or WITH as Cursor Names
          SELECT Statements in WHILE and FOR Statements
          SET keyword in the ON EXCEPTION statement of SPL
      Jar Name
      Optimizer Directives
        Optimizer Directives as Comments
        Restrictions on Optimizer Directives
        Access-Method Directives
        Join-Order Directive
        Join-Method Directives
        Star-Join Directives
        Optimization-Goal Directives
        Explain-Mode Directives
        Statement cache directive
        External Directives
      Owner name
        Using Quotation Marks
        Referencing Tables Owned by User informix
        ANSI-Compliant Database Restrictions and Case Sensitivity
        Setting ANSIOWNER for an ANSI-Compliant Database
        Default Owner Names
        Summary of Lettercase Rules for Owner Names
      Purpose Options
        Purpose Options for Access Methods
        Purpose Functions, Flags, and Values
        Purpose Options for XA Data Source Types
      Return Clause
        Limits on Returned Values
        Subset of SQL Data Types
        Using the REFERENCES Clause to Point to a Simple Large Object
        Returning a value from another database
        Named Return Parameters
        Cursor and Noncursor Functions
      Routine modifier
        Adding or Modifying a Routine Modifier
        Modifier Descriptions
          CLASS
          COSTFUNC (C)
          HANDLESNULLS
          INTERNAL
          ITERATOR
          NEGATOR
          PARALLELIZABLE
          PERCALL_COST (C)
          SELCONST (C)
          SELFUNC (C)
            Concept of Selectivity
            Restrictions on the SELFUNC Modifier
          STACK (C)
          VARIANT and NOT VARIANT
      Routine Parameter List
        Subset of SQL Data Types
        Using the LIKE Clause
        Using the REFERENCES Clause
        Using the DEFAULT Clause
        Specifying OUT Parameters for User-Defined Routines
        Specifying INOUT Parameters for a User-Defined Routine
      Shared-Object Filename
        C Shared-Object File
        Java Shared-Object File
      Specific Name
        Restrictions on the Owner Name
        Restrictions on the Specific Name
      Statement Block
        Subset of SPL Statements Valid in the Statement Block
        SQL Statements Valid in SPL Statement Blocks
        Nested Statement Blocks
          Scope of Reference of SPL Variables and Exception Handlers
        Restrictions on SPL Routines in Data-Manipulation Statements
        Transactions in SPL Routines
        Support for roles and user identity
    Built-in routines
      Interval functions
        TO_DSINTERVAL function
        TO_YMINTERVAL function
      Session Configuration Procedures
        Using SYSDBOPEN and SYSDBCLOSE Procedures
        Configure session properties at connection or access time
        Configuring session properties
      BSON processing functions
        BSON_GET function
        BSON_SIZE function
        BSON_UPDATE function
        BSON_VALUE_BIGINT function
        BSON_VALUE_BOOLEAN function
        BSON_VALUE_DATE function
        BSON_VALUE_DOUBLE function
        BSON_VALUE_INT function
        BSON_VALUE_LVARCHAR function
        BSON_VALUE_OBJECTID function
        BSON_VALUE_TIMESTAMP function
        BSON_VALUE_VARCHAR function
        genBSON function
      DataBlade Module Management Functions
        The SYSBldPrepare Function
        The SYSBldRelease Function
      The EXPLAIN_SQL Routine
      UDR Definition Routines
        IFX_REPLACE_MODULE Function
        IFX_UNLOAD_MODULE Function
      jvpcontrol Function
        Using the MEMORY Keyword
        Using the THREADS Keyword
      SQLJ Driver Built-In Procedures
        sqlj.install_jar
          File Permissions on Jar Files
        sqlj.replace_jar
        sqlj.remove_jar
        sqlj.alter_java_path
        sqlj.setUDTextName
        sqlj.unsetUDTextName
      DRDA Support Functions
        Metadata Function
        sysibm.SQLCAMessage Function
    Appendixes
      Keywords of SQL for HCL Informix
  Guide to SQL: Reference
    What's new in SQL Reference for Informix, Version 12.10
    System catalog tables
      Objects that the system catalog tables track
      Using the system catalog
        Accessing the system catalog
        Update system catalog data
      Structure of the System Catalog
      SYSAGGREGATES
      SYSAMS
      SYSATTRTYPES
      SYSAUTOLOCATE
      SYSBLOBS
      SYSCASTS
      SYSCHECKS
      SYSCHECKUDRDEP
      SYSCOLATTRIBS
      SYSCOLAUTH
      SYSCOLDEPEND
      SYSCOLUMNS
        Storing column length
        Storing Maximum and Minimum Values
      SYSCONSTRAINTS
      SYSDEFAULTS
      SYSDEPEND
      SYSDIRECTIVES
      SYSDISTRIB
      SYSDOMAINS
      SYSERRORS
      SYSEXTCOLS
      SYSEXTDFILES
      SYSEXTERNAL
      SYSFRAGAUTH
      SYSFRAGDIST
      SYSFRAGMENTS
      SYSINDEXES
      SYSINDICES
      SYSINHERITS
      SYSLANGAUTH
      SYSLOGMAP
      SYSOBJSTATE
      SYSOPCLASSES
      SYSPROCAUTH
      SYSPROCBODY
      SYSPROCCOLUMNS
      SYSPROCEDURES
      SYSPROCPLAN
      SYSREFERENCES
      SYSROLEAUTH
      SYSROUTINELANGS
      SYSSECLABELAUTH
      SYSSECLABELCOMPONENTS
      SYSSECLABELCOMPONENTELEMENTS
      SYSSECLABELNAMES
      SYSSECLABELS
      SYSSECPOLICIES
      SYSSECPOLICYCOMPONENTS
      SYSSECPOLICYEXEMPTIONS
      SYSSEQUENCES
      SYSSURROGATEAUTH
      SYSSYNONYMS
      SYSSYNTABLE
      SYSTABAMDATA
      SYSTABAUTH
      SYSTABLES
      SYSTRACECLASSES
      SYSTRACEMSGS
      SYSTRIGBODY
      SYSTRIGGERS
      SYSUSERS
      SYSVIEWS
      SYSVIOLATIONS
      SYSXADATASOURCES
      SYSXASOURCETYPES
      SYSXTDDESC
      SYSXTDTYPEAUTH
      SYSXTDTYPES
      Information Schema
        Generating the Information Schema Views
        Accessing the Information Schema Views
        Structure of the Information Schema Views
          The tables Information Schema View
          The columns Information Schema View
          The sql_languages Information Schema View
          The server_info Information Schema View
    Data types
      Summary of data types
      **** MISSING FILE ****
      Description of Data Types
        BIGINT data type
        BIGSERIAL data type
          Using SERIAL8 and BIGSERIAL with INT8 or BIGINT
        BLOB data type
        BOOLEAN data type
        BYTE data type
        CHAR(n) data type
          Treating CHAR Values as Numeric Values
          Sorting and Relational Comparisons
          Nonprintable Characters with CHAR
        CHARACTER(n) data type
        CHARACTER VARYING(m,r) data type
        CLOB data type
          Multibyte characters with CLOB
        DATE data type
        DATETIME data type
        DEC data type
        DECIMAL
          DECIMAL(p) Floating Point
          DECIMAL (p,s) Fixed Point
          DECIMAL Storage
        DISTINCT data types
        DOUBLE PRECISION data types
        FLOAT(n)
        IDSSECURITYLABEL data type
        INT data type
        INT8
        INTEGER data type
        INTERVAL data type
        LIST(e) data type
        LVARCHAR(m) data type
        MONEY(p,s) data type
        MULTISET(e) data type
        Named ROW
        NCHAR(n) data type
        NUMERIC(p,s) data type
        NVARCHAR(m,r) data type
        OPAQUE data types
        REAL data type
        ROW data type, Named
        ROW data type, Unnamed
          Creating unnamed ROW types
          Inserting Values into Unnamed ROW Type Columns
        SERIAL(n) data type
        SERIAL8(n) data type
          Assigning a Starting Value for SERIAL8
        SET(e) data type
        SMALLFLOAT
        SMALLINT data type
        TEXT data type
          Nonprintable Characters in TEXT Values
        Unnamed ROW
        VARCHAR(m,r) data type
      Built-In Data Types
        Character Data Types
        Large-Object Data Types
          Simple Large Objects
          Smart large objects
        Time Data Types
          Manipulating DATETIME Values
          Manipulating DATETIME with INTERVAL Values
          Manipulating DATE with DATETIME and INTERVAL Values
          Manipulating INTERVAL Values
          Multiplying or Dividing INTERVAL Values
      Extended Data Types
        Complex data types
          Collection Data Types
            Accessing collection data
          ROW Data Types
        Distinct Data Types
        Opaque Data Types
      Data Type Casting and Conversion
        Using Built-in Casts
          Converting from number to number
          Converting Between Number and Character
          Converting Between INTEGER and DATE
          Converting Between DATE and DATETIME
        Using User-Defined Casts
          Implicit Casts
          Explicit Casts
        Determining Which Cast to Apply
        Casts for distinct types
        What Extended Data Types Can Be Cast?
      Operator Precedence
    Environment variables
      Types of environment variables
      Limitations on environment variables
      Using environment variables on UNIX
        Setting environment variables in a configuration file
        Setting environment variables at login time
        Syntax for setting environment variables
        Unsetting environment variables
        Modifying an environment-variable setting
        Viewing your environment-variable settings
        Checking environment variables with the chkenv utility
        Rules of precedence for environment variables
      Using environment variables on Windows
        Where to set environment variables on Windows
        Setting environment variables on Windows
          Using the system applet to change environment variables
          Using the command prompt to change environment variables
          Using dbservername.cmd to initialize a command-prompt environment
        Rules of precedence for Windows environment variables
      Environment variables in Informix products
        Environment variable portal
        ANSIOWNER environment variable
        CPFIRST environment variable
        CMCONFIG environment variable
        CLIENT_LABEL environment variable
        DBACCNOIGN environment variable
          LOAD statement example when DBACCNOIGN is set
        DBANSIWARN environment variable
        DBBLOBBUF environment variable
        DBCENTURY environment variable
          Examples of expanding year values
          Abbreviated years and expressions in database objects
        DBDATE environment variable
          DATE expressions in database objects
        DBDELIMITER environment variable
        DBEDIT environment variable
        DBFLTMASK environment variable
        DBLANG environment variable
        DBMONEY environment variable
        DBONPLOAD environment variable
        DBPATH environment variable
          Using DBPATH with DB-Access
          Searching local directories
          Searching networked computers for databases
          Specifying a servername
        DBPRINT environment variable
        DBREMOTECMD environment variable (UNIX)
        DBSPACETEMP environment variable
        DBTEMP environment variable
        DBTIME environment variable
        DBUPSPACE environment variable
        DEFAULT_ATTACH environment variable
        DELIMIDENT environment variable
        ENVIGNORE environment variable (UNIX)
        FET_BUF_SIZE environment variable
        IFMXMONGOAUTH environment variable
        IFX_DEF_TABLE_LOCKMODE environment variable
        IFX_DIRECTIVES environment variable
        IFX_EXTDIRECTIVES environment variable
        IFX_LARGE_PAGES environment variable
        IFX_LOB_XFERSIZE environment variable
        IFX_LONGID environment variable
        IFX_NETBUF_PVTPOOL_SIZE environment variable (UNIX)
        IFX_NETBUF_SIZE environment variable
        IFX_NO_SECURITY_CHECK environment variable (UNIX)
        IFX_NO_TIMELIMIT_WARNING environment variable
        IFX_NODBPROC environment variable
        IFX_NOT_STRICT_THOUS_SEP environment variable
        IFX_ONTAPE_FILE_PREFIX environment variable
        IFX_PAD_VARCHAR environment variable
        IFX_UNLOAD_EILSEQ_MODE environment variable
        IFX_UPDDESC environment variable
        IFX_XASTDCOMPLIANCE_XAEND environment variable
        IFX_XFER_SHMBASE environment variable
        IMCADMIN environment variable
        IMCCONFIG environment variable
        IMCSERVER environment variable
        INFORMIXC environment variable (UNIX)
        INFORMIXCMNAME environment variable
        INFORMIXCMCONUNITNAME environment variable
        INFORMIXCONCSMCFG environment variable
        INFORMIXCONRETRY environment variable
        INFORMIXCONTIME environment variable
        INFORMIXCPPMAP environment variable
        INFORMIXDIR environment variable
        INFORMIXSERVER environment variable
        INFORMIXSHMBASE environment variable (UNIX)
        INFORMIXSQLHOSTS environment variable
        INFORMIXSTACKSIZE environment variable
        INFORMIXTERM environment variable (UNIX)
        INF_ROLE_SEP environment variable
        INTERACTIVE_DESKTOP_OFF environment variable (Windows)
        JAR_TEMP_PATH environment variable
        JAVA_COMPILER environment variable
        JVM_MAX_HEAP_SIZE environment variable
        LD_LIBRARY_PATH environment variable (UNIX)
        LIBPATH environment variable (UNIX)
        NODEFDAC environment variable
        ONCONFIG environment variable
        ONINIT_STDOUT environment variable (Windows)
        OPTCOMPIND environment variable
        OPTMSG environment variable
        OPTOFC environment variable
        OPT_GOAL environment variable (UNIX)
        PATH environment variable
        PDQPRIORITY environment variable
          Using PDQPRIORITY with Informix
        PLCONFIG environment variable
        PLOAD_LO_PATH environment variable
        PLOAD_SHMBASE environment variable
        PSM_ACT_LOG environment variable
        PSM_CATALOG_PATH environment variable
        PSM_DBS_POOL environment variable
        PSM_DEBUG environment variable
        PSM_DEBUG_LOG environment variable
        PSM_LOG_POOL environment variable
        PSORT_DBTEMP environment variable
        PSORT_NPROCS environment variable
          Default PSORT_NPROCS values for detached indexes
          Default PSORT_NPROCS values for attached indexes
        RTREE_COST_ADJUST_VALUE environment variable
        SHLIB_PATH environment variable (UNIX)
        SRV_FET_BUF_SIZE environment variable
        STMT_CACHE environment variable
        TERM environment variable (UNIX)
        TERMCAP environment variable (UNIX)
        TERMINFO environment variable (UNIX)
        THREADLIB environment variable (UNIX)
        TZ environment variable
        USETABLENAME environment variable
    Appendixes
      The stores_demo Database
        The stores_demo Database Map
      The superstores_demo database
        Structure of the superstores_demo Tables
        User-defined routines and extended data types
        Table Hierarchies
  Guide to SQL: Tutorial
    Database concepts
      Illustration of a data model
        Store data
        Query data
        Modify data
      Concurrent use and security
        Control database use
          Access-management strategies
            Creating and granting a role
            Defining and granting privileges for a default role
            Built-in roles
        Centralized management
      Important database terms
        The relational database model
        Tables
        Columns
        Rows
        Views
        Sequences
        Operations on tables
        The object-relational model
      Structured Query Language
        Standard SQL
        Informix SQL and ANSI SQL
        Interactive SQL
        General programming
        ANSI-compliant databases
        Global Language Support
      Summary
    Compose SELECT statements
      SELECT statement overview
        Output from SELECT statements
          Output from large object data types
          Output from user-defined data types
          Output in non-default code sets
        Some basic concepts
          Privileges
          Relational operations
          Selection and projection
          Join
      Single-table SELECT statements
        The asterisk symbol (*)
          Reorder the columns
        The ORDER BY clause to sort the rows
          Ascending order
          Descending order
          Sorting on multiple columns
        Select specific columns
          Select substrings
          ORDER BY and non-English data
        The WHERE clause
        Create a comparison condition
          Include rows
          Exclude rows
          Specify a range of rows
          Exclude a range of rows
          Use a WHERE clause to find a subset of values
          Identify NULL values
          Form compound conditions
          Exact-text comparisons
          Variable-text searches
          A single-character wildcard
            WHERE clause to specify a range of initial characters
            WHERE clause with variable-length wildcard
          MATCHES clause and non-default locales
          Protect special characters
          Subscripting in a WHERE clause
        FIRST clause to select specific rows
          FIRST clause without an ORDER BY clause
          FIRST clause with an ORDER BY clause
        Expressions and derived values
          Arithmetic expressions
            Display labels
          CASE expressions
          Sorting on derived columns
        Rowid values in SELECT statements
      Multiple-table SELECT statements
        Create a Cartesian product
        Create a join
          Cross join
          Equi-join
          Natural join
          Multiple-table join
        Some query shortcuts
          Aliases
          The INTO TEMP clause
      Summary
    Select data from complex types
      Select row-type data
        Select columns of a typed table
        Select columns that contain row-type data
          Field projections
          Field projections to select nested fields
            Select individual fields of a row type
          Asterisk notation to access all fields of a row type
      Select from a collection
        Select nested collections
        The IN keyword to search for elements in a collection
      Select rows within a table hierarchy
        Select rows of the supertable without the ONLY keyword
        Select rows from a supertable with the ONLY keyword
        An alias for a supertable
      Summary
    Functions in SELECT statements
      Functions in SELECT statements
        Aggregate functions
          The AVG function
          The COUNT function
          The MAX and MIN functions
          The RANGE function
          The STDEV function
          The SUM function
          The VARIANCE function
          Apply aggregate functions to expressions
        Time functions
          The DAY and CURRENT functions
          The MONTH function
          The WEEKDAY function
          The YEAR function
          Format DATETIME values
        Date-conversion functions
          The DATE function
          The TO_CHAR function
          The TO_DATE function
        Cardinality function
        Smart large object functions
        String-manipulation functions
          The LOWER function
          The UPPER function
          The INITCAP function
          The REPLACE function
          The SUBSTRING and SUBSTR functions
          The SUBSTRING function
          The SUBSTR function
          The LPAD function
          The RPAD function
        Other functions
          The LENGTH function
          The USER function
          The TODAY function
          The DBSERVERNAME and SITENAME functions
          The HEX function
          The DBINFO function
          The DECODE function
          The NVL function
      SPL routines in SELECT statements
      Data encryption functions
        Using column-level data encryption to secure credit card data
      Summary
    Compose advanced SELECT statements
      The GROUP BY and HAVING clauses
        The GROUP BY clause
        The HAVING clause
      Create advanced joins
        Self-joins
        Outer joins
          HCL Informix extension to outer join syntax
          ANSI join syntax
          Left outer join
          Right outer join
          Simple join
          Simple outer join on two tables
          Outer join for a simple join to a third table
          Outer join of two tables to a third table
          Joins that combine outer joins
      Subqueries in SELECT statements
        Correlated subqueries
        Using subqueries to combine SELECT statements
        Subqueries in a Projection clause
        Subqueries in the FROM clause
        Subqueries in WHERE clauses
          The ALL keyword
          The ANY keyword
          Single-valued subqueries
          Correlated subqueries
          The EXISTS keyword
        Subqueries in DELETE and UPDATE statements
      Handle collections in SELECT statements
        Collection subqueries
          Omit the ITEM keyword in a collection subquery
          Specify the ITEM keyword in a collection subquery
          Collection subqueries in the FROM clause
        Collection-derived tables
        ISO-compliant syntax for collection derived tables
      Set operations
        Union
          ORDER BY clause with UNION
          The UNION ALL keywords
          Different column names
          UNION with multiple tables
          A literal in the Projection clause
          A FIRST clause
        Intersection
        Difference
      Summary
    Modify data
      Modify data in your database
      Delete rows
        Delete all rows of a table
        Delete all rows using TRUNCATE
        Delete specified rows
        Delete selected rows
        Delete rows that contain row types
        Delete rows that contain collection types
        Delete rows from a supertable
        Complicated delete conditions
        The Delete clause of MERGE
      Insert rows
        Single rows
          Possible column values
          Restrictions on column values
          Serial data types
          List specific column names
        Insert rows into typed tables
        Syntax rules for inserts on columns
          Rows that contain named row types
          Rows that contain unnamed row types
          Specify NULL values for row types
        Insert rows into supertables
        Insert collection values into columns
          Insert values into simple collections and nested collections
          Insert NULL values into a collection that contains a row type
        Insert smart large objects
        Multiple rows and expressions
        Restrictions on the insert selection
      Update rows
        Select rows to update
        Update with uniform values
        Restrictions on updates
        Update with selected values
        Update row types
          Update rows that contain named row types
          Update rows that contain unnamed row types
          Specify Null values for the fields of a row type
        Update collection types
        Update rows of a supertable
        CASE expression to update a column
        SQL functions to update smart large objects
        The MERGE statement to update a table
      Privileges on a database and on its objects
        Database-level privileges
        Table-level privileges
        Display table privileges
        Grant privileges to roles
      Data integrity
        Entity integrity
        Semantic integrity
        Referential integrity
          The ON DELETE CASCADE option
          Example of cascading deletes
          Restrictions on cascading deletes
        Object modes and violation detection
          Definitions of object modes
            Enabled mode
            Disabled mode
            Filtering mode
          Example of modes with data manipulation statements
            Results of the insert operation when the constraint is enabled
            Results of the insert operation when the constraint is disabled
            Results of the insert when constraint is in filtering mode
            Multiple diagnostic rows for one violations row
          Violations and diagnostics tables
            Relationship of violations tables and database object modes
            Examples of START VIOLATIONS TABLE statements
            Example of privileges on the violations table
            Example of privileges on the diagnostics table
      Interrupted modifications
        Transactions
        Transaction logging
          Logging and cascading deletes
        Specify transactions
      Backups and logs with HCL Informix database servers
      Concurrency and locks
      HCL Informix data replication
      Summary
    Access and modify data in an external database
      Access other database servers
        Access ANSI databases
        Create joins between external database servers
        Access external routines
      Restrictions for remote database access
        SQL statements that access more than one database
        Access external database objects
    SQL programming
      SQL in programs
        SQL in SQL APIs
        SQL in application languages
        Static embedding
        Dynamic statements
        Program variables and host variables
      Call the database server
        SQL Communications Area
        SQLCODE field
          End of data
          Negative Codes
        SQLERRD array
        SQLWARN array
        SQLERRM character string
        SQLSTATE value
      Retrieve single rows
        Data type conversion
        What if the program retrieves a NULL value?
        Dealing with errors
          End of data
          End of data with databases that are not ANSI compliant
          Serious errors
          Interpret end of data with aggregate functions
          Default values
      Retrieve multiple rows
        Declare a cursor
        Open a cursor
        Fetch rows
          Detect end of data
          Locate the INTO clause
        Cursor input modes
        Active set of a cursor
          Create the active set
          Active set for a sequential cursor
          Active set for a SCROLL cursor
          Active set and concurrency
        Parts-explosion problem
      Dynamic SQL
        Prepare a statement
        Execute prepared SQL
        Dynamic host variables
        Free prepared statements
        Quick execution
      Embed data-definition statements
      Grant and revoke privileges in applications
        Assign roles
      Summary
    Modify data through SQL programs
      The DELETE statement
        Direct deletions
          Errors during direct deletions
          Transaction logging
          Coordinated deletions
        Delete with a cursor
      The INSERT statement
        An insert cursor
          Declare an insert cursor
          Insert with a cursor
          Status codes after PUT and FLUSH
        Rows of constants
        An insert example
          How many rows were affected?
      The UPDATE statement
        An update cursor
          The purpose of the keyword UPDATE
          Update specific columns
          UPDATE keyword not always needed
        Cleanup a table
      Summary
    Programming for a multiuser environment
      Concurrency and performance
      Locks and integrity
      Locks and performance
      Concurrency issues
      How locks work
        Kinds of locks
        Lock scope
          Database locks
          Table locks
            Lock a table with the LOCK TABLE statement
            When the database server automatically locks a table
            Avoid table locking with the ONLINE keyword
          Row and key locks
          Page locks
            Set the row or page lock mode for all CREATE TABLE statements
              Single-user lock mode
              Multiple-user lock mode
              Rules of precedence
          Coarse index locks
          Smart-large-object locks
            Byte-range locks
        Duration of a lock
        Locks while modifying
      Lock with the SELECT statement
        Set the isolation level
          SET TRANSACTION versus SET ISOLATION
            SET ISOLATION
            SET TRANSACTION
          ANSI Read Uncommitted and HCL Informix Dirty Read isolation
          ANSI Read Committed and HCL Informix Committed Read isolation
          HCL Informix Cursor Stability isolation
          ANSI Serializable, ANSI Repeatable Read, and HCL Informix Repeatable Read isolation
        Update cursors
      Retain update locks
      Exclusive locks that occur with some SQL statements
      The behavior of the lock types
      Control data modification with access modes
      Set the lock mode
        Waiting for locks
        Not waiting for locks
        Limited time wait
        Handle a deadlock
        Handling external deadlock
      Simple concurrency
      Hold cursors
      The SQL statement cache
      Summary
    Create and use SPL routines
      Introduction to SPL routines
        What you can do with SPL routines
      SPL routines format
        The CREATE PROCEDURE or CREATE FUNCTION statement
          Begin and end the routine
          Specify a routine name
          Add a specific name
          Add a parameter list
            Simple large objects as parameters
            Undefined arguments
          Add a return clause
          Add display labels
          Specify whether the SPL function is variant
          Add a modifier
            The COMMUTATOR modifier
            The NEGATOR modifier
          Specify a DOCUMENT clause
          Specify a listing file
          Add comments
        Example of a complete routine
        Create an SPL routine in a program
        Dropping a routine in a local or remote database
      Define and use variables
        Declare local variables
          Scope of local variables
          Declare variables of built-in data types
          Declare variables for smart large objects
          Declare variables for simple large objects
          Declare collection variables
          Declare row-type variables
          Declare opaque- and distinct-type variables
          Declare variables for column data with the LIKE clause
          Declare PROCEDURE type variables
          Subscripts with variables
          Variable and keyword ambiguity
            Variables and column names
            Variables and SQL functions
        Declare global variables
        Assign values to variables
          The LET statement
          Other ways to assign values to variables
      Expressions in SPL routines
      Writing the statement block
        Implicit and explicit statement blocks
        The FOREACH loop
        The FOREACH loop to define cursors
          Restriction for FOREACH loops
        An IF - ELIF - ELSE structure
        Add WHILE and FOR loops
        Exit a loop
      Return values from an SPL function
        Return a single value
        Return multiple values
      Handle row-type data
        Precedence of dot notation
        Update a row-type expression
      Handle collections
        Collection data types
        Prepare for collection data types
          Declare a collection variable
          Declare an element variable
          Select a collection into a collection variable
        Insert elements into a collection variable
          Insert into a SET or MULTISET
          Insert into a LIST
          Check the cardinality of a LIST collection
          Syntax of the VALUES clause
        Select elements from a collection
          The collection query
          Add the collection query to the SPL routine
        Delete a collection element
          Update the collection in the database
          Delete the entire collection
        Update a collection element
          Update a collection with a variable
        Update the entire collection
          Update a collection of row types
          Update a nested collection
        Insert into a collection
          Insert into a nested collection
            Insert a collection into the outer collection
            Insert a value into the inner collection
      Executing routines
        The EXECUTE statements
        The CALL statement
        Execute routines in expressions
        Execute an external function with the RETURN statement
        Execute cursor functions from an SPL routine
        Dynamic routine-name specification
          Rules for dynamic routine-name specification
      Privileges on routines
        Privileges for registering a routine
        Privileges for executing a routine
          Grant and revoke the Execute privilege
          Execute privileges with COMMUTATOR and NEGATOR functions
        Privileges on objects associated with a routine
        DBA privileges for executing a routine
      Find errors in an SPL routine
        Compile-time warnings
        Generate the text of the routine
      Debug an SPL routine
      Exception handling
        Error trapping and recovering
        Scope of control of an ON EXCEPTION statement
        User-generated exceptions
          Simulate SQL errors
          RAISE EXCEPTION to exit nested code
      Check the number of rows processed in an SPL routine
      Summary
    Create and use triggers
      When to use triggers
      How to create a trigger
        Declare a trigger name
        Specify the trigger event
        Define the triggered actions
        A complete CREATE TRIGGER statement
      Triggered actions
        BEFORE and AFTER triggered actions
        FOR EACH ROW triggered actions
          The REFERENCING clause
          The WHEN condition
        SPL routines as triggered actions
          Pass data to an SPL routine
          Using SPL
          Update nontriggering columns with data from an SPL routine
      Trigger routines
      Triggers in a table hierarchy
      Select triggers
        SELECT statements that execute triggered actions
          Stand-alone SELECT statements
          Collection subqueries in the projection list of a query
          SELECT statements embedded in user-defined routines
          Views
        Restrictions on execution of Select triggers
        Select triggers on tables in a table hierarchy
      Re-entrant triggers
      INSTEAD OF triggers on views
        INSTEAD OF trigger to update on a view
      Trace triggered actions
        Example of TRACE statements in an SPL routine
        Example of TRACE output
      Generate error messages
        Apply a fixed error message
        Generate a variable error message
      Summary
Troubleshooting Informix
  Frequently asked questions (FAQs) about HCL Informix 12.10
    Questions about installing Informix
    Questions about upgrading Informix
    Questions about administering and using Informix
    Questions about PDF versions of the Informix documentation
  Error messages
  Troubleshooting and support
    Techniques for troubleshooting problems
    Searching knowledge bases
    Getting fixes from Fix Central
    Correcting assertion failures
      Prevent and prepare for assertion failures
    Contacting IBM Support
    Exchanging information with IBM
    Subscribing to Support updates
  Frequently asked questions (FAQs) about HCL Informix 12.10
    Questions about installing Informix
    Questions about upgrading Informix
    Questions about administering and using Informix
    Questions about PDF versions of the Informix documentation
  Error messages
  Troubleshooting and support
    Techniques for troubleshooting problems
    Searching knowledge bases
    Getting fixes from Fix Central
    Correcting assertion failures
      Prevent and prepare for assertion failures
    Contacting IBM Support
    Exchanging information with IBM
    Subscribing to Support updates