An assertion failure is a hard internal-consistency check inside the Informix engine. When one fires, the engine writes a dump file under $INFORMIXDIR/tmp/ named af.<hex> — this is the AF file. The file contains a stack trace, the offending state, and (with DUMPSHM enabled) a snapshot of shared memory. The analyser parses AF files for known failure patterns to identify likely root causes. Each AF is a real engine problem, not a normal log entry.

A bit on a dbspace's onstat -d hex flag word indicating that the dbspace contains data which has not yet been backed up. The analyser leverages this flag in its backup-hygiene rules: any dbspace carrying 0x04000000 with no recent onstat -g arc activity is flagged as a backup gap. Visually invisible in a quick onstat -d scan, which is why the analyser parses the flag word structurally rather than relying on the rendered text.

Application Support Facility — the session-layer sub-protocol Informix carries inside an SQ_LOGIN_ASC PFPDU for connection negotiation. The ASF body in a LOGIN request carries cmd / user / password / version / mode / default_db / flags plus KEY=VALUE environment variables; the server's accept response carries a session-layer-type outcome byte (CONACC / CONREJ) and a sequence of sub-token records. ASF completes the handshake before any SQL flows.

Informix 8-byte auto-increment integer column type. The Informix equivalent of MySQL BIGINT UNSIGNED NOT NULL AUTO_INCREMENT — the proxy maps the MySQL SERIAL shorthand to BIGSERIAL so values past 2³¹ survive the round trip. Use BIGSERIAL(N) to seed the next value at N (e.g. when carrying an AUTO_INCREMENT=N directive across).

A 56-byte placeholder Informix carries inside a TUPLE row in place of the actual large-object bytes for BYTE and TEXT columns. The real payload streams in separately as one or more SQ_BLOB records (with a final empty SQ_BLOB(0) trailer to close the stream). Tools that walk a result set must follow the locator out-of-band rather than reading the bytes from the row directly.

An onconfig parameter declaring an in-memory page cache for a particular page size. Informix supports multiple BUFFERPOOL entries (one per page size in use). Each row carries a buffer count, LRU thresholds, and LRUS / LMM settings. The analyser parses these rows structurally and recommends sizes via the TUNE-BUF-NNN family of Prescriber rules, derived from observed hit ratios and turnover.

The Informix 4GL compiler. Emits a native ELF binary that connects over TCP and speaks the Informix client/server (SQLI) wire protocol. A compiled c4gl binary cannot be retargeted at the source level — only at the wire layer. The Oninit® 4gl2everywhere bridge accepts stock c4gl-compiled binaries unchanged.

A 16- or 32-bit bitmap exchanged during the MySQL protocol handshake telling each side what the other supports — long passwords, SSL, multiple statements, prepared statements, and so on. Existing MySQL clients in the wild rely on the exact negotiation, so anything that speaks the MySQL wire (such as the Oninit® MySQL-2-Informix proxy) has to advertise the same bits in the same order.

An Informix-internal flush operation that writes dirty pages from the buffer cache to disk and records a recovery marker in the logical log. Long checkpoint durations or large checkpoint waits indicate I/O pressure or buffer pressure. The analyser reads onstat -g ckp for per-checkpoint duration, wait, and reason — outliers feed performance findings.

A physical storage device (raw partition or cooked file) that backs a dbspace. A dbspace can comprise one or many chunks. The analyser reads onstat -d / -D and onstat -g iof per-chunk to detect mirror state, offline state, archive-pending state, and per-chunk I/O latency. Chunk-level state is parsed by hex flag rather than rendered text so subtle states are not missed.

In the Oninit® MySQL-2-Informix proxy, the contract enforced by make test: the same integration suite runs against both backends (m2ie via the IBM Informix CSDK, m2is via pure-C SQLI), and the MySQL-wire output for the same SQL must be byte-identical between them. The ESQL backend is the reference; any divergence is by definition a SQLI-side bug.

IBM Informix Client SDK — the C client library distribution that ships libifsql.so, the esql preprocessor, dbaccess, and the ODBC / JDBC drivers. Anything that uses ESQL/C, the GLS library, or the standard Informix client libraries needs the CSDK installed at runtime; tools that talk SQLI directly over a socket (e.g. the Oninit® Snooper, the m2is backend) deliberately don't.

A logical storage container in Informix — a named collection of one or more chunks. Tables, indexes, logs, and temporary working space all live in dbspaces. The analyser's capacity rules (CAP-001..008) walk dbspace fullness to flag near-full conditions, with plogspace and temp dbspaces correctly skipped from the warning thresholds.

