Mendix Advanced Developer flashcards

32 cards. Read the term and the definition here. The deck at the top of this page is optional.

Single-table inheritance

Mendix stores a general entity and all its specializations in one database table; specialization attributes become nullable columns, and a discriminator column records which type each row is.

Association owner

The entity that owns a reference association stores the foreign-key column and is the only persisted side, so changing the owner of an association that already holds data requires a migration.

Calculated attribute

An attribute whose value is computed from an expression or microflow rather than stored; it is recalculated on retrieval and cannot be used in XPath database constraints.

Non-persistent entity

An entity whose objects exist only in memory and are never written to the database; it cannot be retrieved from the database by XPath and is typically used for page parameters and helper data.

Module role

A role defined inside one module that grants access to that module's entities, pages, microflows and nanoflows; user roles map onto module roles, and a user receives the union of all granted permissions.

Entity access rule

A per-entity rule granting create, read, write and delete rights per attribute or association, plus an XPath constraint limiting which rows the role may see; multiple rules combine with OR.

Apply entity access

A microflow property, enabled by default, that enforces entity-access XPath and member rights on objects the flow retrieves or commits; disabling it speeds up internal flows but bypasses security checks.

Anonymous user role

The user role given to unauthenticated visitors when guest access is enabled in the app settings; pages, entities and microflows must explicitly grant rights to it or anonymous users cannot use them.

Nanoflow restriction

Nanoflows run on the client and support only a subset of activities: no Java actions, no call-microflow activity and no REST or web service calls; they can call other nanoflows and JavaScript actions.

Microflow transaction

A microflow runs inside one database transaction; committed objects are persisted, while an unhandled error rolls back every uncommitted change made in that microflow and the flows it called.

Validation feedback activity

Throws a validation error attached to one attribute of one object; the client shows the message next to that field and the microflow stops unless an error handler catches it.

Raise error activity

Throws a custom error carrying a message you define; the nearest error event on the call stack can catch it, and if unhandled it aborts the transaction and shows the message.

Find or create handling

An import-mapping object handling option that looks for an existing object using an XPath key and creates one only when none is found, preventing duplicates across repeated import runs.

Published REST operation

A resource path plus HTTP method bound to a handler microflow or mapping; authentication is set per operation as guest, basic, active session or custom microflow.

OData query options

$filter, $expand, $orderby, $top, $skip and $count are the standard query options a published OData service can support; enabling them lets clients filter and page results server-side.

Export mapping output

An export mapping converts Mendix objects into an XML or JSON string or a DOM document, which is then used as the body of an outgoing REST or web service call.

XPath to SQL

Retrieve activities with XPath constraints are translated into SQL WHERE clauses, so filtering must happen inside the Retrieve rather than in a loop over all retrieved objects.

Index leftmost prefix

A composite database index can serve queries that constrain its leading column, or leading columns in order; a constraint that skips the first column cannot use that index.

Paging with limit

Retrieve activities accept limit and offset; returning one page at a time keeps memory use and transfer small, while retrieving a whole table to slice it client-side defeats the purpose.

Task queue

A runtime feature (Mendix 9.12 and later) that runs microflows as background jobs with configurable concurrency, keeping long-running work outside the user's request and transaction.

Module package (.mpk)

The distributable file produced by Export Module; importing it adds the module's domain model, microflows, pages and module roles to another app, but its module roles must still be mapped to that app's user roles.

Circular module dependency

A situation where module A references module B and module B also references module A; it prevents clean export and reuse, so dependencies must always point in one direction.

Reusable module contract

The set of microflows and entities a module exposes to consumers, made explicit through allowed module roles and documentation; everything else stays internal and may change between versions.

Constant per environment

A named value defined in the model with a default that is overridden per environment in the Developer Portal, so configuration changes do not require building a new deployment package.

Deployment package (.mda)

The built artifact containing the model, theme and libraries; the same package is transported to acceptance and production, while constants and log levels vary per environment.

Scheduled event leader

In a multi-instance environment only the elected leader node executes a scheduled event, which prevents duplicate runs but means the work must not depend on node-local state.

After startup microflow

A model setting that runs a microflow when the runtime starts; it executes on every runtime instance, so it must be idempotent and must not assume a single running node.

Log node name

The first argument of the Log activity, usually the module name, which tags the message; the Developer Portal then filters log output per node and per level.

CustomJavaAction superclass

Since Mendix 9, a Java action extends CustomJavaAction with a generic return type, receives an IContext in its constructor, and implements executeAction() where the actual logic lives.

Core.create

The runtime API call that instantiates a persistent or non-persistent entity within a given context; the object exists only in memory until Core.commit persists it to the database.

Context parameter

The IContext passed into every Java action carries the user, transaction and security context; passing it to Core calls keeps entity access and transaction behavior consistent with microflows.

Stale proxy classes

Generated Java proxy classes mirror the domain model; after an entity or attribute is renamed, the proxies must be regenerated or the project fails to compile.