Source: projects/identity-management/knowledge-base/oim-dbqueue-and-object-layer-jobs.md

> Source: projects/identity-management/knowledge-base/oim-dbqueue-and-object-layer-jobs.md

OIM DBQueue and Object-Layer Jobs

Goal: capture durable, version-aware notes about DBQueue insertion (QBM_PDBQueueInsert_*) and object-layer job creation (QBM_PJobCreate*) for One Identity Manager 9.3+ and V10.

Source Priority / Provenance

1. Live sandbox DB (OneIM, V10) on im.sandbox.local; SELECT-only metadata queries on 2026-04-27.

2. Local training / KB material from Viktor's downloads:

• C:/Users/vikto/Downloads/One Identity Manager - Employee Empowerment Program (India) - Database Calculations and Processing 1.pptx
• C:/Users/vikto/Downloads/KNOWLEDGE-1IM - QBM_PJobCreate or how to interact with object layer from SQL-270426-060950.pdf
• C:/Users/vikto/Downloads/EEP - OneIM Security Features.pptx

3. Vendor docs / release notes:

• One Identity Manager 9.3 Release Notes.
• One Identity Manager 10.0 Configuration Guide.
• One Identity Manager 10.0 Release Notes.

Version Boundary: 9.2.x vs 9.3+

The important release boundary is 9.3.

Vendor 9.3 release notes say the Database Agent Service was fundamentally revised: process control moved into the Database Agent Service .NET component, and the old database-server control procedure QBM_PWorkDBQueueMain is no longer required. The release notes also say several DBQueue overview/slot/performance tables are read-only views and should not be used as customization foundations.

For 9.3+, treat old training slides about SQL Server Agent jobs, direct slot-agent control, and legacy DBQueue slot-control internals as historical context unless the same behavior is confirmed in current vendor docs or live V10 DB metadata.

Still relevant in 9.3+/V10:

• DBQueue is still the database-side calculation/recalculation framework.
• Tasks are queued in DialogDBQueue and moved to QBMDBQueueCurrent while processing.
• The Database Agent Service controls processing and slot distribution.
• QBMDBQueueTask and QBMDBQueueTaskDepend are still central for task definitions and dependency order.
• QBMDBQueueTask.CustomWeight can influence task priority while respecting dependencies.
• Bulk processing still exists, with reworked 9.3+ configuration parameters.

Changed / do not overapply from older material:

• Do not base customizations on QBMDBQueueSlot, QBMDBQueueOverview*, or QBMDBQueueTaskPerf*; 9.3 release notes mark these as read-only views and not customization bases.
• Old configuration parameters QBM | DBServerAgent, QBM | DBServerAgent | CountSlotAgents, QBM | DBServerAgent | CreateNotification, QBM | DBQueue | ChangeLimitMax, and QBM | DBQueue | ChangeLimitMin were removed in 9.3.
• Negative slot-number information from older training decks was incomplete for V10. V10 documents more deferral meanings than just -1, -2, and -3.

QBM_PDBQueueInsert_Single / QBM_PDBQueueInsert_Bulk

Training material frames DBQueue entries as coming from data changes, typically via SQL triggers, stored procedures, or functions. Administrators can also queue recalculations manually through QBM_PDBQueueInsert_Single or QBM_PDBQueueInsert_Bulk, but this should be treated as a targeted repair/development tool, not as normal application integration.

Live V10 sandbox procedure signatures:

Observed V10 sandbox usage footprint from sys.sql_modules:

Interpretation: DBQueue insertion is not a rare edge mechanism. It is deeply embedded in generated triggers and shipped procedures. Custom use should copy the platform pattern: choose a valid UID_Task, pass the affected object/subobject semantics correctly, and preserve GenProcID traceability.

QBM_PJobCreate*

The local QBM_PJobCreate PDF explains the key architectural reason for these procedures: SQL cannot directly execute object-layer .NET behavior such as templates, formatting scripts, scripts, process generation conditions, or customizer methods. If a DB trigger or DBQueue procedure needs object-layer behavior, it creates Job queue work.