Informix session flag controlling whether double-quoted strings are delimited identifiers ("my col") or string literals; default is OFF, i.e. "hello" is a string.

Embedded SQL for C — IBM's preprocessor-based way of mixing SQL statements into C source. The esql command (part of the CSDK) walks an .ec source file, rewrites the embedded EXEC SQL blocks into runtime calls against libifsql.so, and emits a .c file the C compiler builds normally. The m2ie backend of the MySQL-2-Informix proxy uses ESQL/C; the m2is backend speaks the wire protocol directly and skips the preprocessor entirely.

A SQLI wire-format convention: variable-length string fields inside a PFPDU are followed by enough NUL pad bytes that the next token starts on an even byte offset. Every Informix protocol decoder applies the rule. The Oninit® Snooper and Oninit® 4gl2everywhere both round string lengths up to the next even count when reading or writing PFPDUs.

CREATE FUNCTION clause pointing the SQL signature at a compiled symbol — e.g. EXTERNAL NAME '$INFORMIXDIR/extend/<lib>/<lib>.so(<sym>)' LANGUAGE C.

The standard Prolog term emitted by every analyser rule: finding(RuleId, Title, Severity, Evidence, Remediation). The five arguments are the rule's stable id (e.g. HLTH-007), a one-line title, a severity tier (critical / high / medium / low / info), the supporting facts that justified the finding, and the recommended remediation. Reports group, sort, and link findings using these fields.

SPL cursor loop: FOREACH SELECT … INTO vars … body … END FOREACH opens a server-side cursor, binds INTO targets per row, and runs the body.

Hash-based Message Authentication Code. A cryptographic construction that combines a secret key with a message and a hash function (typically SHA-256) to produce a short authentication tag. Verifying the tag with the same key proves the message was not tampered with and came from a holder of the secret. The portal uses HMAC to sign session cookies; the analyser cluster uses HMAC-SHA256 across multiple subsystems.

A small JavaScript library (htmx.org) that lets HTML elements issue server requests via attributes (hx-post, hx-get, etc.) and swap response HTML into the DOM without writing custom client-side code. The analyser portal uses HTMX for the upload form and the submission cards — the server returns small HTML fragments and the client splices them into place.

Informix Dynamic Server — IBM's brand name for the Informix database server engine. When Oninit documentation says “IDS” it means the running server process (the one you connect to over TCP), as opposed to the client tooling (CSDK, dbaccess) that speaks to it.

Informix's standard diagnostic data collection utility. Run on the customer host, it gathers onconfig, onstat snapshots, online.log tails, sysmaster queries, and other engine state into a single tarball — the canonical input the analyser processes. The analyser supports per-iteration awareness for multi-run captures (ifxcollect -r N -d S) and infers the collection profile from the manifest.log.<TS> file when present.

SWI-Prolog's bidirectional bridge to Python (also known as janus_swi). Lets Python code call Prolog predicates as if they were functions, and lets Prolog rules call back into Python. The analyser uses Janus to drive its rules engine: Python orchestrates I/O and report rendering, Prolog runs the diagnostic rules.

Large Language Model. A machine-learning model trained on text that produces text in response to prompts. The analyser's optional Q&A panel uses an LLM grounded strictly on the report's own findings — the model is not shown the underlying fact base, other customers' data, or historical reports. Customers can request the feature be disabled for their tenant.

Informix's transaction log. Every committed change is recorded as a sequence of log records that allow the engine to recover after a crash and replicate to other servers. The analyser reads logical-log fullness via onstat -l and flags conditions that block progress (such as a full log with no completed backup).

The buffer-cache eviction policy: when the cache is full and a new page must be read in, the page that has been unused longest is evicted. Informix manages LRU queues per BUFFERPOOL with configurable thresholds (LRUS, LRU_MAX_DIRTY, LRU_MIN_DIRTY). The Prescriber recommends values for these thresholds based on observed hit ratio and turnover.

Informix variable-length character column type that extends beyond VARCHAR's 255-byte cap, up to roughly 32 KB. Used as the proxy's mapping target for several MySQL types whose payloads can exceed 255 bytes — BINARY(N) / VARBINARY(N), JSON, and the spatial WKT fallback — because LVARCHAR(N) stores arbitrary byte payloads up to the declared length and accepts inline INSERT literals (which the Informix BYTE type does not).

