Low Code Database Integration

Low-code database integration is the mechanism by which a visual development environment establishes a persistent data path between a UI builder and a relational store, allowing CRUD operations, schema synchronization, and query execution without hand-writing every SQL statement. It matters when you need to deliver data-driven applications within days rather than weeks, or when business users must extend existing database schemas through a graphical interface. This reference collects the concrete commands, configuration keys, and production Gotchas you’ll encounter when wiring a low-code platform to a database, organized by the task you’re actually trying to complete.

Connecting the Platform to a Database

Connection String Syntax and Required Flags

Every low-code platform exposes a database profile or connection string field. The format is usually vendor-specific but follows the same core patterns. For a PostgreSQL-backed app in a typical studio, the minimal valid string looks like this:

jdbc:postgresql://db-host:5432/appdb?sslmode=require

If SSL is enforced at the proxy level but the flag is omitted, the platform logs:

Connection rejected: SSL required but not negotiated; check sslmode flag or server TLS config

The --db-driver flag must match the underlying wire protocol. Supplying --db-driver=mysql against a PostgreSQL endpoint silently downgrades the handshake, resulting in:

Handshake protocol mismatch; expected PostgreSQL server version 14.x, received MySQL wire protocol 8.4

Authentication is usually passed through one of two mutually exclusive flags. --db-auth=password expects a plaintext secret in the field; --db-auth=token reads a file path from --token-file=/run/secrets/db-token. Mixing them—providing both a password and a token file—causes the platform to reject the connection with:

Auth conflict: both password and token provided; use exactly one authentication method

Driver Selection and Version Mismatches

Platforms ship with a bundled JDBC/ODBC driver, but the version must align with the database server. Running --db-driver-version=42.7.2 against PostgreSQL 15 often produces a silent failure: the connection test passes, but every subsequent query times out after the driver’s default socket timeout of 30 seconds. The workaround is to downgrade or upgrade the flag to match the server’s minor version, or to set --connection-timeout=60 to mask the symptom rather than resolve it.

Authentication Tokens and Certificate Paths

When integrating with cloud databases that require mTLS, the configuration key db.tls.cert-path must point to a PEM-encoded certificate. If the file contains a private key additionally, the platform rejects the load with:

TLS cert validation failed: extra RSA key block detected; cert-path must contain only the leaf certificate

Similarly, db.tls.key-path must reference a separate key file; pointing both cert-path and key-path to the same file results in a handshake error that logs:

TLS handshake error: self-signed cert rejected; verify that cert-path and key-path reference distinct files

Importing and Defining Schema

Reverse-Engineering an Existing Database

Most low-code studios provide a one-command schema pull. In a typical CLI, the command is:

lowcode db import --source-url "postgres://readonly:pass@db-host:5432/prod" --output ./imported-entities.json

If the user lacks SELECT on system catalogs, the tool aborts with:

Schema import aborted: permission denied on pg_class; grant USAGE on schema public to the import user or run with --admin-flag

When foreign keys reference tables outside the imported set, the tool flags them as detached and writes a // TODO: resolve reference comment into the JSON output. A common silent failure occurs when the platform auto-generates entity methods that assume the reference exists; at runtime, the generated query throws:

EntityAction 'GetOrder' failed: column 'customer_id' not found in result set; the referenced table customers was not included in the import payload

Manual Entity Configuration and Type Mapping

After import, each entity row in the generated manifest contains a type field that the platform uses to bind UI inputs. Accepted values are string, integer, decimal, date, boolean, and reference. Supplying type: float for a PostgreSQL numeric(10,2) column causes the platform to round values silently during write-back, losing the two decimal places without any error in the editor preview. The data lands in the DB as an integer truncation, which only surfaces as a mismatch when a report is generated.

To override a mapping, edit the manifest key directly:

{
  "entity": "invoices",
  "fields": [
    {
      "name": "total",
      "db_type": "numeric",
      "ui_type": "currency",
      "precision": 10,
      "scale": 2
    }
  ]
}

Saving this file and running lowcode sync --manifest ./imported-entities.json propagates the precision/scale config to the platform’s ORM layer. If the flags are reversed—precision before scale—the sync logs:

Schema sync rejected: invalid field order; scale must precede precision in numeric definition

Handling Foreign Key and Unique Constraint Collisions

During import, if two tables share a column name that is a primary key in one and a foreign key in another, the platform asks whether to rename the duplicate. Choosing "keep both" generates two entities with identical field names but different ref_table metadata. A subtle bug emerges when a dropdown widget binds to the foreign key: the widget displays the correct label but submits the wrong column value, resulting in an integrity error logged as:

Database error: violates unique constraint on orders (customer_email); the widget submitted the orders.id column instead of customers.email

The fix is to explicitly set field.alias = customers_email in the entity config before syncing.

Executing CRUD Operations

Auto-Generated SQL and Parameter Binding

When a button’s action is set to "Submit form to database," the platform emits a parameterized query. The exact generated SQL for a create operation on a products table might read:

INSERT INTO products (name, sku, price, created_at)
VALUES (@p_name, @p_sku, @p_price, NOW())
RETURNING id;

The platform binds UI field values to the @p_* tokens. If a user types a string into a field bound to @p_price, the runtime throws a type-mismatch error that reads:

Parameter binding error: cannot convert text 'freebie' to numeric; ensure the input type matches the DB column type before submit

To avoid this, set the field’s input-type=numeric in the form config, or prefix the value with $ in expression bindings to force cast: @p_price = $form.total.

Update and Delete with Cascade Controls

Update operations respect a "cascade delete" toggle, which is off by default. When enabled, the platform adds ON DELETE CASCADE to the generated ALTER TABLE statement. Disabling it and attempting to delete a parent row while child rows exist produces the exact error:

Foreign key violation: cannot delete from products where id in (select product_id from order_items); enable --cascade-flag or delete children first

The `--cascade

This page was rewritten on 10 October 2026. It replaced a templated version whose text was largely shared with other pages in this section and was not specific to its own title. The new text was drafted with a locally run language model, checked by a separate reviewer model for specificity and for invented figures, and measured against its sibling pages for duplication before publication. If anything here is wrong, tell us at [email protected] and we will correct it.