Live V10 sandbox contains 29 procedures named QBM_PJobCreate*, including:

• Generic: QBM_PJobCreate.
• HandleObject wrappers: QBM_PJobCreate_HOInsert, ..._HOUpdate, ..._HODelete, ..._HOFireEvent, ..._HOTemplate, ..._HOCallMethod, ..._HOImportXML.
• Batch/list variants: _B variants process a where clause in batches; _L variants take a QBM_YParameterList of XObjectKey values and internally use the batch path.
• Utility variants: QBM_PJobCreate_SendMail, QBM_PJobCreate_SendRMail, QBM_PJobCreate_SQLDel, ..._SQLProc, ..._Mnt.

Practical guidance from the local PDF:

• Generate a fresh GenProcID for each execution; do not reuse one over long periods because it hurts traceability/historization.
• Prefer @isToFreezeOnError = 1 for manual/debuggable jobs.
• Be careful with WhereClause; Update, Delete, FireEvent, Template, and CallMethod variants often depend on it.
• HOInsert, HOUpdate, and HODelete run through the object layer, so templates, format scripts, save scripts, and process generation logic are considered.
• HOFireEvent can trigger object events and pass process parameters through _paramNameN / _paramValueN indirection.
• HOTemplate executes templates for pipe-separated columns or *, but should be scoped carefully.
• HOCallMethod can invoke object methods such as request-decision customizer methods.
• Use _B / _L variants for batches or explicit object-key lists instead of hand-building broad one-shot jobs.

Security / operational caution:

• Jobs created this way are normal Job queue work and can execute powerful process components. Treat manual calls as production-impacting changes.
• Some examples in the local PDF intentionally show risky patterns, such as decrypting an encrypted value through a job; that may expose sensitive output in job history. Do not use such examples outside controlled troubleshooting.
• Prefer a supported API/tooling path when available. Use QBM_PJobCreate* when the actual requirement is "run object-layer behavior from SQL/service context" and the scope is explicit.

Methods Callable Through HOCallMethod

QBM_PJobCreate_HOCallMethod, _B, and _L create HandleObject CallMethod jobs. The target is selected by @objecttype plus either @whereclause or @XObjectKeys; the method is named by @MethodName; up to ten positional method parameters can be passed as @param1 ... @param10.

Important distinction:

• DialogMethod is the UI/dialog-method catalog. In this V10 sandbox it contains 45 method definitions and 71 assignments through DialogObjectHasMethod.
• HOCallMethod can also invoke object-layer/customizer methods that are not rows in DialogMethod. Shipped SQL does this for approval and attestation methods such as MakeDecision, Abort, ESCALATE, PrepareAttestations, and MakeDecisionOnInsertAsync.

Live sandbox examples from DialogMethod / DialogObjectHasMethod:

Literal object-layer method names found in shipped SQL calls to QBM_PJobCreate_HOCallMethod*:

Practical rule: before using HOCallMethod, verify the target method against either DialogMethod/DialogObjectHasMethod for UI-visible methods or against existing shipped SQL/object-layer documentation for customizer methods. The procedure does not make the method harmless; it only creates a job that asks the object layer to run it.

Events Fireable Through HOFireEvent

QBM_PJobCreate_HOFireEvent, _B, and _L create HandleObject FireEvent jobs. The target is selected by @objecttype plus either @whereclause or @XObjectKeys; the event is named by @EventName; event/process parameters can be passed with @p2/@v2 ... @p31/@v31. Shipped SQL often uses _ParamNameN / _ParamValueN in those parameter pairs to pass process parameters.

The live event catalog is QBMEvent joined to DialogTable; process generation mapping is JobEventGen joined to JobChain. In this V10 sandbox:

• QBMEvent: 353 table/event rows.
• JobEventGen: 400 event-to-process generation rows.
• Some events map to multiple processes.
• Some events can exist without an active process generator, or with process generators disabled by preprocessor. Check JobChain.NoGenerate and JobChain.IsDeactivatedByPreProcessor before assuming a fire will produce executable work.