A passwordless authentication pattern: the user enters their email address; the server emails a one-time URL that, when clicked, signs the user in. The link expires quickly (the analyser portal uses fifteen minutes) and cannot be replayed once consumed. Trades the password-management problem for a working email path at the cost of a short delay at sign-in time.

A Prolog technique where the rules engine evaluates Prolog rules within Prolog itself, allowing the interpreter to record which rule clauses fired and which facts they consumed. The analyser uses a meta-interpreter so every finding can be traced back to the chain of rule clauses and facts that justified it. Operators can ask "why did this fire?" and get a real answer rather than a black-box score.

DataBlade memory allocator with explicit lifetime: PER_COMMAND survives the entire SQL command (the right duration for iterator state), PER_ROUTINE only the current call, PER_STATEMENT the current statement.

DataBlade primitive that raises a SQL error from inside a C UDR; called as mi_db_error_raise(conn, MI_SQL, "SQLSTATE", "tag%t", val, …, NULL).

Function-parameter struct passed as the trailing argument to every C UDR; carries the iterator phase (mi_fp_request), per-call state slot (mi_fp_funcstate / mi_fp_setfuncstate), and the function's declared return type (mi_fp_rettype).

Per-call state cache hung off MI_FPARAM; survives across iterator phases and is the standard place to stash a connection or state struct so subsequent calls reuse it.

Iterator UDR call signalling cursor exhaustion — mi_fp_setisdone(fparam, MI_TRUE) followed by a NULL return tells the engine no more rows are coming.

Smart Large Object handle for TEXT / BYTE / CLOB / BLOB columns; read with mi_lo_read, written with mi_lo_write; never copied by value.

Row pointer + row descriptor; an MI_ROW * carries the values, MI_ROW_DESC * describes the column layout (derived at runtime from mi_fp_rettype + mi_row_desc_create).

Builds an MI_ROW * from a row descriptor and parallel MI_DATUM[] value / mi_boolean[] null arrays; the standard DataBlade way for a UDR to return more than one column.

Non-sargable (Search ARGument ABLE) queries cannot use database indexes effectively, forcing the engine to perform slow full-table scans instead of fast index seeks. They typically occur when indexed columns are wrapped in functions, calculations, or implicit conversions in the WHERE clause, leading to high CPU usage, slow performance, and improper query plans.

Informix's primary configuration file (typically $INFORMIXDIR/etc/onconfig.<servername>). It declares hundreds of parameters — memory sizes, lock counts, page-size pools, log behaviour, threading. The analyser parses the full parameter set plus structured rows like BUFFERPOOL and VPCLASS, and runs the CFG-001..010 rules to compare values against best practice and version-specific guidance.

SPL exception handler declared at the top of a procedure body; runs when a captured SQL error fires; optional WITH RESUME lets execution continue past the failing statement.

Informix's main server log file (one per instance, typically $INFORMIXDIR/tmp/online.log). It records server start-up, checkpoint completion, archive lifecycle, assertion failures, and many other engine events. The analyser parses online.log for restarts, checkpoint timing, archive activity, and AF-correlated events. The log is append-only on the engine side; the analyser reads it without modification.

A flag to the onmode command that applies a configuration change dynamically — the engine reads the new value and adopts it without a restart. Not every onconfig parameter supports dynamic apply; those that do are tagged in the Prescriber output so the operator knows whether a recommendation can be applied live or requires a restart window.

Informix's online statistics utility. A single binary with many flags (-d dbspaces, -l logs, -p profile counters, -g iof per-chunk I/O, -g glo MT global / VP CPU breakdown, -g ses sessions, -g osi OS / shared memory / semaphores, -g env startup environment, -g arc archive recency, -g ckp checkpoint history). The analyser reads many of these flags from an ifxcollect snapshot to assemble its operational view.

The unit of message exchange in Informix's SQLI wire protocol — the term IBM's wire-format spec uses for one self-contained protocol record. Structurally a PFPDU is a 16-bit token id followed by an optional, token-specific payload. A single SQL statement typically traverses many PFPDUs in each direction (e.g. SELECT → PREPARE, NDESCRIBE, OPEN, NFETCH, TUPLE, EOT, CLOSE). The Oninit® Snooper logs one line per PFPDU.

Informix's pre-image log: as a transaction is about to modify a page, the unmodified version of the page is copied here so a crash mid-transaction can be rolled back cleanly. Distinct from the logical log (which records committed changes). Physical-log fullness is another of the analyser's capacity signals.

A specialised dbspace that holds the physical log when the operator chooses to separate it from the root dbspace. The analyser's capacity rules deliberately skip plogspace fullness checks — that dbspace's expected behaviour is different from a regular data dbspace, and applying the same threshold would generate spurious warnings.