Event families observed in the sandbox:

Literal event names found in shipped SQL calls to QBM_PJobCreate_HOFireEvent* include Assign, Remove, Insert, DecisionRequired, Remind, DeletePRNode, DeployTargetChanged, EXECUTE, FROZENDETECT, OVERLIMITDETECT, OVERLIMITWARNING, Checkversion, GenerateMail, GetDeployTargets, SendMail, SendRichMail, and UpdateSystemSyncs.

Practical rule: an event is a (TableName, EventName) pair, not a global free-form string. Verify it exists in QBMEvent for the target table, then check JobEventGen/JobChain to understand which processes will be generated.

Decompiled Object-Layer Findings

Local V10 application files under F:/Claude/agent-tools/oim/One Identity Manager were decompiled on 2026-04-27 with ilspycmd to verify what HOCallMethod and HOFireEvent do after the SQL procedure creates the Job queue work. The first focused pass inspected VI.DB.dll, QER.Customizer.dll, ATT.Customizer.dll, Common.Customizer.dll, and ADS.Customizer.dll.

A later full local decompile pass covered 1,260 managed assemblies from F:/Claude/agent-tools/oim, scanned 145,636 generated C# files, and generated a searchable relation index at F:/Claude/projects/identity-management/oim-kb-update/local-app/oim-decompile-index.html with machine-readable data beside it at oim-decompile-index-data.json. The full index is static decompile evidence and should be correlated with live DB metadata before acting on a method/event.

The relation index was then joined to live sandbox DB metadata on 2026-04-27. The Database Relations section now includes DialogMethod -> DialogObject -> DialogTable, QBMEvent -> JobEventGen -> JobChain, SQL modules, triggers and parent tables, extracted QBM_PJobCreate_HOCallMethod* / HOFireEvent* calls, and QBM_PDBQueueInsert_Single / _Bulk call sites linked to QBMDBQueueTask where a literal task ID is visible. Evidence note: F:/Claude/projects/identity-management/oim-kb-update/sandbox-db/2026-04-27-oim-db-trigger-method-event-relations.md.

Runtime mechanics observed in VI.DB.dll:

• HandleObject CallMethod reads ObjectType, MethodName, WhereClause, Param1, Param2, and following numbered parameters from the job parameters. It loads the matching entities, resolves the named object method, converts string job parameters to the target .NET parameter types, invokes the method, and saves the entity when the method requires saving or Save is set.
• MethodName can be just a name plus parameter count, or a typed signature form with parentheses. This matters when overloaded methods exist.
• String parameters can be converted to primitive target types. Object/entity parameters are passed by object key and loaded by the object layer.
• HandleObject FireEvent loads matching entities, builds an event parameter collection, adds __StartTime when provided, calls object-layer process generation, and commits the generated job chains.
• Job generation looks for a generated script method named Event_<EventName>. If the event method or chain assembly is not present, the runtime raises/logs a warning and no chains are created. So QBMEvent is necessary discovery metadata, but it is not by itself proof that a specific fire will create executable work.

Customizer methods observed in QER.Customizer.dll:

Customizer methods/events observed in ATT.Customizer.dll:

Operational interpretation:

• HOCallMethod is best thought of as "run an object-layer method in a job-service context", not "execute a row in DialogMethod". Use DialogMethod for UI-visible action discovery, but verify non-UI customizer methods in code, shipped SQL, or vendor documentation.
• For PersonWantsOrg and AttestationCase, method names alone are insufficient. Check current state, enabled functions, parameter shape, and process context.
• For HOFireEvent, validate the target as (table, event), then validate JobEventGen and job-chain generation. A catalog row without a generated chain can produce no work.
• Methods marked ChangesExternalState, NeedsSaving, or implemented as extended methods with OnSaving/OnSaved should be treated as production-impacting operations even if invoked from SQL.

V10 DBQueue Processing Model

V10 Configuration Guide points that are current for V10:

• The Database Agent Service controls DBQueue task processing and slot distribution.
• Staging level controls defaults for central dispatcher runtime: Development 20 minutes, Test 40 minutes, Production 120 minutes.
• QBM | DBQueue | CountSlotsMax limits max slots; values below 5 are not permitted except 0 for hardware-based maximum.
• QBM | DBQueue | MaxSlotsPerTask limits how many slots one task type may use; default is 16.
• Bulk processing uses:
• QBM | DBQueue | DefaultRuntime (default 90 seconds)
• QBM | DBQueue | MaxBulkFactor (default 15000)
• QBM | DBQueue | ChangeLimitDefault (default 3000)
• QBM | DBQueue | OverloadLimit (default 200000)
• QBMDBQueuePond buffers DBQueue tasks during synchronization; QBM | DBQueue | BufferTimeout defaults to 120 minutes.

Live sandbox current QBM\DBQueue config snapshot:

Note: MaxSlotsPerTask is documented in 9.3+/V10 vendor docs, but was not present as an enabled DialogConfigParm row in the current sandbox query output. Verify whether it is represented elsewhere, omitted by this installed module set, or added by a later patch/config transport before relying on it in this sandbox.

Negative Slot Numbers in V10

The training deck mentions negative slot numbers, but the older slide content is incomplete for V10. The V10 Configuration Guide documents these deferral meanings in QBMDBQueueCurrent:

Use this V10 list for sandbox/V10 troubleshooting. Keep 9.2.x-and-earlier slot notes as historical background only.

Research Questions Added

• How exactly do shipped V10 triggers choose between QBM_PDBQueueInsert_Single and QBM_PDBQueueInsert_Bulk, especially for IT Shop / ShoppingRack tasks?
• Which QBM_PJobCreate* calls are used by QER_PITShopProductNodeCreate_b and related ShoppingRack procedures, and which object-layer operations do they delegate?
• In V10, where is the documented QBM | DBQueue | MaxSlotsPerTask setting stored or surfaced in this sandbox, given it did not appear in the DialogConfigParm snapshot?
• Which negative slot numbers actually occur during common sandbox operations (AD sync, IT Shop publish, ShoppingRack refresh), and what is the fastest diagnostic query for each?
• When is manual QBM_PDBQueueInsert_* repair safer than rerunning the supported UI/API operation, and what audit/journal guardrails should agents use?
• Map remaining shipped module customizer assemblies (ADS, TSB, PAG, POL, RPS, SAP, UNS, etc.) for additional non-DialogMethod methods that shipped SQL may call through HOCallMethod.
• Build a repeatable query/script that correlates shipped SQL HOCallMethod method names, DialogMethod metadata, and decompiled customizer registrations.
• Build a repeatable query/script that correlates shipped SQL HOFireEvent event names with QBMEvent, JobEventGen, active JobChain, and generated Event_<EventName> presence where observable.

Sources

• Local source: C:/Users/vikto/Downloads/One Identity Manager - Employee Empowerment Program (India) - Database Calculations and Processing 1.pptx (extracted 2026-04-27).
• Local source: C:/Users/vikto/Downloads/KNOWLEDGE-1IM - QBM_PJobCreate or how to interact with object layer from SQL-270426-060950.pdf (extracted 2026-04-27).
• Local source: C:/Users/vikto/Downloads/EEP - OneIM Security Features.pptx (extracted 2026-04-27; only lightly relevant for DBQueue maintenance/dynamic-user context).
• One Identity Manager 9.3 Release Notes. Source: https://support-public.cfm.quest.com/77417_OneIM_ReleaseNotes.pdf (Accessed: 2026-04-27).
• One Identity Manager 10.0 Configuration Guide. Source: https://support-public.cfm.quest.com/82072_one-identity-manager_configuration_10.0.pdf (Accessed: 2026-04-27).
• One Identity Manager 10.0 Release Notes. Source: https://support-public.cfm.quest.com/82130_one-identity-manager_release-notes_10.0.pdf (Accessed: 2026-04-27).