The recommendation component of the analyser (renamed from "Advisor" on 2026-04-30). Where the diagnostic axes identify what is happening, the Prescriber proposes what to do about it — each recommendation carries its current value, suggested value, and the operational discipline required to apply it (onmode -wf, restart, or operator action). Suggestions are presented for human review; nothing is changed automatically.

A logic-programming language built around facts, rules, and queries. The analyser's diagnostic rules are written as plain SWI-Prolog source files (rules/*.pl), which makes them reviewable, version-controllable, and hand-editable. Python orchestrates I/O via Janus; Prolog runs the rules and emits finding/5 terms.

SPL statement that raises an error with a code and optional ISAM error / text — RAISE EXCEPTION code, isamerr, text.

One request burst from the client (one or more PFPDUs ending in ONI_EOT) plus the server's response burst (one or more PFPDUs also ending in ONI_EOT). The Oninit® Snooper reports the full latency of a round trip in the round_us column on the closing server-side ONI_EOT row, letting an operator find every exchange slower than a threshold with a single awk filter.

Iterator UDR phase flags retrieved via mi_fp_request(fparam): SET_INIT allocates state and opens cursors, SET_RETONE returns the next row (or mi_fp_setisdone + NULL when exhausted), SET_END releases resources.

Informix's procedural extension to SQL; the body language for CREATE PROCEDURE / CREATE FUNCTION interpreted by the engine.

Informix's connection-routing configuration file (usually at the path named by $INFORMIXSQLHOSTS). Each line maps an INFORMIXSERVER name to a transport and an endpoint — for example onsoctcp + host + port for plaintext TCP, or onsocssl for TLS. CSDK-based clients consult it on every connect; tools that speak SQLI directly over a socket (such as the Snooper) bypass it.

The wire protocol Informix clients and the IBM Informix server speak to each other over TCP. Every ESQL/C program, every dbaccess session, every JDBC / ODBC / .NET connection ultimately frames its requests and responses in SQLI. Tools that decode it directly (the Oninit® Snooper, the m2is backend) can observe or substitute for the standard client libraries without depending on the IBM CSDK.

Informix's system catalog database — a virtual database whose tables expose engine state via SQL. Many onstat equivalents have sysmaster counterparts that can be queried with regular SQL tooling. ifxcollect includes selected sysmaster queries so the analyser sees both the onstat and the SQL view of the same data.

Transport Layer Security: the cryptographic protocol that encrypts traffic between a client (browser, API caller) and a server. The portal expects to run behind TLS for any production customer deployment so uploads, downloads, and session cookies travel only over the encrypted channel.

User-Defined Type VARiable — a wire-format encoding category Informix uses for several extended types including LVARCHAR, JSON, and BSON. On the wire UDTVAR appears as sql_type=40 with an ext_name string ("json", "lvarchar", "bson", or empty) reporting the registered datablade type behind it. Tooling that needs to round-trip JSON columns through MySQL SHOW CREATE TABLE reads the ext_name to recover the original MySQL type name.

Universally Unique Lexicographically-Sortable Identifier — a 128-bit identifier encoded as a 26-character Crockford-base32 string. Sorts chronologically in normal string comparison (the leading 48 bits are a millisecond timestamp), is collision-resistant, and is URL-safe. The portal addresses every submission by ULID so submission directories sort by upload order naturally.

Informix's worker-thread abstraction. Each VP class (CPU, AIO, LIO, PIO, KAIO, ADM, MSC, ...) has a configurable count of virtual processors handling that class of work. The analyser reads VPCLASS rows from onconfig and CPU breakdown via onstat -g glo to identify VP saturation and recommend resizing.

CREATE FUNCTION modifier telling Informix to dispatch the function in the multi-call iterator pattern (SET_INIT / SET_RETONE / SET_END); required for C UDRs that yield rows.

SPL iterator yield — RETURN expr WITH RESUME returns one row to the caller and resumes execution at the next statement on the next call; marks the surrounding function as a row-iterator.

Well-Known Text — the Open Geospatial Consortium textual representation of a geometry value, e.g. POINT(1 2), LINESTRING(0 0, 1 1), or POLYGON((0 0, 4 0, 4 3, 0 3, 0 0)). The MySQL-2-Informix proxy stores spatial column values as WKT text inside an LVARCHAR(2048) column when the Informix Spatial DataBlade is not loaded, so the data round-trips even though native query semantics are unavailable.